← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_index.py

  • Committer: John Arbash Meinel
  • Date: 2010-01-13 16:23:07 UTC
  • mto: (4634.119.7 2.0)
  • mto: This revision was merged to the branch mainline in revision 4959.
  • Revision ID: john@arbash-meinel.com-20100113162307-0bs82td16gzih827
Update the MANIFEST.in file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_index.py
1
 
# Copyright (C) 2007 Canonical Ltd
 
1
# Copyright (C) 2007, 2009 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
953
953
            ])
954
954
        self.assertEqual(set([]), index.external_references(0))
955
955
 
 
956
    def test__find_ancestors(self):
 
957
        key1 = ('key-1',)
 
958
        key2 = ('key-2',)
 
959
        index = self.make_index(ref_lists=1, key_elements=1, nodes=[
 
960
            (key1, 'value', ([key2],)),
 
961
            (key2, 'value', ([],)),
 
962
            ])
 
963
        parent_map = {}
 
964
        missing_keys = set()
 
965
        search_keys = index._find_ancestors([key1], 0, parent_map, missing_keys)
 
966
        self.assertEqual({key1: (key2,)}, parent_map)
 
967
        self.assertEqual(set(), missing_keys)
 
968
        self.assertEqual(set([key2]), search_keys)
 
969
        search_keys = index._find_ancestors(search_keys, 0, parent_map,
 
970
                                            missing_keys)
 
971
        self.assertEqual({key1: (key2,), key2: ()}, parent_map)
 
972
        self.assertEqual(set(), missing_keys)
 
973
        self.assertEqual(set(), search_keys)
 
974
 
 
975
    def test__find_ancestors_w_missing(self):
 
976
        key1 = ('key-1',)
 
977
        key2 = ('key-2',)
 
978
        key3 = ('key-3',)
 
979
        index = self.make_index(ref_lists=1, key_elements=1, nodes=[
 
980
            (key1, 'value', ([key2],)),
 
981
            (key2, 'value', ([],)),
 
982
            ])
 
983
        parent_map = {}
 
984
        missing_keys = set()
 
985
        search_keys = index._find_ancestors([key2, key3], 0, parent_map,
 
986
                                            missing_keys)
 
987
        self.assertEqual({key2: ()}, parent_map)
 
988
        self.assertEqual(set([key3]), missing_keys)
 
989
        self.assertEqual(set(), search_keys)
 
990
 
 
991
    def test__find_ancestors_dont_search_known(self):
 
992
        key1 = ('key-1',)
 
993
        key2 = ('key-2',)
 
994
        key3 = ('key-3',)
 
995
        index = self.make_index(ref_lists=1, key_elements=1, nodes=[
 
996
            (key1, 'value', ([key2],)),
 
997
            (key2, 'value', ([key3],)),
 
998
            (key3, 'value', ([],)),
 
999
            ])
 
1000
        # We already know about key2, so we won't try to search for key3
 
1001
        parent_map = {key2: (key3,)}
 
1002
        missing_keys = set()
 
1003
        search_keys = index._find_ancestors([key1], 0, parent_map,
 
1004
                                            missing_keys)
 
1005
        self.assertEqual({key1: (key2,), key2: (key3,)}, parent_map)
 
1006
        self.assertEqual(set(), missing_keys)
 
1007
        self.assertEqual(set(), search_keys)
 
1008
 
 
1009
    def test_supports_unlimited_cache(self):
 
1010
        builder = GraphIndexBuilder(0, key_elements=1)
 
1011
        stream = builder.finish()
 
1012
        trans = get_transport(self.get_url())
 
1013
        size = trans.put_file('index', stream)
 
1014
        # It doesn't matter what unlimited_cache does here, just that it can be
 
1015
        # passed
 
1016
        index = GraphIndex(trans, 'index', size, unlimited_cache=True)
 
1017
 
956
1018
 
957
1019
class TestCombinedGraphIndex(TestCaseWithMemoryTransport):
958
1020
 
1271
1333
                                    ['1', '2', '3'])
1272
1334
        self.assertRaises(errors.NoSuchFile, index.validate)
1273
1335
 
 
1336
    def test_find_ancestors_across_indexes(self):
 
