~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_graph.py

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

• reverse the comparison (4216.4.3 to 5452)
• stop comparing with revision 5452

Show diffs side-by-side

added

removed

bzrlib/tests/test_graph.py

1

 

# Copyright (C) 2007-2010 Canonical Ltd

 

1

# Copyright (C) 2007 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

22

22

    )

23

23

from bzrlib.revision import NULL_REVISION

24

24

from bzrlib.tests import TestCaseWithMemoryTransport

25

 

from bzrlib.symbol_versioning import deprecated_in

26

25

 

27

26

 

28

27

# Ancestry 1:

526

525

        graph = self.make_graph(history_shortcut)

527

526

        self.assertEqual(set(['rev2b']), graph.find_lca('rev3a', 'rev3b'))

528

527

 

529

 

    def test_lefthand_distance_smoke(self):

530

 

        """A simple does it work test for graph.lefthand_distance(keys)."""

531

 

        graph = self.make_graph(history_shortcut)

532

 

        distance_graph = graph.find_lefthand_distances(['rev3b', 'rev2a'])

533

 

        self.assertEqual({'rev2a': 2, 'rev3b': 3}, distance_graph)

534

 

 

535

 

    def test_lefthand_distance_ghosts(self):

536

 

        """A simple does it work test for graph.lefthand_distance(keys)."""

537

 

        nodes = {'nonghost':[NULL_REVISION], 'toghost':['ghost']}

538

 

        graph = self.make_graph(nodes)

539

 

        distance_graph = graph.find_lefthand_distances(['nonghost', 'toghost'])

540

 

        self.assertEqual({'nonghost': 1, 'toghost': -1}, distance_graph)

541

 

 

542

528

    def test_recursive_unique_lca(self):

543

529

        """Test finding a unique least common ancestor.

544

530

 

675

661

        self.assertEqual((set(['e']), set(['f', 'g'])),

676

662

                         graph.find_difference('e', 'f'))

677

663

 

678

 

 

679

664

    def test_stacked_parents_provider(self):

680

665

        parents1 = _mod_graph.DictParentsProvider({'rev2': ['rev3']})

681

666

        parents2 = _mod_graph.DictParentsProvider({'rev1': ['rev4']})

682

 

        stacked = _mod_graph.StackedParentsProvider([parents1, parents2])

683

 

        self.assertEqual({'rev1':['rev4'], 'rev2':['rev3']},

684

 

                         stacked.get_parent_map(['rev1', 'rev2']))

685

 

        self.assertEqual({'rev2':['rev3'], 'rev1':['rev4']},

686

 

                         stacked.get_parent_map(['rev2', 'rev1']))

687

 

        self.assertEqual({'rev2':['rev3']},

688

 

                         stacked.get_parent_map(['rev2', 'rev2']))

689

 

        self.assertEqual({'rev1':['rev4']},

690

 

                         stacked.get_parent_map(['rev1', 'rev1']))

691

 

    

692

 

    def test_stacked_parents_provider_overlapping(self):

693

 

        # rev2 is availible in both providers.

694

 

        # 1

695

 

        # |

696

 

        # 2

697

 

        parents1 = _mod_graph.DictParentsProvider({'rev2': ['rev1']})

698

 

        parents2 = _mod_graph.DictParentsProvider({'rev2': ['rev1']})

699

 

        stacked = _mod_graph.StackedParentsProvider([parents1, parents2])

700

 

        self.assertEqual({'rev2': ['rev1']},

701

 

                         stacked.get_parent_map(['rev2']))

702

 

 

703

 

    def test__stacked_parents_provider_deprecated(self):

704

 

        parents1 = _mod_graph.DictParentsProvider({'rev2': ['rev3']})

705

 

        parents2 = _mod_graph.DictParentsProvider({'rev1': ['rev4']})

706

 

        stacked = self.applyDeprecated(deprecated_in((1, 16, 0)),

707

 

                    _mod_graph._StackedParentsProvider, [parents1, parents2])

 

667

        stacked = _mod_graph._StackedParentsProvider([parents1, parents2])

708

668

        self.assertEqual({'rev1':['rev4'], 'rev2':['rev3']},

709

669

                         stacked.get_parent_map(['rev1', 'rev2']))

710

670

        self.assertEqual({'rev2':['rev3'], 'rev1':['rev4']},

1424

1384

        self.assertMergeOrder(['rev3', 'rev1'], graph, 'rev4', ['rev1', 'rev3'])

1425

1385

 

1426

1386

 

1427

 

class TestFindDescendants(TestGraphBase):

1428

 

 

1429

 

    def test_find_descendants_rev1_rev3(self):

1430

 

        graph = self.make_graph(ancestry_1)

1431

 

        descendants = graph.find_descendants('rev1', 'rev3')

1432

 

        self.assertEqual(set(['rev1', 'rev2a', 'rev3']), descendants)

1433

 

 

1434

 

    def test_find_descendants_rev1_rev4(self):

1435

 

        graph = self.make_graph(ancestry_1)

1436

 

        descendants = graph.find_descendants('rev1', 'rev4')

1437

 

        self.assertEqual(set(['rev1', 'rev2a', 'rev2b', 'rev3', 'rev4']),

1438

 

                         descendants)

1439

 

 

1440

 

    def test_find_descendants_rev2a_rev4(self):

1441

 

        graph = self.make_graph(ancestry_1)

1442

 

        descendants = graph.find_descendants('rev2a', 'rev4')

1443

 

        self.assertEqual(set(['rev2a', 'rev3', 'rev4']), descendants)

1444

 

 

1445

 

class TestFindLefthandMerger(TestGraphBase):

1446

 

 

1447

 

    def check_merger(self, result, ancestry, merged, tip):

1448

 

        graph = self.make_graph(ancestry)

1449

 

        self.assertEqual(result, graph.find_lefthand_merger(merged, tip))

1450

 

 

1451

 

    def test_find_lefthand_merger_rev2b(self):

1452

 

        self.check_merger('rev4', ancestry_1, 'rev2b', 'rev4')

1453

 

 

1454

 

    def test_find_lefthand_merger_rev2a(self):

1455

 

        self.check_merger('rev2a', ancestry_1, 'rev2a', 'rev4')

1456

 

 

1457

 

    def test_find_lefthand_merger_rev4(self):

1458

 

        self.check_merger(None, ancestry_1, 'rev4', 'rev2a')

1459

 

 

1460

 

    def test_find_lefthand_merger_f(self):

1461

 

        self.check_merger('i', complex_shortcut, 'f', 'm')

1462

 

 

1463

 

    def test_find_lefthand_merger_g(self):

1464

 

        self.check_merger('i', complex_shortcut, 'g', 'm')

1465

 

 

1466

 

    def test_find_lefthand_merger_h(self):

1467

 

        self.check_merger('n', complex_shortcut, 'h', 'n')

1468

 

 

1469

 

 

1470

 

class TestGetChildMap(TestGraphBase):

1471

 

 

1472

 

    def test_get_child_map(self):

1473

 

        graph = self.make_graph(ancestry_1)

1474

 

        child_map = graph.get_child_map(['rev4', 'rev3', 'rev2a', 'rev2b'])

1475

 

        self.assertEqual({'rev1': ['rev2a', 'rev2b'],

1476

 

                          'rev2a': ['rev3'],

1477

 

                          'rev2b': ['rev4'],

1478

 

                          'rev3': ['rev4']},

1479

 

                          child_map)

1480

 

 

1481

 

 

1482

1387

class TestCachingParentsProvider(tests.TestCase):

1483

1388

    """These tests run with:

