/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_weave.py

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_weave.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005-2011, 2016 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
23
23
 
24
24
from pprint import pformat
25
25
 
26
 
from bzrlib import (
 
26
from .. import (
27
27
    errors,
28
28
    )
29
 
from bzrlib.osutils import sha_string
30
 
from bzrlib.tests import TestCase, TestCaseInTempDir
31
 
from bzrlib.weave import Weave, WeaveFormatError, WeaveError
32
 
from bzrlib.weavefile import write_weave, read_weave
 
29
from ..osutils import sha_string
 
30
from ..sixish import (
 
31
    BytesIO,
 
32
    )
 
33
from . import TestCase, TestCaseInTempDir
 
34
from ..bzr.weave import Weave, WeaveFormatError, WeaveInvalidChecksum
 
35
from ..bzr.weavefile import write_weave, read_weave
33
36
 
34
37
 
35
38
# texts for use in testing
36
 
TEXT_0 = ["Hello world"]
37
 
TEXT_1 = ["Hello world",
38
 
          "A second line"]
 
39
TEXT_0 = [b"Hello world"]
 
40
TEXT_1 = [b"Hello world",
 
41
          b"A second line"]
39
42
 
40
43
 
41
44
class TestBase(TestCase):
64
67
 
65
68
class WeaveContains(TestBase):
66
69
    """Weave __contains__ operator"""
 
70
 
67
71
    def runTest(self):
68
72
        k = Weave(get_scope=lambda:None)
69
 
        self.assertFalse('foo' in k)
70
 
        k.add_lines('foo', [], TEXT_1)
71
 
        self.assertTrue('foo' in k)
 
73
        self.assertFalse(b'foo' in k)
 
74
        k.add_lines(b'foo', [], TEXT_1)
 
75
        self.assertTrue(b'foo' in k)
72
76
 
73
77
 
74
78
class Easy(TestBase):
 
79
 
75
80
    def runTest(self):
76
81
        k = Weave()
77
82
 
78
83
 
79
84
class AnnotateOne(TestBase):
 
85
 
80
86
    def runTest(self):
81
87
        k = Weave()
82
 
        k.add_lines('text0', [], TEXT_0)
83
 
        self.assertEqual(k.annotate('text0'),
84
 
                         [('text0', TEXT_0[0])])
 
88
        k.add_lines(b'text0', [], TEXT_0)
 
89
        self.assertEqual(k.annotate(b'text0'),
 
90
                         [(b'text0', TEXT_0[0])])
85
91
 
86
92
 
87
93
class InvalidAdd(TestBase):
88
94
    """Try to use invalid version number during add."""
 
95
 
89
96
    def runTest(self):
90
97
        k = Weave()
91
98
 
92
99
        self.assertRaises(errors.RevisionNotPresent,
93
100
                          k.add_lines,
94
 
                          'text0',
95
 
                          ['69'],
96
 
                          ['new text!'])
 
101
                          b'text0',
 
102
                          [b'69'],
 
103
                          [b'new text!'])
97
104
 
98
105
 
99
106
class RepeatedAdd(TestBase):
101
108
 
102
109
    def test_duplicate_add(self):
103
110
        k = Weave()
104
 
        idx = k.add_lines('text0', [], TEXT_0)
105
 
        idx2 = k.add_lines('text0', [], TEXT_0)
 
111
        idx = k.add_lines(b'text0', [], TEXT_0)
 
112
        idx2 = k.add_lines(b'text0', [], TEXT_0)
106
113
        self.assertEqual(idx, idx2)
107
114
 
108
115
 
109
116
class InvalidRepeatedAdd(TestBase):
 
117
 
110
118
    def runTest(self):
111
119
        k = Weave()
112
 
        k.add_lines('basis', [], TEXT_0)
113
 
        idx = k.add_lines('text0', [], TEXT_0)
 
120
        k.add_lines(b'basis', [], TEXT_0)
 
121
        idx = k.add_lines(b'text0', [], TEXT_0)
114
122
        self.assertRaises(errors.RevisionAlreadyPresent,
115
123
                          k.add_lines,
116
 
                          'text0',
 
124
                          b'text0',
117
125
                          [],
118
 
                          ['not the same text'])
 
126
                          [b'not the same text'])
119
127
        self.assertRaises(errors.RevisionAlreadyPresent,
120
128
                          k.add_lines,
121
 
                          'text0',
122
 
                          ['basis'],         # not the right parents
 
129
                          b'text0',
 
130
                          [b'basis'],         # not the right parents
123
131
                          TEXT_0)
124
132
 
125
133
 
131
139
    def runTest(self):
132
140
        k = Weave()
