← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_graph.py

  • Committer: John Arbash Meinel
  • Date: 2009-07-08 15:43:51 UTC
  • mto: This revision was merged to the branch mainline in revision 4521.
  • Revision ID: john@arbash-meinel.com-20090708154351-u0t41fwjqm28pbnu
Add comments in the finally sections as to why we want them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_graph.py
1
 
# Copyright (C) 2007-2011 Canonical Ltd
 
1
# Copyright (C) 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
from bzrlib import (
18
18
    errors,
19
19
    graph as _mod_graph,
 
20
    symbol_versioning,
20
21
    tests,
21
22
    )
22
23
from bzrlib.revision import NULL_REVISION
23
24
from bzrlib.tests import TestCaseWithMemoryTransport
 
25
from bzrlib.symbol_versioning import deprecated_in
24
26
 
25
27
 
26
28
# Ancestry 1:
524
526
        graph = self.make_graph(history_shortcut)
525
527
        self.assertEqual(set(['rev2b']), graph.find_lca('rev3a', 'rev3b'))
526
528
 
527
 
    def test_lefthand_distance_smoke(self):
528
 
        """A simple does it work test for graph.lefthand_distance(keys)."""
529
 
        graph = self.make_graph(history_shortcut)
530
 
        distance_graph = graph.find_lefthand_distances(['rev3b', 'rev2a'])
531
 
        self.assertEqual({'rev2a': 2, 'rev3b': 3}, distance_graph)
532
 
 
533
 
    def test_lefthand_distance_ghosts(self):
534
 
        """A simple does it work test for graph.lefthand_distance(keys)."""
535
 
        nodes = {'nonghost':[NULL_REVISION], 'toghost':['ghost']}
536
 
        graph = self.make_graph(nodes)
537
 
        distance_graph = graph.find_lefthand_distances(['nonghost', 'toghost'])
538
 
        self.assertEqual({'nonghost': 1, 'toghost': -1}, distance_graph)
539
 
 
540
529
    def test_recursive_unique_lca(self):
541
530
        """Test finding a unique least common ancestor.
542
531
 
698
687
        self.assertEqual({'rev2': ['rev1']},
699
688
                         stacked.get_parent_map(['rev2']))
700
689
 
 
690
    def test__stacked_parents_provider_deprecated(self):
 
691
        parents1 = _mod_graph.DictParentsProvider({'rev2': ['rev3']})
 
692
        parents2 = _mod_graph.DictParentsProvider({'rev1': ['rev4']})
 
693
        stacked = self.applyDeprecated(deprecated_in((1, 16, 0)),
 
694
                    _mod_graph._StackedParentsProvider, [parents1, parents2])
 
695
        self.assertEqual({'rev1':['rev4'], 'rev2':['rev3']},
 
696
                         stacked.get_parent_map(['rev1', 'rev2']))
 
697
        self.assertEqual({'rev2':['rev3'], 'rev1':['rev4']},
 
698
                         stacked.get_parent_map(['rev2', 'rev1']))
 
699
        self.assertEqual({'rev2':['rev3']},
 
700
                         stacked.get_parent_map(['rev2', 'rev2']))
 
701
        self.assertEqual({'rev1':['rev4']},
 
702
                         stacked.get_parent_map(['rev1', 'rev1']))
 
703
 
701
704
    def test_iter_topo_order(self):
702
705
        graph = self.make_graph(ancestry_1)
703
706
        args = ['rev2a', 'rev3', 'rev1']
1408
1411
        self.assertMergeOrder(['rev3', 'rev1'], graph, 'rev4', ['rev1', 'rev3'])
1409
1412
 
1410
1413
 
1411
 
class TestFindDescendants(TestGraphBase):
1412
 
 
1413
 
    def test_find_descendants_rev1_rev3(self):
1414
 
        graph = self.make_graph(ancestry_1)
1415
 
        descendants = graph.find_descendants('rev1', 'rev3')
1416
 
        self.assertEqual(set(['rev1', 'rev2a', 'rev3']), descendants)
1417
 
 
1418
 
    def test_find_descendants_rev1_rev4(self):
1419
 
        graph = self.make_graph(ancestry_1)
1420
 
        descendants = graph.find_descendants('rev1', 'rev4')
1421
 
        self.assertEqual(set(['rev1', 'rev2a', 'rev2b', 'rev3', 'rev4']),
1422
 
                         descendants)
1423
 
 
1424
 
    def test_find_descendants_rev2a_rev4(self):
1425
 
        graph = self.make_graph(ancestry_1)
1426
 
        descendants = graph.find_descendants('rev2a', 'rev4')
1427
 
        self.assertEqual(set(['rev2a', 'rev3', 'rev4']), descendants)
1428
 
 
1429
 
class TestFindLefthandMerger(TestGraphBase):
1430
 
 
1431
 
    def check_merger(self, result, ancestry, merged, tip):
1432
 
        graph = self.make_graph(ancestry)
1433
 
        self.assertEqual(result, graph.find_lefthand_merger(merged, tip))
1434
 
 
1435
 
    def test_find_lefthand_merger_rev2b(self):
1436
 
        self.check_merger('rev4', ancestry_1, 'rev2b', 'rev4')
1437
 
 
1438
 
    def test_find_lefthand_merger_rev2a(self):
1439
 
        self.check_merger('rev2a', ancestry_1, 'rev2a', 'rev4')
1440
 
 
1441
 
    def test_find_lefthand_merger_rev4(self):
1442
 
        self.check_merger(None, ancestry_1, 'rev4', 'rev2a')
1443
 
 
1444
 
    def test_find_lefthand_merger_f(self):
1445
 
        self.check_merger('i', complex_shortcut, 'f', 'm')
1446
 
 
1447
 
    def test_find_lefthand_merger_g(self):
1448
 
        self.check_merger('i', complex_shortcut, 'g', 'm')
1449
 
 
1450
 
    def test_find_lefthand_merger_h(self):
1451
 
        self.check_merger('n', complex_shortcut, 'h', 'n')
1452
 
 
1453
 
 
1454
 
class TestGetChildMap(TestGraphBase):
1455
 
 
1456
 
    def test_get_child_map(self):
1457
 
        graph = self.make_graph(ancestry_1)
1458
 
        child_map = graph.get_child_map(['rev4', 'rev3', 'rev2a', 'rev2b'])
1459
 
        self.assertEqual({'rev1': ['rev2a', 'rev2b'],
1460
 
                          'rev2a': ['rev3'],
1461
 
                          'rev2b': ['rev4'],
1462
 
                          'rev3': ['rev4']},
1463
 
                          child_map)
1464
 
 
1465
 
 
1466
1414
class TestCachingParentsProvider(tests.TestCase):
1467
1415
    """These tests run with:
