/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_graph.py

  • Committer: Jelmer Vernooij
  • Date: 2009-03-22 00:24:37 UTC
  • mfrom: (4180 +trunk)
  • mto: (3920.2.35 dpush)
  • mto: This revision was merged to the branch mainline in revision 4281.
  • Revision ID: jelmer@samba.org-20090322002437-0vlyqnz29isqeozo
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_graph.py
237
237
                    'e':['d'], 'f':['e'], 'g':['f'], 'h':['d'], 'i':['g'],
238
238
                    'j':['h'], 'k':['h', 'i'], 'l':['k'], 'm':['l'], 'n':['m'],
239
239
                    'o':['n'], 'p':['o'], 'q':['p'], 'r':['q'], 's':['r'],
240
 
                    't':['i', 's'], 'u':['s', 'j'], 
 
240
                    't':['i', 's'], 'u':['s', 'j'],
241
241
                    }
242
242
 
243
243
# Graph where different walkers will race to find the common and uncommon
711
711
 
712
712
    def test_is_ancestor_boundary(self):
713
713
        """Ensure that we avoid searching the whole graph.
714
 
        
 
714
 
715
715
        This requires searching through b as a common ancestor, so we
716
716
        can identify that e is common.
717
717
        """
737
737
        # 'a' is not in the ancestry of 'c', and 'g' is a ghost
738
738
        expected['g'] = None
739
739
        self.assertEqual(expected, dict(graph.iter_ancestry(['a', 'c'])))
740
 
        expected.pop('a') 
 
740
        expected.pop('a')
741
741
        self.assertEqual(expected, dict(graph.iter_ancestry(['c'])))
742
742
 
743
743
    def test_filter_candidate_lca(self):
845
845
 
846
846
    def _run_heads_break_deeper(self, graph_dict, search):
847
847
        """Run heads on a graph-as-a-dict.
848
 
        
 
848
 
849
849
        If the search asks for the parents of 'deeper' the test will fail.
850
850
        """
851
851
        class stub(object):
992
992
        :param next: A callable to advance the search.
