← 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: Martin Pool
  • Date: 2009-07-24 03:15:56 UTC
  • mfrom: (4565 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4566.
  • Revision ID: mbp@sourcefrog.net-20090724031556-5zyef6f1ixtn6r3z
merge news

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_knit.py
366
366
        :return: (versioned_file, reload_counter)
367
367
            versioned_file  a KnitVersionedFiles using the packs for access
368
368
        """
369
 
        tree = self.make_branch_and_memory_tree('tree')
370
 
        tree.lock_write()
371
 
        self.addCleanup(tree.unlock)
372
 
        tree.add([''], ['root-id'])
373
 
        tree.commit('one', rev_id='rev-1')
374
 
        tree.commit('two', rev_id='rev-2')
375
 
        tree.commit('three', rev_id='rev-3')
 
369
        builder = self.make_branch_builder('.')
 
370
        builder.start_series()
 
371
        builder.build_snapshot('rev-1', None, [
 
372
            ('add', ('', 'root-id', 'directory', None)),
 
373
            ('add', ('file', 'file-id', 'file', 'content\nrev 1\n')),
 
374
            ])
 
375
        builder.build_snapshot('rev-2', ['rev-1'], [
 
376
            ('modify', ('file-id', 'content\nrev 2\n')),
 
377
            ])
 
378
        builder.build_snapshot('rev-3', ['rev-2'], [
 
379
            ('modify', ('file-id', 'content\nrev 3\n')),
 
380
            ])
 
381
        builder.finish_series()
 
382
        b = builder.get_branch()
 
383
        b.lock_write()
 
384
        self.addCleanup(b.unlock)
376
385
        # Pack these three revisions into another pack file, but don't remove
377
386
        # the originals
378
 
        repo = tree.branch.repository
 
387
        repo = b.repository
379
388
        collection = repo._pack_collection
380
389
        collection.ensure_loaded()
381
390
        orig_packs = collection.packs
384
393
        # forget about the new pack
385
394
        collection.reset()
386
395
        repo.refresh_data()
387
 
        vf = tree.branch.repository.revisions
 
396
        vf = repo.revisions
388
397
        # Set up a reload() function that switches to using the new pack file
389
398
        new_index = new_pack.revision_index
390
399
        access_tuple = new_pack.access_tuple()
1313
1322
        return _KndxIndex(transport, mapper, lambda:None, allow_writes, lambda:True)
1314
1323
 
1315
1324
 
 
1325
class Test_KnitAnnotator(TestCaseWithMemoryTransport):
 
1326
 
 
1327
    def make_annotator(self):
 
1328
        factory = knit.make_pack_factory(True, True, 1)
 
1329
        vf = factory(self.get_transport())
 
1330
        return knit._KnitAnnotator(vf)
 
1331
 
 
1332
    def test__expand_fulltext(self):
 
1333
        ann = self.make_annotator()
 
1334
        rev_key = ('rev-id',)
 
1335
        ann._num_compression_children[rev_key] = 1
 
1336
        res = ann._expand_record(rev_key, (('parent-id',),), None,
 
1337
                           ['line1\n', 'line2\n'], ('fulltext', True))
 
1338
        # The content object and text lines should be cached appropriately
 
1339
        self.assertEqual(['line1\n', 'line2'], res)
 
1340
        content_obj = ann._content_objects[rev_key]
 
1341
        self.assertEqual(['line1\n', 'line2\n'], content_obj._lines)
 
1342
        self.assertEqual(res, content_obj.text())
 
1343
        self.assertEqual(res, ann._text_cache[rev_key])
 
1344
 
 
1345
    def test__expand_delta_comp_parent_not_available(self):
 
1346
        # Parent isn't available yet, so we return nothing, but queue up this
 
1347
        # node for later processing
 
1348
        ann = self.make_annotator()
 
1349
        rev_key = ('rev-id',)
 
1350
        parent_key = ('parent-id',)
 
1351
        record = ['0,1,1\n', 'new-line\n']
 
1352
        details = ('line-delta', False)
 
1353
        res = ann._expand_record(rev_key, (parent_key,), parent_key,
 
1354
                                 record, details)
 
1355
        self.assertEqual(None, res)
 
1356
        self.assertTrue(parent_key in ann._pending_deltas)
 
1357
        pending = ann._pending_deltas[parent_key]
 
1358
        self.assertEqual(1, len(pending))
 
1359
        self.assertEqual((rev_key, (parent_key,), record, details), pending[0])
 
1360
 
 
1361
    def test__expand_record_tracks_num_children(self):
 
1362
        ann = self.make_annotator()
 
1363
        rev_key = ('rev-id',)
 
1364
        rev2_key = ('rev2-id',)
 
1365
        parent_key = ('parent-id',)
 
1366
        record = ['0,1,1\n', 'new-line\n']
 
1367
        details = ('line-delta', False)
 
1368
        ann._num_compression_children[parent_key] = 2
 
1369
        ann._expand_record(parent_key, (), None, ['line1\n', 'line2\n'],
 
1370
                           ('fulltext', False))
 
1371
        res = ann._expand_record(rev_key, (parent_key,), parent_key,
 
1372
                                 record, details)
 
1373
        self.assertEqual({parent_key: 1}, ann._num_compression_children)
 
1374
        # Expanding the second child should remove the content object, and the
 
1375
        # num_compression_children entry
 
1376
        res = ann._expand_record(rev2_key, (parent_key,), parent_key,
 
1377
                                 record, details)
 
1378
        self.assertFalse(parent_key in ann._content_objects)
 
1379
        self.assertEqual({}, ann._num_compression_children)
 
1380
        # We should not cache the content_objects for rev2 and rev, because
 
1381
        # they do not have compression children of their own.
 
1382
        self.assertEqual({}, ann._content_objects)
 
1383
 
 
1384
    def test__expand_delta_records_blocks(self):
 
1385
        ann = self.make_annotator()
 
1386
        rev_key = ('rev-id',)
 
1387
        parent_key = ('parent-id',)
 
1388
        record = ['0,1,1\n', 'new-line\n']
 
1389
        details = ('line-delta', True)
 
1390
        ann._num_compression_children[parent_key] = 2
 
1391
        ann._expand_record(parent_key, (), None,
 
1392
                           ['line1\n', 'line2\n', 'line3\n'],
 
1393
                           ('fulltext', False))
 
1394
        ann._expand_record(rev_key, (parent_key,), parent_key, record, details)
 
1395
        self.assertEqual({(rev_key, parent_key): [(1, 1, 1), (3, 3, 0)]},
 
1396
                         ann._matching_blocks)
 
1397
        rev2_key = ('rev2-id',)
 
1398
        record = ['0,1,1\n', 'new-line\n']
 
1399
        details = ('line-delta', False)
 
1400
        ann._expand_record(rev2_key, (parent_key,), parent_key, record, details)
 
1401
        self.assertEqual([(1, 1, 2), (3, 3, 0)],
 
1402
                         ann._matching_blocks[(rev2_key, parent_key)])
 
1403
 
 
1404
    def test__get_parent_ann_uses_matching_blocks(self):
 
1405
        ann = self.make_annotator()
 
1406
        rev_key = ('rev-id',)
 
1407
        parent_key = ('parent-id',)
 
1408
        parent_ann = [(parent_key,)]*3
 
1409
        block_key = (rev_key, parent_key)
 
1410
        ann._annotations_cache[parent_key] = parent_ann
 
1411
        ann._matching_blocks[block_key] = [(0, 1, 1), (3, 3, 0)]
 
1412
        # We should not try to access any parent_lines content, because we know
 
1413
        # we already have the matching blocks
 
1414
        par_ann, blocks = ann._get_parent_annotations_and_matches(rev_key,
 
1415
                                        ['1\n', '2\n', '3\n'], parent_key)
 
1416
        self.assertEqual(parent_ann, par_ann)
 
1417
        self.assertEqual([(0, 1, 1), (3, 3, 0)], blocks)
 
1418
        self.assertEqual({}, ann._matching_blocks)
 
1419
 
 
1420
    def test__process_pending(self):
 
1421
        ann = self.make_annotator()
 
1422
        rev_key = ('rev-id',)
 
1423
        p1_key = ('p1-id',)
 
1424
        p2_key = ('p2-id',)
 
1425
        record = ['0,1,1\n', 'new-line\n']
 
1426
        details = ('line-delta', False)
 
1427
        p1_record = ['line1\n', 'line2\n']
 
1428
        ann._num_compression_children[p1_key] = 1
 
1429
        res = ann._expand_record(rev_key, (p1_key,p2_key), p1_key,
 
1430
                                 record, details)
 
1431
        self.assertEqual(None, res)
 
1432
        # self.assertTrue(p1_key in ann._pending_deltas)
 
1433
        self.assertEqual({}, ann._pending_annotation)
 
1434
        # Now insert p1, and we should be able to expand the delta
 
1435
        res = ann._expand_record(p1_key, (), None, p1_record,
 
1436
                                 ('fulltext', False))
 
1437
        self.assertEqual(p1_record, res)
 
1438
        ann._annotations_cache[p1_key] = [(p1_key,)]*2
 
1439
        res = ann._process_pending(p1_key)
 
1440
        self.assertEqual([], res)
 
1441
        self.assertFalse(p1_key in ann._pending_deltas)
 
1442
        self.assertTrue(p2_key in ann._pending_annotation)
 
1443
        self.assertEqual({p2_key: [(rev_key, (p1_key, p2_key))]},
 
1444
                         ann._pending_annotation)
 
1445
        # Now fill in parent 2, and pending annotation should be satisfied
 
1446
        res = ann._expand_record(p2_key, (), None, [], ('fulltext', False))
 
1447
        ann._annotations_cache[p2_key] = []
 
1448
        res = ann._process_pending(p2_key)
 
1449
        self.assertEqual([rev_key], res)
 
1450
        self.assertEqual({}, ann._pending_annotation)
 
1451
        self.assertEqual({}, ann._pending_deltas)
 
1452
 
 
1453
    def test_record_delta_removes_basis(self):
 
1454
        ann = self.make_annotator()
 
1455
        ann._expand_record(('parent-id',), (), None,
 
1456
                           ['line1\n', 'line2\n'], ('fulltext', False))
 
1457
        ann._num_compression_children['parent-id'] = 2
 
1458
 
 
1459
    def test_annotate_special_text(self):
 
1460
        ann = self.make_annotator()
 
1461
        vf = ann._vf
 
1462
        rev1_key = ('rev-1',)
 
1463
        rev2_key = ('rev-2',)
 
1464
        rev3_key = ('rev-3',)
 
1465
        spec_key = ('special:',)
 
1466
        vf.add_lines(rev1_key, [], ['initial content\n'])
 
1467
        vf.add_lines(rev2_key, [rev1_key], ['initial content\n',
 
1468
                                            'common content\n',
 
1469
                                            'content in 2\n'])
 
1470
        vf.add_lines(rev3_key, [rev1_key], ['initial content\n',
 
1471
                                            'common content\n',
 
1472
                                            'content in 3\n'])
 
1473
        spec_text = ('initial content\n'
 
1474
                     'common content\n'
 
1475
                     'content in 2\n'
 
1476
                     'content in 3\n')
 
1477
        ann.add_special_text(spec_key, [rev2_key, rev3_key], spec_text)
 
1478
        anns, lines = ann.annotate(spec_key)
 
1479
        self.assertEqual([(rev1_key,),
 
1480
                          (rev2_key, rev3_key),
 
1481
                          (rev2_key,),
 
1482
                          (rev3_key,),
 
1483
                         ], anns)
 
1484
        self.assertEqualDiff(spec_text, ''.join(lines))
 
1485
 
 
1486
 
1316
1487
class KnitTests(TestCaseWithTransport):
1317
1488
    """Class containing knit test helper routines."""
1318
1489