133
141
 
134
 
        k.add_lines('text0', [], ['line 1'])
135
 
        k.add_lines('text1', ['text0'], ['line 1', 'line 2'])
 
142
        k.add_lines(b'text0', [], [b'line 1'])
 
143
        k.add_lines(b'text1', [b'text0'], [b'line 1', b'line 2'])
136
144
 
137
 
        self.assertEqual(k.annotate('text0'),
138
 
                         [('text0', 'line 1')])
 
145
        self.assertEqual(k.annotate(b'text0'),
 
146
                         [(b'text0', b'line 1')])
139
147
 
140
148
        self.assertEqual(k.get_lines(1),
141
 
                         ['line 1',
142
 
                          'line 2'])
143
 
 
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')])
153
 
 
154
 
        text3 = ['line 1', 'middle line', 'line 2']
155
 
        k.add_lines('text3',
156
 
              ['text0', 'text1'],
 
149
                         [b'line 1',
 
150
                          b'line 2'])
 
151
 
 
152
        self.assertEqual(k.annotate(b'text1'),
 
153
                         [(b'text0', b'line 1'),
 
154
                          (b'text1', b'line 2')])
 
155
 
 
156
        k.add_lines(b'text2', [b'text0'], [b'line 1', b'diverged line'])
 
157
 
 
158
        self.assertEqual(k.annotate(b'text2'),
 
159
                         [(b'text0', b'line 1'),
 
160
                          (b'text2', b'diverged line')])
 
161
 
 
162
        text3 = [b'line 1', b'middle line', b'line 2']
 
163
        k.add_lines(b'text3',
 
164
              [b'text0', b'text1'],
157
165
              text3)
158
166
 
159
167
        # self.log("changes to text3: " + pformat(list(k._delta(set([0, 1]), text3))))
160
168
 
161
169
        self.log("k._weave=" + pformat(k._weave))
162
170
 
163
 
        self.assertEqual(k.annotate('text3'),
164
 
                         [('text0', 'line 1'),
165
 
                          ('text3', 'middle line'),
166
 
                          ('text1', 'line 2')])
 
171
        self.assertEqual(k.annotate(b'text3'),
 
172
                         [(b'text0', b'line 1'),
 
173
                          (b'text3', b'middle line'),
 
174
                          (b'text1', b'line 2')])
167
175
 
168
176
        # now multiple insertions at different places
169
 
        k.add_lines('text4',
170
 
              ['text0', 'text1', 'text3'],
171
 
              ['line 1', 'aaa', 'middle line', 'bbb', 'line 2', 'ccc'])
 
177
        k.add_lines(b'text4',
 
178
              [b'text0', b'text1', b'text3'],
 
179
              [b'line 1', b'aaa', b'middle line', b'bbb', b'line 2', b'ccc'])
172
180
 
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')])
 
181
        self.assertEqual(k.annotate(b'text4'),
 
182
                         [(b'text0', b'line 1'),
 
183
                          (b'text4', b'aaa'),
 
184
                          (b'text3', b'middle line'),
 
185
                          (b'text4', b'bbb'),
 
186
                          (b'text1', b'line 2'),
 
187
                          (b'text4', b'ccc')])
180
188
 
181
189
 
182
190
class DeleteLines(TestBase):
186
194
    def runTest(self):
187
195
        k = Weave()
188
196
 
189
 
        base_text = ['one', 'two', 'three', 'four']
190
 
 
191
 
        k.add_lines('text0', [], base_text)