993
993
        """
994
994
        for seen, recipe, included_keys, starts, stops in instructions:
 
995
            # Adjust for recipe contract changes that don't vary for all the
 
996
            # current tests.
 
997
            recipe = ('search',) + recipe
995
998
            next()
996
999
            if starts is not None:
997
1000
                search.start_searching(starts)
1011
1014
        search = graph._make_breadth_first_searcher(['head'])
1012
1015
        # At the start, nothing has been seen, to its all excluded:
1013
1016
        result = search.get_result()
1014
 
        self.assertEqual((set(['head']), set(['head']), 0),
 
1017
        self.assertEqual(('search', set(['head']), set(['head']), 0),
1015
1018
            result.get_recipe())
1016
1019
        self.assertEqual(set(), result.get_keys())
1017
1020
        self.assertEqual(set(), search.seen)
1043
1046
        search.start_searching(['head'])
1044
1047
        # head has been seen:
1045
1048
        result = search.get_result()
1046
 
        self.assertEqual((set(['head']), set(['child']), 1),
 
1049
        self.assertEqual(('search', set(['head']), set(['child']), 1),
1047
1050
            result.get_recipe())
1048
1051
        self.assertEqual(set(['head']), result.get_keys())
1049
1052
        self.assertEqual(set(['head']), search.seen)
1080
1083
        search = graph._make_breadth_first_searcher(['head'])
1081
1084
        expected = [
1082
1085
            # NULL_REVISION and ghost1 have not been returned
1083
 
            (set(['head']), (set(['head']), set(['child', 'ghost1']), 1),
 
1086
            (set(['head']),
 
1087
             (set(['head']), set(['child', NULL_REVISION, 'ghost1']), 1),
1084
1088
             ['head'], None, [NULL_REVISION, 'ghost1']),
1085
1089
            # ghost1 has been returned, NULL_REVISION is to be returned in the
1086
1090
            # next iteration.
1202
1206
        self.assertRaises(StopIteration, search.next)
1203
1207
        self.assertEqual(set(['head', 'ghost', NULL_REVISION]), search.seen)
1204
1208
        result = search.get_result()
1205
 
        self.assertEqual((set(['ghost', 'head']), set(['ghost']), 2),
 
1209
        self.assertEqual(('search', set(['ghost', 'head']), set(['ghost']), 2),
1206
1210
            result.get_recipe())
1207
1211
        self.assertEqual(set(['head', NULL_REVISION]), result.get_keys())
1208
1212
        # using next_with_ghosts:
1211
1215
        self.assertRaises(StopIteration, search.next)
1212
1216
        self.assertEqual(set(['head', 'ghost', NULL_REVISION]), search.seen)
1213
1217
        result = search.get_result()
1214
 
        self.assertEqual((set(['ghost', 'head']), set(['ghost']), 2),
 
1218
        self.assertEqual(('search', set(['ghost', 'head']), set(['ghost']), 2),
1215
1219
            result.get_recipe())
1216
1220
        self.assertEqual(set(['head', NULL_REVISION]), result.get_keys())
1217
1221
 
1524
1528
        # 2 and 3 cannot be removed because 1 has 2 parents
1525
1529
        d = {1:[2, 3], 2:[4], 4:[6], 3:[5], 5:[6], 6:[7], 7:[]}
1526
1530
        self.assertCollapsed(d, d)
 
1531
 
 
1532
 
 
1533
class TestPendingAncestryResultGetKeys(TestCaseWithMemoryTransport):
 
1534
    """Tests for bzrlib.graph.PendingAncestryResult."""
 
1535
 
 
1536
    def test_get_keys(self):
 
1537
        builder = self.make_branch_builder('b')
 
1538
        builder.start_series()
 
1539
        builder.build_snapshot('rev-1', None, [
 
1540
            ('add', ('', 'root-id', 'directory', ''))])
 
1541
        builder.build_snapshot('rev-2', ['rev-1'], [])
 
1542
        builder.finish_series()
 
1543
        repo = builder.get_branch().repository
 
1544
        repo.lock_read()
 
1545
        self.addCleanup(repo.unlock)
 
1546
        result = _mod_graph.PendingAncestryResult(['rev-2'], repo)
 
1547
        self.assertEqual(set(['rev-1', 'rev-2']), set(result.get_keys()))
 
1548
 
 
1549
    def test_get_keys_excludes_null(self):
 
1550
        # Make a 'graph' with an iter_ancestry that returns NULL_REVISION
 
1551
        # somewhere other than the last element, which can happen in real
 
1552
        # ancestries.
 
1553
        class StubGraph(object):
 
1554
            def iter_ancestry(self, keys):
 
1555
                return [(NULL_REVISION, ()), ('foo', (NULL_REVISION,))]
 
1556
        result = _mod_graph.PendingAncestryResult(['rev-3'], None)
 
1557
        result_keys = result._get_keys(StubGraph())
 
1558
        # Only the non-null keys from the ancestry appear.
 
1559
        self.assertEqual(set(['foo']), set(result_keys))
 
1560
 
 
1561
 
 
1562
class TestPendingAncestryResultRefine(TestGraphBase):
 
1563
 
 
1564
    def test_refine(self):
 
1565
        # Used when pulling from a stacked repository, so test some revisions
 
1566
        # being satisfied from the stacking branch.
 
1567
        g = self.make_graph(
 
1568
            {"tip":["mid"], "mid":["base"], "tag":["base"],
 
1569
             "base":[NULL_REVISION], NULL_REVISION:[]})
 
1570
        result = _mod_graph.PendingAncestryResult(['tip', 'tag'], None)
 
1571
        result = result.refine(set(['tip']), set(['mid']))
 
1572
        self.assertEqual(set(['mid', 'tag']), result.heads)
 
1573
        result = result.refine(set(['mid', 'tag', 'base']),
 
1574
            set([NULL_REVISION]))
 
1575
        self.assertEqual(set([NULL_REVISION]), result.heads)
 
1576
        self.assertTrue(result.is_empty())
 
1577
 
 
1578
 
 
1579
class TestSearchResultRefine(TestGraphBase):
 
1580
 
 
1581
    def test_refine(self):
 
1582
        # Used when pulling from a stacked repository, so test some revisions
 
1583
        # being satisfied from the stacking branch.
 
1584
        g = self.make_graph(
 
1585
            {"tip":["mid"], "mid":["base"], "tag":["base"],
 
1586
             "base":[NULL_REVISION], NULL_REVISION:[]})
 
1587
        result = _mod_graph.SearchResult(set(['tip', 'tag']),
 
1588
            set([NULL_REVISION]), 4, set(['tip', 'mid', 'tag', 'base']))
 
1589
        result = result.refine(set(['tip']), set(['mid']))
 
1590
        recipe = result.get_recipe()
 
1591
        # We should be starting from tag (original head) and mid (seen ref)
 
1592
        self.assertEqual(set(['mid', 'tag']), recipe[1])
 
1593
        # We should be stopping at NULL (original stop) and tip (seen head)
 
1594
        self.assertEqual(set([NULL_REVISION, 'tip']), recipe[2])
 
1595
        self.assertEqual(3, recipe[3])
 
1596
        result = result.refine(set(['mid', 'tag', 'base']),
 
1597
            set([NULL_REVISION]))
 
1598
        recipe = result.get_recipe()
 
1599
        # We should be starting from nothing (NULL was known as a cut point)
 
1600
        self.assertEqual(set([]), recipe[1])
 
1601
        # We should be stopping at NULL (original stop) and tip (seen head) and
 
1602
        # tag (seen head) and mid(seen mid-point head). We could come back and
 
1603
        # define this as not including mid, for minimal results, but it is
 
1604
        # still 'correct' to include mid, and simpler/easier.
 
1605
        self.assertEqual(set([NULL_REVISION, 'tip', 'tag', 'mid']), recipe[2])
 
1606
        self.assertEqual(0, recipe[3])
 
1607
        self.assertTrue(result.is_empty())