← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_chk_map.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-05-13 17:16:28 UTC
  • mfrom: (4324.5.1 bzr.dev)
  • Revision ID: pqm@pqm.ubuntu.com-20090513171628-zmtijps3xl06nr9j
(Jelmer) Use utility function to check for control filename rather
        than assuming it is '.bzr'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_chk_map.py
53
53
    def test_not_a_prefix(self):
54
54
        self.assertCommonPrefix('b', 'begin', 'b')
55
55
 
56
 
    def test_empty(self):
57
 
        self.assertCommonPrefix('', '', 'end')
58
 
        self.assertCommonPrefix('', 'begin', '')
59
 
        self.assertCommonPrefix('', '', '')
60
 
 
61
56
 
62
57
class TestCaseWithStore(tests.TestCaseWithTransport):
63
58
 
1560
1555
        child.map(None, ("baz",), "val")
1561
1556
        node.add_node("b", child)
1562
1557
 
1563
 
        # Note that 'ram' doesn't match anything, so it should be freely
1564
 
        # ignored
1565
 
        key_filter = (('foo',), ('fob',), ('bar',), ('baz',), ('ram',))
 
1558
        key_filter = (('foo',), ('fob',), ('bar',), ('baz',))
1566
1559
        for child, node_key_filter in node._iter_nodes(None,
1567
1560
                                                       key_filter=key_filter):
1568
 
            # each child could match two key filters, so make sure they were
 
1561
            # each child could matches two key filters, so make sure they were
1569
1562
            # both included.
1570
1563
            self.assertEqual(2, len(node_key_filter))
1571
1564
 
1572
 
    def make_fo_fa_node(self):
1573
 
        node = InternalNode('f')
1574
 
        child = LeafNode()
1575
 
        child.set_maximum_size(100)
1576
 
        child.map(None, ("foo",), "val")
1577
 
        child.map(None, ("fob",), "val")
1578
 
        node.add_node('fo', child)
1579
 
        child = LeafNode()
1580
 
        child.set_maximum_size(100)
1581
 
        child.map(None, ("far",), "val")
1582
 
        child.map(None, ("faz",), "val")
1583
 
        node.add_node("fa", child)
1584
 
        return node
1585
 
 
1586
 
    def test__iter_nodes_single_entry(self):
1587
 
        node = self.make_fo_fa_node()
1588
 
        key_filter = [('foo',)]
1589
 
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
1590
 
        self.assertEqual(1, len(nodes))
1591
 
        self.assertEqual(key_filter, nodes[0][1])
1592
 
 
1593
 
    def test__iter_nodes_single_entry_misses(self):
1594
 
        node = self.make_fo_fa_node()
1595
 
        key_filter = [('bar',)]
1596
 
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
1597
 
        self.assertEqual(0, len(nodes))
1598
 
 
1599
 
    def test__iter_nodes_mixed_key_width(self):
1600
 
        node = self.make_fo_fa_node()
1601
 
        key_filter = [('foo', 'bar'), ('foo',), ('fo',), ('b',)]
1602
 
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
1603
 
        self.assertEqual(1, len(nodes))
1604
 
        matches = key_filter[:]
1605
 
        matches.remove(('b',))
1606
 
        self.assertEqual(sorted(matches), sorted(nodes[0][1]))
1607
 
 
1608
 
    def test__iter_nodes_match_all(self):
1609
 
        node = self.make_fo_fa_node()
1610
 
        key_filter = [('foo', 'bar'), ('foo',), ('fo',), ('f',)]
1611
 
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
1612
 
        self.assertEqual(2, len(nodes))
1613
 
 
1614
 
    def test__iter_nodes_fixed_widths_and_misses(self):
1615
 
        node = self.make_fo_fa_node()
1616
 
        # foo and faa should both match one child, baz should miss
1617
 
        key_filter = [('foo',), ('faa',), ('baz',)]
1618
 
        nodes = list(node._iter_nodes(None, key_filter=key_filter))
1619
 
        self.assertEqual(2, len(nodes))
1620
 
        for node, matches in nodes:
1621
 
            self.assertEqual(1, len(matches))
1622
 
 
1623
1565
    def test_iteritems_empty_new(self):
1624
1566
        node = InternalNode()
1625
1567
        self.assertEqual([], sorted(node.iteritems(None)))