← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to tools/testweave.py

  • Committer: Martin Pool
  • Date: 2005-07-15 23:35:18 UTC
  • Revision ID: mbp@sourcefrog.net-20050715233518-04217797d302244f
- optimization for Inventory.id2path; access byid map directly rather than 
  through the __getitem__ on the inventory; rather faster

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/testweave.py
28
28
from pprint import pformat
29
29
 
30
30
 
 
31
 
31
32
try:
32
33
    set
33
34
    frozenset
105
106
 
106
107
 
107
108
 
 
109
class DeltaAdd(TestBase):
 
110
    """Detection of changes prior to inserting new revision."""
 
111
    def runTest(self):
 
112
        k = Weave()
 
113
        k.add([], ['line 1'])
 
114
 
 
115
        self.assertEqual(k._l,
 
116
                         [('{', 0),
 
117
                          'line 1',
 
118
                          ('}', 0),
 
119
                          ])
 
120
 
 
121
        changes = list(k._delta(set([0]),
 
122
                                ['line 1',
 
123
                                 'new line']))
 
124
 
 
125
        self.log('raw changes: ' + pformat(changes))
 
126
 
 
127
        # currently there are 3 lines in the weave, and we insert after them
 
128
        self.assertEquals(changes,
 
129
                          [(3, 3, ['new line'])])
 
130
 
 
131
        changes = k._delta(set([0]),
 
132
                           ['top line',
 
133
                            'line 1'])
 
134
        
 
135
        self.assertEquals(list(changes),
 
136
                          [(1, 1, ['top line'])])
 
137
 
 
138
        self.check_read_write(k)
 
139
 
 
140
 
108
141
class InvalidAdd(TestBase):
109
142
    """Try to use invalid version number during add."""
110
143
    def runTest(self):
111
144
        k = Weave()
112
145
 
113
 
        self.assertRaises(IndexError,
 
146
        self.assertRaises(ValueError,
114
147
                          k.add,
115
148
                          [69],
116
149
                          ['new text!'])
148
181
        k.add([0, 1],
149
182
              text3)
150
183
 
151
 
        # self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))
 
184
        self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))
152
185
 
153
 
        self.log("k._weave=" + pformat(k._weave))
 
186
        self.log("k._l=" + pformat(k._l))
154
187
 
