~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 03:42:53 UTC
  • Revision ID: mbp@sourcefrog.net-20050711034253-412281abeb9f56ad
doc

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
 
24
 
 
25
import testsweet
 
26
from bzrlib.weave import Weave, WeaveFormatError
 
27
from bzrlib.weavefile import write_weave, read_weave
26
28
from pprint import pformat
27
29
 
28
 
from bzrlib.weave import Weave, WeaveFormatError, WeaveError
29
 
from bzrlib.weavefile import write_weave, read_weave
30
 
from bzrlib.selftest import TestCase
31
 
from bzrlib.osutils import sha_string
 
30
 
 
31
 
 
32
try:
 
33
    set
 
34
    frozenset
 
35
except NameError:
 
36
    from sets import Set, ImmutableSet
 
37
    set = Set
 
38
    frozenset = ImmutableSet
 
39
    del Set, ImmutableSet
 
40
 
32
41
 
33
42
 
34
43
# texts for use in testing
38
47
 
39
48
 
40
49
 
41
 
class TestBase(TestCase):
 
50
class TestBase(testsweet.TestBase):
42
51
    def check_read_write(self, k):
43
52
        """Check the weave k can be written & re-read."""
44
53
        from tempfile import TemporaryFile
52
61
            tf.seek(0)
53
62
            self.log('serialized weave:')
54
63
            self.log(tf.read())
55
 
 
56
 
            self.log('')
57
 
            self.log('parents: %s' % (k._parents == k2._parents))
58
 
            self.log('         %r' % k._parents)
59
 
            self.log('         %r' % k2._parents)
60
 
            self.log('')
61
 
 
62
 
            
63
64
            self.fail('read/write check failed')
64
65
        
65
66
        
74
75
    """Store and retrieve a simple text."""
75
76
    def runTest(self):
76
77
        k = Weave()
77
 
        idx = k.add('text0', [], TEXT_0)
 
78
        idx = k.add([], TEXT_0)
78
79
        self.assertEqual(k.get(idx), TEXT_0)
79
80
        self.assertEqual(idx, 0)
80
81
 
83
84
class AnnotateOne(TestBase):
84
85
    def runTest(self):
85
86
        k = Weave()
86
 
        k.add('text0', [], TEXT_0)
 
87
        k.add([], TEXT_0)
87
88
        self.assertEqual(k.annotate(0),
88
89
                         [(0, TEXT_0[0])])
89
90
 
92
93
    def runTest(self):
93
94
        k = Weave()
94
95
 
95
 
        idx = k.add('text0', [], TEXT_0)
 
96
        idx = k.add([], TEXT_0)
96
97
        self.assertEqual(idx, 0)
97
98
 
98
 
        idx = k.add('text1', [], TEXT_1)
 
99
        idx = k.add([], TEXT_1)
99
100
        self.assertEqual(idx, 1)
100
101
 
101
102
        self.assertEqual(k.get(0), TEXT_0)
102
103
        self.assertEqual(k.get(1), TEXT_1)
103
104
 
104
 
 
105
 
 
106
 
class AddWithGivenSha(TestBase):
 
105
        k.dump(self.TEST_LOG)
 
106
 
 
107
 
 
108
 
 
109
class DeltaAdd(TestBase):
 
110
    """Detection of changes prior to inserting new revision."""
107
111
    def runTest(self):
108
 
        """Add with caller-supplied SHA-1"""
109
112
        k = Weave()
110
 
 
111
 
        t = 'text0'
112
 
        k.add('text0', [], [t], sha1=sha_string(t))
113
 
 
 
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)
114
139
 
115
140
 
116
141
class InvalidAdd(TestBase):
118
143
    def runTest(self):
119
144
        k = Weave()
120
145
 
