← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_weave.py

  • Committer: Robert Collins
  • Date: 2009-09-07 03:08:30 UTC
  • mto: This revision was merged to the branch mainline in revision 4690.
  • Revision ID: robertc@robertcollins.net-20090907030830-rf59kt28d550eauj
Milestones language tightning, internal consistency.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_weave.py
1
 
#! /usr/bin/python2.4
2
 
 
3
 
# Copyright (C) 2005 by Canonical Ltd
4
 
 
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
7
5
# the Free Software Foundation; either version 2 of the License, or
8
6
# (at your option) any later version.
9
 
 
 
7
#
10
8
# This program is distributed in the hope that it will be useful,
11
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
11
# GNU General Public License for more details.
14
 
 
 
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
 
20
18
# TODO: tests regarding version names
21
 
# TODO: rbc 20050108 test that join does not leave an inconsistent weave 
 
19
# TODO: rbc 20050108 test that join does not leave an inconsistent weave
22
20
#       if it fails.
23
21
 
24
22
"""test suite for weave algorithm"""
25
23
 
26
24
from pprint import pformat
27
25
 
28
 
import bzrlib.errors as errors
29
 
from bzrlib.weave import Weave, WeaveFormatError, WeaveError, reweave
 
26
from bzrlib import (
 
27
    errors,
 
28
    )
 
29
from bzrlib.osutils import sha_string
 
30
from bzrlib.tests import TestCase, TestCaseInTempDir
 
31
from bzrlib.weave import Weave, WeaveFormatError, WeaveError
30
32
from bzrlib.weavefile import write_weave, read_weave
31
 
from bzrlib.tests import TestCase
32
 
from bzrlib.osutils import sha_string
33
33
 
34
34
 
35
35
# texts for use in testing
39
39
 
40
40
 
41
41
class TestBase(TestCase):
 
42
 
42
43
    def check_read_write(self, k):
43
44
        """Check the weave k can be written & re-read."""
44
45
        from tempfile import TemporaryFile
64
65
class WeaveContains(TestBase):
65
66
    """Weave __contains__ operator"""
66
67
    def runTest(self):
67
 
        k = Weave()
 
68
        k = Weave(get_scope=lambda:None)
68
69
        self.assertFalse('foo' in k)
69
 
        k.add('foo', [], TEXT_1)
 
70
        k.add_lines('foo', [], TEXT_1)
70
71
        self.assertTrue('foo' in k)
71
72
 
72
73
 
75
76
        k = Weave()
76
77
 
77
78
 
78
 
class StoreText(TestBase):
79
 
    """Store and retrieve a simple text."""
80
 
    def runTest(self):
81
 
        k = Weave()
82
 
        idx = k.add('text0', [], TEXT_0)
83
 
        self.assertEqual(k.get(idx), TEXT_0)
84
 
        self.assertEqual(idx, 0)
85
 
 
86
 
 
87
79
class AnnotateOne(TestBase):
88
80
    def runTest(self):
89
81
        k = Weave()
90
 
        k.add('text0', [], TEXT_0)
91
 
        self.assertEqual(k.annotate(0),
92
 
                         [(0, TEXT_0[0])])
93
 
 
94
 
 
95
 
class StoreTwo(TestBase):
96
 
    def runTest(self):
97
 
        k = Weave()
98
 
 
99
 
        idx = k.add('text0', [], TEXT_0)
100
 
        self.assertEqual(idx, 0)
101
 
 
102
 
        idx = k.add('text1', [], TEXT_1)
103
 
        self.assertEqual(idx, 1)
104
 
 
105
 
        self.assertEqual(k.get(0), TEXT_0)
106
 
        self.assertEqual(k.get(1), TEXT_1)
107
 
 
108
 
 
109
 
class AddWithGivenSha(TestBase):
110
 
    def runTest(self):
111
 
        """Add with caller-supplied SHA-1"""
112
 
        k = Weave()
113
 
 
114
 
        t = 'text0'
115
 
        k.add('text0', [], [t], sha1=sha_string(t))
116
 
 
117
 
 
118
 
class GetSha1(TestBase):
119
 
    def test_get_sha1(self):
120
 
        k = Weave()
121
 
        k.add('text0', [], 'text0')
122
 
        self.assertEqual('34dc0e430c642a26c3dd1c2beb7a8b4f4445eb79',
123
 
                         k.get_sha1('text0'))
124
 
        self.assertRaises(errors.WeaveRevisionNotPresent,
125
 
                          k.get_sha1, 0)
126
 
        self.assertRaises(errors.WeaveRevisionNotPresent,
127
 
                          k.get_sha1, 'text1')
128
 
                        
 
82
        k.add_lines('text0', [], TEXT_0)
 
83
        self.assertEqual(k.annotate('text0'),
 
84
                         [('text0', TEXT_0[0])])
 
85
 
129
86
 
130
87
class InvalidAdd(TestBase):
131
88
    """Try to use invalid version number during add."""
132
89
    def runTest(self):
133
90
        k = Weave()
134
91
 