192
 
 
193
 
        texts = [['one', 'two', 'three'],
194
 
                 ['two', 'three', 'four'],
195
 
                 ['one', 'four'],
196
 
                 ['one', 'two', 'three', 'four'],
 
197
        base_text = [b'one', b'two', b'three', b'four']
 
198
 
 
199
        k.add_lines(b'text0', [], base_text)
 
200
 
 
201
        texts = [[b'one', b'two', b'three'],
 
202
                 [b'two', b'three', b'four'],
 
203
                 [b'one', b'four'],
 
204
                 [b'one', b'two', b'three', b'four'],
197
205
                 ]
198
206
 
199
207
        i = 1
200
208
        for t in texts:
201
 
            ver = k.add_lines('text%d' % i,
202
 
                        ['text0'], t)
 
209
            ver = k.add_lines(b'text%d' % i,
 
210
                        [b'text0'], t)
203
211
            i += 1
204
212
 
205
213
        self.log('final weave:')
217
225
 
218
226
        k._parents = [(),
219
227
                ]
220
 
        k._weave = [('{', 0),
221
 
                'first line',
222
 
                ('[', 0),
223
 
                'deleted in 0',
224
 
                (']', 0),
225
 
                ('}', 0),
 
228
        k._weave = [(b'{', 0),
 
229
                b'first line',
 
230
                (b'[', 0),
 
231
                b'deleted in 0',
 
232
                (b']', 0),
 
233
                (b'}', 0),
226
234
                ]
227
235
        ################################### SKIPPED
228
236
        # Weave.get doesn't trap this anymore
241
249
        k._parents = [(),
242
250
                frozenset([0]),
243
251
                ]
244
 
        k._weave = [('{', 0),
245
 
                'first line',
246
 
                ('[', 1),
247
 
                'line to be deleted',
248
 
                (']', 1),
249
 
                'last line',
250
 
                ('}', 0),
 
252
        k._weave = [(b'{', 0),
 
253
                b'first line',
 
254
                (b'[', 1),
 
255
                b'line to be deleted',
 
256
                (b']', 1),
 
257
                b'last line',
 
258
                (b'}', 0),
251
259
                ]
252
 
        k._sha1s = [sha_string('first lineline to be deletedlast line')
253
 
                  , sha_string('first linelast line')]
 
260
        k._sha1s = [sha_string(b'first lineline to be deletedlast line')
 
261
                  , sha_string(b'first linelast line')]
254
262
 
255
263
        self.assertEqual(k.get_lines(0),
256
 
                         ['first line',
257
 
                          'line to be deleted',
258
 
                          'last line',
 
264
                         [b'first line',
 
265
                          b'line to be deleted',
 
266
                          b'last line',
259
267
                          ])
260
268
 
261
269
        self.assertEqual(k.get_lines(1),
262
 
                         ['first line',
263
 
                          'last line',
 
270
                         [b'first line',
 
271
                          b'last line',
264
272
                          ])
265
273
 
266
274
 
272
280
        k._parents = [frozenset(),
273
281
                frozenset([0]),
274
282
                ]
275
 
        k._weave = [('{', 0),
276
 
                'first line',
277
 
                ('[', 1),
278
 
                'line to be deleted',
279
 
                (']', 1),
280
 
                ('{', 1),
281
 
                'replacement line',
282
 
                ('}', 1),
283
 
                'last line',
284
 
                ('}', 0),
 
283
        k._weave = [(b'{', 0),
 
284
                b'first line',
 
285
                (b'[', 1),
 
286
                b'line to be deleted',
 
287
                (b']', 1),
 
288
                (b'{', 1),
 
289
                b'replacement line',
 
290
                (b'}', 1),
 
291
                b'last line',
 
292
                (b'}', 0),
285
293
                ]
286
 
        k._sha1s = [sha_string('first lineline to be deletedlast line')
287
 
                  , sha_string('first linereplacement linelast line')]
 
294
        k._sha1s = [sha_string(b'first lineline to be deletedlast line')
 
295
                  , sha_string(b'first linereplacement linelast line')]
288
296
 
289
297
        self.assertEqual(k.get_lines(0),
290
 
                         ['first line',
291
 
                          'line to be deleted',
292
 
                          'last line',
 
298
                         [b'first line',
 
299
                          b'line to be deleted',
 
300
                          b'last line',
293
301
                          ])
294
302
 
295
303
        self.assertEqual(k.get_lines(1),
296
 
                         ['first line',
297
 
                          'replacement line',
298
 
                          'last line',
 
304
                         [b'first line',
 
305
                          b'replacement line',
 
306
                          b'last line',
299
307
                          ])
300
308
 
301
309
 
306
314
 
307
315
        k._parents = [frozenset(),
308
316
                ]
309
 
        k._weave = ['bad line',
310
 
                ('{', 0),
311
 
                'foo {',
312
 
                ('{', 1),
313
 
                '  added in version 1',
314
 
                ('{', 2),
315
 
                '  added in v2',
316
 
                ('}', 2),
317
 
                '  also from v1',
318
 
                ('}', 1),
319
 
                '}',
320
 
                ('}', 0)]
 
317
        k._weave = [b'bad line',
 
318
                (b'{', 0),
 
319
                b'foo {',
 
320
                (b'{', 1),
 
321
                b'  added in version 1',
 
322
                (b'{', 2),
 
323
                b'  added in v2',
 
324
                (b'}', 2),
 
325
                b'  also from v1',
 
326
                (b'}', 1),
 
327
                b'}',
 
328
                (b'}', 0)]
321
329
 
322
330
        ################################### SKIPPED
323
331
        # Weave.get doesn't trap this anymore
337
345
        k._parents = [frozenset(),
338
346
                frozenset([0]),
339
347
                frozenset([0]),
340
 
                frozenset([0,1,2]),
 
348
                frozenset([0, 1, 2]),
341
349
                ]
342
 
        k._weave = [('{', 0),
343
 
                'foo {',
344
 
                ('{', 1),
345
 
                '  added in version 1',
346
 
                ('{', 1),
347
 
                '  more in 1',
348
 
                ('}', 1),
349
 
                ('}', 1),
350
 
                ('}', 0)]
 
350
        k._weave = [(b'{', 0),
 
351
                b'foo {',
 
352
                (b'{', 1),
 
353
                b'  added in version 1',
 
354
                (b'{', 1),
 
355
                b'  more in 1',
 
356
                (b'}', 1),
 
357
                (b'}', 1),
 
358
                (b'}', 0)]
351
359
 
352
360
 
353
361
        # this is not currently enforced by get
370
378
        k._parents = [frozenset(),
371
379
                frozenset([0]),
372
380
                frozenset([0]),
373
 
                frozenset([0,1,2]),
 
381
                frozenset([0, 1, 2]),
374
382
                ]
375
 
        k._weave = [('{', 0),
376
 
                'foo {',
377
 
                ('{', 1),
378
 
                '  added in version 1',
379
 
                ('{', 2),
380
 
                '  added in v2',
381
 
                ('}', 2),
382
 
                '  also from v1',
383
 
                ('}', 1),
384
 
                '}',
385
 
                ('}', 0)]
 
383
        k._weave = [(b'{', 0),
 
384
                b'foo {',
 
385
                (b'{', 1),
 
386
                b'  added in version 1',
 
387
                (b'{', 2),
 
388
                b'  added in v2',
 
389
                (b'}', 2),
 
390
                b'  also from v1',
 
391
                (b'}', 1),
 
392
                b'}',
 
393
                (b'}', 0)]
386
394
 
387
 
        k._sha1s = [sha_string('foo {}')
388
 
                  , sha_string('foo {  added in version 1  also from v1}')
389
 
                  , sha_string('foo {  added in v2}')
390
 
                  , sha_string('foo {  added in version 1  added in v2  also from v1}')
 
395
        k._sha1s = [sha_string(b'foo {}')
 
396
                  , sha_string(b'foo {  added in version 1  also from v1}')
 
397
                  , sha_string(b'foo {  added in v2}')
 
398
                  , sha_string(b'foo {  added in version 1  added in v2  also from v1}')
391
399
                  ]
392
400
 
393
401
        self.assertEqual(k.get_lines(0),
394
 
                         ['foo {',
395
 
                          '}'])
 
402
                         [b'foo {',
 
403
                          b'}'])
396
404
 
397
405
        self.assertEqual(k.get_lines(1),
398
 
                         ['foo {',
399
 
                          '  added in version 1',
400
 
                          '  also from v1',
401
 
                          '}'])
 
406
                         [b'foo {',
 
407
                          b'  added in version 1',
 
408
                          b'  also from v1',
 
409
                          b'}'])
402
410
 
403
411
        self.assertEqual(k.get_lines(2),
404
 
                         ['foo {',
405
 
                          '  added in v2',
406
 
                          '}'])
 
412
                         [b'foo {',
 
413
                          b'  added in v2',
 
414
                          b'}'])
407
415
 
408
416
        self.assertEqual(k.get_lines(3),
409
 
                         ['foo {',
410
 
                          '  added in version 1',
411
 
                          '  added in v2',
412
 
                          '  also from v1',
413
 
                          '}'])
 
417
                         [b'foo {',
 
418
                          b'  added in version 1',
 
419
                          b'  added in v2',
 
420
                          b'  also from v1',
 
421
                          b'}'])
414
422
 
415
423
 
416
424
class DeleteLines2(TestBase):
421
429
    def runTest(self):
422
430
        k = Weave()
423
431
 
424
 
        k.add_lines('text0', [], ["line the first",
425
 
                   "line 2",
426
 
                   "line 3",
427
 
                   "fine"])
 
432
        k.add_lines(b'text0', [], [b"line the first",
 
433
                   b"line 2",
 
434
                   b"line 3",
 
435
                   b"fine"])
428
436
 
429
437
        self.assertEqual(len(k.get_lines(0)), 4)
430
438
 
431
 
        k.add_lines('text1', ['text0'], ["line the first",
432
 
                   "fine"])
 
439
        k.add_lines(b'text1', [b'text0'], [b"line the first",
 
440
                   b"fine"])
433
441
 
434
442
        self.assertEqual(k.get_lines(1),
435
 
                         ["line the first",
436
 
                          "fine"])
 
443
                         [b"line the first",
 
444
                          b"fine"])
437
445
 
438
 
        self.assertEqual(k.annotate('text1'),
439
 
                         [('text0', "line the first"),
440
 
                          ('text0', "fine")])
 
446
        self.assertEqual(k.annotate(b'text1'),
 
447
                         [(b'text0', b"line the first"),
 
448
                          (b'text0', b"fine")])
441
449
 
442
450
 
443
451
class IncludeVersions(TestBase):
454
462
        k = Weave()
455
463
 
456
464
        k._parents = [frozenset(), frozenset([0])]
457
 
        k._weave = [('{', 0),
458
 
                "first line",
459
 
                ('}', 0),
460
 
                ('{', 1),
461
 
                "second line",
462
 
                ('}', 1)]
 
465
        k._weave = [(b'{', 0),
 
466
                b"first line",
 
467
                (b'}', 0),
 
468
                (b'{', 1),
 
469
                b"second line",
 
470
                (b'}', 1)]
463
471
 
464
 
        k._sha1s = [sha_string('first line')
465
 
                  , sha_string('first linesecond line')]
 
472
        k._sha1s = [sha_string(b'first line')
 
473
                  , sha_string(b'first linesecond line')]
466
474
 
467
475
        self.assertEqual(k.get_lines(1),
468
 
                         ["first line",
469
 
                          "second line"])
 
476
                         [b"first line",
 
477
                          b"second line"])
470
478
 
471
479
        self.assertEqual(k.get_lines(0),
472
 
                         ["first line"])
 
480
                         [b"first line"])
473
481
 
474
482
 
475
483
class DivergedIncludes(TestBase):
479
487
        # FIXME make the weave, dont poke at it.
480
488
        k = Weave()
481
489
 
482
 
        k._names = ['0', '1', '2']
483
 
        k._name_map = {'0':0, '1':1, '2':2}
 
490
        k._names = [b'0', b'1', b'2']
 
491
        k._name_map = {b'0':0, b'1':1, b'2':2}
484
492
        k._parents = [frozenset(),
485
493
                frozenset([0]),
486
494
                frozenset([0]),
487
495
                ]
488
 
        k._weave = [('{', 0),
489
 
                "first line",
490
 
                ('}', 0),
491
 
                ('{', 1),
492
 
                "second line",
493
 
                ('}', 1),
494
 
                ('{', 2),
495
 
                "alternative second line",
496
 
                ('}', 2),
 
496
        k._weave = [(b'{', 0),
 
497
                b"first line",
 
498
                (b'}', 0),
 
499
                (b'{', 1),
 
500
                b"second line",
 
501
                (b'}', 1),
 
502
                (b'{', 2),
 
503
                b"alternative second line",
 
504
                (b'}', 2),
497
505
                ]
498
506
 
499
 
        k._sha1s = [sha_string('first line')
500
 
                  , sha_string('first linesecond line')
501
 
                  , sha_string('first linealternative second line')]
 
507
        k._sha1s = [sha_string(b'first line')
 
508
                  , sha_string(b'first linesecond line')
 
509
                  , sha_string(b'first linealternative second line')]
502
510
 
503
511
        self.assertEqual(k.get_lines(0),
504
 
                         ["first line"])
 
512
                         [b"first line"])
505
513
 
506
514
        self.assertEqual(k.get_lines(1),
507
 
                         ["first line",
508
 
                          "second line"])
509
 
 
510
 
        self.assertEqual(k.get_lines('2'),
511
 
                         ["first line",
512
 
                          "alternative second line"])
513
 
 
514
 
        self.assertEqual(list(k.get_ancestry(['2'])),
515
 
                         ['0', '2'])
 
515
                         [b"first line",
 
516
                          b"second line"])
 
517
 
 
518
        self.assertEqual(k.get_lines(b'2'),
 
519
                         [b"first line",
 
520
                          b"alternative second line"])
 
521
 
 
522
        self.assertEqual(list(k.get_ancestry([b'2'])),
 
523
                         [b'0', b'2'])
516
524
 
517
525
 
518
526
class ReplaceLine(TestBase):
519
527
    def runTest(self):
520
528
        k = Weave()
521
529
 
522
 
        text0 = ['cheddar', 'stilton', 'gruyere']
523
 
        text1 = ['cheddar', 'blue vein', 'neufchatel', 'chevre']
 
530
        text0 = [b'cheddar', b'stilton', b'gruyere']
 
531
        text1 = [b'cheddar', b'blue vein', b'neufchatel', b'chevre']
524
532
 
525
 
        k.add_lines('text0', [], text0)
526
 
        k.add_lines('text1', ['text0'], text1)
 
533
        k.add_lines(b'text0', [], text0)
 
534
        k.add_lines(b'text1', [b'text0'], text1)
527
535
 
528
536
        self.log('k._weave=' + pformat(k._weave))
529
537
 
533
541
 
534
542
class Merge(TestBase):
535
543
    """Storage of versions that merge diverged parents"""
 
544
 
536
545
    def runTest(self):
537
546
        k = Weave()
538
547
 
539
 
        texts = [['header'],
540
 
                 ['header', '', 'line from 1'],
541
 
                 ['header', '', 'line from 2', 'more from 2'],
542
 
                 ['header', '', 'line from 1', 'fixup line', 'line from 2'],
 
548
        texts = [[b'header'],
 
549
                 [b'header', b'', b'line from 1'],
 
550
                 [b'header', b'', b'line from 2', b'more from 2'],
 
551
                 [b'header', b'', b'line from 1', b'fixup line', b'line from 2'],
543
552
                 ]
544
553
 
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])
 
