← 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-07 10:31:36 UTC
  • Revision ID: mbp@sourcefrog.net-20050707103135-9b4d911d8df6e880
- fix pwk help

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"""
25
23
 
26
24
 
27
25
import testsweet
28
 
from bzrlib.weave import Weave, WeaveFormatError
29
 
from bzrlib.weavefile import write_weave, read_weave
 
26
from weave import Weave, WeaveFormatError
30
27
from pprint import pformat
31
28
 
32
29
 
 
30
 
33
31
try:
34
32
    set
35
33
    frozenset
52
50
    def check_read_write(self, k):
53
51
        """Check the weave k can be written & re-read."""
54
52
        from tempfile import TemporaryFile
 
53
        from weavefile import write_weave, read_weave
55
54
        tf = TemporaryFile()
56
55
 
57
56
        write_weave(k, tf)
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):
122
145
 
123
146
        self.assertRaises(IndexError,
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',
231
248
                (']', 0),
232
249
                ('}', 0),
233
250
                ]
234
 
        ################################### SKIPPED
235
 
        # Weave.get doesn't trap this anymore
236
 
        return 
237
251
 
238
252
        self.assertRaises(WeaveFormatError,
239
253
                          k.get,
246
260
    def runTest(self):
247
261
        k = Weave()
248
262
 
249
 
        k._parents = [(),
 
263
        k._v = [(),
250
264
                frozenset([0]),
251
265
                ]
252
 
        k._weave = [('{', 0),
 
266
        k._l = [('{', 0),
253
267
                'first line',
254
268
                ('[', 1),
255
269
                'line to be deleted',
276
290
    def runTest(self):
277
291
        k = Weave()
278
292
 
279
 
        k._parents = [frozenset(),
 
293
        k._v = [frozenset(),
280
294
                frozenset([0]),
281
295
                ]
282
 
        k._weave = [('{', 0),
 
296
        k._l = [('{', 0),
283
297
                'first line',
284
298
                ('[', 1),
285
299
                'line to be deleted',
310
324
    def runTest(self):
311
325
        k = Weave()
312
326
 
313
 
        k._parents = [frozenset(),
 
327
        k._v = [frozenset(),
314
328
                ]
315
 
        k._weave = ['bad line',
 
329
        k._l = ['bad line',
316
330
                ('{', 0),
317
331
                'foo {',
318
332
                ('{', 1),
325
339
                '}',
326
340
                ('}', 0)]
327
341
 
328
 
        ################################### SKIPPED
329
 
        # Weave.get doesn't trap this anymore
330
 
        return 
331
 
 
332
 
 
333
342
        self.assertRaises(WeaveFormatError,
334
343
                          k.get,
335
344
                          0)
340
349
    def runTest(self):
341
350
        k = Weave()
342
351
 
343
 
        k._parents = [frozenset(),
 
352
        k._v = [frozenset(),
344
353
                frozenset([0]),
345
354
                frozenset([0]),
346
355
                frozenset([0,1,2]),
347
356
                ]
348
 
        k._weave = [('{', 0),
 
357
        k._l = [('{', 0),
349
358
                'foo {',
350
359
                ('{', 1),
351
360
                '  added in version 1',
355
364
                ('}', 1),
356
365
                ('}', 0)]
357
366
 
358
 
 
359
 
        # this is not currently enforced by get
360
 
        return  ##########################################
361
 
 
362
367
        self.assertRaises(WeaveFormatError,
363
368
                          k.get,
364
369
                          0)
373
378
    def runTest(self):
374
379
        k = Weave()
375
380
 
376
 
        k._parents = [frozenset(),
 
381
        k._v = [frozenset(),
377
382
                frozenset([0]),
378
383
                frozenset([0]),
379
384
                frozenset([0,1,2]),
380
385
                ]
381
 
        k._weave = [('{', 0),
 
386
        k._l = [('{', 0),
382
387
                'foo {',
383
388
                ('{', 1),
384
389
                '  added in version 1',
422
427
    def runTest(self):
423
428
        k = Weave()
424
429
 
425
 
        k.add('text0', [], ["line the first",
 
430
        k.add([], ["line the first",
426
431
                   "line 2",
427
432
                   "line 3",
428
433
                   "fine"])
429
434
 
430
435
        self.assertEqual(len(k.get(0)), 4)
431
436
 
432
 
        k.add('text1', [0], ["line the first",
 
437
        k.add([0], ["line the first",
433
438
                   "fine"])
434
439
 
435
440
        self.assertEqual(k.get(1),
455
460
    def runTest(self):
456
461
        k = Weave()
457
462
 
458
 
        k._parents = [frozenset(), frozenset([0])]
459
 
        k._weave = [('{', 0),
 
463
        k._v = [frozenset(), frozenset([0])]
 
464
        k._l = [('{', 0),
460
465
                "first line",
461
466
                ('}', 0),
462
467
                ('{', 1),
479
484
    def runTest(self):
480
485
        k = Weave()
481
486
 
482
 
        k._parents = [frozenset(),
 
487
        k._v = [frozenset(),
483
488
                frozenset([0]),
484
489
                frozenset([0]),
485
490
                ]
486
 
        k._weave = [('{', 0),
 
491
        k._l = [('{', 0),
487
492
                "first line",
488
493
                ('}', 0),
489
494
                ('{', 1),
505
510
                         ["first line",
506
511
                          "alternative second line"])
507
512
 
508
 
        self.assertEqual(list(k.inclusions([2])),
509
 
                         [0, 2])
 
513
        self.assertEqual(k.inclusions([2]),
 
514
                         set([0, 2]))
510
515
 
511
516
 
512
517
 
517
522
        text0 = ['cheddar', 'stilton', 'gruyere']
518
523
        text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']
519
524
        
520
 
        k.add('text0', [], text0)
521
 
        k.add('text1', [0], text1)
 
525
        k.add([], text0)
 
526
        k.add([0], text1)
522
527
 
523
 
        self.log('k._weave=' + pformat(k._weave))
 
528
        self.log('k._l=' + pformat(k._l))
524
529
 
525
530
        self.assertEqual(k.get(0), text0)
526
531
        self.assertEqual(k.get(1), text1)
538
543
                 ['header', '', 'line from 1', 'fixup line', 'line from 2'],
539
544
                 ]
540
545
 
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])
 
546
        k.add([], texts[0])
 
547
        k.add([0], texts[1])
 
548
        k.add([0], texts[2])
 
549
        k.add([0, 1, 2], texts[3])
545
550
 
546
551
        for i, t in enumerate(texts):
547
552
            self.assertEqual(k.get(i), t)
554
559
                          (2, 'line from 2'),
555
560
                          ])
556
561
 
557
 
        self.assertEqual(list(k.inclusions([3])),
558
 
                         [0, 1, 2, 3])
 
562
        self.assertEqual(k.inclusions([3]),
 
563
                         set([0, 1, 2, 3]))
559
564
 
560
 
        self.log('k._weave=' + pformat(k._weave))
 
565
        self.log('k._l=' + pformat(k._l))
561
566
 
562
567
        self.check_read_write(k)
563
568
 
609
614
                 ['header', 'aaa', 'bbb', 'line from 2', 'more from 2'],
610
615
                 ]
611
616
 
612
 
        k.add('text0', [], texts[0])
613
 
        k.add('text1', [0], texts[1])
614
 
        k.add('text2', [0], texts[2])
 
617
        k.add([], texts[0])
 
618
        k.add([0], texts[1])
 
619
        k.add([0], texts[2])
615
620
 
616
 
        self.log('k._weave=' + pformat(k._weave))
 
621
        self.log('k._l=' + pformat(k._l))
617
622
 
618
623
        m = list(k.mash_iter([0, 1, 2]))
619
624
 
657
662
 
658
663
        k = Weave()
659
664
        parents = set()
660
 
        i = 0
661
665
        for t in texts:
662
 
            ver = k.add('text%d' % i,
663
 
                        list(parents), t)
 
666
            ver = k.add(list(parents), t)
664
667
            parents.add(ver)
665
 
            i += 1
666
668
 
667
 
        self.log("k._weave=" + pformat(k._weave))
 
669
        self.log("k._l=" + pformat(k._l))
668
670
 
669
671
        for i, t in enumerate(texts):
670
672
            self.assertEqual(k.get(i), t)
672
674
        self.check_read_write(k)
673
675
 
674
676
 
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
677
def testweave():
775
678
    import testsweet
776
679
    from unittest import TestSuite, TestLoader
777
680
    import testweave
778
 
 
 
681
 
779
682
    tl = TestLoader()
780
683
    suite = TestSuite()
781
684
    suite.addTest(tl.loadTestsFromModule(testweave))