← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_knit.py

  • Committer: Dmitry Vasiliev
  • Date: 2006-12-01 10:44:42 UTC
  • mto: (2196.2.1 knit_index_optim)
  • mto: This revision was merged to the branch mainline in revision 2212.
  • Revision ID: dima@hlabs.spb.ru-20061201104442-57108aafbad6498c
KnitIndex tests/fixes/optimizations

 - Added _KnitIndex tests.
 - Fixed bug with undecoded version ids.
 - Extracted the knit index file parsing code from __init__() into _load_data()
   method.
 - Converted loops into list comprehensions where appropriate.
 - Localized attributes for faster access inside loops where appropriate.
 - Added forgotten import.
 - Removed trailing whitespaces.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_knit.py
16
16
 
17
17
"""Tests for Knit data structure"""
18
18
 
19
 
 
 
19
from cStringIO import StringIO
20
20
import difflib
21
21
 
22
 
 
23
 
from bzrlib.errors import KnitError, RevisionAlreadyPresent, NoSuchFile
 
22
from bzrlib.errors import (
 
23
    RevisionAlreadyPresent,
 
24
    KnitHeaderError,
 
25
    RevisionNotPresent,
 
26
    NoSuchFile,
 
27
    )
24
28
from bzrlib.knit import (
25
29
    KnitContent,
26
30
    KnitVersionedFile,
27
31
    KnitPlainFactory,
28
32
    KnitAnnotateFactory,
29
 
    WeaveToKnit)
 
33
    _KnitIndex,
 
34
    WeaveToKnit,
 
35
    )
30
36
from bzrlib.osutils import split_lines
31
37
from bzrlib.tests import TestCase, TestCaseWithTransport
32
38
from bzrlib.transport import TransportLogger, get_transport
85
91
        self.assertEqual(it.next(), (1, 2, 2, [("", "a"), ("", "c")]))
86
92
        self.assertRaises(StopIteration, it.next)
87
93
 
 
94
 
 
95
class MockTransport(object):
 
96
 
 
97
    def __init__(self, file_lines=None):
 
98
        self.file_lines = file_lines
 
99
        self.calls = []
 
100
 
 
101
    def get(self, filename):
 
102
        if self.file_lines is None:
 
103
            raise NoSuchFile(filename)
 
104
        else:
 
105
            return StringIO("\n".join(self.file_lines))
 
106
 
 
107
    def __getattr__(self, name):
 
108
        def queue_call(*args, **kwargs):
 
109
            self.calls.append((name, args, kwargs))
 
110
        return queue_call
 
111
 
 
112
 
 
113
class LowLevelKnitIndexTests(TestCase):
 
114
 
 
115
    def test_no_such_file(self):
 
116
        transport = MockTransport()
 
117
 
 
118
        self.assertRaises(NoSuchFile, _KnitIndex, transport, "filename", "r")
 
119
        self.assertRaises(NoSuchFile, _KnitIndex, transport,
 
120
            "filename", "w", create=False)
 
121
 
 
122
    def test_create_file(self):
 
123
        transport = MockTransport()
 
124
 
 
125
        index = _KnitIndex(transport, "filename", "w",
 
126
            file_mode="wb", create=True)
 
127
        self.assertEqual(
 
128
                ("put_bytes_non_atomic",
 
129
                    ("filename", index.HEADER), {"mode": "wb"}),
 
130
                transport.calls.pop(0))
 
131
 
 
132
    def test_delay_create_file(self):
 
133
        transport = MockTransport()
 
134
 
 
135
        index = _KnitIndex(transport, "filename", "w",
 
136
            create=True, file_mode="wb", create_parent_dir=True,
 
137
            delay_create=True, dir_mode=0777)
 
138
        self.assertEqual([], transport.calls)
 
139
 
 
140
        index.add_versions([])
 
141
        name, (filename, f), kwargs = transport.calls.pop(0)
 
142
        self.assertEqual("put_file_non_atomic", name)
 
143
        self.assertEqual(
 
144
            {"dir_mode": 0777, "create_parent_dir": True, "mode": "wb"},
 
145
            kwargs)
 
146
        self.assertEqual("filename", filename)
 
147
        self.assertEqual(index.HEADER, f.read())
 
148
 
 
149
        index.add_versions([])
 
150
        self.assertEqual(("append_bytes", ("filename", ""), {}),
 
151
            transport.calls.pop(0))
 
