/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_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:
16
16
 
17
17
"""Tests for indices."""
18
18
 
19
 
from bzrlib import (
 
19
from .. import (
20
20
    errors,
21
21
    index,
22
22
    tests,
738
738
        index = self.make_index(1, nodes=[
739
739
            (('name', ), 'data', ([('ref', )], )),
740
740
            (('ref', ), 'refdata', ([], ))])
741
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
742
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
741
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
742
            (index, ('ref', ), 'refdata', ((), ))},
743
743
            set(index.iter_all_entries()))
744
744
 
745
745
    def test_iter_entries_buffers_once(self):
746
746
        index = self.make_index(nodes=self.make_nodes(2))
747
747
        # reset the transport log
748
748
        del index._transport._activity[:]
749
 
        self.assertEqual(set([(index, self.make_key(1), self.make_value(1))]),
 
749
        self.assertEqual({(index, self.make_key(1), self.make_value(1))},
750
750
                         set(index.iter_entries([self.make_key(1)])))
751
751
        # We should have requested reading the header bytes
752
752
        # But not needed any more than that because it would have triggered a
788
788
        index = self.make_index(1, nodes=[
789
789
            (('name', ), 'data', ([('ref', ), ('ref', )], )),
790
790
            (('ref', ), 'refdata', ([], ))])
791
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),('ref',)),)),
792
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
791
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),('ref',)),)),
 
792
            (index, ('ref', ), 'refdata', ((), ))},
793
793
            set(index.iter_entries([('name',), ('ref',)])))
794
794
 
795
795
    def test_iter_entries_references_2_refs_resolved(self):
796
796
        index = self.make_index(2, nodes=[
797
797
            (('name', ), 'data', ([('ref', )], [('ref', )])),
798
798
            (('ref', ), 'refdata', ([], []))])
799
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),), (('ref',),))),
800
 
            (index, ('ref', ), 'refdata', ((), ()))]),
 
799
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),), (('ref',),))),
 
800
            (index, ('ref', ), 'refdata', ((), ()))},
801
801
            set(index.iter_entries([('name',), ('ref',)])))
802
802
 
803
803
    def test_iteration_absent_skipped(self):
804
804
        index = self.make_index(1, nodes=[
805
805
            (('name', ), 'data', ([('ref', )], ))])
806
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
806
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
807
807
            set(index.iter_all_entries()))
808
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
808
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
809
809
            set(index.iter_entries([('name', )])))
810
810
        self.assertEqual([], list(index.iter_entries([('ref', )])))
811
811
 
812
812
    def test_iteration_absent_skipped_2_element_keys(self):
813
813
        index = self.make_index(1, key_elements=2, nodes=[
814
814
            (('name', 'fin'), 'data', ([('ref', 'erence')], ))])
815
 
        self.assertEqual(set([(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))]),
 
815
        self.assertEqual({(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))},
816
816
            set(index.iter_all_entries()))
817
 
        self.assertEqual(set([(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))]),
 
817
        self.assertEqual({(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))},
818
818
            set(index.iter_entries([('name', 'fin')])))
819
819
        self.assertEqual([], list(index.iter_entries([('ref', 'erence')])))
820
820
 
822
822
        index = self.make_index(1, nodes=[
823
823
            (('name', ), 'data', ([('ref', )], )),
824
824
            (('ref', ), 'refdata', ([], ))])
825
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
826
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
825
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
826
            (index, ('ref', ), 'refdata', ((), ))},
827
827
            set(index.iter_entries([('name', ), ('ref', )])))
828
828
 
829
829
    def test_iter_nothing_empty(self):
858
858
        index = self.make_index( nodes=[
859
859
            (('name', ), 'data', ()),
860
860
            (('ref', ), 'refdata', ())])
861
 
        self.assertEqual(set([(index, ('name', ), 'data'),
862
 
            (index, ('ref', ), 'refdata')]),
 
861
        self.assertEqual({(index, ('name', ), 'data'),
 
862
            (index, ('ref', ), 'refdata')},
863
863
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
864
864
 
865
865
    def test_iter_key_prefix_1_key_element_refs(self):
866
866
        index = self.make_index(1, nodes=[
867
867
            (('name', ), 'data', ([('ref', )], )),
868
868
            (('ref', ), 'refdata', ([], ))])
869
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
870
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
869
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
870
            (index, ('ref', ), 'refdata', ((), ))},
871
871
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
872
872
 
873
873
    def test_iter_key_prefix_2_key_element_no_refs(self):
875
875
            (('name', 'fin1'), 'data', ()),
876
876
            (('name', 'fin2'), 'beta', ()),
877
877
            (('ref', 'erence'), 'refdata', ())])
