/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_btree_index.py

• browse files at revision 6624
• compare with another revision
• download diff
• download tarball
• view history from revision 6624

Show diffs side-by-side

added

removed

breezy/tests/test_btree_index.py

20

20

import pprint

21

21

import zlib

22

22

 

23

 

from breezy 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 breezy.tests import (

 

32

from ..tests import (

33

33

    TestCaseWithTransport,

34

34

    scenarios,

35

35

    )

36

 

from breezy.tests import (

 

36

from ..tests import (

37

37

    features,

38

38

    )

39

39

 

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)

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0