~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_graph.py

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

• reverse the comparison (3193.8.33 to 5200.1.2)
• stop comparing with revision 5200.1.2

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']},

1425

1385

 

1426

1386

 

1427

1387

class TestCachingParentsProvider(tests.TestCase):

1428

 

    """These tests run with:

1429

 

 

1430

 

    self.inst_pp, a recording parents provider with a graph of a->b, and b is a

1431

 

    ghost.

1432

 

    self.caching_pp, a CachingParentsProvider layered on inst_pp.

1433

 

    """

1434

1388

 

1435

1389

    def setUp(self):

1436

1390

        super(TestCachingParentsProvider, self).setUp()

1455

1409

        self.assertEqual({}, self.caching_pp.get_parent_map(['b']))

1456

1410

        # No new calls

1457

1411

        self.assertEqual(['b'], self.inst_pp.calls)

 

1412

        self.assertEqual({'b':None}, self.caching_pp._cache)

1458

1413

 

1459

1414

    def test_get_parent_map_mixed(self):

1460

1415

        """Anything that can be returned from cache, should be"""

1472

1427

        # only present 1 time.

1473

1428

        self.assertEqual(['a', 'b'], sorted(self.inst_pp.calls))

1474

1429

 

1475

 

    def test_note_missing_key(self):

1476

 

        """After noting that a key is missing it is cached."""

1477

 

        self.caching_pp.note_missing_key('b')

1478

 

        self.assertEqual({}, self.caching_pp.get_parent_map(['b']))

1479

 

        self.assertEqual([], self.inst_pp.calls)

1480

 

        self.assertEqual(set(['b']), self.caching_pp.missing_keys)

1481

 

 

1482

1430

 

1483

1431

class TestCachingParentsProviderExtras(tests.TestCaseWithTransport):

1484

1432

    """Test the behaviour when parents are provided that were not requested."""

1582

1530

        self.assertCollapsed(d, d)

1583

1531

 

1584

1532

 

1585

 

class TestGraphThunkIdsToKeys(tests.TestCase):

1586

 

 

1587

 

    def test_heads(self):

1588

 

        # A

1589

 

        # |\

1590

 

        # B C

1591

 

        # |/

1592

 

        # D

1593

 

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

1594

 

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

1595

 

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

1596

 

        graph_thunk = _mod_graph.GraphThunkIdsToKeys(g)

1597

 

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

1598

 

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

1599

 

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

1600

 

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

1601

 

 

1602

 

 

1603

1533

class TestPendingAncestryResultGetKeys(TestCaseWithMemoryTransport):

1604

1534

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

1605

1535

 

1616

1546

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

1617

1547

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

1618

1548

 

1619

 

    def test_get_keys_excludes_ghosts(self):

1620

 

        builder = self.make_branch_builder('b')

1621

 

        builder.start_series()

1622

 

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

1623

 

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

1624

 

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

1625

 

        builder.finish_series()

1626

 

        repo = builder.get_branch().repository

1627

 

        repo.lock_read()

1628

 

        self.addCleanup(repo.unlock)

1629

 

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

1630

 

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

1631

 

 

1632

1549

    def test_get_keys_excludes_null(self):

1633

1550

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

1634

1551

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

• Older »

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