121
 
        self.assertRaises(IndexError,
 
146
        self.assertRaises(ValueError,
122
147
                          k.add,
123
 
                          'text0',
124
148
                          [69],
125
149
                          ['new text!'])
126
150
 
127
151
 
128
 
class RepeatedAdd(TestBase):
129
 
    """Add the same version twice; harmless."""
130
 
    def runTest(self):
131
 
        k = Weave()
132
 
        idx = k.add('text0', [], TEXT_0)
133
 
        idx2 = k.add('text0', [], TEXT_0)
134
 
        self.assertEqual(idx, idx2)
135
 
 
136
 
 
137
 
 
138
 
class InvalidRepeatedAdd(TestBase):
139
 
    def runTest(self):
140
 
        k = Weave()
141
 
        idx = k.add('text0', [], TEXT_0)
142
 
        self.assertRaises(WeaveError,
143
 
                          k.add,
144
 
                          'text0',
145
 
                          [],
146
 
                          ['not the same text'])
147
 
        self.assertRaises(WeaveError,
148
 
                          k.add,
149
 
                          'text0',
150
 
                          [12],         # not the right parents
151
 
                          TEXT_0)
152
 
        
153
 
 
154
 
 
155
152
class InsertLines(TestBase):
156
153
    """Store a revision that adds one line to the original.
157
154
 
160
157
    def runTest(self):
161
158
        k = Weave()
162
159
 
163
 
        k.add('text0', [], ['line 1'])
164
 
        k.add('text1', [0], ['line 1', 'line 2'])
 
160
        k.add([], ['line 1'])
 
161
        k.add([0], ['line 1', 'line 2'])
165
162
 
166
163
        self.assertEqual(k.annotate(0),
167
164
                         [(0, 'line 1')])
174
171
                         [(0, 'line 1'),
175
172
                          (1, 'line 2')])
176
173
 
177
 
        k.add('text2', [0], ['line 1', 'diverged line'])
 
174
        k.add([0], ['line 1', 'diverged line'])
178
175
 
179
176
        self.assertEqual(k.annotate(2),
180
177
                         [(0, 'line 1'),
181
178
                          (2, 'diverged line')])
182
179
 
183
180
        text3 = ['line 1', 'middle line', 'line 2']
184
 
        k.add('text3',
185
 
              [0, 1],
 
181
        k.add([0, 1],
186
182
              text3)
187
183
 
188
 
        # 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))))
189
185
 
190
 
        self.log("k._weave=" + pformat(k._weave))
 
186
        self.log("k._l=" + pformat(k._l))
191
187
 
192
188
        self.assertEqual(k.annotate(3),
193
189
                         [(0, 'line 1'),
195
191
                          (1, 'line 2')])
196
192
 
197
193
        # now multiple insertions at different places
198
 
        k.add('text4',
199
 
              [0, 1, 3],
 
194
        k.add([0, 1, 3],
200
195
              ['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])
201
196
 
202
197
        self.assertEqual(k.annotate(4), 
218
213
 
219
214
        base_text = ['one', 'two', 'three', 'four']
220
215
 
221
 
        k.add('text0', [], base_text)
 
216
        k.add([], base_text)
222
217
        
223
218
        texts = [['one', 'two', 'three'],
224
219
                 ['two', 'three', 'four'],
226
221
                 ['one', 'two', 'three', 'four'],
227
222
                 ]
228
223
 
229
 
        i = 1
230
224
        for t in texts:
231
 
            ver = k.add('text%d' % i,
232
 
                        [0], t)
233
 
            i += 1
 
225
            ver = k.add([0], t)
234
226
 
235
227
        self.log('final weave:')
236
 
        self.log('k._weave=' + pformat(k._weave))
 
228
        self.log('k._l=' + pformat(k._l))
237
229
 
238
230
        for i in range(len(texts)):
239
231
            self.assertEqual(k.get(i+1),
247
239
    def runTest(self):
248
240
        k = Weave()
249
241
 
250
 
        k._parents = [(),
 
242
        k._v = [(),
251
243
                ]
252
 
        k._weave = [('{', 0),
 
244
        k._l = [('{', 0),
253
245
                'first line',
254
246
                ('[', 0),
255
247
                'deleted in 0',
256
248
                (']', 0),
257
249
                ('}', 0),
258
250
                ]
259
 
        ################################### SKIPPED
260
 
        # Weave.get doesn't trap this anymore
261
 
        return 
262
251
 
263
252
        self.assertRaises(WeaveFormatError,
264
253
                          k.get,
271
260
    def runTest(self):
272
261
        k = Weave()
273
262
 
274
 
        k._parents = [(),
 
263
        k._v = [(),
275
264
                frozenset([0]),
276
265
                ]
277
 
        k._weave = [('{', 0),
 
266
        k._l = [('{', 0),
278
267
                'first line',
279
268
                ('[', 1),
280
269
                'line to be deleted',
301
290
    def runTest(self):
302
291
        k = Weave()
303
292
 
304
 
        k._parents = [frozenset(),
 
293
        k._v = [frozenset(),
305
294
                frozenset([0]),
306
295
                ]
307
 
        k._weave = [('{', 0),
 
296
        k._l = [('{', 0),
308
297
                'first line',
309
298
                ('[', 1),
310
299
                'line to be deleted',
335
324
    def runTest(self):
336
325
        k = Weave()
337
326
 
338
 
        k._parents = [frozenset(),
 
327
        k._v = [frozenset(),
339
328
                ]
340
 
        k._weave = ['bad line',
 
329
        k._l = ['bad line',
341
330
                ('{', 0),
342
331
                'foo {',
343
332
                ('{', 1),
350
339
                '}',
351
340
                ('}', 0)]
352
341
 
353
 
        ################################### SKIPPED
354
 
        # Weave.get doesn't trap this anymore
355
 
        return 
356
 
 
357
 
 
358
342
        self.assertRaises(WeaveFormatError,
359
343
                          k.get,
360
344
                          0)
365
349
    def runTest(self):
366
350
        k = Weave()
367
351
 
368
 
        k._parents = [frozenset(),
 
352
        k._v = [frozenset(),
369
353
                frozenset([0]),
370
354
                frozenset([0]),
371
355
                frozenset([0,1,2]),
372
356
                ]
373
 
        k._weave = [('{', 0),
 
357
        k._l = [('{', 0),
374
358
                'foo {',
375
359
                ('{', 1),
376
360
                '  added in version 1',
380
364
                ('}', 1),
381
365
                ('}', 0)]
382
366
 
383
 
 
384
 
        # this is not currently enforced by get
385
 
        return  ##########################################
386
 
 
387
367
        self.assertRaises(WeaveFormatError,
388
368
                          k.get,
389
369
                          0)
398
378
    def runTest(self):
399
379
        k = Weave()
400
380
 
401
 
        k._parents = [frozenset(),
 
381
        k._v = [frozenset(),
402
382
                frozenset([0]),
403
383
                frozenset([0]),
404
384
                frozenset([0,1,2]),
405
385
                ]
406
 
        k._weave = [('{', 0),
 
386
        k._l = [('{', 0),
407
387
                'foo {',
408
388
                ('{', 1),
409
389
                '  added in version 1',
447
427
    def runTest(self):
448
428
        k = Weave()
449
429
 
450
 
        k.add('text0', [], ["line the first",
 
430
        k.add([], ["line the first",
451
431
                   "line 2",
452
432
                   "line 3",
453
433
                   "fine"])
454
434
 
455
435
        self.assertEqual(len(k.get(0)), 4)
456
436
 
457
 
        k.add('text1', [0], ["line the first",
 
437
        k.add([0], ["line the first",
458
438
                   "fine"])
459
439
 
460
440
        self.assertEqual(k.get(1),
480
460
    def runTest(self):
481
461
        k = Weave()
482
462
 
483
 
        k._parents = [frozenset(), frozenset([0])]
484
 
        k._weave = [('{', 0),
 
463
        k._v = [frozenset(), frozenset([0])]
 
464
        k._l = [('{', 0),
485
465
                "first line",
486
466
                ('}', 0),
487
467
                ('{', 1),
495
475
        self.assertEqual(k.get(0),
496
476
                         ["first line"])
497
477
 
 
478
        k.dump(self.TEST_LOG)
 
479
 
498
480
 
499
481
class DivergedIncludes(TestBase):
500
482
    """Weave with two diverged texts based on version 0.
502
484
    def runTest(self):
503
485
        k = Weave()
504
486
 
505
 
        k._parents = [frozenset(),
 
487
        k._v = [frozenset(),
506
488
                frozenset([0]),
507
489
                frozenset([0]),
508
490
                ]
509
 
        k._weave = [('{', 0),
 
491
        k._l = [('{', 0),
510
492
                "first line",
511
493
                ('}', 0),
512
494
                ('{', 1),
528
510
                         ["first line",
529
511
                          "alternative second line"])
530
512
 
531
 
        self.assertEqual(list(k.inclusions([2])),
532
 
                         [0, 2])
 
513
        self.assertEqual(k.inclusions([2]),
 
514
                         set([0, 2]))
533
515
 
534
516
 
535
517
 
540
522
        text0 = ['cheddar', 'stilton', 'gruyere']
541
523
        text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']
542
524
        
543
 
        k.add('text0', [], text0)
544
 
        k.add('text1', [0], text1)
 
525
        k.add([], text0)
 
526
        k.add([0], text1)
545
527
 
546
 
        self.log('k._weave=' + pformat(k._weave))
 
528
        self.log('k._l=' + pformat(k._l))
547
529
 
548
530
        self.assertEqual(k.get(0), text0)
549
531
        self.assertEqual(k.get(1), text1)
561
543
                 ['header', '', 'line from 1', 'fixup line', 'line from 2'],
562
544
                 ]
563
545
 
564
 
        k.add('text0', [], texts[0])
565
 
        k.add('text1', [0], texts[1])
566
 
        k.add('text2', [0], texts[2])
567
 
        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])