878
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
879
 
            (index, ('ref', 'erence'), 'refdata')]),
 
878
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
879
            (index, ('ref', 'erence'), 'refdata')},
880
880
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
881
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
882
 
            (index, ('name', 'fin2'), 'beta')]),
 
881
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
882
            (index, ('name', 'fin2'), 'beta')},
883
883
            set(index.iter_entries_prefix([('name', None)])))
884
884
 
885
885
    def test_iter_key_prefix_2_key_element_refs(self):
887
887
            (('name', 'fin1'), 'data', ([('ref', 'erence')], )),
888
888
            (('name', 'fin2'), 'beta', ([], )),
889
889
            (('ref', 'erence'), 'refdata', ([], ))])
890
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
891
 
            (index, ('ref', 'erence'), 'refdata', ((), ))]),
 
890
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
891
            (index, ('ref', 'erence'), 'refdata', ((), ))},
892
892
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
893
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
894
 
            (index, ('name', 'fin2'), 'beta', ((), ))]),
 
893
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
894
            (index, ('name', 'fin2'), 'beta', ((), ))},
895
895
            set(index.iter_entries_prefix([('name', None)])))
896
896
 
897
897
    def test_key_count_empty(self):
984
984
        missing_key = ('missing',)
985
985
        index = self.make_index(ref_lists=1, nodes=[
986
986
            (('key',), 'value', ([missing_key],))])
987
 
        self.assertEqual(set([missing_key]), index.external_references(0))
 
987
        self.assertEqual({missing_key}, index.external_references(0))
988
988
 
989
989
    def test_external_references_multiple_ref_lists(self):
990
990
        missing_key = ('missing',)
991
991
        index = self.make_index(ref_lists=2, nodes=[
992
992
            (('key',), 'value', ([], [missing_key]))])
993
993
        self.assertEqual(set([]), index.external_references(0))
994
 
        self.assertEqual(set([missing_key]), index.external_references(1))
 
994
        self.assertEqual({missing_key}, index.external_references(1))
995
995
 
996
996
    def test_external_references_two_records(self):
997
997
        index = self.make_index(ref_lists=1, nodes=[
1012
1012
        search_keys = index._find_ancestors([key1], 0, parent_map, missing_keys)
1013
1013
        self.assertEqual({key1: (key2,)}, parent_map)
1014
1014
        self.assertEqual(set(), missing_keys)
1015
 
        self.assertEqual(set([key2]), search_keys)
 
1015
        self.assertEqual({key2}, search_keys)
1016
1016
        search_keys = index._find_ancestors(search_keys, 0, parent_map,
1017
1017
                                            missing_keys)
1018
1018
        self.assertEqual({key1: (key2,), key2: ()}, parent_map)
1032
1032
        search_keys = index._find_ancestors([key2, key3], 0, parent_map,
1033
1033
                                            missing_keys)
1034
1034
        self.assertEqual({key2: ()}, parent_map)
1035
 
        self.assertEqual(set([key3]), missing_keys)
 
1035
        self.assertEqual({key3}, missing_keys)
1036
1036
        self.assertEqual(set(), search_keys)
1037
1037
 
1038
1038
    def test__find_ancestors_dont_search_known(self):
1187
1187
                (('name', 'fin2'), 'beta', ([], )),
1188
1188
                (('ref', 'erence'), 'refdata', ([], ))])
1189
1189
        idx = index.CombinedGraphIndex([idx1, idx2])