554
        k.add_lines(b'text0', [], texts[0])
 
555
        k.add_lines(b'text1', [b'text0'], texts[1])
 
556
        k.add_lines(b'text2', [b'text0'], texts[2])
 
557
        k.add_lines(b'merge', [b'text0', b'text1', b'text2'], texts[3])
549
558
 
550
559
        for i, t in enumerate(texts):
551
560
            self.assertEqual(k.get_lines(i), t)
552
561
 
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'),
 
562
        self.assertEqual(k.annotate(b'merge'),
 
563
                         [(b'text0', b'header'),
 
564
                          (b'text1', b''),
 
565
                          (b'text1', b'line from 1'),
 
566
                          (b'merge', b'fixup line'),
 
567
                          (b'text2', b'line from 2'),
559
568
                          ])
560
569
 
561
 
        self.assertEqual(list(k.get_ancestry(['merge'])),
562
 
                         ['text0', 'text1', 'text2', 'merge'])
 
570
        self.assertEqual(list(k.get_ancestry([b'merge'])),
 
571
                         [b'text0', b'text1', b'text2', b'merge'])
563
572
 
564
573
        self.log('k._weave=' + pformat(k._weave))
565
574
 
576
585
        return  # NOT RUN
577
586
        k = Weave()
578
587
 
