← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to tools/testweave.py

  • Committer: Aaron Bentley
  • Date: 2005-07-26 14:06:11 UTC
  • mto: (1092.1.41) (1185.3.4) (974.1.47)
  • mto: This revision was merged to the branch mainline in revision 982.
  • Revision ID: abentley@panoramicfeedback.com-20050726140611-403e366f3c79c1f1
Fixed python invocation

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
 
 
32
31
try:
33
32
    set
34
33
    frozenset
106
105
 
107
106
 
108
107
 
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
 
 
141
108
class InvalidAdd(TestBase):
142
109
    """Try to use invalid version number during add."""
143
110
    def runTest(self):
144
111
        k = Weave()
145
112
 
146
 
        self.assertRaises(ValueError,
 
113
        self.assertRaises(IndexError,
147
114
                          k.add,
148
115
                          [69],
149
116
                          ['new text!'])
181
148
        k.add([0, 1],
182
149
              text3)
183
150
 
184
 
        self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))
 
151
        # self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))
185
152
 
186
 
        self.log("k._l=" + pformat(k._l))
 
153
        self.log("k._weave=" + pformat(k._weave))
187
154
 
188
155
        self.assertEqual(k.annotate(3),
189
156
                         [(0, 'line 1'),
225
192
            ver = k.add([0], t)
226
193
 
227
194
        self.log('final weave:')
228
 
        self.log('k._l=' + pformat(k._l))
 
195
        self.log('k._weave=' + pformat(k._weave))
229
196
 
230
197
        for i in range(len(texts)):
231
198
            self.assertEqual(k.get(i+1),
239
206
    def runTest(self):
240
207
        k = Weave()
241
208
 
242
 
        k._v = [(),
 
209
        k._parents = [(),
243
210
                ]
244
 
        k._l = [('{', 0),
 
211
        k._weave = [('{', 0),
245
212
                'first line',
246
213
                ('[', 0),
247
214
                'deleted in 0',
263
230
    def runTest(self):
264
231
        k = Weave()
265
232
 
266
 
        k._v = [(),
 
233
        k._parents = [(),
267
234
                frozenset([0]),
268
235
                ]
269
 
        k._l = [('{', 0),
 
236
        k._weave = [('{', 0),
270
237
                'first line',
271
238
                ('[', 1),
272
239
                'line to be deleted',
293
260
    def runTest(self):
294
261
        k = Weave()
295
262
 
296
 
        k._v = [frozenset(),
 
263
        k._parents = [frozenset(),
297
264
                frozenset([0]),
298
265
                ]
299
 
        k._l = [('{', 0),
 
266
        k._weave = [('{', 0),
300
267
                'first line',
301
268
                ('[', 1),
302
269
                'line to be deleted',
327
294
    def runTest(self):
328
295
        k = Weave()
329
296
 
330
 
        k._v = [frozenset(),
 
297
        k._parents = [frozenset(),
331
298
                ]
332
 
        k._l = ['bad line',
 
299
        k._weave = ['bad line',
333
300
                ('{', 0),
334
301
                'foo {',
335
302
                ('{', 1),
357
324
    def runTest(self):
358
325
        k = Weave()
359
326
 
360
 
        k._v = [frozenset(),
 
327
        k._parents = [frozenset(),
361
328
                frozenset([0]),
362
329
                frozenset([0]),
363
330
                frozenset([0,1,2]),
364
331
                ]
365
 
        k._l = [('{', 0),
 
332
        k._weave = [('{', 0),
366
333
                'foo {',
367
334
                ('{', 1),
368
335
                '  added in version 1',
390
357
    def runTest(self):
391
358
        k = Weave()
392
359
 
393
 
        k._v = [frozenset(),
 
360
        k._parents = [frozenset(),
394
361
                frozenset([0]),
395
362
                frozenset([0]),
396
363
                frozenset([0,1,2]),
397
364
                ]
398
 
        k._l = [('{', 0),
 
365
        k._weave = [('{', 0),
399
366
                'foo {',
400
367
                ('{', 1),
401
368
                '  added in version 1',
472
439
    def runTest(self):
473
440
        k = Weave()
474
441
 
475
 
        k._v = [frozenset(), frozenset([0])]
476
 
        k._l = [('{', 0),
 
442
        k._parents = [frozenset(), frozenset([0])]
 
443
        k._weave = [('{', 0),
477
444
                "first line",
478
445
                ('}', 0),
479
446
                ('{', 1),
496
463
    def runTest(self):
497
464
        k = Weave()
498
465
 
499
 
        k._v = [frozenset(),
 
466
        k._parents = [frozenset(),
500
467
                frozenset([0]),
501
468
                frozenset([0]),
502
469
                ]
503
 
        k._l = [('{', 0),
 
470
        k._weave = [('{', 0),
504
471
                "first line",
505
472
                ('}', 0),
506
473
                ('{', 1),
522
489
                         ["first line",
523
490
                          "alternative second line"])
524
491
 
525
 
        self.assertEqual(k.inclusions([2]),
526
 
                         set([0, 2]))
 
492
        self.assertEqual(list(k.inclusions([2])),
 
493
                         [0, 2])
527
494
 
528
495
 
529
496
 
537
504
        k.add([], text0)
538
505
        k.add([0], text1)
539
506
 
540
 
        self.log('k._l=' + pformat(k._l))
 
507
        self.log('k._weave=' + pformat(k._weave))
541
508
 
542
509
        self.assertEqual(k.get(0), text0)
543
510
        self.assertEqual(k.get(1), text1)
571
538
                          (2, 'line from 2'),
572
539
                          ])
573
540
 
574
 
        self.assertEqual(k.inclusions([3]),
575
 
                         set([0, 1, 2, 3]))
 
541
        self.assertEqual(list(k.inclusions([3])),
 
542
                         [0, 1, 2, 3])
576
543
 
577
 
        self.log('k._l=' + pformat(k._l))
 
544
        self.log('k._weave=' + pformat(k._weave))
578
545
 
579
546
        self.check_read_write(k)
580
547
 
630
597
        k.add([0], texts[1])
631
598
        k.add([0], texts[2])
632
599
 
633
 
        self.log('k._l=' + pformat(k._l))
 
600
        self.log('k._weave=' + pformat(k._weave))
634
601
 
635
602
        m = list(k.mash_iter([0, 1, 2]))
636
603
 
678
645
            ver = k.add(list(parents), t)
679
646
            parents.add(ver)
680
647
 
681
 
        self.log("k._l=" + pformat(k._l))
 
648
        self.log("k._weave=" + pformat(k._weave))
682
649
 
683
650
        for i, t in enumerate(texts):
684
651
            self.assertEqual(k.get(i), t)
700
667
        w.add([0], map(addcrlf, a))
701
668
        w.add([0], map(addcrlf, b))
702
669
 
 
670
        self.log('weave is:')
 
671
        tmpf = StringIO()
 
672
        write_weave(w, tmpf)
 
673
        self.log(tmpf.getvalue())
 
674
 
703
675
        self.log('merge plan:')
704
676
        p = list(w.plan_merge(1, 2))
705
677
        for state, line in p:
760
732
                     ['aaa'],
761
733
                     ['yyy', 'zzz'],
762
734
                     ['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'])
763
752
    
764
753
 
765
754
 
767
756
    import testsweet
768
757
    from unittest import TestSuite, TestLoader
769
758
    import testweave
770
 
 
 
759
 
771
760
    tl = TestLoader()
772
761
    suite = TestSuite()
773
762
    suite.addTest(tl.loadTestsFromModule(testweave))