135
 
        self.assertRaises(IndexError,
136
 
                          k.add,
 
92
        self.assertRaises(errors.RevisionNotPresent,
 
93
                          k.add_lines,
137
94
                          'text0',
138
 
                          [69],
 
95
                          ['69'],
139
96
                          ['new text!'])
140
97
 
141
98
 
142
99
class RepeatedAdd(TestBase):
143
100
    """Add the same version twice; harmless."""
144
 
    def runTest(self):
 
101
 
 
102
    def test_duplicate_add(self):
145
103
        k = Weave()
146
 
        idx = k.add('text0', [], TEXT_0)
147
 
        idx2 = k.add('text0', [], TEXT_0)
 
104
        idx = k.add_lines('text0', [], TEXT_0)
 
105
        idx2 = k.add_lines('text0', [], TEXT_0)
148
106
        self.assertEqual(idx, idx2)
149
107
 
150
108
 
151
109
class InvalidRepeatedAdd(TestBase):
152
110
    def runTest(self):
153
111
        k = Weave()
154
 
        idx = k.add('text0', [], TEXT_0)
155
 
        self.assertRaises(WeaveError,
156
 
                          k.add,
 
112
        k.add_lines('basis', [], TEXT_0)
 
113
        idx = k.add_lines('text0', [], TEXT_0)
 
114
        self.assertRaises(errors.RevisionAlreadyPresent,
 
115
                          k.add_lines,
157
116
                          'text0',
158
117
                          [],
159
118
                          ['not the same text'])
160
 
        self.assertRaises(WeaveError,
161
 
                          k.add,
 
119
        self.assertRaises(errors.RevisionAlreadyPresent,
 
120
                          k.add_lines,
162
121
                          'text0',
163
 
                          [12],         # not the right parents
 
122
                          ['basis'],         # not the right parents
164
123
                          TEXT_0)
165
 
        
 
124
 
166
125
 
167
126
class InsertLines(TestBase):
168
127
    """Store a revision that adds one line to the original.
172
131
    def runTest(self):
173
132
        k = Weave()
174
133
 
175
 
        k.add('text0', [], ['line 1'])
176
 
        k.add('text1', [0], ['line 1', 'line 2'])
177
 
 
178
 
        self.assertEqual(k.annotate(0),
179
 
                         [(0, 'line 1')])
180
 
 
181
 
        self.assertEqual(k.get(1),
 
134
        k.add_lines('text0', [], ['line 1'])
 
135
        k.add_lines('text1', ['text0'], ['line 1', 'line 2'])
 
136
 
 
137
        self.assertEqual(k.annotate('text0'),
 
138
                         [('text0', 'line 1')])
 
139
 
 
140
        self.assertEqual(k.get_lines(1),
182
141
                         ['line 1',
183
142
                          'line 2'])
184
143
 
185
 
        self.assertEqual(k.annotate(1),
186
 
                         [(0, 'line 1'),
187
 
                          (1, 'line 2')])
188
 
 
189
 
        k.add('text2', [0], ['line 1', 'diverged line'])
190
 
 
191
 
        self.assertEqual(k.annotate(2),
192
 
                         [(0, 'line 1'),
193
 
                          (2, 'diverged line')])
 
144
        self.assertEqual(k.annotate('text1'),
 
145
                         [('text0', 'line 1'),
 
146
                          ('text1', 'line 2')])
 
147
 
 
148
        k.add_lines('text2', ['text0'], ['line 1', 'diverged line'])
 
149
 
 
150
        self.assertEqual(k.annotate('text2'),
 
151
                         [('text0', 'line 1'),
 
152
                          ('text2', 'diverged line')])
194
153
 
195
154
        text3 = ['line 1', 'middle line', 'line 2']
196
 
        k.add('text3',
197
 
              [0, 1],
 
155
        k.add_lines('text3',
 
156
              ['text0', 'text1'],
198
157
              text3)
199
158
 
200
159
        # self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))
201
160
 
202
161
        self.log("k._weave=" + pformat(k._weave))
203
162
 
204
 
        self.assertEqual(k.annotate(3),
205
 
                         [(0, 'line 1'),
206
 
                          (3, 'middle line'),
207
 
                          (1, 'line 2')])
 
163
        self.assertEqual(k.annotate('text3'),
 
164
                         [('text0', 'line 1'),
 
165
                          ('text3', 'middle line'),
 
166
                          ('text1', 'line 2')])
208
167
 
209
168
        # now multiple insertions at different places
210
 
        k.add('text4',
211
 
              [0, 1, 3],
 
169
        k.add_lines('text4',
 
170
              ['text0', 'text1', 'text3'],
212
171
              ['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])
213
172
 
214
 
        self.assertEqual(k.annotate(4), 
215
 
                         [(0, 'line 1'),
216
 
                          (4, 'aaa'),
217
 
                          (3, 'middle line'),
218
 
                          (4, 'bbb'),
219
 
                          (1, 'line 2'),
220
 
                          (4, 'ccc')])
 
173
        self.assertEqual(k.annotate('text4'),
 
174
                         [('text0', 'line 1'),
 
175
                          ('text4', 'aaa'),
 
176
                          ('text3', 'middle line'),
 
177
                          ('text4', 'bbb'),
 
178
                          ('text1', 'line 2'),
 
179
                          ('text4', 'ccc')])
221
180
 
222
181
 
223
182
class DeleteLines(TestBase):
229
188
 
230
189
        base_text = ['one', 'two', 'three', 'four']
231
190
 
232
 
        k.add('text0', [], base_text)
233
 
        
 
191
        k.add_lines('text0', [], base_text)
 
192
 
234
193
        texts = [['one', 'two', 'three'],
235
194
                 ['two', 'three', 'four'],
236
195
                 ['one', 'four'],
239
198
 
240
199
        i = 1
241
200
        for t in texts:
242
 
            ver = k.add('text%d' % i,
243
 
                        [0], t)
 
201
            ver = k.add_lines('text%d' % i,
 
202
                        ['text0'], t)
244
203
            i += 1
245
204
 
246
205
        self.log('final weave:')
247
206
        self.log('k._weave=' + pformat(k._weave))
248
207
 
249
208
        for i in range(len(texts)):
250
 
            self.assertEqual(k.get(i+1),
 
209
            self.assertEqual(k.get_lines(i+1),
251
210
                             texts[i])
252
211
 
253
212
 
267
226
                ]
268
227
        ################################### SKIPPED
269
228
        # Weave.get doesn't trap this anymore
270
 
        return 
 
229
        return
271
230
 
272
231
        self.assertRaises(WeaveFormatError,
273
 
                          k.get,
274
 
                          0)        
 
232
                          k.get_lines,
 
233
                          0)
275
234
 
276
235
 
277
236
class CannedDelete(TestBase):
293
252
        k._sha1s = [sha_string('first lineline to be deletedlast line')
294
253
                  , sha_string('first linelast line')]
295
254
 
296
 
        self.assertEqual(k.get(0),
 
255
        self.assertEqual(k.get_lines(0),
297
256
                         ['first line',
298
257
                          'line to be deleted',
299
258
                          'last line',
300
259
                          ])
301
260
 
302
 
        self.assertEqual(k.get(1),
 
261
        self.assertEqual(k.get_lines(1),
303
262
                         ['first line',
304
263
                          'last line',
305
264
                          ])
319
278
                'line to be deleted',
320
279
                (']', 1),
321
280
                ('{', 1),
322
 
                'replacement line',                
 
281
                'replacement line',
323
282
                ('}', 1),
324
283
                'last line',
325
284
                ('}', 0),
327
286
        k._sha1s = [sha_string('first lineline to be deletedlast line')
328
287
                  , sha_string('first linereplacement linelast line')]
329
288
 
330
 
        self.assertEqual(k.get(0),
 
289
        self.assertEqual(k.get_lines(0),
331
290
                         ['first line',
332
291
                          'line to be deleted',
333
292
                          'last line',
334
293
                          ])
335
294
 
336
 
        self.assertEqual(k.get(1),
 
295
        self.assertEqual(k.get_lines(1),
337
296
                         ['first line',
338
297
                          'replacement line',
339
298
                          'last line',
362
321
 
363
322
        ################################### SKIPPED
364
323
        # Weave.get doesn't trap this anymore
365
 
        return 
 
324
        return
366
325
 
367
326
 
368
327
        self.assertRaises(WeaveFormatError,
431
390
                  , sha_string('foo {  added in version 1  added in v2  also from v1}')
432
391
                  ]
433
392
 
434
 
        self.assertEqual(k.get(0),
435
 
                         ['foo {',
436
 
                          '}'])
437
 
 
438
 
        self.assertEqual(k.get(1),
439
 
                         ['foo {',
440
 
                          '  added in version 1',
441
 
                          '  also from v1',
442
 
                          '}'])
443
 
                       
444
 
        self.assertEqual(k.get(2),
445
 
                         ['foo {',
446
 
                          '  added in v2',
447
 
                          '}'])
448
 
 
449
 
        self.assertEqual(k.get(3),
450
 
                         ['foo {',
451
 
                          '  added in version 1',
452
 
                          '  added in v2',
453
 
                          '  also from v1',
454
 
                          '}'])
455
 
                         
 
393
        self.assertEqual(k.get_lines(0),
 
394
                         ['foo {',
 
395
                          '}'])
 
396
 
 
397
        self.assertEqual(k.get_lines(1),
 
398
                         ['foo {',
 
399
                          '  added in version 1',
 
400
                          '  also from v1',
 
401
                          '}'])
 
402
 
 
403
        self.assertEqual(k.get_lines(2),
 
404
                         ['foo {',
 
405
                          '  added in v2',
 
406
                          '}'])
 
407
 
 
408
        self.assertEqual(k.get_lines(3),
 
409
                         ['foo {',
 
410
                          '  added in version 1',
 
411
                          '  added in v2',
 
412
                          '  also from v1',
 
413
                          '}'])
 
414
 
456
415
 
457
416
class DeleteLines2(TestBase):
458
417
    """Test recording revisions that delete lines.
462
421
    def runTest(self):
463
422
        k = Weave()
464
423
 
465
 
        k.add('text0', [], ["line the first",
 
424
        k.add_lines('text0', [], ["line the first",
466
425
                   "line 2",
467
426
                   "line 3",
468
427
                   "fine"])
469
428
 
470
 
        self.assertEqual(len(k.get(0)), 4)
 
429
        self.assertEqual(len(k.get_lines(0)), 4)
471
430
 
472
 
        k.add('text1', [0], ["line the first",
 
431
        k.add_lines('text1', ['text0'], ["line the first",
473
432
                   "fine"])
474
433
 
475
 
        self.assertEqual(k.get(1),
 
434
        self.assertEqual(k.get_lines(1),
476
435
                         ["line the first",
477
436
                          "fine"])
478
437
 
479
 
        self.assertEqual(k.annotate(1),
480
 
                         [(0, "line the first"),
481
 
                          (0, "fine")])
 
438
        self.assertEqual(k.annotate('text1'),
 
439
                         [('text0', "line the first"),
 
440
                          ('text0', "fine")])
482
441
 
483
442
 
484
443
class IncludeVersions(TestBase):
505
464
        k._sha1s = [sha_string('first line')
506
465
                  , sha_string('first linesecond line')]
507
466
 
508
 
        self.assertEqual(k.get(1),
 
467
        self.assertEqual(k.get_lines(1),
509
468
                         ["first line",
510
469
                          "second line"])
511
470
 
512
 
        self.assertEqual(k.get(0),
 
471
        self.assertEqual(k.get_lines(0),
513
472
                         ["first line"])
514
473
 
515
474
 
517
476
    """Weave with two diverged texts based on version 0.
518
477
    """
519
478
    def runTest(self):
 
479
        # FIXME make the weave, dont poke at it.
520
480
        k = Weave()
521
481
 
 
482
        k._names = ['0', '1', '2']
 
483
        k._name_map = {'0':0, '1':1, '2':2}
522
484
        k._parents = [frozenset(),
523
485
                frozenset([0]),
524
486
                frozenset([0]),
531
493
                ('}', 1),
532
494
                ('{', 2),
533
495
                "alternative second line",
534
 
                ('}', 2),                
 
496
                ('}', 2),
535
497
                ]
536
498
 
537
499
        k._sha1s = [sha_string('first line')
538
500
                  , sha_string('first linesecond line')
539
501
                  , sha_string('first linealternative second line')]
540
502
 
541
 
        self.assertEqual(k.get(0),
 
503
        self.assertEqual(k.get_lines(0),
542
504
                         ["first line"])
543
505
 
544
 
        self.assertEqual(k.get(1),
 
506
        self.assertEqual(k.get_lines(1),
545
507
                         ["first line",
546
508
                          "second line"])
547
509
 
548
 
        self.assertEqual(k.get(2),
 
510
        self.assertEqual(k.get_lines('2'),
549
511
                         ["first line",
550
512
                          "alternative second line"])
551
513
 
552
 
        self.assertEqual(list(k.inclusions([2])),
553
 
                         [0, 2])
 
514
        self.assertEqual(list(k.get_ancestry(['2'])),
 
515
                         ['0', '2'])
554
516
 
555
517
 
556
518
class ReplaceLine(TestBase):
559
521
 
560
522
        text0 = ['cheddar', 'stilton', 'gruyere']
561
523
        text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']
562
 
        
563
 
        k.add('text0', [], text0)
564
 
        k.add('text1', [0], text1)
 
524
 
 
525
        k.add_lines('text0', [], text0)
 
526
        k.add_lines('text1', ['text0'], text1)
565
527
 
566
528
        self.log('k._weave=' + pformat(k._weave))
567
529
 
568
 
        self.assertEqual(k.get(0), text0)
569
 
        self.assertEqual(k.get(1), text1)
 
530
        self.assertEqual(k.get_lines(0), text0)
 
531
        self.assertEqual(k.get_lines(1), text1)
570
532
 
571
533
 
572
534
class Merge(TestBase):
580
542
                 ['header', '', 'line from 1', 'fixup line', 'line from 2'],
581
543
                 ]
582
544
 
583
 
        k.add('text0', [], texts[0])
584
 
        k.add('text1', [0], texts[1])
585
 
        k.add('text2', [0], texts[2])
586
 
        k.add('merge', [0, 1, 2], texts[3])
 
545
        k.add_lines('text0', [], texts[0])
 
546
        k.add_lines('text1', ['text0'], texts[1])
 
547
        k.add_lines('text2', ['text0'], texts[2])
 
548
        k.add_lines('merge', ['text0', 'text1', 'text2'], texts[3])
587
549
 
588
550
        for i, t in enumerate(texts):
589
 
            self.assertEqual(k.get(i), t)
 
551
            self.assertEqual(k.get_lines(i), t)
590
552
 
591
 
        self.assertEqual(k.annotate(3),
592
 
                         [(0, 'header'),
593
 
                          (1, ''),
594
 
                          (1, 'line from 1'),
595
 
                          (3, 'fixup line'),
596
 
                          (2, 'line from 2'),
 
553
        self.assertEqual(k.annotate('merge'),
 
554
                         [('text0', 'header'),
 
555
                          ('text1', ''),
 
556
                          ('text1', 'line from 1'),
 
557
                          ('merge', 'fixup line'),
 
558
                          ('text2', 'line from 2'),
597
559
                          ])
598
560
 
599
 
        self.assertEqual(list(k.inclusions([3])),
600
 
                         [0, 1, 2, 3])
 
561
        self.assertEqual(list(k.get_ancestry(['merge'])),
 
562
                         ['text0', 'text1', 'text2', 'merge'])
601
563
 
602
564
        self.log('k._weave=' + pformat(k._weave))
603
565
 
614
576
        return  # NOT RUN
615
577
        k = Weave()
616
578
 
617
 
        k.add([], ['aaa', 'bbb'])
618
 
        k.add([0], ['aaa', '111', 'bbb'])
619
 
        k.add([1], ['aaa', '222', 'bbb'])
 
579
        k.add_lines([], ['aaa', 'bbb'])
 
580
        k.add_lines([0], ['aaa', '111', 'bbb'])
 
581
        k.add_lines([1], ['aaa', '222', 'bbb'])
620
582
 
621
583
        merged = k.merge([1, 2])
622
584
 
633
595
        return  # NOT RUN
634
596
        k = Weave()
635
597
 
636
 
        k.add([], ['aaa', 'bbb'])
637
 
        k.add([0], ['111', 'aaa', 'ccc', 'bbb'])
638
 
        k.add([1], ['aaa', 'ccc', 'bbb', '222'])
639
 
 
640
 
 
641
 
class AutoMerge(TestBase):
642
 
    def runTest(self):
643
 
        k = Weave()
644
 
 
645
 
        texts = [['header', 'aaa', 'bbb'],
646
 
                 ['header', 'aaa', 'line from 1', 'bbb'],
647
 
                 ['header', 'aaa', 'bbb', 'line from 2', 'more from 2'],
648
 
                 ]
649
 
 
650
 
        k.add('text0', [], texts[0])
651
 
        k.add('text1', [0], texts[1])
652
 
        k.add('text2', [0], texts[2])
653
 
 
654
 
        self.log('k._weave=' + pformat(k._weave))
655
 
 
656
 
        m = list(k.mash_iter([0, 1, 2]))
657
 
 
658
 
        self.assertEqual(m,
659
 
                         ['header', 'aaa',
660
 
                          'line from 1',
661
 
                          'bbb',
662
 
                          'line from 2', 'more from 2'])
 
598
        k.add_lines([], ['aaa', 'bbb'])
 
599
        k.add_lines([0], ['111', 'aaa', 'ccc', 'bbb'])
 
600
        k.add_lines([1], ['aaa', 'ccc', 'bbb', '222'])
663
601
 
664
602
 
665
603
class Khayyam(TestBase):
666
604
    """Test changes to multi-line texts, and read/write"""
667
 
    def runTest(self):
 
605
 
 
606
    def test_multi_line_merge(self):
668
607
        rawtexts = [
669
608
            """A Book of Verses underneath the Bough,
670
609
            A Jug of Wine, a Loaf of Bread, -- and Thou
671
610
            Beside me singing in the Wilderness --
672
611
            Oh, Wilderness were Paradise enow!""",
673
 
            
 
612
 
674
613
            """A Book of Verses underneath the Bough,
675
614
            A Jug of Wine, a Loaf of Bread, -- and Thou
676
615
            Beside me singing in the Wilderness --
696
635
        parents = set()
697
636
        i = 0
698
637
        for t in texts:
699
 
            ver = k.add('text%d' % i,
 
638
            ver = k.add_lines('text%d' % i,
700
639
                        list(parents), t)
701
 
            parents.add(ver)
 
640
            parents.add('text%d' % i)
702
641
            i += 1
703
642
 
704
643
        self.log("k._weave=" + pformat(k._weave))
705
644
 
706
645
        for i, t in enumerate(texts):
707
 
            self.assertEqual(k.get(i), t)
 
646
            self.assertEqual(k.get_lines(i), t)
708
647
 
709
648
        self.check_read_write(k)
710
649
 
711
650
 
712
 
class MergeCases(TestBase):
713
 
    def doMerge(self, base, a, b, mp):
714
 
        from cStringIO import StringIO
715
 
        from textwrap import dedent
716
 
 
717
 
        def addcrlf(x):
718
 
            return x + '\n'
719
 
        
720
 
        w = Weave()
721
 
        w.add('text0', [], map(addcrlf, base))
722
 
        w.add('text1', [0], map(addcrlf, a))
723
 
        w.add('text2', [0], map(addcrlf, b))
724
 
 
725
 
        self.log('weave is:')
726
 
        tmpf = StringIO()
727
 
        write_weave(w, tmpf)
728
 
        self.log(tmpf.getvalue())
729
 
 
730
 
        self.log('merge plan:')
731
 
        p = list(w.plan_merge(1, 2))
732
 
        for state, line in p:
733
 
            if line:
734
 
                self.log('%12s | %s' % (state, line[:-1]))
735
 
 
736
 
        self.log('merge:')
737
 
        mt = StringIO()
738
 
        mt.writelines(w.weave_merge(p))
739
 
        mt.seek(0)
740
 
        self.log(mt.getvalue())
741
 
 
742
 
        mp = map(addcrlf, mp)
743
 
        self.assertEqual(mt.readlines(), mp)
744
 
        
745
 
        
746
 
    def testOneInsert(self):
747
 
        self.doMerge([],
748
 
                     ['aa'],
749
 
                     [],
750
 
                     ['aa'])
751
 
 
752
 
    def testSeparateInserts(self):
753
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
754
 
                     ['aaa', 'xxx', 'bbb', 'ccc'],
755
 
                     ['aaa', 'bbb', 'yyy', 'ccc'],
756
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
757
 
 
758
 
    def testSameInsert(self):
759
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
760
 
                     ['aaa', 'xxx', 'bbb', 'ccc'],
761
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'],
762
 
                     ['aaa', 'xxx', 'bbb', 'yyy', 'ccc'])
763
 
 
764
 
    def testOverlappedInsert(self):
765
 
        self.doMerge(['aaa', 'bbb'],
766
 
                     ['aaa', 'xxx', 'yyy', 'bbb'],
767
 
                     ['aaa', 'xxx', 'bbb'],
768
 
                     ['aaa', '<<<<<<< ', 'xxx', 'yyy', '=======', 'xxx', 
769
 
                      '>>>>>>> ', 'bbb'])
770
 
 
771
 
        # really it ought to reduce this to 
772
 
        # ['aaa', 'xxx', 'yyy', 'bbb']
773
 
 
774
 
 
775
 
    def testClashReplace(self):
776
 
        self.doMerge(['aaa'],
777
 
                     ['xxx'],
778
 
                     ['yyy', 'zzz'],
779
 
                     ['<<<<<<< ', 'xxx', '=======', 'yyy', 'zzz', 
780
 
                      '>>>>>>> '])
781
 
 
782
 
    def testNonClashInsert(self):
783
 
        self.doMerge(['aaa'],
784
 
                     ['xxx', 'aaa'],
785
 
                     ['yyy', 'zzz'],
786
 
                     ['<<<<<<< ', 'xxx', 'aaa', '=======', 'yyy', 'zzz', 
787
 
                      '>>>>>>> '])
788
 
 
789
 
        self.doMerge(['aaa'],
790
 
                     ['aaa'],
791
 
                     ['yyy', 'zzz'],
792
 
                     ['yyy', 'zzz'])
793
 
 
794
 
 
795
 
    def testDeleteAndModify(self):
796
 
        """Clashing delete and modification.
797
 
 
798
 
        If one side modifies a region and the other deletes it then
799
 
        there should be a conflict with one side blank.
800
 
        """
801
 
 
802
 
        #######################################
803
 
        # skippd, not working yet
804
 
        return
805
 
        
806
 
        self.doMerge(['aaa', 'bbb', 'ccc'],
807
 
                     ['aaa', 'ddd', 'ccc'],
808
 
                     ['aaa', 'ccc'],
809
 
                     ['<<<<<<<< ', 'aaa', '=======', '>>>>>>> ', 'ccc'])
810
 
 
811
 
 
812
651
class JoinWeavesTests(TestBase):
813
652
    def setUp(self):
814
653
        super(JoinWeavesTests, self).setUp()
815
654
        self.weave1 = Weave()
816
655
        self.lines1 = ['hello\n']
817
656
        self.lines3 = ['hello\n', 'cruel\n', 'world\n']
818
 
        self.weave1.add('v1', [], self.lines1)
819
 
        self.weave1.add('v2', [0], ['hello\n', 'world\n'])
820
 
        self.weave1.add('v3', [1], self.lines3)
821
 
        
822
 
    def test_join_empty(self):
823
 
        """Join two empty weaves."""
824
 
        eq = self.assertEqual
825
 
        w1 = Weave()
826
 
        w2 = Weave()
827
 
        w1.join(w2)
828
 
        eq(w1.numversions(), 0)
829
 
        
830
 
    def test_join_empty_to_nonempty(self):
831
 
        """Join empty weave onto nonempty."""
832
 
        self.weave1.join(Weave())
833
 
        self.assertEqual(len(self.weave1), 3)
834
 
 
835
 
    def test_join_unrelated(self):
836
 
        """Join two weaves with no history in common."""
837
 
        wb = Weave()
838
 
        wb.add('b1', [], ['line from b\n'])
839
 
        w1 = self.weave1
840
 
        w1.join(wb)
841
 
        eq = self.assertEqual
842
 
        eq(len(w1), 4)
843
 
        eq(sorted(list(w1.iter_names())),
844
 
           ['b1', 'v1', 'v2', 'v3'])
845
 
 
846
 
    def test_join_related(self):
847
 
        wa = self.weave1.copy()
848
 
        wb = self.weave1.copy()
849
 
        wa.add('a1', ['v3'], ['hello\n', 'sweet\n', 'world\n'])
850
 
        wb.add('b1', ['v3'], ['hello\n', 'pale blue\n', 'world\n'])
851
 
        eq = self.assertEquals
852
 
        eq(len(wa), 4)
853
 
        eq(len(wb), 4)
854
 
        wa.join(wb)
855
 
        eq(len(wa), 5)
856
 
        eq(wa.get_lines('b1'),
857
 
           ['hello\n', 'pale blue\n', 'world\n'])
858
 
 
859
 
    def test_join_parent_disagreement(self):
860
 
        """Cannot join weaves with different parents for a version."""
861
 
        wa = Weave()
862
 
        wb = Weave()
863
 
        wa.add('v1', [], ['hello\n'])
864
 
        wb.add('v0', [], [])
865
 
        wb.add('v1', ['v0'], ['hello\n'])
866
 
        self.assertRaises(WeaveError,
867
 
                          wa.join, wb)
868
 
 
869
 
    def test_join_text_disagreement(self):
870
 
        """Cannot join weaves with different texts for a version."""
871
 
        wa = Weave()
872
 
        wb = Weave()
873
 
        wa.add('v1', [], ['hello\n'])
874
 
        wb.add('v1', [], ['not\n', 'hello\n'])
875
 
        self.assertRaises(WeaveError,
876
 
                          wa.join, wb)
877
 
 
878
 
    def test_join_unordered(self):
879
 
        """Join weaves where indexes differ.
880
 
        
881
 
        The source weave contains a different version at index 0."""
882
 
        wa = self.weave1.copy()
883
 
        wb = Weave()
884
 
        wb.add('x1', [], ['line from x1\n'])
885
 
        wb.add('v1', [], ['hello\n'])
886
 
        wb.add('v2', ['v1'], ['hello\n', 'world\n'])
887
 
        wa.join(wb)
888
 
        eq = self.assertEquals
889
 
        eq(sorted(wa.iter_names()), ['v1', 'v2', 'v3', 'x1',])
890
 
        eq(wa.get_text('x1'), 'line from x1\n')
891
 
 
892
 
 
893
 
class Corruption(TestCase):
894
 
 
895
 
    def test_detection(self):
896
 
        # Test weaves detect corruption.
897
 
        #
898
 
        # Weaves contain a checksum of their texts.
899
 
        # When a text is extracted, this checksum should be
900
 
        # verified.
901
 
 
902
 
        w = Weave()
903
 
        w.add('v1', [], ['hello\n'])
904
 
        w.add('v2', ['v1'], ['hello\n', 'there\n'])
905
 
 
906
 
        # We are going to invasively corrupt the text
907
 
        # Make sure the internals of weave are the same
908
 
        self.assertEqual([('{', 0)
909
 
                        , 'hello\n'
910
 
                        , ('}', None)
911
 
                        , ('{', 1)
912
 
                        , 'there\n'
913
 
                        , ('}', None)
914
 
                        ], w._weave)
915
 
 
916
 
        self.assertEqual(['f572d396fae9206628714fb2ce00f72e94f2258f'
917
 
                        , '90f265c6e75f1c8f9ab76dcf85528352c5f215ef'
918
 
                        ], w._sha1s)
919
 
        w.check()
920
 
 
921
 
        # Corrupted
922
 
        w._weave[4] = 'There\n'
923
 
 
924
 
        self.assertEqual('hello\n', w.get_text('v1'))
925
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
926
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
927
 
        self.assertRaises(errors.WeaveInvalidChecksum, list, w.get_iter('v2'))
928
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.check)
929
 
 
930
 
        # Corrected
931
 
        w._weave[4] = 'there\n'
932
 
        self.assertEqual('hello\nthere\n', w.get_text('v2'))
933
 
 
934
 
        #Invalid checksum, first digit changed
935
 
        w._sha1s[1] =  'f0f265c6e75f1c8f9ab76dcf85528352c5f215ef'
936
 
 
937
 
        self.assertEqual('hello\n', w.get_text('v1'))
938
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
939
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
940
 
        self.assertRaises(errors.WeaveInvalidChecksum, list, w.get_iter('v2'))
941
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.check)
 
657
        self.weave1.add_lines('v1', [], self.lines1)
 
658
        self.weave1.add_lines('v2', ['v1'], ['hello\n', 'world\n'])
 
659
        self.weave1.add_lines('v3', ['v2'], self.lines3)
942
660
 
943
661
    def test_written_detection(self):
944
662
        # Test detection of weave file corruption.
949
667
        from cStringIO import StringIO
950
668
 
951
669
        w = Weave()
952
 
        w.add('v1', [], ['hello\n'])
953
 
        w.add('v2', ['v1'], ['hello\n', 'there\n'])
 
670
        w.add_lines('v1', [], ['hello\n'])
 
671
        w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
954
672
 
955
673
        tmpf = StringIO()
956
674
        write_weave(w, tmpf)
973
691
        self.assertEqual('hello\n', w.get_text('v1'))
974
692
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
975
693
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
976
 
        self.assertRaises(errors.WeaveInvalidChecksum, list, w.get_iter('v2'))
977
694
        self.assertRaises(errors.WeaveInvalidChecksum, w.check)
978
695
 
979
696
        # Change the sha checksum
987
704
        self.assertEqual('hello\n', w.get_text('v1'))
988
705
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
989
706
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
990
 
        self.assertRaises(errors.WeaveInvalidChecksum, list, w.get_iter('v2'))
991
707
        self.assertRaises(errors.WeaveInvalidChecksum, w.check)
992
708
 
993
709
 
 
710
class TestWeave(TestCase):
 
711
 
 
712
    def test_allow_reserved_false(self):
 
713
        w = Weave('name', allow_reserved=False)
 
714
        # Add lines is checked at the WeaveFile level, not at the Weave level
 
715
        w.add_lines('name:', [], TEXT_1)
 
716
        # But get_lines is checked at this level
 
717
        self.assertRaises(errors.ReservedId, w.get_lines, 'name:')
 
718
 
 
719
    def test_allow_reserved_true(self):
 
720
        w = Weave('name', allow_reserved=True)
 
721
        w.add_lines('name:', [], TEXT_1)
 
722
        self.assertEqual(TEXT_1, w.get_lines('name:'))
 
723
 
 
724
 
994
725
class InstrumentedWeave(Weave):
995
726
    """Keep track of how many times functions are called."""
996
 
    
 
727
 
997
728
    def __init__(self, weave_name=None):
998
729
        self._extract_count = 0
999
730
        Weave.__init__(self, weave_name=weave_name)
1003
734
        return Weave._extract(self, versions)
1004
735
 
1005
736
 
1006
 
class JoinOptimization(TestCase):
1007
 
    """Test that Weave.join() doesn't extract all texts, only what must be done."""
1008
 
 
1009
 
    def test_join(self):
1010
 
        w1 = InstrumentedWeave()
1011
 
        w2 = InstrumentedWeave()
1012
 
 
1013
 
        txt0 = ['a\n']
1014
 
        txt1 = ['a\n', 'b\n']
1015
 
        txt2 = ['a\n', 'c\n']
1016
 
        txt3 = ['a\n', 'b\n', 'c\n']
1017
 
 
1018
 
        w1.add('txt0', [], txt0) # extract 1a
1019
 
        w2.add('txt0', [], txt0) # extract 1b
1020
 
        w1.add('txt1', [0], txt1)# extract 2a
1021
 
        w2.add('txt2', [0], txt2)# extract 2b
1022
 
        w1.join(w2) # extract 3a to add txt2 
1023
 
        w2.join(w1) # extract 3b to add txt1 
1024
 
 
1025
 
        w1.add('txt3', [1, 2], txt3) # extract 4a 
1026
 
        w2.add('txt3', [1, 2], txt3) # extract 4b
1027
 
        # These secretly have inverted parents
1028
 
 
1029
 
        # This should not have to do any extractions
1030
 
        w1.join(w2) # NO extract, texts already present with same parents
1031
 
        w2.join(w1) # NO extract, texts already present with same parents
1032
 
 
1033
 
        self.assertEqual(4, w1._extract_count)
1034
 
        self.assertEqual(4, w2._extract_count)
1035
 
 
1036
 
    def test_double_parent(self):
1037
 
        # It should not be considered illegal to add
1038
 
        # a revision with the same parent twice
1039
 
        w1 = InstrumentedWeave()
1040
 
        w2 = InstrumentedWeave()
1041
 
 
1042
 
        txt0 = ['a\n']
1043
 
        txt1 = ['a\n', 'b\n']
1044
 
        txt2 = ['a\n', 'c\n']
1045
 
        txt3 = ['a\n', 'b\n', 'c\n']
1046
 
 
1047
 
        w1.add('txt0', [], txt0)
1048
 
        w2.add('txt0', [], txt0)
1049
 
        w1.add('txt1', [0], txt1)
1050
 
        w2.add('txt1', [0,0], txt1)
1051
 
        # Same text, effectively the same, because the
1052
 
        # parent is only repeated
1053
 
        w1.join(w2) # extract 3a to add txt2 
1054
 
        w2.join(w1) # extract 3b to add txt1 
1055
 
 
1056
 
 
1057
 
class MismatchedTexts(TestCase):
1058
 
    """Test that merging two weaves with different texts fails."""
1059
 
 
1060
 
    def test_reweave(self):
 
737
class TestNeedsReweave(TestCase):
 
738
    """Internal corner cases for when reweave is needed."""
 
739
 
 
740
    def test_compatible_parents(self):
1061
741
        w1 = Weave('a')
1062
 
        w2 = Weave('b')
1063
 
 
1064
 
        w1.add('txt0', [], ['a\n'])
1065
 
        w2.add('txt0', [], ['a\n'])
1066
 
        w1.add('txt1', [0], ['a\n', 'b\n'])
1067
 
        w2.add('txt1', [0], ['a\n', 'c\n'])
1068
 
 
1069
 
        self.assertRaises(errors.WeaveTextDiffers, w1.reweave, w2)
1070
 
 
1071
 
 
 
742
        my_parents = set([1, 2, 3])
 
743
        # subsets are ok
 
744
        self.assertTrue(w1._compatible_parents(my_parents, set([3])))
 
745
        # same sets
 
746
        self.assertTrue(w1._compatible_parents(my_parents, set(my_parents)))
 
747
        # same empty corner case
 
748
        self.assertTrue(w1._compatible_parents(set(), set()))
 
749
        # other cannot contain stuff my_parents does not
 
750
        self.assertFalse(w1._compatible_parents(set(), set([1])))
 
751
        self.assertFalse(w1._compatible_parents(my_parents, set([1, 2, 3, 4])))
 
752
        self.assertFalse(w1._compatible_parents(my_parents, set([4])))
 
753
 
 
754
 
 
755
class TestWeaveFile(TestCaseInTempDir):
 
756
 
 
757
    def test_empty_file(self):
 
758
        f = open('empty.weave', 'wb+')
 
759
        try:
 
760
            self.assertRaises(errors.WeaveFormatError,
 
761
                              read_weave, f)
 
762
        finally:
 
763
            f.close()