579
 
        k.add_lines([], ['aaa', 'bbb'])
580
 
        k.add_lines([0], ['aaa', '111', 'bbb'])
581
 
        k.add_lines([1], ['aaa', '222', 'bbb'])
 
588
        k.add_lines([], [b'aaa', b'bbb'])
 
589
        k.add_lines([0], [b'aaa', b'111', b'bbb'])
 
590
        k.add_lines([1], [b'aaa', b'222', b'bbb'])
582
591
 
583
592
        merged = k.merge([1, 2])
584
593
 
585
 
        self.assertEquals([[['aaa']],
586
 
                           [['111'], ['222']],
587
 
                           [['bbb']]])
 
594
        self.assertEqual([[[b'aaa']],
 
595
                           [[b'111'], [b'222']],
 
596
                           [[b'bbb']]])
588
597
 
589
598
 
590
599
class NonConflict(TestBase):
595
604
        return  # NOT RUN
596
605
        k = Weave()
597
606
 
598
 
        k.add_lines([], ['aaa', 'bbb'])
599
 
        k.add_lines([0], ['111', 'aaa', 'ccc', 'bbb'])
600
 
        k.add_lines([1], ['aaa', 'ccc', 'bbb', '222'])
 
607
        k.add_lines([], [b'aaa', b'bbb'])
 