568
550
 
569
551
        for i, t in enumerate(texts):
570
552
            self.assertEqual(k.get(i), t)
577
559
                          (2, 'line from 2'),
578
560
                          ])
579
561
 
580
 
        self.assertEqual(list(k.inclusions([3])),
581
 
                         [0, 1, 2, 3])
 
562
        self.assertEqual(k.inclusions([3]),
 
563
                         set([0, 1, 2, 3]))
582
564
 
583
 
        self.log('k._weave=' + pformat(k._weave))
 
565
        self.log('k._l=' + pformat(k._l))
584
566
 
585
567
        self.check_read_write(k)
586
568
 
632
614
                 ['header', 'aaa', 'bbb', 'line from 2', 'more from 2'],
633
615
                 ]
634
616
 
635
 
        k.add('text0', [], texts[0])
636
 
        k.add('text1', [0], texts[1])
637
 
        k.add('text2', [0], texts[2])
 
617
        k.add([], texts[0])
 
618
        k.add([0], texts[1])
 
619
        k.add([0], texts[2])
638
620
 
639
 
        self.log('k._weave=' + pformat(k._weave))
 
621
        self.log('k._l=' + pformat(k._l))
640
622
 
641
623
        m = list(k.mash_iter([0, 1, 2]))
642
624
 
