/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/tests/test_btree_index.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
20
20
import pprint
21
21
import zlib
22
22
 
23
 
from bzrlib import (
 
23
from .. import (
24
24
    btree_index,
25
25
    errors,
26
26
    fifo_cache,
29
29
    tests,
30
30
    transport,
31
31
    )
32
 
from bzrlib.tests import (
 
32
from ..tests import (
33
33
    TestCaseWithTransport,
34
34
    scenarios,
35
35
    )
36
 
from bzrlib.tests import (
 
36
from ..tests import (
37
37
    features,
38
38
    )
39
39
 
42
42
 
43
43
 
44
44
def btreeparser_scenarios():
45
 
    import bzrlib._btree_serializer_py as py_module
 
45
    import breezy._btree_serializer_py as py_module
46
46
    scenarios = [('python', {'parse_btree': py_module})]
47
47
    if compiled_btreeparser_feature.available():
48
48
        scenarios.append(('C', 
51
51
 
52
52
 
53
53
compiled_btreeparser_feature = features.ModuleAvailableFeature(
54
 
    'bzrlib._btree_serializer_pyx')
 
54
    'breezy._btree_serializer_pyx')
55
55
 
56
56
 
57
57
class BTreeTestCase(TestCaseWithTransport):
402
402
        self.assertEqual([(builder,) + node for node in sorted(nodes[:13])],
403
403
            list(builder.iter_all_entries()))
404
404
        # Two nodes - one memory one disk
405
 
        self.assertEqual(set([(builder,) + node for node in nodes[11:13]]),
 
405
        self.assertEqual({(builder,) + node for node in nodes[11:13]},
406
406
            set(builder.iter_entries([nodes[12][0], nodes[11][0]])))
407
407
        self.assertEqual(13, builder.key_count())
408
 
        self.assertEqual(set([(builder,) + node for node in nodes[11:13]]),
 
408
        self.assertEqual({(builder,) + node for node in nodes[11:13]},
409
409
            set(builder.iter_entries_prefix([nodes[12][0], nodes[11][0]])))
410
410
        builder.add_node(*nodes[13])
411
411
        self.assertEqual(3, len(builder._backing_indices))
476
476
        self.assertEqual([(builder,) + node for node in sorted(nodes[:13])],
477
477
            list(builder.iter_all_entries()))
478
478
        # Two nodes - one memory one disk
479
 
        self.assertEqual(set([(builder,) + node for node in nodes[11:13]]),
 
479
        self.assertEqual({(builder,) + node for node in nodes[11:13]},
480
480
            set(builder.iter_entries([nodes[12][0], nodes[11][0]])))
481
481
        self.assertEqual(13, builder.key_count())
482
 
        self.assertEqual(set([(builder,) + node for node in nodes[11:13]]),
 
482
        self.assertEqual({(builder,) + node for node in nodes[11:13]},
483
483
            set(builder.iter_entries_prefix([nodes[12][0], nodes[11][0]])))
484
484
        builder.add_node(*nodes[13])
485
485
        builder.add_node(*nodes[14])
576
576
        self.assertEqual([(builder,) + node for node in sorted(nodes[:13])],
577
577
            list(builder.iter_all_entries()))
578
578
        # Two nodes - one memory one disk
579
 
        self.assertEqual(set([(builder,) + node for node in nodes[11:13]]),
 
579
        self.assertEqual({(builder,) + node for node in nodes[11:13]},
580
580
            set(builder.iter_entries([nodes[12][0], nodes[11][0]])))
581
581
        self.assertEqual(13, builder.key_count())
582
 
        self.assertEqual(set([(builder,) + node for node in nodes[11:13]]),
 
582
        self.assertEqual({(builder,) + node for node in nodes[11:13]},
583
583
            set(builder.iter_entries_prefix([nodes[12][0], nodes[11][0]])))
584
584
        builder.add_node(*nodes[13])
585
585
        self.assertEqual(3, len(builder._backing_indices))
910
910
        index = self.make_index(1, nodes=[
911
911
            (('name', ), 'data', ([('ref', ), ('ref', )], )),
912
912
            (('ref', ), 'refdata', ([], ))])
913
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),('ref',)),)),
914
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
913
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),('ref',)),)),
 
914
            (index, ('ref', ), 'refdata', ((), ))},
915
915
            set(index.iter_entries([('name',), ('ref',)])))
916
916
 
917
917
    def test_iter_entries_references_2_refs_resolved(self):
962
962
        index = self.make_index( nodes=[
963
963
            (('name', ), 'data', ()),
964
964
            (('ref', ), 'refdata', ())])
965
 
        self.assertEqual(set([(index, ('name', ), 'data'),
966
 
            (index, ('ref', ), 'refdata')]),
 
965
        self.assertEqual({(index, ('name', ), 'data'),
 
966
            (index, ('ref', ), 'refdata')},
967
967
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
968
968
 
969
969
    def test_iter_key_prefix_1_key_element_refs(self):
970
970
        index = self.make_index(1, nodes=[
971
971
            (('name', ), 'data', ([('ref', )], )),
972
972
            (('ref', ), 'refdata', ([], ))])
973
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
974
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
973
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
974
            (index, ('ref', ), 'refdata', ((), ))},
975
975
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
976
976
 
977
977
    def test_iter_key_prefix_2_key_element_no_refs(self):
979
979
            (('name', 'fin1'), 'data', ()),
980
980
            (('name', 'fin2'), 'beta', ()),
981
981
            (('ref', 'erence'), 'refdata', ())])