608
        k.add_lines([0], [b'111', b'aaa', b'ccc', b'bbb'])
 
609
        k.add_lines([1], [b'aaa', b'ccc', b'bbb', b'222'])
601
610
 
602
611
 
603
612
class Khayyam(TestBase):
605
614
 
606
615
    def test_multi_line_merge(self):
607
616
        rawtexts = [
608
 
            """A Book of Verses underneath the Bough,
 
617
            b"""A Book of Verses underneath the Bough,
609
618
            A Jug of Wine, a Loaf of Bread, -- and Thou
610
619
            Beside me singing in the Wilderness --
611
620
            Oh, Wilderness were Paradise enow!""",
612
621
 
613
 
            """A Book of Verses underneath the Bough,
 
622
            b"""A Book of Verses underneath the Bough,
614
623
            A Jug of Wine, a Loaf of Bread, -- and Thou
615
624
            Beside me singing in the Wilderness --
616
625
            Oh, Wilderness were Paradise now!""",
617
626
 
618
 
            """A Book of poems underneath the tree,
 
627
            b"""A Book of poems underneath the tree,
619
628
            A Jug of Wine, a Loaf of Bread,
620
629
            and Thou
621
630
            Beside me singing in the Wilderness --
623
632
 
624
633
            -- O. Khayyam""",
625
634
 
626
 
            """A Book of Verses underneath the Bough,
 
635
            b"""A Book of Verses underneath the Bough,
627
636
            A Jug of Wine, a Loaf of Bread,
628
637
            and Thou
629
638
            Beside me singing in the Wilderness --
630
639
            Oh, Wilderness were Paradise now!""",
631
640
            ]
