← 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-11 05:46:55 UTC
  • Revision ID: mbp@sourcefrog.net-20050711054655-47ea25e1f75a8813
- ignore tmp dir

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/testweave.py
17
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 
19
19
 
20
 
# TODO: tests regarding version names
21
 
 
22
20
 
23
21
 
24
22
"""test suite for weave algorithm"""
30
28
from pprint import pformat
31
29
 
32
30
 
 
31
 
33
32
try:
34
33
    set
35
34
    frozenset
62
61
            tf.seek(0)
63
62
            self.log('serialized weave:')
64
63
            self.log(tf.read())
65
 
 
66
 
            self.log('')
67
 
            self.log('parents: %s' % (k._parents == k2._parents))
68
 
            self.log('         %r' % k._parents)
69
 
            self.log('         %r' % k2._parents)
70
 
            self.log('')
71
 
 
72
 
            
73
64
            self.fail('read/write check failed')
74
65
        
75
66
        
84
75
    """Store and retrieve a simple text."""
85
76
    def runTest(self):
86
77
        k = Weave()
87
 
        idx = k.add('text0', [], TEXT_0)
 
78
        idx = k.add([], TEXT_0)
88
79
        self.assertEqual(k.get(idx), TEXT_0)
89
80
        self.assertEqual(idx, 0)
90
81
 
93
84
class AnnotateOne(TestBase):
94
85
    def runTest(self):
95
86
        k = Weave()
96
 
        k.add('text0', [], TEXT_0)
 
87
        k.add([], TEXT_0)
97
88
        self.assertEqual(k.annotate(0),
98
89
                         [(0, TEXT_0[0])])
99
90
 
102
93
    def runTest(self):
103
94
        k = Weave()
104
95
 
105
 
        idx = k.add('text0', [], TEXT_0)
 
96
        idx = k.add([], TEXT_0)
106
97
        self.assertEqual(idx, 0)
107
98
 
108
 
        idx = k.add('text1', [], TEXT_1)
 
99
        idx = k.add([], TEXT_1)
109
100
        self.assertEqual(idx, 1)
110
101
 
111
102
        self.assertEqual(k.get(0), TEXT_0)
115
106
 
116
107
 
117
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
 
118
141
class InvalidAdd(TestBase):
119
142
    """Try to use invalid version number during add."""
120
143
    def runTest(self):
121
144
        k = Weave()
122
145
 
123
 
        self.assertRaises(IndexError,
 
146
        self.assertRaises(ValueError,
124
147
                          k.add,
125
 
                          'text0',
126
148
                          [69],
127
149
                          ['new text!'])
128
150
 
135
157
    def runTest(self):
136
158
        k = Weave()
137
159
 
138
 
        k.add('text0', [], ['line 1'])
139
 
        k.add('text1', [0], ['line 1', 'line 2'])
 
160
        k.add([], ['line 1'])
 
161
        k.add([0], ['line 1', 'line 2'])
140
162
 
141
163
        self.assertEqual(k.annotate(0),
142
164
                         [(0, 'line 1')])
149
171
                         [(0, 'line 1'),
150
172
                          (1, 'line 2')])
151
173
 
152
 
        k.add('text2', [0], ['line 1', 'diverged line'])
 
174
        k.add([0], ['line 1', 'diverged line'])
153
175
 
154
176
        self.assertEqual(k.annotate(2),
155
177
                         [(0, 'line 1'),
156
178
                          (2, 'diverged line')])
157
179
 
158
180
        text3 = ['line 1', 'middle line', 'line 2']