155
188
        self.assertEqual(k.annotate(3),
156
189
                         [(0, 'line 1'),
192
225
            ver = k.add([0], t)
193
226
 
194
227
        self.log('final weave:')
195
 
        self.log('k._weave=' + pformat(k._weave))
 
228
        self.log('k._l=' + pformat(k._l))
196
229
 
197
230
        for i in range(len(texts)):
198
231
            self.assertEqual(k.get(i+1),
206
239
    def runTest(self):
207
240
        k = Weave()
208
241
 
209
 
        k._parents = [(),
 
242
        k._v = [(),
210
243
                ]
211
 
        k._weave = [('{', 0),
 
244
        k._l = [('{', 0),
212
245
                'first line',
213
246
                ('[', 0),
214
247
                'deleted in 0',
230
263
    def runTest(self):
231
264
        k = Weave()
232
265
 
233
 
        k._parents = [(),
 
266
        k._v = [(),
234
267
                frozenset([0]),
235
268
                ]
236
 
        k._weave = [('{', 0),
 
269
        k._l = [('{', 0),
237
270
                'first line',
238
271
                ('[', 1),
239
272
                'line to be deleted',
260
293
    def runTest(self):
261
294
        k = Weave()
262
295
 
263
 
        k._parents = [frozenset(),
 
296
        k._v = [frozenset(),
264
297
                frozenset([0]),
265
298
                ]
266
 
        k._weave = [('{', 0),
 
299
        k._l = [('{', 0),
267
300
                'first line',
268
301
                ('[', 1),
269
302
                'line to be deleted',
294
327
    def runTest(self):
295
328
        k = Weave()
296
329
 
297
 
        k._parents = [frozenset(),
 
330
        k._v = [frozenset(),
298
331
                ]
299
 
        k._weave = ['bad line',
 
332
        k._l = ['bad line',
300
333
                ('{', 0),
301
334
                'foo {',
302
335
                ('{', 1),
324
357
    def runTest(self):
325
358
        k = Weave()
326
359
 
327
 
        k._parents = [frozenset(),
 
360
        k._v = [frozenset(),
328
361
                frozenset([0]),
329
362
                frozenset([0]),
330
363
                frozenset([0,1,2]),
331
364
                ]
332
 
        k._weave = [('{', 0),
 
365
        k._l = [('{', 0),
333
366
                'foo {',
334
367
                ('{', 1),
335
368
                '  added in version 1',
357
390
    def runTest(self):
358
391
        k = Weave()
359
392
 
360
 
        k._parents = [frozenset(),
 
393
        k._v = [frozenset(),
361
394
                frozenset([0]),
362
395
                frozenset([0]),
363
396
                frozenset([0,1,2]),
364
397
                ]
365
 
        k._weave = [('{', 0),
 
398
        k._l = [('{', 0),
366
399
                'foo {',
367
400
                ('{', 1),
368
401
                '  added in version 1',
439
472
    def runTest(self):
440
473
        k = Weave()
441
474
 
442
 
        k._parents = [frozenset(), frozenset([0])]
443
 
        k._weave = [('{', 0),
 
475
        k._v = [frozenset(), frozenset([0])]
 
476
        k._l = [('{', 0),
444
477
                "first line",
445
478
                ('}', 0),
446
479
                ('{', 1),
463
496
    def runTest(self):
464
497
        k = Weave()
465
498
 
466
 
        k._parents = [frozenset(),
 
499
        k._v = [frozenset(),
467
500
                frozenset([0]),
468
501
                frozenset([0]),
469
502
                ]
470
 
        k._weave = [('{', 0),
 
503
        k._l = [('{', 0),
471
504
                "first line",
472
505
                ('}', 0),
473
506
                ('{', 1),
489
522
                         ["first line",
490
523
                          "alternative second line"])
491
524
 
492
 
        self.assertEqual(list(k.inclusions([2])),
493
 
                         [0, 2])
 
525
        self.assertEqual(k.inclusions([2]),
 
526
                         set([0, 2]))
494
527
 
495
528
 
496
529
 
504
537
        k.add([], text0)
505
538
        k.add([0], text1)
506
539
 
507
 
        self.log('k._weave=' + pformat(k._weave))
 
540
        self.log('k._l=' + pformat(k._l))
508
541
 
509
542
        self.assertEqual(k.get(0), text0)
510
543
        self.assertEqual(k.get(1), text1)
538
571
                          (2, 'line from 2'),
539
572
                          ])
540
573
 
541
 
        self.assertEqual(list(k.inclusions([3])),
542
 
                         [0, 1, 2, 3])
 
574
        self.assertEqual(k.inclusions([3]),
 
575
                         set([0, 1, 2, 3]))
543
576
 
544
 
        self.log('k._weave=' + pformat(k._weave))
 
577
        self.log('k._l=' + pformat(k._l))
545
578
 
546
579
        self.check_read_write(k)
547
580
 
597
630
        k.add([0], texts[1])
598
631
        k.add([0], texts[2])
599
632
 
600
 
        self.log('k._weave=' + pformat(k._weave))
 
633
        self.log('k._l=' + pformat(k._l))
601
634
 
602
635
        m = list(k.mash_iter([0, 1, 2]))
603
636
 
645
678
            ver = k.add(list(parents), t)
646
679
            parents.add(ver)
647
680
 
648
 
        self.log("k._weave=" + pformat(k._weave))
 
681
        self.log("k._l=" + pformat(k._l))
649
682
 
650
683
        for i, t in enumerate(texts):
651
684
            self.assertEqual(k.get(i), t)
667
700
        w.add([0], map(addcrlf, a))
668
701
        w.add([0], map(addcrlf, b))
669
702
 
670
 
        self.log('weave is:')
671
 
        tmpf = StringIO()
672
 
        write_weave(w, tmpf)
673
 
        self.log(tmpf.getvalue())
674
 
 
675
703
        self.log('merge plan:')
676
704
        p = list(w.plan_merge(1, 2))
677
705
        for state, line in p:
732
760
                     ['aaa'],
733
761
                     ['yyy', 'zzz'],
734
762
                     ['yyy', 'zzz'])
735
 
 
736
 
 
737
 
    def testDeleteAndModify(self):
738
 
        """Clashing delete and modification.
739
 
 
740
 
        If one side modifies a region and the other deletes it then
741
 
        there should be a conflict with one side blank.
742
 
        """
743
 
 
744
 
        #######################################
745
 
        # skippd, not working yet
746
 
        return
747
 
        
748
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
749
 
                     ['aaa', 'ddd', 'ccc'],
750
 
                     ['aaa', 'ccc'],
751
 
                     ['<<<<', 'aaa', '====', '>>>>', 'ccc'])
752
763
    
753
764
 
754
765
 
756
767
    import testsweet
757
768
    from unittest import TestSuite, TestLoader
758
769
    import testweave
759
 
 
 
770
 
760
771
    tl = TestLoader()
761
772
    suite = TestSuite()
762
773
    suite.addTest(tl.loadTestsFromModule(testweave))