1337
        key1 = ('key-1',)
 
1338
        key2 = ('key-2',)
 
1339
        key3 = ('key-3',)
 
1340
        key4 = ('key-4',)
 
1341
        index1 = self.make_index('12', ref_lists=1, nodes=[
 
1342
            (key1, 'value', ([],)),
 
1343
            (key2, 'value', ([key1],)),
 
1344
            ])
 
1345
        index2 = self.make_index('34', ref_lists=1, nodes=[
 
1346
            (key3, 'value', ([key2],)),
 
1347
            (key4, 'value', ([key3],)),
 
1348
            ])
 
1349
        c_index = CombinedGraphIndex([index1, index2])
 
1350
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
 
1351
        self.assertEqual({key1: ()}, parent_map)
 
1352
        self.assertEqual(set(), missing_keys)
 
1353
        # Now look for a key from index2 which requires us to find the key in
 
1354
        # the second index, and then continue searching for parents in the
 
1355
        # first index
 
1356
        parent_map, missing_keys = c_index.find_ancestry([key3], 0)
 
1357
        self.assertEqual({key1: (), key2: (key1,), key3: (key2,)}, parent_map)
 
1358
        self.assertEqual(set(), missing_keys)
 
1359
 
 
1360
    def test_find_ancestors_missing_keys(self):
 
1361
        key1 = ('key-1',)
 
1362
        key2 = ('key-2',)
 
1363
        key3 = ('key-3',)
 
1364
        key4 = ('key-4',)
 
1365
        index1 = self.make_index('12', ref_lists=1, nodes=[
 
1366
            (key1, 'value', ([],)),
 
1367
            (key2, 'value', ([key1],)),
 
1368
            ])
 
1369
        index2 = self.make_index('34', ref_lists=1, nodes=[
 
1370
            (key3, 'value', ([key2],)),
 
1371
            ])
 
1372
        c_index = CombinedGraphIndex([index1, index2])
 
1373
        # Searching for a key which is actually not present at all should
 
1374
        # eventually converge
 
1375
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
 
1376
        self.assertEqual({}, parent_map)
 
1377
        self.assertEqual(set([key4]), missing_keys)
 
1378
 
 
1379
    def test_find_ancestors_no_indexes(self):
 
1380
        c_index = CombinedGraphIndex([])
 
1381
        key1 = ('key-1',)
 
1382
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
 
1383
        self.assertEqual({}, parent_map)
 
1384
        self.assertEqual(set([key1]), missing_keys)
 
1385
 
 
1386
    def test_find_ancestors_ghost_parent(self):
 
1387
        key1 = ('key-1',)
 
1388
        key2 = ('key-2',)
 
1389
        key3 = ('key-3',)
 
1390
        key4 = ('key-4',)
 
1391
        index1 = self.make_index('12', ref_lists=1, nodes=[
 
1392
            (key1, 'value', ([],)),
 
1393
            (key2, 'value', ([key1],)),
 
1394
            ])
 
1395
        index2 = self.make_index('34', ref_lists=1, nodes=[
 
1396
            (key4, 'value', ([key2, key3],)),
 
1397
            ])
 
1398
        c_index = CombinedGraphIndex([index1, index2])
 
1399
        # Searching for a key which is actually not present at all should
 
1400
        # eventually converge
 
1401
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
 
1402
        self.assertEqual({key4: (key2, key3), key2: (key1,), key1: ()},
 
1403
                         parent_map)
 
1404
        self.assertEqual(set([key3]), missing_keys)
 
1405
 
 
1406
    def test__find_ancestors_empty_index(self):
 
1407
        index = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
 
1408
        parent_map = {}
 
1409
        missing_keys = set()
 
1410
        search_keys = index._find_ancestors([('one',), ('two',)], 0, parent_map,
 
1411
                                            missing_keys)
 
1412
        self.assertEqual(set(), search_keys)
 
1413
        self.assertEqual({}, parent_map)
 
1414
        self.assertEqual(set([('one',), ('two',)]), missing_keys)
 
1415
 
1274
1416
 
1275
1417
class TestInMemoryGraphIndex(TestCaseWithMemoryTransport):
1276
1418