632
 
        texts = [[l.strip() for l in t.split('\n')] for t in rawtexts]
 
641
        texts = [[l.strip() for l in t.split(b'\n')] for t in rawtexts]
633
642
 
634
643
        k = Weave()
635
644
        parents = set()
636
645
        i = 0
637
646
        for t in texts:
638
 
            ver = k.add_lines('text%d' % i,
 
647
            ver = k.add_lines(b'text%d' % i,
639
648
                        list(parents), t)
640
 
            parents.add('text%d' % i)
 
649
            parents.add(b'text%d' % i)
641
650
            i += 1
642
651
 
643
652
        self.log("k._weave=" + pformat(k._weave))
649
658
 
650
659
 
651
660
class JoinWeavesTests(TestBase):
 
661
 
652
662
    def setUp(self):
653
663
        super(JoinWeavesTests, self).setUp()
654
664
        self.weave1 = Weave()
655
 
        self.lines1 = ['hello\n']
656
 
        self.lines3 = ['hello\n', 'cruel\n', 'world\n']
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)
 
665
        self.lines1 = [b'hello\n']
 
666
        self.lines3 = [b'hello\n', b'cruel\n', b'world\n']
 
667
        self.weave1.add_lines(b'v1', [], self.lines1)
 
668
        self.weave1.add_lines(b'v2', [b'v1'], [b'hello\n', b'world\n'])
 
669
        self.weave1.add_lines(b'v3', [b'v2'], self.lines3)
660
670
 
661
671
    def test_written_detection(self):
662
672
        # Test detection of weave file corruption.
664
674
        # Make sure that we can detect if a weave file has
665
675
        # been corrupted. This doesn't test all forms of corruption,
666
676
        # but it at least helps verify the data you get, is what you want.
667
 
        from cStringIO import StringIO
668
677
 
669
678
        w = Weave()
670
 
        w.add_lines('v1', [], ['hello\n'])
671
 
        w.add_lines('v2', ['v1'], ['hello\n', 'there\n'])
 
679
        w.add_lines(b'v1', [], [b'hello\n'])
 
680
        w.add_lines(b'v2', [b'v1'], [b'hello\n', b'there\n'])
672
681
 
673
 
        tmpf = StringIO()
 
682
        tmpf = BytesIO()
674
683
        write_weave(w, tmpf)
675
684
 
676
685
        # Because we are corrupting, we need to make sure we have the exact text
677
 
        self.assertEquals('# bzr weave file v5\n'
678
 
                          'i\n1 f572d396fae9206628714fb2ce00f72e94f2258f\nn v1\n\n'
679
 
                          'i 0\n1 90f265c6e75f1c8f9ab76dcf85528352c5f215ef\nn v2\n\n'
680
 
                          'w\n{ 0\n. hello\n}\n{ 1\n. there\n}\nW\n',
681
 
                          tmpf.getvalue())
 
686
        self.assertEqual(b'# bzr weave file v5\n'
 
687
                         b'i\n1 f572d396fae9206628714fb2ce00f72e94f2258f\nn v1\n\n'
 
688
                         b'i 0\n1 90f265c6e75f1c8f9ab76dcf85528352c5f215ef\nn v2\n\n'
 
689
                         b'w\n{ 0\n. hello\n}\n{ 1\n. there\n}\nW\n',
 
690
                         tmpf.getvalue())
682
691
 
683
692
        # Change a single letter
684
 
        tmpf = StringIO('# bzr weave file v5\n'
685
 
                        'i\n1 f572d396fae9206628714fb2ce00f72e94f2258f\nn v1\n\n'
686
 
                        'i 0\n1 90f265c6e75f1c8f9ab76dcf85528352c5f215ef\nn v2\n\n'
687
 
                        'w\n{ 0\n. hello\n}\n{ 1\n. There\n}\nW\n')
 
693
        tmpf = BytesIO(b'# bzr weave file v5\n'
 
694
                       b'i\n1 f572d396fae9206628714fb2ce00f72e94f2258f\nn v1\n\n'
 
695
                       b'i 0\n1 90f265c6e75f1c8f9ab76dcf85528352c5f215ef\nn v2\n\n'
 
696
                       b'w\n{ 0\n. hello\n}\n{ 1\n. There\n}\nW\n')