1484

1389

 

1637

1542

        self.assertCollapsed(d, d)

1638

1543

 

1639

1544

 

1640

 

class TestGraphThunkIdsToKeys(tests.TestCase):

1641

 

 

1642

 

    def test_heads(self):

1643

 

        # A

1644

 

        # |\

1645

 

        # B C

1646

 

        # |/

1647

 

        # D

1648

 

        d = {('D',): [('B',), ('C',)], ('C',):[('A',)],

1649

 

             ('B',): [('A',)], ('A',): []}

1650

 

        g = _mod_graph.Graph(_mod_graph.DictParentsProvider(d))

1651

 

        graph_thunk = _mod_graph.GraphThunkIdsToKeys(g)

1652

 

        self.assertEqual(['D'], sorted(graph_thunk.heads(['D', 'A'])))

1653

 

        self.assertEqual(['D'], sorted(graph_thunk.heads(['D', 'B'])))

1654

 

        self.assertEqual(['D'], sorted(graph_thunk.heads(['D', 'C'])))

1655

 

        self.assertEqual(['B', 'C'], sorted(graph_thunk.heads(['B', 'C'])))

1656

 

 

1657

 

 

1658

1545

class TestPendingAncestryResultGetKeys(TestCaseWithMemoryTransport):

1659

1546

    """Tests for bzrlib.graph.PendingAncestryResult."""

1660

1547

 

1671

1558

        result = _mod_graph.PendingAncestryResult(['rev-2'], repo)

1672

1559

        self.assertEqual(set(['rev-1', 'rev-2']), set(result.get_keys()))

1673

1560

 

1674

 

    def test_get_keys_excludes_ghosts(self):

1675

 

        builder = self.make_branch_builder('b')

1676

 

        builder.start_series()

1677

 

        builder.build_snapshot('rev-1', None, [

1678

 

            ('add', ('', 'root-id', 'directory', ''))])

1679

 

        builder.build_snapshot('rev-2', ['rev-1', 'ghost'], [])

1680

 

        builder.finish_series()

1681

 

        repo = builder.get_branch().repository

1682

 

        repo.lock_read()

1683

 

        self.addCleanup(repo.unlock)

1684

 

        result = _mod_graph.PendingAncestryResult(['rev-2'], repo)

1685

 

        self.assertEqual(sorted(['rev-1', 'rev-2']), sorted(result.get_keys()))

1686

 

 

1687

1561

    def test_get_keys_excludes_null(self):

1688

1562

        # Make a 'graph' with an iter_ancestry that returns NULL_REVISION

1689

1563

        # somewhere other than the last element, which can happen in real

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1