152
 
 
153
    def test_read_utf8_version_id(self):
 
154
        transport = MockTransport([
 
155
            _KnitIndex.HEADER,
 
156
            u"version-\N{CYRILLIC CAPITAL LETTER A}"
 
157
                u" option 0 1 :".encode("utf-8")
 
158
            ])
 
159
        index = _KnitIndex(transport, "filename", "r")
 
160
        self.assertTrue(
 
161
            index.has_version(u"version-\N{CYRILLIC CAPITAL LETTER A}"))
 
162
 
 
163
    def test_read_utf8_parents(self):
 
164
        transport = MockTransport([
 
165
            _KnitIndex.HEADER,
 
166
            u"version option 0 1"
 
167
                u" .version-\N{CYRILLIC CAPITAL LETTER A} :".encode("utf-8")
 
168
            ])
 
169
        index = _KnitIndex(transport, "filename", "r")
 
170
        self.assertEqual([u"version-\N{CYRILLIC CAPITAL LETTER A}"],
 
171
            index.get_parents_with_ghosts("version"))
 
172
 
 
173
    def test_read_ignore_corrupted_lines(self):
 
174
        transport = MockTransport([
 
175
            _KnitIndex.HEADER,
 
176
            "corrupted",
 
177
            "corrupted options 0 1 .b .c ",
 
178
            "version options 0 1 :"
 
179
            ])
 
180
        index = _KnitIndex(transport, "filename", "r")
 
181
        self.assertEqual(1, index.num_versions())
 
182
        self.assertTrue(index.has_version(u"version"))
 
183
 
 
184
    def test_read_corrupted_header(self):
 
185
        transport = MockTransport([])
 
186
        self.assertRaises(KnitHeaderError,
 
187
            _KnitIndex, transport, "filename", "r")
 
188
 
 
189
    def test_read_duplicate_entries(self):
 
190
        transport = MockTransport([
 
191
            _KnitIndex.HEADER,
 
192
            "parent options 0 1 :",
 
193
            "version options1 0 1 0 :",
 
194
            "version options2 1 2 .other :",
 
195
            "version options3 3 4 0 .other :"
 
196
            ])
 
197
        index = _KnitIndex(transport, "filename", "r")
 
198
        self.assertEqual(2, index.num_versions())
 
199
        self.assertEqual(1, index.lookup(u"version"))
 
200
        self.assertEqual((3, 4), index.get_position(u"version"))
 
201
        self.assertEqual(["options3"], index.get_options(u"version"))
 
202
        self.assertEqual([u"parent", u"other"],
 
203
            index.get_parents_with_ghosts(u"version"))
 
204
 
 
205
    def test_read_compressed_parents(self):
 
206
        transport = MockTransport([
 
207
            _KnitIndex.HEADER,
 
208
            "a option 0 1 :",
 
209
            "b option 0 1 0 :",
 
210
            "c option 0 1 1 0 :",
 
211
            ])
 
212
        index = _KnitIndex(transport, "filename", "r")
 
213
        self.assertEqual([u"a"], index.get_parents(u"b"))
 
214
        self.assertEqual([u"b", u"a"], index.get_parents(u"c"))
 
215
 
 
216
    def test_write_utf8_version_id(self):
 
217
        transport = MockTransport([
 
218
            _KnitIndex.HEADER
 
219
            ])
 
220
        index = _KnitIndex(transport, "filename", "r")
 
221
        index.add_version(u"version-\N{CYRILLIC CAPITAL LETTER A}",
 
222
            ["option"], 0, 1, [])
 
223
        self.assertEqual(("append_bytes", ("filename",
 
224
            u"\nversion-\N{CYRILLIC CAPITAL LETTER A}"
 
225
                u" option 0 1  :".encode("utf-8")),
 
226
            {}),
 
227
            transport.calls.pop(0))
 
228
 
 
229
    def test_write_utf8_parents(self):
 
230
        transport = MockTransport([
 
231
            _KnitIndex.HEADER
 
232
            ])
 
233
        index = _KnitIndex(transport, "filename", "r")
 
234
        index.add_version(u"version", ["option"], 0, 1,
 
235
            [u"version-\N{CYRILLIC CAPITAL LETTER A}"])
 