1190
 
        self.assertEqual(set([(idx1, ('name', 'fin1'), 'data',
 
1190
        self.assertEqual({(idx1, ('name', 'fin1'), 'data',
1191
1191
                               ((('ref', 'erence'),),)),
1192
 
                              (idx2, ('ref', 'erence'), 'refdata', ((), ))]),
 
1192
                              (idx2, ('ref', 'erence'), 'refdata', ((), ))},
1193
1193
                         set(idx.iter_entries_prefix([('name', 'fin1'),
1194
1194
                                                        ('ref', 'erence')])))
1195
 
        self.assertEqual(set([(idx1, ('name', 'fin1'), 'data',
 
1195
        self.assertEqual({(idx1, ('name', 'fin1'), 'data',
1196
1196
                               ((('ref', 'erence'),),)),
1197
 
                              (idx2, ('name', 'fin2'), 'beta', ((), ))]),
 
1197
                              (idx2, ('name', 'fin2'), 'beta', ((), ))},
1198
1198
                         set(idx.iter_entries_prefix([('name', None)])))
1199
1199
 
1200
1200
    def test_iter_nothing_empty(self):
1211
1211
                                               ([('ref', )], ))])
1212
1212
        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ((), ))])
1213
1213
        idx = index.CombinedGraphIndex([idx1, idx2])
1214
 
        self.assertEqual(set([(idx1, ('name', ), 'data', ((('ref', ), ), )),
1215
 
                              (idx2, ('ref', ), 'refdata', ((), ))]),
 
1214
        self.assertEqual({(idx1, ('name', ), 'data', ((('ref', ), ), )),
 
1215
                              (idx2, ('ref', ), 'refdata', ((), ))},
1216
1216
                         set(idx.iter_entries([('name', ), ('ref', )])))
1217
1217
 
1218
1218
    def test_iter_all_keys_dup_entry(self):
1221
1221
                                                (('ref', ), 'refdata', ([], ))])
1222
1222
        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ([], ))])
1223
1223
        idx = index.CombinedGraphIndex([idx1, idx2])
1224
 
        self.assertEqual(set([(idx1, ('name', ), 'data', ((('ref',),),)),
1225
 
                              (idx1, ('ref', ), 'refdata', ((), ))]),
 
1224
        self.assertEqual({(idx1, ('name', ), 'data', ((('ref',),),)),
 
1225
                              (idx1, ('ref', ), 'refdata', ((), ))},
1226
1226
                         set(idx.iter_entries([('name', ), ('ref', )])))
1227
1227
 
1228
1228
    def test_iter_missing_entry_empty(self):
1491
1491
        # eventually converge
1492
1492
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1493
1493
        self.assertEqual({}, parent_map)
1494
 
        self.assertEqual(set([key4]), missing_keys)
 
1494
        self.assertEqual({key4}, missing_keys)
1495
1495
 
1496
1496
    def test_find_ancestors_no_indexes(self):
1497
1497
        c_index = index.CombinedGraphIndex([])
1498
1498
        key1 = ('key-1',)
1499
1499
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1500
1500
        self.assertEqual({}, parent_map)
1501
 
        self.assertEqual(set([key1]), missing_keys)
 
1501
        self.assertEqual({key1}, missing_keys)
1502
1502
 
1503
1503
    def test_find_ancestors_ghost_parent(self):
1504
1504
        key1 = ('key-1',)
1518
1518
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1519
1519
        self.assertEqual({key4: (key2, key3), key2: (key1,), key1: ()},
1520
1520
                         parent_map)
1521
 
        self.assertEqual(set([key3]), missing_keys)
 
1521
        self.assertEqual({key3}, missing_keys)
1522
1522
 
1523
1523
    def test__find_ancestors_empty_index(self):
1524
1524
        idx = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
1528
1528
                                          missing_keys)
1529
1529
        self.assertEqual(set(), search_keys)
1530
1530
        self.assertEqual({}, parent_map)
1531
 
        self.assertEqual(set([('one',), ('two',)]), missing_keys)
 
1531
        self.assertEqual({('one',), ('two',)}, missing_keys)
1532
1532
 
1533
1533
 
1534
1534
class TestInMemoryGraphIndex(tests.TestCaseWithMemoryTransport):
1542
1542
        index = self.make_index(0)
1543
1543
        index.add_nodes([(('name', ), 'data')])
1544
1544
        index.add_nodes([(('name2', ), ''), (('name3', ), '')])
1545
 
        self.assertEqual(set([
 
1545
        self.assertEqual({
1546
1546
            (index, ('name', ), 'data'),
1547
1547
            (index, ('name2', ), ''),
1548
1548
            (index, ('name3', ), ''),
1549
 
            ]), set(index.iter_all_entries()))
 
1549
            }, set(index.iter_all_entries()))