680
662
 
681
663
        k = Weave()
682
664
        parents = set()
683
 
        i = 0
684
665
        for t in texts:
685
 
            ver = k.add('text%d' % i,
686
 
                        list(parents), t)
 
666
            ver = k.add(list(parents), t)
687
667
            parents.add(ver)
688
 
            i += 1
689
668
 
690
 
        self.log("k._weave=" + pformat(k._weave))
 
669
        self.log("k._l=" + pformat(k._l))
691
670
 
692
671
        for i, t in enumerate(texts):
693
672
            self.assertEqual(k.get(i), t)
695
674
        self.check_read_write(k)
696
675
 
697
676
 
698
 
 
699
 
class MergeCases(TestBase):
700
 
    def doMerge(self, base, a, b, mp):
701
 
        from cStringIO import StringIO
702
 
        from textwrap import dedent
703
 
 
704
 
        def addcrlf(x):
705
 
            return x + '\n'
706
 
        
707
 
        w = Weave()
708
 
        w.add('text0', [], map(addcrlf, base))
709
 
        w.add('text1', [0], map(addcrlf, a))
710
 
        w.add('text2', [0], map(addcrlf, b))
711
 
 
712
 
        self.log('weave is:')
713
 
        tmpf = StringIO()
714
 
        write_weave(w, tmpf)
715
 
        self.log(tmpf.getvalue())
716
 
 
717
 
        self.log('merge plan:')
718
 
        p = list(w.plan_merge(1, 2))
719
 
        for state, line in p:
720
 
            if line:
721
 
                self.log('%12s | %s' % (state, line[:-1]))