236
        self.assertEqual(("append_bytes", ("filename",
 
237
            u"\nversion option 0 1"
 
238
                u" .version-\N{CYRILLIC CAPITAL LETTER A} :".encode("utf-8")),
 
239
            {}),
 
240
            transport.calls.pop(0))
 
241
 
 
242
    def test_get_graph(self):
 
243
        transport = MockTransport()
 
244
        index = _KnitIndex(transport, "filename", "w", create=True)
 
245
        self.assertEqual([], index.get_graph())
 
246
 
 
247
        index.add_version(u"a", ["option"], 0, 1, [u"b"])
 
248
        self.assertEqual([(u"a", [u"b"])], index.get_graph())
 
249
 
 
250
        index.add_version(u"c", ["option"], 0, 1, [u"d"])
 
251
        self.assertEqual([(u"a", [u"b"]), (u"c", [u"d"])],
 
252
            sorted(index.get_graph()))
 
253
 
 
254
    def test_get_ancestry(self):
 
255
        transport = MockTransport([
 
256
            _KnitIndex.HEADER,
 
257
            "a option 0 1 :",
 
258
            "b option 0 1 0 .e :",
 
259
            "c option 0 1 1 0 :",
 
260
            "d option 0 1 2 .f :"
 
261
            ])
 
262
        index = _KnitIndex(transport, "filename", "r")
 
263
 
 
264
        self.assertEqual([], index.get_ancestry([]))
 
265
        self.assertEqual([u"a"], index.get_ancestry([u"a"]))
 
266
        self.assertEqual([u"a", u"b"], index.get_ancestry([u"b"]))
 
267
        self.assertEqual([u"a", u"b", u"c"], index.get_ancestry([u"c"]))
 
268
        self.assertEqual([u"a", u"b", u"c", u"d"], index.get_ancestry([u"d"]))
 
269
        self.assertEqual([u"a", u"b"], index.get_ancestry([u"a", u"b"]))
 
270
        self.assertEqual([u"a", u"b", u"c"], index.get_ancestry([u"a", u"c"]))
 
271
 
 
272
        self.assertRaises(RevisionNotPresent, index.get_ancestry, [u"e"])
 
273
 
 
274
    def test_get_ancestry_with_ghosts(self):
 
275
        transport = MockTransport([
 
276
            _KnitIndex.HEADER,
 
277
            "a option 0 1 :",
 
278
            "b option 0 1 0 .e :",
 
279
            "c option 0 1 0 .f .g :",
 
280
            "d option 0 1 2 .h .j .k :"
 
281
            ])
 
282
        index = _KnitIndex(transport, "filename", "r")
 
283
 
 
284
        self.assertEqual([], index.get_ancestry_with_ghosts([]))
 
285
        self.assertEqual([u"a"], index.get_ancestry_with_ghosts([u"a"]))
 
286
        self.assertEqual([u"a", u"e", u"b"],
 
287
            index.get_ancestry_with_ghosts([u"b"]))
 
288
        self.assertEqual([u"a", u"g", u"f", u"c"],
 
289
            index.get_ancestry_with_ghosts([u"c"]))
 
290
        self.assertEqual([u"a", u"g", u"f", u"c", u"k", u"j", u"h", u"d"],
 
291
            index.get_ancestry_with_ghosts([u"d"]))
 
292
        self.assertEqual([u"a", u"e", u"b"],
 
293
            index.get_ancestry_with_ghosts([u"a", u"b"]))
 
294
        self.assertEqual([u"a", u"g", u"f", u"c"],
 
295
            index.get_ancestry_with_ghosts([u"a", u"c"]))
 
296
        self.assertEqual(
 
297
            [u"a", u"g", u"f", u"c", u"e", u"b", u"k", u"j", u"h", u"d"],
 
298
            index.get_ancestry_with_ghosts([u"b", u"d"]))
 
299
 
 
300
        self.assertRaises(RevisionNotPresent,
 
301
            index.get_ancestry_with_ghosts, [u"e"])
 
302
 
 
303
    def test_num_versions(self):
 
304
        transport = MockTransport([
 
305
            _KnitIndex.HEADER
 
306
            ])
 
307
        index = _KnitIndex(transport, "filename", "r")
 
308
 
 
309
        self.assertEqual(0, index.num_versions())
 
310
        self.assertEqual(0, len(index))
 
311
 
 
312
        index.add_version(u"a", ["option"], 0, 1, [])
 