688
697
 
689
698
        w = read_weave(tmpf)
690
699
 
691
 
        self.assertEqual('hello\n', w.get_text('v1'))
692
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
693
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
694
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.check)
 
700
        self.assertEqual(b'hello\n', w.get_text(b'v1'))
 
701
        self.assertRaises(WeaveInvalidChecksum, w.get_text, b'v2')
 
702
        self.assertRaises(WeaveInvalidChecksum, w.get_lines, b'v2')
 
703
        self.assertRaises(WeaveInvalidChecksum, w.check)
695
704
 
696
705
        # Change the sha checksum
697
 
        tmpf = StringIO('# bzr weave file v5\n'
698
 
                        'i\n1 f572d396fae9206628714fb2ce00f72e94f2258f\nn v1\n\n'
699
 
                        'i 0\n1 f0f265c6e75f1c8f9ab76dcf85528352c5f215ef\nn v2\n\n'
700
 
                        'w\n{ 0\n. hello\n}\n{ 1\n. there\n}\nW\n')
 
706
        tmpf = BytesIO(b'# bzr weave file v5\n'
 
707
                       b'i\n1 f572d396fae9206628714fb2ce00f72e94f2258f\nn v1\n\n'
 
708
                       b'i 0\n1 f0f265c6e75f1c8f9ab76dcf85528352c5f215ef\nn v2\n\n'
 
709
                       b'w\n{ 0\n. hello\n}\n{ 1\n. there\n}\nW\n')
701
710
 
702
711
        w = read_weave(tmpf)
703
712
 
704
 
        self.assertEqual('hello\n', w.get_text('v1'))
705
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_text, 'v2')
706
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.get_lines, 'v2')
707
 
        self.assertRaises(errors.WeaveInvalidChecksum, w.check)
 
713
        self.assertEqual(b'hello\n', w.get_text(b'v1'))
 
714
        self.assertRaises(WeaveInvalidChecksum, w.get_text, b'v2')
 
715
        self.assertRaises(WeaveInvalidChecksum, w.get_lines, b'v2')
 
716
        self.assertRaises(WeaveInvalidChecksum, w.check)
708
717
 
709
718
 
710
719
class TestWeave(TestCase):
712
721
    def test_allow_reserved_false(self):
713
722
        w = Weave('name', allow_reserved=False)
714
723
        # Add lines is checked at the WeaveFile level, not at the Weave level
715
 
        w.add_lines('name:', [], TEXT_1)
 
724
        w.add_lines(b'name:', [], TEXT_1)
716
725
        # But get_lines is checked at this level
717
 
        self.assertRaises(errors.ReservedId, w.get_lines, 'name:')
 
726
        self.assertRaises(errors.ReservedId, w.get_lines, b'name:')
718
727
 
719
728
    def test_allow_reserved_true(self):
720
729
        w = Weave('name', allow_reserved=True)
721
 
        w.add_lines('name:', [], TEXT_1)
722
 
        self.assertEqual(TEXT_1, w.get_lines('name:'))
 
730
        w.add_lines(b'name:', [], TEXT_1)
 
731
        self.assertEqual(TEXT_1, w.get_lines(b'name:'))
723
732
 
724
733
 
725
734
class InstrumentedWeave(Weave):
739
748
 
740
749
    def test_compatible_parents(self):
741
750
        w1 = Weave('a')
742
 
        my_parents = set([1, 2, 3])
 
751
        my_parents = {1, 2, 3}
743
752
        # subsets are ok
744
 
        self.assertTrue(w1._compatible_parents(my_parents, set([3])))
 
753
        self.assertTrue(w1._compatible_parents(my_parents, {3}))
745
754
        # same sets
746
755
        self.assertTrue(w1._compatible_parents(my_parents, set(my_parents)))
747
756
        # same empty corner case
748
757
        self.assertTrue(w1._compatible_parents(set(), set()))
749
758
        # 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])))
 
759
        self.assertFalse(w1._compatible_parents(set(), {1}))
 
760
        self.assertFalse(w1._compatible_parents(my_parents, {1, 2, 3, 4}))
 
761
        self.assertFalse(w1._compatible_parents(my_parents, {4}))
753
762
 
754
763
 
755
764
class TestWeaveFile(TestCaseInTempDir):
756
765
 
757
766
    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()
 
767
        with open('empty.weave', 'wb+') as f:
 
768
            self.assertRaises(WeaveFormatError, read_weave, f)