1550
1550
 
1551
1551
    def test_add_nodes(self):
1552
1552
        index = self.make_index(1)
1553
1553
        index.add_nodes([(('name', ), 'data', ([],))])
1554
1554
        index.add_nodes([(('name2', ), '', ([],)), (('name3', ), '', ([('r', )],))])
1555
 
        self.assertEqual(set([
 
1555
        self.assertEqual({
1556
1556
            (index, ('name', ), 'data', ((),)),
1557
1557
            (index, ('name2', ), '', ((),)),
1558
1558
            (index, ('name3', ), '', ((('r', ), ), )),
1559
 
            ]), set(index.iter_all_entries()))
 
1559
            }, set(index.iter_all_entries()))
1560
1560
 
1561
1561
    def test_iter_all_entries_empty(self):
1562
1562
        index = self.make_index()
1571
1571
        index = self.make_index(1, nodes=[
1572
1572
            (('name', ), 'data', ([('ref', )], )),
1573
1573
            (('ref', ), 'refdata', ([], ))])
1574
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref', ),),)),
1575
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
1574
        self.assertEqual({(index, ('name', ), 'data', ((('ref', ),),)),
 
1575
            (index, ('ref', ), 'refdata', ((), ))},
1576
1576
            set(index.iter_all_entries()))
1577
1577
 
1578
1578
    def test_iteration_absent_skipped(self):
1579
1579
        index = self.make_index(1, nodes=[
1580
1580
            (('name', ), 'data', ([('ref', )], ))])
1581
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
1581
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
1582
1582
            set(index.iter_all_entries()))
1583
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
1583
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
1584
1584
            set(index.iter_entries([('name', )])))
1585
1585
        self.assertEqual([], list(index.iter_entries([('ref', )])))
1586
1586
 
1588
1588
        index = self.make_index(1, nodes=[
1589
1589
            (('name', ), 'data', ([('ref', )], )),
1590
1590
            (('ref', ), 'refdata', ([], ))])
1591
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
1592
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
1591
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
1592
            (index, ('ref', ), 'refdata', ((), ))},
1593
1593
            set(index.iter_entries([('name', ), ('ref', )])))
1594
1594
 
1595
1595
    def test_iter_key_prefix_1_key_element_no_refs(self):
1596
1596
        index = self.make_index( nodes=[
1597
1597
            (('name', ), 'data'),
1598
1598
            (('ref', ), 'refdata')])
1599
 
        self.assertEqual(set([(index, ('name', ), 'data'),
1600
 
            (index, ('ref', ), 'refdata')]),
 
1599
        self.assertEqual({(index, ('name', ), 'data'),
 
1600
            (index, ('ref', ), 'refdata')},
1601
1601
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
1602
1602
 
1603
1603
    def test_iter_key_prefix_1_key_element_refs(self):
1604
1604
        index = self.make_index(1, nodes=[
1605
1605
            (('name', ), 'data', ([('ref', )], )),
1606
1606
            (('ref', ), 'refdata', ([], ))])
1607
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
1608
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
1607
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
1608
            (index, ('ref', ), 'refdata', ((), ))},
1609
1609
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
1610
1610
 
1611
1611
    def test_iter_key_prefix_2_key_element_no_refs(self):
1613
1613
            (('name', 'fin1'), 'data'),
1614
1614
            (('name', 'fin2'), 'beta'),
1615
1615
            (('ref', 'erence'), 'refdata')])
1616
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
1617
 
            (index, ('ref', 'erence'), 'refdata')]),
 
1616
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
1617
            (index, ('ref', 'erence'), 'refdata')},
1618
1618
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
1619
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
1620
 
            (index, ('name', 'fin2'), 'beta')]),
 
1619
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
1620
            (index, ('name', 'fin2'), 'beta')},
1621
1621
            set(index.iter_entries_prefix([('name', None)])))
1622
1622
 
1623
1623
    def test_iter_key_prefix_2_key_element_refs(self):
1625
1625
            (('name', 'fin1'), 'data', ([('ref', 'erence')], )),
1626
1626
            (('name', 'fin2'), 'beta', ([], )),