722
 
 
723
 
        self.log('merge:')
724
 
        mt = StringIO()
725
 
        mt.writelines(w.weave_merge(p))
726
 
        mt.seek(0)
727
 
        self.log(mt.getvalue())
728
 
 
729
 
        mp = map(addcrlf, mp)
730
 
        self.assertEqual(mt.readlines(), mp)
731
 
        
732
 
        
733
 
    def testOneInsert(self):
734
 
        self.doMerge([],
735
 
                     ['aa'],
736
 
                     [],
737
 
                     ['aa'])
738
 
 
739
 
    def testSeparateInserts(self):
740
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
741
 
                     ['aaa', 'xxx', 'bbb', 'ccc'],
742
 
                     ['aaa', 'bbb', 'yyy', 'ccc'],
743
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
744
 
 
745
 
    def testSameInsert(self):
746
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
747
 
                     ['aaa', 'xxx', 'bbb', 'ccc'],
748
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'],
749
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
750
 
 
751
 
    def testOverlappedInsert(self):
752
 
        self.doMerge(['aaa', 'bbb'],
753
 
                     ['aaa', 'xxx', 'yyy', 'bbb'],
754
 
                     ['aaa', 'xxx', 'bbb'],
755
 
                     ['aaa', '<<<<', 'xxx', 'yyy', '====', 'xxx', '>>>>', 'bbb'])
756
 
 
757
 
        # really it ought to reduce this to 
758
 
        # ['aaa', 'xxx', 'yyy', 'bbb']
759
 
 
760
 
 
761
 
    def testClashReplace(self):
762
 
        self.doMerge(['aaa'],
763
 
                     ['xxx'],
764
 
                     ['yyy', 'zzz'],
765
 
                     ['<<<<', 'xxx', '====', 'yyy', 'zzz', '>>>>'])
766
 
 
767
 
    def testNonClashInsert(self):
768
 
        self.doMerge(['aaa'],
769
 
                     ['xxx', 'aaa'],
770
 
                     ['yyy', 'zzz'],
771
 
                     ['<<<<', 'xxx', 'aaa', '====', 'yyy', 'zzz', '>>>>'])
772
 
 
773
 
        self.doMerge(['aaa'],
774
 
                     ['aaa'],
775
 
                     ['yyy', 'zzz'],
776
 
                     ['yyy', 'zzz'])
777
 
 
778
 
 
779
 
    def testDeleteAndModify(self):
780
 
        """Clashing delete and modification.
781
 
 
782
 
        If one side modifies a region and the other deletes it then
783
 
        there should be a conflict with one side blank.
784
 
        """
785
 
 
786
 
        #######################################
787
 
        # skippd, not working yet
788
 
        return
789
 
        
790
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
791
 
                     ['aaa', 'ddd', 'ccc'],
792
 
                     ['aaa', 'ccc'],
793
 
                     ['<<<<', 'aaa', '====', '>>>>', 'ccc'])
794
 
 
795
 
 
796
 
class JoinWeavesTests(TestBase):
797
 
    def setUp(self):
798
 
        super(JoinWeavesTests, self).setUp()
799
 
        self.weave1 = Weave()
800
 
        self.lines1 = ['hello\n']
801
 
        self.lines3 = ['hello\n', 'cruel\n', 'world\n']
802
 
        self.weave1.add('v1', [], self.lines1)
803
 
        self.weave1.add('v2', [0], ['hello\n', 'world\n'])
804
 
        self.weave1.add('v3', [1], self.lines3)
805
 
        
806
 
    def test_join_empty(self):
807
 
        """Join two empty weaves."""
808
 
        eq = self.assertEqual
809
 
        w1 = Weave()
810
 
        w2 = Weave()
811
 
        w1.join(w2)
812
 
        eq(w1.numversions(), 0)
813
 
        
814
 
    def test_join_empty_to_nonempty(self):
815
 
        """Join empty weave onto nonempty."""
816
 
        self.weave1.join(Weave())
817
 
        self.assertEqual(len(self.weave1), 3)
818
 
 
819
 
    def test_join_unrelated(self):
820
 
        """Join two weaves with no history in common."""
821
 
        wb = Weave()