313
        self.assertEqual(1, index.num_versions())
 
314
        self.assertEqual(1, len(index))
 
315
 
 
316
        index.add_version(u"a", ["option2"], 1, 2, [])
 
317
        self.assertEqual(1, index.num_versions())
 
318
        self.assertEqual(1, len(index))
 
319
 
 
320
        index.add_version(u"b", ["option"], 0, 1, [])
 
321
        self.assertEqual(2, index.num_versions())
 
322
        self.assertEqual(2, len(index))
 
323
 
 
324
    def test_get_versions(self):
 
325
        transport = MockTransport([
 
326
            _KnitIndex.HEADER
 
327
            ])
 
328
        index = _KnitIndex(transport, "filename", "r")
 
329
 
 
330
        self.assertEqual([], index.get_versions())
 
331
 
 
332
        index.add_version(u"a", ["option"], 0, 1, [])
 
333
        self.assertEqual([u"a"], index.get_versions())
 
334
 
 
335
        index.add_version(u"a", ["option"], 0, 1, [])
 
336
        self.assertEqual([u"a"], index.get_versions())
 
337
 
 
338
        index.add_version(u"b", ["option"], 0, 1, [])
 
339
        self.assertEqual([u"a", u"b"], index.get_versions())
 
340
 
 
341
    def test_idx_to_name(self):
 
342
        transport = MockTransport([
 
343
            _KnitIndex.HEADER,
 
344
            "a option 0 1 :",
 
345
            "b option 0 1 :"
 
346
            ])
 
347
        index = _KnitIndex(transport, "filename", "r")
 
348
 
 
349
        self.assertEqual(u"a", index.idx_to_name(0))
 
350
        self.assertEqual(u"b", index.idx_to_name(1))
 
351
        self.assertEqual(u"b", index.idx_to_name(-1))
 
352
        self.assertEqual(u"a", index.idx_to_name(-2))
 
353
 
 
354
    def test_lookup(self):
 
355
        transport = MockTransport([
 
356
            _KnitIndex.HEADER,
 
357
            "a option 0 1 :",
 
358
            "b option 0 1 :"
 
359
            ])
 
360
        index = _KnitIndex(transport, "filename", "r")
 
361
 
 
362
        self.assertEqual(0, index.lookup(u"a"))
 
363
        self.assertEqual(1, index.lookup(u"b"))
 
364
 
 
365
    def test_add_version(self):
 
366
        transport = MockTransport([
 
367
            _KnitIndex.HEADER
 
368
            ])
 
369
        index = _KnitIndex(transport, "filename", "r")
 
370
 
 
371
        index.add_version(u"a", ["option"], 0, 1, [u"b"])
 
372
        self.assertEqual(("append_bytes",
 
373
            ("filename", "\na option 0 1 .b :"),
 
374
            {}), transport.calls.pop(0))
 
375
        self.assertTrue(index.has_version(u"a"))
 
376
        self.assertEqual(1, index.num_versions())
 
377
        self.assertEqual((0, 1), index.get_position(u"a"))
 
378
        self.assertEqual(["option"], index.get_options(u"a"))
 
379
        self.assertEqual([u"b"], index.get_parents_with_ghosts(u"a"))
 
380
 
 
381
        index.add_version(u"a", ["opt"], 1, 2, [u"c"])
 
382
        self.assertEqual(("append_bytes",
 
383
            ("filename", "\na opt 1 2 .c :"),
 
384
            {}), transport.calls.pop(0))
 
385
        self.assertTrue(index.has_version(u"a"))
 
386
        self.assertEqual(1, index.num_versions())
 
387
        self.assertEqual((1, 2), index.get_position(u"a"))
 
388
        self.assertEqual(["opt"], index.get_options(u"a"))
 
389
        self.assertEqual([u"c"], index.get_parents_with_ghosts(u"a"))
 
390
 
 
391
        index.add_version(u"b", ["option"], 2, 3, [u"a"])
 
392
        self.assertEqual(("append_bytes",
 
393
            ("filename", "\nb option 2 3 0 :"),
 
394
            {}), transport.calls.pop(0))
 
395
        self.assertTrue(index.has_version(u"b"))
 
396
        self.assertEqual(2, index.num_versions())
 
397
        self.assertEqual((2, 3), index.get_position(u"b"))
 
