~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_graph.py

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

• reverse the comparison (4325.4.2 to 4595.7.3)
• stop comparing with revision 4595.7.3

Show diffs side-by-side

added

removed

bzrlib/tests/test_graph.py

1

 

# Copyright (C) 2007, 2008, 2009 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']},

1598

1558

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

1599

1559

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

1600

1560

 

1601

 

    def test_get_keys_excludes_ghosts(self):

1602

 

        builder = self.make_branch_builder('b')

1603

 

        builder.start_series()

1604

 

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

1605

 

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

1606

 

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

1607

 

        builder.finish_series()

1608

 

        repo = builder.get_branch().repository

1609

 

        repo.lock_read()

1610

 

        self.addCleanup(repo.unlock)

1611

 

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

1612

 

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

1613

 

 

1614

1561

    def test_get_keys_excludes_null(self):

1615

1562

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

1616

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