159
 
        k.add('text3',
160
 
              [0, 1],
 
181
        k.add([0, 1],
161
182
              text3)
162
183
 
163
 
        # 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))))
164
185
 
165
 
        self.log("k._weave=" + pformat(k._weave))
 
186
        self.log("k._l=" + pformat(k._l))
166
187
 
167
188
        self.assertEqual(k.annotate(3),
168
189
                         [(0, 'line 1'),
170
191
                          (1, 'line 2')])
171
192
 
172
193
        # now multiple insertions at different places
173
 
        k.add('text4',
174
 
              [0, 1, 3],
 
194
        k.add([0, 1, 3],
175
195
              ['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])
176
196
 
177
197
        self.assertEqual(k.annotate(4), 
193
213
 
194
214
        base_text = ['one', 'two', 'three', 'four']
195
215
 
196
 
        k.add('text0', [], base_text)
 
216
        k.add([], base_text)
197
217
        
198
218
        texts = [['one', 'two', 'three'],
199
219
                 ['two', 'three', 'four'],
201
221
                 ['one', 'two', 'three', 'four'],
202
222
                 ]
203
223
 
204
 
        i = 1
205
224
        for t in texts:
206
 
            ver = k.add('text%d' % i,
207
 
                        [0], t)
208
 
            i += 1
 
225
            ver = k.add([0], t)
209
226
 
210
227
        self.log('final weave:')
211
 
        self.log('k._weave=' + pformat(k._weave))
 
228
        self.log('k._l=' + pformat(k._l))
212
229
 
213
230
        for i in range(len(texts)):
214
231
            self.assertEqual(k.get(i+1),
222
239
    def runTest(self):
223
240
        k = Weave()
224
241
 
225
 
        k._parents = [(),
 
242
        k._v = [(),
226
243
                ]
227
 
        k._weave = [('{', 0),
 
244
        k._l = [('{', 0),
228
245
                'first line',
229
246
                ('[', 0),
230
247
                'deleted in 0',
246
263
    def runTest(self):
247
264
        k = Weave()
248
265
 
249
 
        k._parents = [(),
 
266
        k._v = [(),
250
267
                frozenset([0]),
251
268
                ]
252
 
        k._weave = [('{', 0),
 
269
        k._l = [('{', 0),
253
270
                'first line',
254
271
                ('[', 1),
255
272
                'line to be deleted',
276
293
    def runTest(self):
277
294
        k = Weave()
278
295
 
279
 
        k._parents = [frozenset(),
 
296
        k._v = [frozenset(),
280
297
                frozenset([0]),
281
298
                ]
282
 
        k._weave = [('{', 0),
 
299
        k._l = [('{', 0),
283
300
                'first line',
284
301
                ('[', 1),
285
302
                'line to be deleted',
310
327
    def runTest(self):
311
328
        k = Weave()
312
329
 
313
 
        k._parents = [frozenset(),
 
330
        k._v = [frozenset(),
314
331
                ]
315
 
        k._weave = ['bad line',
 
332
        k._l = ['bad line',
316
333
                ('{', 0),
317
334
                'foo {',
318
335
                ('{', 1),
340
357
    def runTest(self):
341
358
        k = Weave()
342
359
 
343
 
        k._parents = [frozenset(),
 
360
        k._v = [frozenset(),
344
361
                frozenset([0]),
345
362
                frozenset([0]),
346
363
                frozenset([0,1,2]),
347
364
                ]
348
 
        k._weave = [('{', 0),
 
365
        k._l = [('{', 0),
349
366
                'foo {',
350
367
                ('{', 1),
351
368
                '  added in version 1',
373
390
    def runTest(self):
374
391
        k = Weave()
375
392
 
376
 
        k._parents = [frozenset(),
 
393
        k._v = [frozenset(),
377
394
                frozenset([0]),
378
395
                frozenset([0]),
379
396
                frozenset([0,1,2]),
380
397
                ]
381
 
        k._weave = [('{', 0),
 
398
        k._l = [('{', 0),
382
399
                'foo {',
383
400
                ('{', 1),
384
401
                '  added in version 1',
422
439
    def runTest(self):
423
440
        k = Weave()
424
441
 
425
 
        k.add('text0', [], ["line the first",
 
442
        k.add([], ["line the first",
426
443
                   "line 2",
427
444
                   "line 3",
428
445
                   "fine"])
429
446
 
430
447
        self.assertEqual(len(k.get(0)), 4)
431
448
 
432
 
        k.add('text1', [0], ["line the first",
 
449
        k.add([0], ["line the first",
433
450
                   "fine"])
434
451
 
435
452
        self.assertEqual(k.get(1),
455
472
    def runTest(self):
456
473
        k = Weave()
457
474
 
458
 
        k._parents = [frozenset(), frozenset([0])]
459
 
        k._weave = [('{', 0),
 
475
        k._v = [frozenset(), frozenset([0])]
 
476
        k._l = [('{', 0),
460
477
                "first line",
461
478
                ('}', 0),
462
479
                ('{', 1),
479
496
    def runTest(self):
480
497
        k = Weave()
481
498
 
482
 
        k._parents = [frozenset(),
 
499
        k._v = [frozenset(),
483
500
                frozenset([0]),
484
501
                frozenset([0]),
485
502
                ]
486
 
        k._weave = [('{', 0),
 
503
        k._l = [('{', 0),
487
504
                "first line",
488
505
                ('}', 0),
489
506
                ('{', 1),
505
522
                         ["first line",
506
523
                          "alternative second line"])
507
524
 
508
 
        self.assertEqual(list(k.inclusions([2])),
509
 
                         [0, 2])
 
525
        self.assertEqual(k.inclusions([2]),
 
526
                         set([0, 2]))
510
527
 
511
528
 
512
529
 
517
534
        text0 = ['cheddar', 'stilton', 'gruyere']
518
535
        text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']
519
536
        
520
 
        k.add('text0', [], text0)
521
 
        k.add('text1', [0], text1)
 
537
        k.add([], text0)
 
538
        k.add([0], text1)
522
539
 
523
 
        self.log('k._weave=' + pformat(k._weave))
 
540
        self.log('k._l=' + pformat(k._l))
524
541
 
525
542
        self.assertEqual(k.get(0), text0)
526
543
        self.assertEqual(k.get(1), text1)
538
555
                 ['header', '', 'line from 1', 'fixup line', 'line from 2'],
539
556
                 ]
540
557
 
541
 
        k.add('text0', [], texts[0])
542
 
        k.add('text1', [0], texts[1])
543
 
        k.add('text2', [0], texts[2])
544
 
        k.add('merge', [0, 1, 2], texts[3])
 
558
        k.add([], texts[0])
 
559
        k.add([0], texts[1])
 
560
        k.add([0], texts[2])
 
561
        k.add([0, 1, 2], texts[3])
545
562
 
546
563
        for i, t in enumerate(texts):
547
564
            self.assertEqual(k.get(i), t)
554
571
                          (2, 'line from 2'),
555
572
                          ])
556
573
 
557
 
        self.assertEqual(list(k.inclusions([3])),
558
 
                         [0, 1, 2, 3])
 
574
        self.assertEqual(k.inclusions([3]),
 
575
                         set([0, 1, 2, 3]))
559
576
 
560
 
        self.log('k._weave=' + pformat(k._weave))
 
577
        self.log('k._l=' + pformat(k._l))
561
578
 
562
579
        self.check_read_write(k)
563
580
 
609
626
                 ['header', 'aaa', 'bbb', 'line from 2', 'more from 2'],
610
627
                 ]
611
628
 
612
 
        k.add('text0', [], texts[0])
613
 
        k.add('text1', [0], texts[1])
614
 
        k.add('text2', [0], texts[2])
 
629
        k.add([], texts[0])
 
630
        k.add([0], texts[1])
 
631
        k.add([0], texts[2])
615
632
 
616
 
        self.log('k._weave=' + pformat(k._weave))
 
633
        self.log('k._l=' + pformat(k._l))
617
634
 
618
635
        m = list(k.mash_iter([0, 1, 2]))
619
636
 
657
674
 
658
675
        k = Weave()
659
676
        parents = set()
660
 
        i = 0
661
677
        for t in texts:
662
 
            ver = k.add('text%d' % i,
663
 
                        list(parents), t)
 
678
            ver = k.add(list(parents), t)
664
679
            parents.add(ver)
665
 
            i += 1
666
680
 
667
 
        self.log("k._weave=" + pformat(k._weave))
 
681
        self.log("k._l=" + pformat(k._l))
668
682
 
669
683
        for i, t in enumerate(texts):
670
684
            self.assertEqual(k.get(i), t)
672
686
        self.check_read_write(k)
673
687
 
674
688
 
675
 
 
676
 
class MergeCases(TestBase):
677
 
    def doMerge(self, base, a, b, mp):
678
 
        from cStringIO import StringIO
679
 
        from textwrap import dedent
680
 
 
681
 
        def addcrlf(x):
682
 
            return x + '\n'
683
 
        
684
 
        w = Weave()
685
 
        w.add('text0', [], map(addcrlf, base))
686
 
        w.add('text1', [0], map(addcrlf, a))
687
 
        w.add('text2', [0], map(addcrlf, b))
688
 
 
689
 
        self.log('weave is:')
690
 
        tmpf = StringIO()
691
 
        write_weave(w, tmpf)
692
 
        self.log(tmpf.getvalue())
693
 
 
694
 
        self.log('merge plan:')
695
 
        p = list(w.plan_merge(1, 2))
696
 
        for state, line in p:
697
 
            if line:
698
 
                self.log('%12s | %s' % (state, line[:-1]))
699
 
 
700
 
        self.log('merge:')
701
 
        mt = StringIO()
702
 
        mt.writelines(w.weave_merge(p))
703
 
        mt.seek(0)
704
 
        self.log(mt.getvalue())
705
 
 
706
 
        mp = map(addcrlf, mp)
707
 
        self.assertEqual(mt.readlines(), mp)
708
 
        
709
 
        
710
 
    def testOneInsert(self):
711
 
        self.doMerge([],
712
 
                     ['aa'],
713
 
                     [],
714
 
                     ['aa'])
715
 
 
716
 
    def testSeparateInserts(self):
717
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
718
 
                     ['aaa', 'xxx', 'bbb', 'ccc'],
719
 
                     ['aaa', 'bbb', 'yyy', 'ccc'],
720
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
721
 
 
722
 
    def testSameInsert(self):
723
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
724
 
                     ['aaa', 'xxx', 'bbb', 'ccc'],
725
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'],
726
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
727
 
 
728
 
    def testOverlappedInsert(self):
729
 
        self.doMerge(['aaa', 'bbb'],
730
 
                     ['aaa', 'xxx', 'yyy', 'bbb'],
731
 
                     ['aaa', 'xxx', 'bbb'],
732
 
                     ['aaa', '<<<<', 'xxx', 'yyy', '====', 'xxx', '>>>>', 'bbb'])
733
 
 
734
 
        # really it ought to reduce this to 
735
 
        # ['aaa', 'xxx', 'yyy', 'bbb']
736
 
 
737
 
 
738
 
    def testClashReplace(self):
739
 
        self.doMerge(['aaa'],
740
 
                     ['xxx'],
741
 
                     ['yyy', 'zzz'],
742
 
                     ['<<<<', 'xxx', '====', 'yyy', 'zzz', '>>>>'])
743
 
 
744
 
    def testNonClashInsert(self):
745
 
        self.doMerge(['aaa'],
746
 
                     ['xxx', 'aaa'],
747
 
                     ['yyy', 'zzz'],
748
 
                     ['<<<<', 'xxx', 'aaa', '====', 'yyy', 'zzz', '>>>>'])
749
 
 
750
 
        self.doMerge(['aaa'],
751
 
                     ['aaa'],
752
 
                     ['yyy', 'zzz'],
753
 
                     ['yyy', 'zzz'])
754
 
 
755
 
 
756
 
    def testDeleteAndModify(self):
757
 
        """Clashing delete and modification.
758
 
 
759
 
        If one side modifies a region and the other deletes it then
760
 
        there should be a conflict with one side blank.
761
 
        """
762
 
 
763
 
        #######################################
764
 
        # skippd, not working yet
765
 
        return
766
 
        
767
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
768
 
                     ['aaa', 'ddd', 'ccc'],
769
 
                     ['aaa', 'ccc'],
770
 
                     ['<<<<', 'aaa', '====', '>>>>', 'ccc'])
771
 
    
772
 
 
773
 
 
774
689
def testweave():
775
690
    import testsweet
776
691
    from unittest import TestSuite, TestLoader
777
692
    import testweave
778
 
 
 
693
 
779
694
    tl = TestLoader()
780
695
    suite = TestSuite()
781
696
    suite.addTest(tl.loadTestsFromModule(testweave))