398
        self.assertEqual(["option"], index.get_options(u"b"))
 
399
        self.assertEqual([u"a"], index.get_parents_with_ghosts(u"b"))
 
400
 
 
401
    def test_add_versions(self):
 
402
        transport = MockTransport([
 
403
            _KnitIndex.HEADER
 
404
            ])
 
405
        index = _KnitIndex(transport, "filename", "r")
 
406
 
 
407
        index.add_versions([
 
408
            (u"a", ["option"], 0, 1, [u"b"]),
 
409
            (u"a", ["opt"], 1, 2, [u"c"]),
 
410
            (u"b", ["option"], 2, 3, [u"a"])
 
411
            ])
 
412
        self.assertEqual(("append_bytes", ("filename",
 
413
            "\na option 0 1 .b :"
 
414
            "\na opt 1 2 .c :"
 
415
            "\nb option 2 3 0 :"
 
416
            ), {}), transport.calls.pop(0))
 
417
        self.assertTrue(index.has_version(u"a"))
 
418
        self.assertTrue(index.has_version(u"b"))
 
419
        self.assertEqual(2, index.num_versions())
 
420
        self.assertEqual((1, 2), index.get_position(u"a"))
 
421
        self.assertEqual((2, 3), index.get_position(u"b"))
 
422
        self.assertEqual(["opt"], index.get_options(u"a"))
 
423
        self.assertEqual(["option"], index.get_options(u"b"))
 
424
        self.assertEqual([u"c"], index.get_parents_with_ghosts(u"a"))
 
425
        self.assertEqual([u"a"], index.get_parents_with_ghosts(u"b"))
 
426
 
 
427
    def test_delay_create_and_add_versions(self):
 
428
        transport = MockTransport()
 
429
 
 
430
        index = _KnitIndex(transport, "filename", "w",
 
431
            create=True, file_mode="wb", create_parent_dir=True,
 
432
            delay_create=True, dir_mode=0777)
 
433
        self.assertEqual([], transport.calls)
 
434
 
 
435
        index.add_versions([
 
436
            (u"a", ["option"], 0, 1, [u"b"]),
 
437
            (u"a", ["opt"], 1, 2, [u"c"]),
 
438
            (u"b", ["option"], 2, 3, [u"a"])
 
439
            ])
 
440
        name, (filename, f), kwargs = transport.calls.pop(0)
 
441
        self.assertEqual("put_file_non_atomic", name)
 
442
        self.assertEqual(
 
443
            {"dir_mode": 0777, "create_parent_dir": True, "mode": "wb"},
 
444
            kwargs)
 
445
        self.assertEqual("filename", filename)
 
446
        self.assertEqual(
 
447
            index.HEADER +
 
448
            "\na option 0 1 .b :"
 
449
            "\na opt 1 2 .c :"
 
450
            "\nb option 2 3 0 :",
 
451
            f.read())
 
452
 
 
453
    def test_has_version(self):
 
454
        transport = MockTransport([
 
455
            _KnitIndex.HEADER,
 
456
            "a option 0 1 :"
 
457
            ])
 
458
        index = _KnitIndex(transport, "filename", "r")
 
459
 
 
460
        self.assertTrue(index.has_version(u"a"))
 
461
        self.assertFalse(index.has_version(u"b"))
 
462
 
 
463
    def test_get_position(self):
 
464
        transport = MockTransport([
 
465
            _KnitIndex.HEADER,
 
466
            "a option 0 1 :",
 
467
            "b option 1 2 :"
 
468
            ])
 
469
        index = _KnitIndex(transport, "filename", "r")
 
470
 
 
471
        self.assertEqual((0, 1), index.get_position(u"a"))
 
472
        self.assertEqual((1, 2), index.get_position(u"b"))
 
473
 
 
474
    def test_get_method(self):
 
475
        transport = MockTransport([
 
476
            _KnitIndex.HEADER,
 
477
            "a fulltext,unknown 0 1 :",
 
478
            "b unknown,line-delta 1 2 :",
 
479
            "c bad 3 4 :"
 
480
            ])
 
481
        index = _KnitIndex(transport, "filename", "r")
 
482
 
 
483
        self.assertEqual("fulltext", index.get_method(u"a"))
 
484
        self.assertEqual("line-delta", index.get_method(u"b"))
 
485
        self.assertRaises(AssertionError, index.get_method, u"c")
 