1468
1416
 
1621
1569
        self.assertCollapsed(d, d)
1622
1570
 
1623
1571
 
1624
 
class TestGraphThunkIdsToKeys(tests.TestCase):
1625
 
 
1626
 
    def test_heads(self):
1627
 
        # A
1628
 
        # |\
1629
 
        # B C
1630
 
        # |/
1631
 
        # D
1632
 
        d = {('D',): [('B',), ('C',)], ('C',):[('A',)],
1633
 
             ('B',): [('A',)], ('A',): []}
1634
 
        g = _mod_graph.Graph(_mod_graph.DictParentsProvider(d))
1635
 
        graph_thunk = _mod_graph.GraphThunkIdsToKeys(g)
1636
 
        self.assertEqual(['D'], sorted(graph_thunk.heads(['D', 'A'])))
1637
 
        self.assertEqual(['D'], sorted(graph_thunk.heads(['D', 'B'])))
1638
 
        self.assertEqual(['D'], sorted(graph_thunk.heads(['D', 'C'])))
1639
 
        self.assertEqual(['B', 'C'], sorted(graph_thunk.heads(['B', 'C'])))
1640
 
 
1641
 
    def test_add_node(self):
1642
 
        d = {('C',):[('A',)], ('B',): [('A',)], ('A',): []}
1643
 
        g = _mod_graph.KnownGraph(d)
1644
 
        graph_thunk = _mod_graph.GraphThunkIdsToKeys(g)
1645
 
        graph_thunk.add_node("D", ["A", "C"])
1646
 
        self.assertEqual(['B', 'D'],
1647
 
            sorted(graph_thunk.heads(['D', 'B', 'A'])))
1648
 
 
1649
 
    def test_merge_sort(self):
1650
 
        d = {('C',):[('A',)], ('B',): [('A',)], ('A',): []}
1651
 
        g = _mod_graph.KnownGraph(d)
1652
 
        graph_thunk = _mod_graph.GraphThunkIdsToKeys(g)
1653
 
        graph_thunk.add_node("D", ["A", "C"])
1654
 
        self.assertEqual([('C', 0, (2,), False), ('A', 0, (1,), True)],
1655
 
            [(n.key, n.merge_depth, n.revno, n.end_of_merge)
1656
 
                 for n in graph_thunk.merge_sort('C')])
1657
 
 
1658
 
 
1659
1572
class TestPendingAncestryResultGetKeys(TestCaseWithMemoryTransport):
1660
1573
    """Tests for bzrlib.graph.PendingAncestryResult."""
1661
1574