822
 
        wb.add('b1', [], ['line from b\n'])
823
 
        w1 = self.weave1
824
 
        w1.join(wb)
825
 
        eq = self.assertEqual
826
 
        eq(len(w1), 4)
827
 
        eq(sorted(list(w1.iter_names())),
828
 
           ['b1', 'v1', 'v2', 'v3'])
829
 
 
830
 
    def test_join_related(self):
831
 
        wa = self.weave1.copy()
832
 
        wb = self.weave1.copy()
833
 
        wa.add('a1', ['v3'], ['hello\n', 'sweet\n', 'world\n'])
834
 
        wb.add('b1', ['v3'], ['hello\n', 'pale blue\n', 'world\n'])
835
 
        eq = self.assertEquals
836
 
        eq(len(wa), 4)
837
 
        eq(len(wb), 4)
838
 
        wa.join(wb)
839
 
        eq(len(wa), 5)
840
 
        eq(wa.get_lines('b1'),
841
 
           ['hello\n', 'pale blue\n', 'world\n'])
842
 
 
843
 
    def test_join_parent_disagreement(self):
844
 
        """Cannot join weaves with different parents for a version."""
845
 
        wa = Weave()
846
 
        wb = Weave()
847
 
        wa.add('v1', [], ['hello\n'])
848
 
        wb.add('v0', [], [])
849
 
        wb.add('v1', ['v0'], ['hello\n'])
850
 
        self.assertRaises(WeaveError,
851
 
                          wa.join, wb)
852
 
 
853
 
    def test_join_text_disagreement(self):
854
 
        """Cannot join weaves with different texts for a version."""
855
 
        wa = Weave()
856
 
        wb = Weave()
857
 
        wa.add('v1', [], ['hello\n'])
858
 
        wb.add('v1', [], ['not\n', 'hello\n'])
859
 
        self.assertRaises(WeaveError,
860
 
                          wa.join, wb)
861
 
 
862
 
    def test_join_unordered(self):
863
 
        """Join weaves where indexes differ.
864
 
        
865
 
        The source weave contains a different version at index 0."""
866
 
        wa = self.weave1.copy()
867
 
        wb = Weave()
868
 
        wb.add('x1', [], ['line from x1\n'])
869
 
        wb.add('v1', [], ['hello\n'])
870
 
        wb.add('v2', ['v1'], ['hello\n', 'world\n'])
871
 
        wa.join(wb)
872
 
        eq = self.assertEquals
873
 
        eq(sorted(wa.iter_names()), ['v1', 'v2', 'v3', 'x1',])
874
 
        eq(wa.get_text('x1'), 'line from x1\n')
875
 
 
876
 
    def test_join_with_ghosts(self):
877
 
        """Join that inserts parents of an existing revision.
878
 
 
879
 
        This can happen when merging from another branch who
880
 
        knows about revisions the destination does not.  In 
881
 
        this test the second weave knows of an additional parent of 
882
 
        v2.  Any revisions which are in common still have to have the 
883
 
        same text."""
884
 
        return ###############################
885
 
        wa = self.weave1.copy()
886
 
        wb = Weave()
887
 
        wb.add('x1', [], ['line from x1\n'])
888
 
        wb.add('v1', [], ['hello\n'])
889
 
        wb.add('v2', ['v1', 'x1'], ['hello\n', 'world\n'])
890
 
        wa.join(wb)
891
 
        eq = self.assertEquals
892
 
        eq(sorted(wa.iter_names()), ['v1', 'v2', 'v3', 'x1',])
893
 
        eq(wa.get_text('x1'), 'line from x1\n')
 
677
def testweave():
 
678
    import testsweet
 
679
    from unittest import TestSuite, TestLoader
 
680
    import testweave
 
681
 
 
682
    tl = TestLoader()
 
683
    suite = TestSuite()
 
684
    suite.addTest(tl.loadTestsFromModule(testweave))
 
685
    
 
686
    return int(not testsweet.run_suite(suite)) # for shell 0=true
894
687
 
895
688
 
896
689
if __name__ == '__main__':
897
690
    import sys
898
 
    import unittest
899
 
    sys.exit(unittest.main())
 
691
    sys.exit(testweave())
900
692