← 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-08 06:54:58 UTC
  • Revision ID: mbp@sourcefrog.net-20050708065458-2af06c3659faf1d8
- use new path-based hashcache for WorkingTree- squash mtime/ctime to whole seconds- update and if necessary write out hashcache when WorkingTree object is   created.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/testweave.py
23
23
 
24
24
 
25
25
import testsweet
26
 
from bzrlib.weave import Weave, WeaveFormatError
27
 
from bzrlib.weavefile import write_weave, read_weave
 
26
from weave import Weave, WeaveFormatError
28
27
from pprint import pformat
29
28
 
30
29
 
 
30
 
31
31
try:
32
32
    set
33
33
    frozenset
50
50
    def check_read_write(self, k):
51
51
        """Check the weave k can be written & re-read."""
52
52
        from tempfile import TemporaryFile
 
53
        from weavefile import write_weave, read_weave
53
54
        tf = TemporaryFile()
54
55
 
55
56
        write_weave(k, tf)
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):
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',
215
248
                (']', 0),
216
249
                ('}', 0),
217
250
                ]
218
 
        ################################### SKIPPED
219
 
        # Weave.get doesn't trap this anymore
220
 
        return 
221
251
 
222
252
        self.assertRaises(WeaveFormatError,
223
253
                          k.get,
230
260
    def runTest(self):
231
261
        k = Weave()
232
262
 
233
 
        k._parents = [(),
 
263
        k._v = [(),
234
264
                frozenset([0]),
235
265
                ]
236
 
        k._weave = [('{', 0),
 
266
        k._l = [('{', 0),
237
267
                'first line',
238
268
                ('[', 1),
239
269
                'line to be deleted',
260
290
    def runTest(self):
261
291
        k = Weave()
262
292
 
263
 
        k._parents = [frozenset(),
 
293
        k._v = [frozenset(),
264
294
                frozenset([0]),
265
295
                ]
266
 
        k._weave = [('{', 0),
 
296
        k._l = [('{', 0),
267
297
                'first line',
268
298
                ('[', 1),
269
299
                'line to be deleted',
294
324
    def runTest(self):
295
325
        k = Weave()
296
326
 
297
 
        k._parents = [frozenset(),
 
327
        k._v = [frozenset(),
298
328
                ]
299
 
        k._weave = ['bad line',
 
329
        k._l = ['bad line',
300
330
                ('{', 0),
301
331
                'foo {',
302
332
                ('{', 1),
309
339
                '}',
310
340
                ('}', 0)]
311
341
 
312
 
        ################################### SKIPPED
313
 
        # Weave.get doesn't trap this anymore
314
 
        return 
315
 
 
316
 
 
317
342
        self.assertRaises(WeaveFormatError,
318
343
                          k.get,
319
344
                          0)
324
349
    def runTest(self):
325
350
        k = Weave()
326
351
 
327
 
        k._parents = [frozenset(),
 
352
        k._v = [frozenset(),
328
353
                frozenset([0]),
329
354
                frozenset([0]),
330
355
                frozenset([0,1,2]),
331
356
                ]
332
 
        k._weave = [('{', 0),
 
357
        k._l = [('{', 0),
333
358
                'foo {',
334
359
                ('{', 1),
335
360
                '  added in version 1',
339
364
                ('}', 1),
340
365
                ('}', 0)]
341
366
 
342
 
 
343
 
        # this is not currently enforced by get
344
 
        return  ##########################################
345
 
 
346
367
        self.assertRaises(WeaveFormatError,
347
368
                          k.get,
348
369
                          0)
357
378
    def runTest(self):
358
379
        k = Weave()
359
380
 
360
 
        k._parents = [frozenset(),
 
381
        k._v = [frozenset(),
361
382
                frozenset([0]),
362
383
                frozenset([0]),
363
384
                frozenset([0,1,2]),
364
385
                ]
365
 
        k._weave = [('{', 0),
 
386
        k._l = [('{', 0),
366
387
                'foo {',
367
388
                ('{', 1),
368
389
                '  added in version 1',
439
460
    def runTest(self):
440
461
        k = Weave()
441
462
 
442
 
        k._parents = [frozenset(), frozenset([0])]
443
 
        k._weave = [('{', 0),
 
463
        k._v = [frozenset(), frozenset([0])]
 
464
        k._l = [('{', 0),
444
465
                "first line",
445
466
                ('}', 0),
446
467
                ('{', 1),
463
484
    def runTest(self):
464
485
        k = Weave()
465
486
 
466
 
        k._parents = [frozenset(),
 
487
        k._v = [frozenset(),
467
488
                frozenset([0]),
468
489
                frozenset([0]),
469
490
                ]
470
 
        k._weave = [('{', 0),
 
491
        k._l = [('{', 0),
471
492
                "first line",
472
493
                ('}', 0),
473
494
                ('{', 1),
489
510
                         ["first line",
490
511
                          "alternative second line"])
491
512
 
492
 
        self.assertEqual(list(k.inclusions([2])),
493
 
                         [0, 2])
 
513
        self.assertEqual(k.inclusions([2]),
 
514
                         set([0, 2]))
494
515
 
495
516
 
496
517
 
504
525
        k.add([], text0)
505
526
        k.add([0], text1)
506
527
 
507
 
        self.log('k._weave=' + pformat(k._weave))
 
528
        self.log('k._l=' + pformat(k._l))
508
529
 
509
530
        self.assertEqual(k.get(0), text0)
510
531
        self.assertEqual(k.get(1), text1)
538
559
                          (2, 'line from 2'),
539
560
                          ])
540
561
 
541
 
        self.assertEqual(list(k.inclusions([3])),
542
 
                         [0, 1, 2, 3])
 
562
        self.assertEqual(k.inclusions([3]),
 
563
                         set([0, 1, 2, 3]))
543
564
 
544
 
        self.log('k._weave=' + pformat(k._weave))
 
565
        self.log('k._l=' + pformat(k._l))
545
566
 
546
567
        self.check_read_write(k)
547
568
 
597
618
        k.add([0], texts[1])
598
619
        k.add([0], texts[2])
599
620
 
600
 
        self.log('k._weave=' + pformat(k._weave))
 
621
        self.log('k._l=' + pformat(k._l))
601
622
 
602
623
        m = list(k.mash_iter([0, 1, 2]))
603
624
 
645
666
            ver = k.add(list(parents), t)
646
667
            parents.add(ver)
647
668
 
648
 
        self.log("k._weave=" + pformat(k._weave))
 
669
        self.log("k._l=" + pformat(k._l))
649
670
 
650
671
        for i, t in enumerate(texts):
651
672
            self.assertEqual(k.get(i), t)
653
674
        self.check_read_write(k)
654
675
 
655
676
 
656
 
 
657
 
class MergeCases(TestBase):
658
 
    def doMerge(self, base, a, b, mp):
659
 
        from cStringIO import StringIO
660
 
        from textwrap import dedent
661
 
 
662
 
        def addcrlf(x):
663
 
            return x + '\n'
664
 
        
665
 
        w = Weave()
666
 
        w.add([], map(addcrlf, base))
667
 
        w.add([0], map(addcrlf, a))
668
 
        w.add([0], map(addcrlf, b))
669
 
 
670
 
        self.log('weave is:')
671
 
        tmpf = StringIO()
672
 
        write_weave(w, tmpf)
673
 
        self.log(tmpf.getvalue())
674
 
 
675
 
        self.log('merge plan:')
676
 
        p = list(w.plan_merge(1, 2))
677
 
        for state, line in p:
678
 
            if line:
679
 
                self.log('%12s | %s' % (state, line[:-1]))
680
 
 
681
 
        self.log('merge:')
682
 
        mt = StringIO()
683
 
        mt.writelines(w.weave_merge(p))
684
 
        mt.seek(0)
685
 
        self.log(mt.getvalue())
686
 
 
687
 
        mp = map(addcrlf, mp)
688
 
        self.assertEqual(mt.readlines(), mp)
689
 
        
690
 
        
691
 
    def testOneInsert(self):
692
 
        self.doMerge([],
693
 
                     ['aa'],
694
 
                     [],
695
 
                     ['aa'])
696
 
 
697
 
    def testSeparateInserts(self):
698
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
699
 
                     ['aaa', 'xxx', 'bbb', 'ccc'],
700
 
                     ['aaa', 'bbb', 'yyy', 'ccc'],
701
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
702
 
 
703
 
    def testSameInsert(self):
704
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
705
 
                     ['aaa', 'xxx', 'bbb', 'ccc'],
706
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'],
707
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
708
 
 
709
 
    def testOverlappedInsert(self):
710
 
        self.doMerge(['aaa', 'bbb'],
711
 
                     ['aaa', 'xxx', 'yyy', 'bbb'],
712
 
                     ['aaa', 'xxx', 'bbb'],
713
 
                     ['aaa', '<<<<', 'xxx', 'yyy', '====', 'xxx', '>>>>', 'bbb'])
714
 
 
715
 
        # really it ought to reduce this to 
716
 
        # ['aaa', 'xxx', 'yyy', 'bbb']
717
 
 
718
 
 
719
 
    def testClashReplace(self):
720
 
        self.doMerge(['aaa'],
721
 
                     ['xxx'],
722
 
                     ['yyy', 'zzz'],
723
 
                     ['<<<<', 'xxx', '====', 'yyy', 'zzz', '>>>>'])
724
 
 
725
 
    def testNonClashInsert(self):
726
 
        self.doMerge(['aaa'],
727
 
                     ['xxx', 'aaa'],
728
 
                     ['yyy', 'zzz'],
729
 
                     ['<<<<', 'xxx', 'aaa', '====', 'yyy', 'zzz', '>>>>'])
730
 
 
731
 
        self.doMerge(['aaa'],
732
 
                     ['aaa'],
733
 
                     ['yyy', 'zzz'],
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'])
752
 
    
753
 
 
754
 
 
755
677
def testweave():
756
678
    import testsweet
757
679
    from unittest import TestSuite, TestLoader
758
680
    import testweave
759
 
 
 
681
 
760
682
    tl = TestLoader()
761
683
    suite = TestSuite()
762
684
    suite.addTest(tl.loadTestsFromModule(testweave))