1627
1627
            (('ref', 'erence'), 'refdata', ([], ))])
1628
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1629
 
            (index, ('ref', 'erence'), 'refdata', ((), ))]),
 
1628
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
1629
            (index, ('ref', 'erence'), 'refdata', ((), ))},
1630
1630
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
1631
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1632
 
            (index, ('name', 'fin2'), 'beta', ((), ))]),
 
1631
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
1632
            (index, ('name', 'fin2'), 'beta', ((), ))},
1633
1633
            set(index.iter_entries_prefix([('name', None)])))
1634
1634
 
1635
1635
    def test_iter_nothing_empty(self):
1679
1679
    def test_add_node(self):
1680
1680
        index, adapter = self.make_index(add_callback=True)
1681
1681
        adapter.add_node(('key',), 'value', ((('ref',),),))
1682
 
        self.assertEqual(set([(index, ('prefix', 'key'), 'value',
1683
 
                               ((('prefix', 'ref'),),))]),
 
1682
        self.assertEqual({(index, ('prefix', 'key'), 'value',
 
1683
                               ((('prefix', 'ref'),),))},
1684
1684
            set(index.iter_all_entries()))
1685
1685
 
1686
1686
    def test_add_nodes(self):
1689
1689
            (('key',), 'value', ((('ref',),),)),
1690
1690
            (('key2',), 'value2', ((),)),
1691
1691
            ))
1692
 
        self.assertEqual(set([
 
1692
        self.assertEqual({
1693
1693
            (index, ('prefix', 'key2'), 'value2', ((),)),
1694
1694
            (index, ('prefix', 'key'), 'value', ((('prefix', 'ref'),),))
1695
 
            ]),
 
1695
            },
1696
1696
            set(index.iter_all_entries()))
1697
1697
 
1698
1698
    def test_construct(self):
1714
1714
            (('notprefix', 'key1'), 'data', ((), )),
1715
1715
            (('prefix', 'key1'), 'data1', ((), )),
1716
1716
            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
1717
 
        self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),
1718
 
            (index, ('key2', ), 'data2', ((('key1',),),))]),
 
1717
        self.assertEqual({(index, ('key1', ), 'data1', ((),)),
 
1718
            (index, ('key2', ), 'data2', ((('key1',),),))},
1719
1719
            set(adapter.iter_all_entries()))
1720
1720
 
1721
1721
    def test_iter_entries(self):
1724
1724
            (('prefix', 'key1'), 'data1', ((), )),
1725
1725
            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
1726
1726
        # ask for many - get all
1727
 
        self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),
1728
 
            (index, ('key2', ), 'data2', ((('key1', ),),))]),
 
1727
        self.assertEqual({(index, ('key1', ), 'data1', ((),)),
 
1728
            (index, ('key2', ), 'data2', ((('key1', ),),))},
1729
1729
            set(adapter.iter_entries([('key1', ), ('key2', )])))
1730
1730
        # ask for one, get one
1731
 
        self.assertEqual(set([(index, ('key1', ), 'data1', ((),))]),
 
1731
        self.assertEqual({(index, ('key1', ), 'data1', ((),))},
1732
1732
            set(adapter.iter_entries([('key1', )])))
1733
1733
        # ask for missing, get none
1734
1734
        self.assertEqual(set(),
1740
1740
            (('prefix', 'prefix2', 'key1'), 'data1', ((), )),
1741
1741
            (('prefix', 'prefix2', 'key2'), 'data2', ((('prefix', 'prefix2', 'key1'),),))])
1742
1742
        # ask for a prefix, get the results for just that prefix, adjusted.
1743
 
        self.assertEqual(set([(index, ('prefix2', 'key1', ), 'data1', ((),)),
1744
 
            (index, ('prefix2', 'key2', ), 'data2', ((('prefix2', 'key1', ),),))]),
 
1743
        self.assertEqual({(index, ('prefix2', 'key1', ), 'data1', ((),)),
 
1744
            (index, ('prefix2', 'key2', ), 'data2', ((('prefix2', 'key1', ),),))},
1745
1745
            set(adapter.iter_entries_prefix([('prefix2', None)])))
1746
1746
 
1747
1747
    def test_key_count_no_matching_keys(self):