/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_chk_map.py

  • Committer: John Arbash Meinel
  • Date: 2009-06-22 15:47:25 UTC
  • mfrom: (4467 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4469.
  • Revision ID: john@arbash-meinel.com-20090622154725-eidwkrs93j1qhmsf
Merge bzr.dev 4467 in prep for updating NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_chk_map.py
78
78
        root_key = CHKMap.from_dict(chk_bytes, a_dict,
79
79
            maximum_size=maximum_size, key_width=key_width,
80
80
            search_key_func=search_key_func)
 
81
        root_key2 = CHKMap._create_via_map(chk_bytes, a_dict,
 
82
            maximum_size=maximum_size, key_width=key_width,
 
83
            search_key_func=search_key_func)
 
84
        self.assertEqual(root_key, root_key2, "CHKMap.from_dict() did not"
 
85
                         " match CHKMap._create_via_map")
81
86
        chkmap = CHKMap(chk_bytes, root_key, search_key_func=search_key_func)
82
87
        return chkmap
83
88
 
1560
1565
        child.map(None, ("baz",), "val")
1561
1566
        node.add_node("b", child)
1562
1567
 
1563
 
        key_filter = (('foo',), ('fob',), ('bar',), ('baz',))
 
1568
        # Note that 'ram' doesn't match anything, so it should be freely
 
1569
        # ignored
 
1570
        key_filter = (('foo',), ('fob',), ('bar',), ('baz',), ('ram',))
1564
1571
        for child, node_key_filter in node._iter_nodes(None,
1565
1572
                                                       key_filter=key_filter):
1566
 
            # each child could matches two key filters, so make sure they were
 
1573
            # each child could match two key filters, so make sure they were
1567
1574
            # both included.
1568
1575
            self.assertEqual(2, len(node_key_filter))
1569
1576
 
 
1577
    def make_fo_fa_node(self):
 
1578
        node = InternalNode('f')
 
1579
        child = LeafNode()
 
1580
        child.set_maximum_size(100)
 
1581
        child.map(None, ("foo",), "val")
 
1582
        child.map(None, ("fob",), "val")
 
1583
        node.add_node('fo', child)
 
1584
        child = LeafNode()
 
1585
        child.set_maximum_size(100)
 
1586
        child.map(None, ("far",), "val")
 
1587
        child.map(None, ("faz",), "val")
 
1588
        node.add_node("fa", child)
 
1589
        return node
 
1590
 
 
1591
    def test__iter_nodes_single_entry(self):
 
1592
        node = self.make_fo_fa_node()
 
1593
        key_filter = [('foo',)]
 
1594
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
 
1595
        self.assertEqual(1, len(nodes))
 
1596
        self.assertEqual(key_filter, nodes[0][1])
 
1597
 
 
1598
    def test__iter_nodes_single_entry_misses(self):
 
1599
        node = self.make_fo_fa_node()
 
1600
        key_filter = [('bar',)]
 
1601
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
 
1602
        self.assertEqual(0, len(nodes))
 
1603
 
 
1604
    def test__iter_nodes_mixed_key_width(self):
 
1605
        node = self.make_fo_fa_node()
 
1606
        key_filter = [('foo', 'bar'), ('foo',), ('fo',), ('b',)]
 
1607
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
 
1608
        self.assertEqual(1, len(nodes))
 
1609
        matches = key_filter[:]
 
1610
        matches.remove(('b',))
 
1611
        self.assertEqual(sorted(matches), sorted(nodes[0][1]))
 
1612
 
 
1613
    def test__iter_nodes_match_all(self):
 
1614
        node = self.make_fo_fa_node()
 
1615
        key_filter = [('foo', 'bar'), ('foo',), ('fo',), ('f',)]
 
1616
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
 
1617
        self.assertEqual(2, len(nodes))
 
1618
 
 
1619
    def test__iter_nodes_fixed_widths_and_misses(self):
 
1620
        node = self.make_fo_fa_node()
 
1621
        # foo and faa should both match one child, baz should miss
 
1622
        key_filter = [('foo',), ('faa',), ('baz',)]
 
1623
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
 
1624
        self.assertEqual(2, len(nodes))
 
1625
        for node, matches in nodes:
 
1626
            self.assertEqual(1, len(matches))
 
1627
 
1570
1628
    def test_iteritems_empty_new(self):
1571
1629
        node = InternalNode()
1572
1630
        self.assertEqual([], sorted(node.iteritems(None)))