← 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-18 13:12:43 UTC
  • Revision ID: mbp@sourcefrog.net-20050718131243-44532527fd065b31
- update convertinv to work with current weave code

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"""
62
60
            tf.seek(0)
63
61
            self.log('serialized weave:')
64
62
            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
63
            self.fail('read/write check failed')
74
64
        
75
65
        
84
74
    """Store and retrieve a simple text."""
85
75
    def runTest(self):
86
76
        k = Weave()
87
 
        idx = k.add('text0', [], TEXT_0)
 
77
        idx = k.add([], TEXT_0)
88
78
        self.assertEqual(k.get(idx), TEXT_0)
89
79
        self.assertEqual(idx, 0)
90
80
 
93
83
class AnnotateOne(TestBase):
94
84
    def runTest(self):
95
85
        k = Weave()
96
 
        k.add('text0', [], TEXT_0)
 
86
        k.add([], TEXT_0)
97
87
        self.assertEqual(k.annotate(0),
98
88
                         [(0, TEXT_0[0])])
99
89
 
102
92
    def runTest(self):
103
93
        k = Weave()
104
94
 
105
 
        idx = k.add('text0', [], TEXT_0)
 
95
        idx = k.add([], TEXT_0)
106
96
        self.assertEqual(idx, 0)
107
97
 
108
 
        idx = k.add('text1', [], TEXT_1)
 
98
        idx = k.add([], TEXT_1)
109
99
        self.assertEqual(idx, 1)
110
100
 
111
101
        self.assertEqual(k.get(0), TEXT_0)
122
112
 
123
113
        self.assertRaises(IndexError,
124
114
                          k.add,
125
 
                          'text0',
126
115
                          [69],
127
116
                          ['new text!'])
128
117
 
135
124
    def runTest(self):
136
125
        k = Weave()
137
126
 
138
 
        k.add('text0', [], ['line 1'])
139
 
        k.add('text1', [0], ['line 1', 'line 2'])
 
127
        k.add([], ['line 1'])
 
128
        k.add([0], ['line 1', 'line 2'])
140
129
 
141
130
        self.assertEqual(k.annotate(0),
142
131
                         [(0, 'line 1')])
149
138
                         [(0, 'line 1'),
150
139
                          (1, 'line 2')])
151
140
 
152
 
        k.add('text2', [0], ['line 1', 'diverged line'])
 
141
        k.add([0], ['line 1', 'diverged line'])
153
142
 
154
143
        self.assertEqual(k.annotate(2),
155
144
                         [(0, 'line 1'),
156
145
                          (2, 'diverged line')])
157
146
 
158
147
        text3 = ['line 1', 'middle line', 'line 2']
159
 
        k.add('text3',
160
 
              [0, 1],
 
148
        k.add([0, 1],
161
149
              text3)
162
150
 
163
151
        # self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))
164
152
 
165
 
        self.log("k._weave=" + pformat(k._weave))
 
153
        self.log("k._l=" + pformat(k._l))
166
154
 
167
155
        self.assertEqual(k.annotate(3),
168
156
                         [(0, 'line 1'),
170
158
                          (1, 'line 2')])
171
159
 
172
160
        # now multiple insertions at different places
173
 
        k.add('text4',
174
 
              [0, 1, 3],
 
161
        k.add([0, 1, 3],
175
162
              ['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])
176
163
 
177
164
        self.assertEqual(k.annotate(4), 
193
180
 
194
181
        base_text = ['one', 'two', 'three', 'four']
195
182
 
196
 
        k.add('text0', [], base_text)
 
183
        k.add([], base_text)
197
184
        
198
185
        texts = [['one', 'two', 'three'],
199
186
                 ['two', 'three', 'four'],
201
188
                 ['one', 'two', 'three', 'four'],
202
189
                 ]
203
190
 
204
 
        i = 1
205
191
        for t in texts:
206
 
            ver = k.add('text%d' % i,
207
 
                        [0], t)
208
 
            i += 1
 
192
            ver = k.add([0], t)
209
193
 
210
194
        self.log('final weave:')
211
 
        self.log('k._weave=' + pformat(k._weave))
 
195
        self.log('k._l=' + pformat(k._l))
212
196
 
213
197
        for i in range(len(texts)):
214
198
            self.assertEqual(k.get(i+1),
222
206
    def runTest(self):
223
207
        k = Weave()
224
208
 
225
 
        k._parents = [(),
 
209
        k._v = [(),
226
210
                ]
227
 
        k._weave = [('{', 0),
 
211
        k._l = [('{', 0),
228
212
                'first line',
229
213
                ('[', 0),
230
214
                'deleted in 0',
246
230
    def runTest(self):
247
231
        k = Weave()
248
232
 
249
 
        k._parents = [(),
 
233
        k._v = [(),
250
234
                frozenset([0]),
251
235
                ]
252
 
        k._weave = [('{', 0),
 
236
        k._l = [('{', 0),
253
237
                'first line',
254
238
                ('[', 1),
255
239
                'line to be deleted',
276
260
    def runTest(self):
277
261
        k = Weave()
278
262
 
279
 
        k._parents = [frozenset(),
 
263
        k._v = [frozenset(),
280
264
                frozenset([0]),
281
265
                ]
282
 
        k._weave = [('{', 0),
 
266
        k._l = [('{', 0),
283
267
                'first line',
284
268
                ('[', 1),
285
269
                'line to be deleted',
310
294
    def runTest(self):
311
295
        k = Weave()
312
296
 
313
 
        k._parents = [frozenset(),
 
297
        k._v = [frozenset(),
314
298
                ]
315
 
        k._weave = ['bad line',
 
299
        k._l = ['bad line',
316
300
                ('{', 0),
317
301
                'foo {',
318
302
                ('{', 1),
340
324
    def runTest(self):
341
325
        k = Weave()
342
326
 
343
 
        k._parents = [frozenset(),
 
327
        k._v = [frozenset(),
344
328
                frozenset([0]),
345
329
                frozenset([0]),
346
330
                frozenset([0,1,2]),
347
331
                ]
348
 
        k._weave = [('{', 0),
 
332
        k._l = [('{', 0),
349
333
                'foo {',
350
334
                ('{', 1),
351
335
                '  added in version 1',
373
357
    def runTest(self):
374
358
        k = Weave()
375
359
 
376
 
        k._parents = [frozenset(),
 
360
        k._v = [frozenset(),
377
361
                frozenset([0]),
378
362
                frozenset([0]),
379
363
                frozenset([0,1,2]),
380
364
                ]
381
 
        k._weave = [('{', 0),
 
365
        k._l = [('{', 0),
382
366
                'foo {',
383
367
                ('{', 1),
384
368
                '  added in version 1',
422
406
    def runTest(self):
423
407
        k = Weave()
424
408
 
425
 
        k.add('text0', [], ["line the first",
 
409
        k.add([], ["line the first",
426
410
                   "line 2",
427
411
                   "line 3",
428
412
                   "fine"])
429
413
 
430
414
        self.assertEqual(len(k.get(0)), 4)
431
415
 
432
 
        k.add('text1', [0], ["line the first",
 
416
        k.add([0], ["line the first",
433
417
                   "fine"])
434
418
 
435
419
        self.assertEqual(k.get(1),
455
439
    def runTest(self):
456
440
        k = Weave()
457
441
 
458
 
        k._parents = [frozenset(), frozenset([0])]
459
 
        k._weave = [('{', 0),
 
442
        k._v = [frozenset(), frozenset([0])]
 
443
        k._l = [('{', 0),
460
444
                "first line",
461
445
                ('}', 0),
462
446
                ('{', 1),
479
463
    def runTest(self):
480
464
        k = Weave()
481
465
 
482
 
        k._parents = [frozenset(),
 
466
        k._v = [frozenset(),
483
467
                frozenset([0]),
484
468
                frozenset([0]),
485
469
                ]
486
 
        k._weave = [('{', 0),
 
470
        k._l = [('{', 0),
487
471
                "first line",
488
472
                ('}', 0),
489
473
                ('{', 1),
517
501
        text0 = ['cheddar', 'stilton', 'gruyere']
518
502
        text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']
519
503
        
520
 
        k.add('text0', [], text0)
521
 
        k.add('text1', [0], text1)
 
504
        k.add([], text0)
 
505
        k.add([0], text1)
522
506
 
523
 
        self.log('k._weave=' + pformat(k._weave))
 
507
        self.log('k._l=' + pformat(k._l))
524
508
 
525
509
        self.assertEqual(k.get(0), text0)
526
510
        self.assertEqual(k.get(1), text1)
538
522
                 ['header', '', 'line from 1', 'fixup line', 'line from 2'],
539
523
                 ]
540
524
 
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])
 
525
        k.add([], texts[0])
 
526
        k.add([0], texts[1])
 
527
        k.add([0], texts[2])
 
528
        k.add([0, 1, 2], texts[3])
545
529
 
546
530
        for i, t in enumerate(texts):
547
531
            self.assertEqual(k.get(i), t)
557
541
        self.assertEqual(list(k.inclusions([3])),
558
542
                         [0, 1, 2, 3])
559
543
 
560
 
        self.log('k._weave=' + pformat(k._weave))
 
544
        self.log('k._l=' + pformat(k._l))
561
545
 
562
546
        self.check_read_write(k)
563
547
 
609
593
                 ['header', 'aaa', 'bbb', 'line from 2', 'more from 2'],
610
594
                 ]
611
595
 
612
 
        k.add('text0', [], texts[0])
613
 
        k.add('text1', [0], texts[1])
614
 
        k.add('text2', [0], texts[2])
 
596
        k.add([], texts[0])
 
597
        k.add([0], texts[1])
 
598
        k.add([0], texts[2])
615
599
 
616
 
        self.log('k._weave=' + pformat(k._weave))
 
600
        self.log('k._l=' + pformat(k._l))
617
601
 
618
602
        m = list(k.mash_iter([0, 1, 2]))
619
603
 
657
641
 
658
642
        k = Weave()
659
643
        parents = set()
660
 
        i = 0
661
644
        for t in texts:
662
 
            ver = k.add('text%d' % i,
663
 
                        list(parents), t)
 
645
            ver = k.add(list(parents), t)
664
646
            parents.add(ver)
665
 
            i += 1
666
647
 
667
 
        self.log("k._weave=" + pformat(k._weave))
 
648
        self.log("k._l=" + pformat(k._l))
668
649
 
669
650
        for i, t in enumerate(texts):
670
651
            self.assertEqual(k.get(i), t)
682
663
            return x + '\n'
683
664
        
684
665
        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))
 
666
        w.add([], map(addcrlf, base))
 
667
        w.add([0], map(addcrlf, a))
 
668
        w.add([0], map(addcrlf, b))
688
669
 
689
670
        self.log('weave is:')
690
671
        tmpf = StringIO()
751
732
                     ['aaa'],
752
733
                     ['yyy', 'zzz'],
753
734
                     ['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
735
    
772
736
 
773
737
 
775
739
    import testsweet
776
740
    from unittest import TestSuite, TestLoader
777
741
    import testweave
778
 
 
 
742
 
779
743
    tl = TestLoader()
780
744
    suite = TestSuite()
781
745
    suite.addTest(tl.loadTestsFromModule(testweave))