982
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
983
 
            (index, ('ref', 'erence'), 'refdata')]),
 
982
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
983
            (index, ('ref', 'erence'), 'refdata')},
984
984
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
985
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
986
 
            (index, ('name', 'fin2'), 'beta')]),
 
985
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
986
            (index, ('name', 'fin2'), 'beta')},
987
987
            set(index.iter_entries_prefix([('name', None)])))
988
988
 
989
989
    def test_iter_key_prefix_2_key_element_refs(self):
991
991
            (('name', 'fin1'), 'data', ([('ref', 'erence')], )),
992
992
            (('name', 'fin2'), 'beta', ([], )),
993
993
            (('ref', 'erence'), 'refdata', ([], ))])
994
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
995
 
            (index, ('ref', 'erence'), 'refdata', ((), ))]),
 
994
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
995
            (index, ('ref', 'erence'), 'refdata', ((), ))},
996
996
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
997
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
998
 
            (index, ('name', 'fin2'), 'beta', ((), ))]),
 
997
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
998
            (index, ('name', 'fin2'), 'beta', ((), ))},
999
999
            set(index.iter_entries_prefix([('name', None)])))
1000
1000
 
1001
1001
    # XXX: external_references tests are duplicated in test_index.  We
1013
1013
        missing_key = ('missing',)
1014
1014
        index = self.make_index(ref_lists=1, nodes=[
1015
1015
            (('key',), 'value', ([missing_key],))])
1016
 
        self.assertEqual(set([missing_key]), index.external_references(0))
 
1016
        self.assertEqual({missing_key}, index.external_references(0))
1017
1017
 
1018
1018
    def test_external_references_multiple_ref_lists(self):
1019
1019
        missing_key = ('missing',)
1020
1020
        index = self.make_index(ref_lists=2, nodes=[
1021
1021
            (('key',), 'value', ([], [missing_key]))])
1022
1022
        self.assertEqual(set([]), index.external_references(0))
1023
 
        self.assertEqual(set([missing_key]), index.external_references(1))
 
1023
        self.assertEqual({missing_key}, index.external_references(1))
1024
1024
 
1025
1025
    def test_external_references_two_records(self):
1026
1026
        index = self.make_index(ref_lists=1, nodes=[
1058
1058
        self.assertEqual({key2: ()}, parent_map)
1059
1059
        # we know that key3 is missing because we read the page that it would
1060
1060
        # otherwise be on
1061
 
        self.assertEqual(set([key3]), missing_keys)
 
1061
        self.assertEqual({key3}, missing_keys)
1062
1062
        self.assertEqual(set(), search_keys)
1063
1063
 
1064
1064
    def test__find_ancestors_one_parent_missing(self):
1078
1078
        # all we know is that key3 wasn't present on the page we were reading
1079
1079
        # but if you look, the last key is key2 which comes before key3, so we
1080
1080
        # don't know whether key3 would land on this page or not.
1081
 
        self.assertEqual(set([key3]), search_keys)
 
1081
        self.assertEqual({key3}, search_keys)
1082
1082
        search_keys = index._find_ancestors(search_keys, 0, parent_map,
1083
1083
                                            missing_keys)
1084
1084
        # passing it back in, we are sure it is 'missing'
1085
1085
        self.assertEqual({key1: (key2,), key2: (key3,)}, parent_map)
1086
 
        self.assertEqual(set([key3]), missing_keys)
 
1086
        self.assertEqual({key3}, missing_keys)
1087
1087
        self.assertEqual(set([]), search_keys)
1088
1088
 
1089
1089
    def test__find_ancestors_dont_search_known(self):
1145
1145
                                            missing_keys)
1146
1146
        self.assertEqual([min_l2_key, next_key], sorted(parent_map))
1147
1147
        self.assertEqual(set(), missing_keys)
1148
 
        self.assertEqual(set([max_l1_key]), search_keys)
 
1148
        self.assertEqual({max_l1_key}, search_keys)
1149
1149
        parent_map = {}
1150
1150
        search_keys = index._find_ancestors([max_l1_key], 0, parent_map,
1151
1151
                                            missing_keys)
1161
1161
                                            missing_keys)
1162
1162
        self.assertEqual(set(), search_keys)
1163
1163
        self.assertEqual({}, parent_map)
1164
 
        self.assertEqual(set([('one',), ('two',)]), missing_keys)
 
1164
        self.assertEqual({('one',), ('two',)}, missing_keys)
1165
1165
 
1166
1166
    def test_supports_unlimited_cache(self):
1167
1167
        builder = btree_index.BTreeBuilder(reference_lists=0, key_elements=1)