486
 
 
487
    def test_get_options(self):
 
488
        transport = MockTransport([
 
489
            _KnitIndex.HEADER,
 
490
            "a opt1 0 1 :",
 
491
            "b opt2,opt3 1 2 :"
 
492
            ])
 
493
        index = _KnitIndex(transport, "filename", "r")
 
494
 
 
495
        self.assertEqual(["opt1"], index.get_options(u"a"))
 
496
        self.assertEqual(["opt2", "opt3"], index.get_options(u"b"))
 
497
 
 
498
    def test_get_parents(self):
 
499
        transport = MockTransport([
 
500
            _KnitIndex.HEADER,
 
501
            "a option 0 1 :",
 
502
            "b option 1 2 0 .c :",
 
503
            "c option 1 2 1 0 .e :"
 
504
            ])
 
505
        index = _KnitIndex(transport, "filename", "r")
 
506
 
 
507
        self.assertEqual([], index.get_parents(u"a"))
 
508
        self.assertEqual([u"a", u"c"], index.get_parents(u"b"))
 
509
        self.assertEqual([u"b", u"a"], index.get_parents(u"c"))
 
510
 
 
511
    def test_get_parents_with_ghosts(self):
 
512
        transport = MockTransport([
 
513
            _KnitIndex.HEADER,
 
514
            "a option 0 1 :",
 
515
            "b option 1 2 0 .c :",
 
516
            "c option 1 2 1 0 .e :"
 
517
            ])
 
518
        index = _KnitIndex(transport, "filename", "r")
 
519
 
 
520
        self.assertEqual([], index.get_parents_with_ghosts(u"a"))
 
521
        self.assertEqual([u"a", u"c"], index.get_parents_with_ghosts(u"b"))
 
522
        self.assertEqual([u"b", u"a", u"e"],
 
523
            index.get_parents_with_ghosts(u"c"))
 
524
 
 
525
    def test_check_versions_present(self):
 
526
        transport = MockTransport([
 
527
            _KnitIndex.HEADER,
 
528
            "a option 0 1 :",
 
529
            "b option 0 1 :"
 
530
            ])
 
531
        index = _KnitIndex(transport, "filename", "r")
 
532
 
 
533
        check = index.check_versions_present
 
534
 
 
535
        check([])
 
536
        check([u"a"])
 
537
        check([u"b"])
 
538
        check([u"a", u"b"])
 
539
        self.assertRaises(RevisionNotPresent, check, [u"c"])
 
540
        self.assertRaises(RevisionNotPresent, check, [u"a", u"b", u"c"])
 
541
 
 
542
 
88
543
class KnitTests(TestCaseWithTransport):
89
544
    """Class containing knit test helper routines."""
90
545
 
131
586
        k.add_lines('text-2', [], split_lines(TEXT_2))
132
587
        self.assertEqualDiff(''.join(k.get_lines('text-1')), TEXT_1)
133
588
        self.assertEqualDiff(''.join(k.get_lines('text-2')), TEXT_2)
134
 
        
 
589
 
135
590
    def test_repeated_add(self):
136
591
        """Knit traps attempt to replace existing version"""
137
592
        k = self.make_test_knit()
138
593
        k.add_lines('text-1', [], split_lines(TEXT_1))
139
 
        self.assertRaises(RevisionAlreadyPresent, 
 
594
        self.assertRaises(RevisionAlreadyPresent,
140
595
                k.add_lines,
141
596
                'text-1', [], split_lines(TEXT_1))
142
597
 
328
783
 
329
784
    def test_get_line_delta_texts(self):
330
785
        """Make sure we can call get_texts on text with reused line deltas"""
331
 
        k1 = KnitVersionedFile('test1', get_transport('.'), 
 
786
        k1 = KnitVersionedFile('test1', get_transport('.'),
332
787
                               factory=KnitPlainFactory(), create=True)
333
788
        for t in range(3):
334
789
            if t == 0:
337
792
                parents = ['%d' % (t-1)]
338
793
            k1.add_lines('%d' % t, parents, ['hello\n'] * t)
339
794
        k1.get_texts(('%d' % t) for t in range(3))
340
 
        
 
795
 
341
796
    def test_iter_lines_reads_in_order(self):
342
797
        t = MemoryTransport()
343
798
        instrumented_t = TransportLogger(t)