/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/selftest/testrevision.py

  • Committer: Robert Collins
  • Date: 2005-10-16 22:31:25 UTC
  • mto: This revision was merged to the branch mainline in revision 1458.
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051016223125-26d4401cb94b7b82
Branch.relpath has been moved to WorkingTree.relpath.

WorkingTree no no longer takes an inventory, rather it takes an optional branch
parameter, and if None is given will open the branch at basedir implicitly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testrevision.py
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
#
 
1
# (C) 2005 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
import os
19
 
import warnings
20
19
 
21
 
from bzrlib import (
22
 
    bugtracker,
23
 
    revision,
24
 
    symbol_versioning,
25
 
    )
 
20
from bzrlib.selftest import TestCaseInTempDir
26
21
from bzrlib.branch import Branch
27
 
from bzrlib.errors import (
28
 
    InvalidBugStatus,
29
 
    InvalidLineInBugsProperty,
30
 
    NoSuchRevision,
31
 
    )
32
 
from bzrlib.deprecated_graph import Graph
33
 
from bzrlib.revision import (find_present_ancestors,
34
 
                             NULL_REVISION)
35
 
from bzrlib.tests import TestCase, TestCaseWithTransport
 
22
from bzrlib.commit import commit
 
23
from bzrlib.fetch import fetch
 
24
from bzrlib.revision import (find_present_ancestors, combined_graph,
 
25
                             is_ancestor, MultipleRevisionSources)
36
26
from bzrlib.trace import mutter
37
 
from bzrlib.workingtree import WorkingTree
38
 
 
39
 
# We're allowed to test deprecated interfaces
40
 
warnings.filterwarnings('ignore',
41
 
        '.*get_intervening_revisions was deprecated',
42
 
        DeprecationWarning,
43
 
        r'bzrlib\.tests\.test_revision')
44
 
 
45
 
# XXX: Make this a method of a merge base case
46
 
def make_branches(self, format=None):
 
27
from bzrlib.errors import NoSuchRevision
 
28
 
 
29
def make_branches():
47
30
    """Create two branches
48
31
 
49
32
    branch 1 has 6 commits, branch 2 has 3 commits
50
 
    commit 10 is a ghosted merge merge from branch 1
 
33
    commit 10 was a psuedo merge from branch 1
 
34
    but has been disabled until ghost support is
 
35
    implemented.
51
36
 
52
37
    the object graph is
53
38
    B:     A:
54
 
    a..0   a..0
 
39
    a..0   a..0 
55
40
    a..1   a..1
56
41
    a..2   a..2
57
42
    b..3   a..3 merges b..4
62
47
    so A is missing b6 at the start
63
48
    and B is missing a3, a4, a5
64
49
    """
65
 
    tree1 = self.make_branch_and_tree("branch1", format=format)
66
 
    br1 = tree1.branch
67
 
 
68
 
    tree1.commit("Commit one", rev_id="a@u-0-0")
69
 
    tree1.commit("Commit two", rev_id="a@u-0-1")
70
 
    tree1.commit("Commit three", rev_id="a@u-0-2")
71
 
 
72
 
    tree2 = tree1.bzrdir.sprout("branch2").open_workingtree()
73
 
    br2 = tree2.branch
74
 
    tree2.commit("Commit four", rev_id="b@u-0-3")
75
 
    tree2.commit("Commit five", rev_id="b@u-0-4")
 
50
    os.mkdir("branch1")
 
51
    br1 = Branch.initialize("branch1")
 
52
    
 
53
    commit(br1, "Commit one", rev_id="a@u-0-0")
 
54
    commit(br1, "Commit two", rev_id="a@u-0-1")
 
55
    commit(br1, "Commit three", rev_id="a@u-0-2")
 
56
 
 
57
    os.mkdir("branch2")
 
58
    br2 = Branch.initialize("branch2")
 
59
    br2.update_revisions(br1)
 
60
    commit(br2, "Commit four", rev_id="b@u-0-3")
 
61
    commit(br2, "Commit five", rev_id="b@u-0-4")
76
62
    revisions_2 = br2.revision_history()
77
 
    self.assertEquals(revisions_2[-1], 'b@u-0-4')
78
 
 
79
 
    tree1.merge_from_branch(br2)
80
 
    tree1.commit("Commit six", rev_id="a@u-0-3")
81
 
    tree1.commit("Commit seven", rev_id="a@u-0-4")
82
 
    tree2.commit("Commit eight", rev_id="b@u-0-5")
83
 
    self.assertEquals(br2.revision_history()[-1], 'b@u-0-5')
84
 
 
85
 
    tree1.merge_from_branch(br2)
86
 
    tree1.commit("Commit nine", rev_id="a@u-0-5")
87
 
    # DO NOT MERGE HERE - we WANT a GHOST.
88
 
    tree2.add_parent_tree_id(br1.revision_history()[4])
89
 
    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")
90
 
 
 
63
    
 
64
    fetch(from_branch=br2, to_branch=br1)
 
65
    br1.add_pending_merge(revisions_2[4])
 
66
    assert revisions_2[4] == 'b@u-0-4'
 
67
    commit(br1, "Commit six", rev_id="a@u-0-3")
 
68
    commit(br1, "Commit seven", rev_id="a@u-0-4")
 
69
    commit(br2, "Commit eight", rev_id="b@u-0-5")
 
70
    
 
71
    fetch(from_branch=br2, to_branch=br1)
 
72
    br1.add_pending_merge(br2.revision_history()[5])
 
73
    commit(br1, "Commit nine", rev_id="a@u-0-5")
 
74
    # DO NOT FETCH HERE - we WANT a GHOST.
 
75
    #fetch(from_branch=br1, to_branch=br2)
 
76
    br2.add_pending_merge(br1.revision_history()[4])
 
77
    commit(br2, "Commit ten - ghost merge", rev_id="b@u-0-6")
 
78
    
91
79
    return br1, br2
92
80
 
93
81
 
94
 
class TestIsAncestor(TestCaseWithTransport):
95
 
 
 
82
class TestIsAncestor(TestCaseInTempDir):
96
83
    def test_recorded_ancestry(self):
97
84
        """Test that commit records all ancestors"""
98
 
        br1, br2 = make_branches(self)
 
85
        br1, br2 = make_branches()
99
86
        d = [('a@u-0-0', ['a@u-0-0']),
100
87
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
101
88
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
124
111
                if rev_id in br2_only and not branch is br2:
125
112
                    continue
126
113
                mutter('ancestry of {%s}: %r',
127
 
                       rev_id, branch.repository.get_ancestry(rev_id))
128
 
                result = sorted(branch.repository.get_ancestry(rev_id))
129
 
                self.assertEquals(result, [None] + sorted(anc))
130
 
 
131
 
 
132
 
class TestIntermediateRevisions(TestCaseWithTransport):
 
114
                       rev_id, branch.get_ancestry(rev_id))
 
115
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
 
116
                                  [None] + sorted(anc))
 
117
    
 
118
    
 
119
    def test_is_ancestor(self):
 
120
        """Test checking whether a revision is an ancestor of another revision"""
 
121
        br1, br2 = make_branches()
 
122
        revisions = br1.revision_history()
 
123
        revisions_2 = br2.revision_history()
 
124
        sources = br1
 
125
 
 
126
        assert is_ancestor(revisions[0], revisions[0], br1)
 
127
        assert is_ancestor(revisions[1], revisions[0], sources)
 
128
        assert not is_ancestor(revisions[0], revisions[1], sources)
 
129
        assert is_ancestor(revisions_2[3], revisions[0], sources)
 
130
        # disabled mbp 20050914, doesn't seem to happen anymore
 
131
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
132
        ##                  revisions[0], br1)        
 
133
        assert is_ancestor(revisions[3], revisions_2[4], sources)
 
134
        assert is_ancestor(revisions[3], revisions_2[4], br1)
 
135
        assert is_ancestor(revisions[3], revisions_2[3], sources)
 
136
        ## assert not is_ancestor(revisions[3], revisions_2[3], br1)
 
137
 
 
138
 
 
139
class TestIntermediateRevisions(TestCaseInTempDir):
133
140
 
134
141
    def setUp(self):
135
 
        TestCaseWithTransport.setUp(self)
136
 
        self.br1, self.br2 = make_branches(self)
137
 
        wt1 = self.br1.bzrdir.open_workingtree()
138
 
        wt2 = self.br2.bzrdir.open_workingtree()
139
 
        wt2.commit("Commit eleven", rev_id="b@u-0-7")
140
 
        wt2.commit("Commit twelve", rev_id="b@u-0-8")
141
 
        wt2.commit("Commit thirtteen", rev_id="b@u-0-9")
142
 
 
143
 
        wt1.merge_from_branch(self.br2)
144
 
        wt1.commit("Commit fourtten", rev_id="a@u-0-6")
145
 
 
146
 
        wt2.merge_from_branch(self.br1)
147
 
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
148
 
 
149
 
 
150
 
class MockRevisionSource(object):
151
 
    """A RevisionSource that takes a pregenerated graph.
152
 
 
153
 
    This is useful for testing revision graph algorithms where
154
 
    the actual branch existing is irrelevant.
155
 
    """
156
 
 
157
 
    def __init__(self, full_graph):
158
 
        self._full_graph = full_graph
159
 
 
160
 
    def get_revision_graph_with_ghosts(self, revision_ids):
161
 
        # This is mocked out to just return a constant graph.
162
 
        return self._full_graph
163
 
 
164
 
 
165
 
class TestCommonAncestor(TestCaseWithTransport):
 
142
        from bzrlib.commit import commit
 
143
        TestCaseInTempDir.setUp(self)
 
144
        self.br1, self.br2 = make_branches()
 
145
 
 
146
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
 
147
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
 
148
        self.br2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
149
 
 
150
        fetch(from_branch=self.br2, to_branch=self.br1)
 
151
        self.br1.add_pending_merge(self.br2.revision_history()[6])
 
152
        self.br1.commit("Commit fourtten", rev_id="a@u-0-6")
 
153
 
 
154
        fetch(from_branch=self.br1, to_branch=self.br2)
 
155
        self.br2.add_pending_merge(self.br1.revision_history()[6])
 
156
        self.br2.commit("Commit fifteen", rev_id="b@u-0-10")
 
157
 
 
158
        from bzrlib.revision import MultipleRevisionSources
 
159
        self.sources = MultipleRevisionSources(self.br1, self.br2)
 
160
 
 
161
    def intervene(self, ancestor, revision, revision_history=None):
 
162
        from bzrlib.revision import get_intervening_revisions
 
163
        return get_intervening_revisions(ancestor,revision, self.sources, 
 
164
                                         revision_history)
 
165
 
 
166
    def test_intervene(self):
 
167
        """Find intermediate revisions, without requiring history"""
 
168
        from bzrlib.errors import NotAncestor, NoSuchRevision
 
169
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
 
170
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
 
171
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
 
172
                         ['a@u-0-1', 'a@u-0-2'])
 
173
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
 
174
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
 
175
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
 
176
                         ['b@u-0-4', 'a@u-0-3'])
 
177
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
 
178
                                        self.br1.revision_history()), 
 
179
                         ['a@u-0-3'])
 
180
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
 
181
                                        self.br1.revision_history()), 
 
182
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
183
                          'a@u-0-5'])
 
184
        print ("testrevision.py 191 - intervene appears to return b..6 even"
 
185
               "though it is not reachable!")
 
186
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
 
187
#                         self.br1.revision_history()), 
 
188
#                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
189
#                          'b@u-0-6'])
 
190
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
 
191
#                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
 
192
#                          'b@u-0-5'])
 
193
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
 
194
                         self.br2.revision_history()), 
 
195
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
 
196
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
 
197
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
198
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
 
199
                                        self.br2.revision_history()), 
 
200
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
201
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
 
202
                          self.br2.revision_history())
 
203
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
 
204
                          'b@u-0-6', self.br2.revision_history())
 
205
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
 
206
                          'c@u-0-6', self.br2.revision_history())
 
207
 
 
208
 
 
209
class TestCommonAncestor(TestCaseInTempDir):
166
210
    """Test checking whether a revision is an ancestor of another revision"""
167
211
 
168
 
    def test_get_history(self):
169
 
        # TODO: test ghosts on the left hand branch's impact
170
 
        # TODO: test ghosts on all parents, we should get some
171
 
        # indicator. i.e. NULL_REVISION
172
 
        # RBC 20060608
173
 
        tree = self.make_branch_and_tree('.')
174
 
        tree.commit('1', rev_id = '1', allow_pointless=True)
175
 
        tree.commit('2', rev_id = '2', allow_pointless=True)
176
 
        tree.commit('3', rev_id = '3', allow_pointless=True)
177
 
        rev = tree.branch.repository.get_revision('1')
178
 
        history = rev.get_history(tree.branch.repository)
179
 
        self.assertEqual([None, '1'], history)
180
 
        rev = tree.branch.repository.get_revision('2')
181
 
        history = rev.get_history(tree.branch.repository)
182
 
        self.assertEqual([None, '1', '2'], history)
183
 
        rev = tree.branch.repository.get_revision('3')
184
 
        history = rev.get_history(tree.branch.repository)
185
 
        self.assertEqual([None, '1', '2' ,'3'], history)
186
 
 
187
 
 
188
 
class TestReservedId(TestCase):
189
 
 
190
 
    def test_is_reserved_id(self):
191
 
        self.assertEqual(True, revision.is_reserved_id(NULL_REVISION))
192
 
        self.assertEqual(True, revision.is_reserved_id(
193
 
            revision.CURRENT_REVISION))
194
 
        self.assertEqual(True, revision.is_reserved_id('arch:'))
195
 
        self.assertEqual(False, revision.is_reserved_id('null'))
196
 
        self.assertEqual(False, revision.is_reserved_id(
197
 
            'arch:a@example.com/c--b--v--r'))
198
 
        self.assertEqual(False, revision.is_reserved_id(None))
199
 
 
200
 
 
201
 
class TestRevisionMethods(TestCase):
202
 
 
203
 
    def test_get_summary(self):
204
 
        r = revision.Revision('1')
205
 
        r.message = 'a'
206
 
        self.assertEqual('a', r.get_summary())
207
 
        r.message = 'a\nb'
208
 
        self.assertEqual('a', r.get_summary())
209
 
        r.message = '\na\nb'
210
 
        self.assertEqual('a', r.get_summary())
211
 
        r.message = None
212
 
        self.assertEqual('', r.get_summary())
213
 
 
214
 
    def test_get_apparent_author(self):
215
 
        r = revision.Revision('1')
216
 
        r.committer = 'A'
217
 
        author = self.applyDeprecated(
218
 
                symbol_versioning.deprecated_in((1, 13, 0)),
219
 
                r.get_apparent_author)
220
 
        self.assertEqual('A', author)
221
 
        r.properties['author'] = 'B'
222
 
        author = self.applyDeprecated(
223
 
                symbol_versioning.deprecated_in((1, 13, 0)),
224
 
                r.get_apparent_author)
225
 
        self.assertEqual('B', author)
226
 
        r.properties['authors'] = 'C\nD'
227
 
        author = self.applyDeprecated(
228
 
                symbol_versioning.deprecated_in((1, 13, 0)),
229
 
                r.get_apparent_author)
230
 
        self.assertEqual('C', author)
231
 
 
232
 
    def test_get_apparent_author_none(self):
233
 
        r = revision.Revision('1')
234
 
        author = self.applyDeprecated(
235
 
                symbol_versioning.deprecated_in((1, 13, 0)),
236
 
                r.get_apparent_author)
237
 
        self.assertEqual(None, author)
238
 
 
239
 
    def test_get_apparent_authors(self):
240
 
        r = revision.Revision('1')
241
 
        r.committer = 'A'
242
 
        self.assertEqual(['A'], r.get_apparent_authors())
243
 
        r.properties['author'] = 'B'
244
 
        self.assertEqual(['B'], r.get_apparent_authors())
245
 
        r.properties['authors'] = 'C\nD'
246
 
        self.assertEqual(['C', 'D'], r.get_apparent_authors())
247
 
 
248
 
    def test_get_apparent_authors_no_committer(self):
249
 
        r = revision.Revision('1')
250
 
        self.assertEqual([], r.get_apparent_authors())
251
 
 
252
 
 
253
 
class TestRevisionBugs(TestCase):
254
 
    """Tests for getting the bugs that a revision is linked to."""
255
 
 
256
 
    def test_no_bugs(self):
257
 
        r = revision.Revision('1')
258
 
        self.assertEqual([], list(r.iter_bugs()))
259
 
 
260
 
    def test_some_bugs(self):
261
 
        r = revision.Revision(
262
 
            '1', properties={
263
 
                'bugs': bugtracker.encode_fixes_bug_urls(
264
 
                    ['http://example.com/bugs/1',
265
 
                     'http://launchpad.net/bugs/1234'])})
266
 
        self.assertEqual(
267
 
            [('http://example.com/bugs/1', bugtracker.FIXED),
268
 
             ('http://launchpad.net/bugs/1234', bugtracker.FIXED)],
269
 
            list(r.iter_bugs()))
270
 
 
271
 
    def test_no_status(self):
272
 
        r = revision.Revision(
273
 
            '1', properties={'bugs': 'http://example.com/bugs/1'})
274
 
        self.assertRaises(InvalidLineInBugsProperty, list, r.iter_bugs())
275
 
 
276
 
    def test_too_much_information(self):
277
 
        r = revision.Revision(
278
 
            '1', properties={'bugs': 'http://example.com/bugs/1 fixed bar'})
279
 
        self.assertRaises(InvalidLineInBugsProperty, list, r.iter_bugs())
280
 
 
281
 
    def test_invalid_status(self):
282
 
        r = revision.Revision(
283
 
            '1', properties={'bugs': 'http://example.com/bugs/1 faxed'})
284
 
        self.assertRaises(InvalidBugStatus, list, r.iter_bugs())
 
212
    def test_old_common_ancestor(self):
 
213
        """Pick a resonable merge base using the old functionality"""
 
214
        from bzrlib.revision import old_common_ancestor as common_ancestor
 
215
        br1, br2 = make_branches()
 
216
        revisions = br1.revision_history()
 
217
        revisions_2 = br2.revision_history()
 
218
        sources = br1
 
219
 
 
220
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
221
                                   revisions[2]:(1, 1),
 
222
                                   revisions_2[4]:(2, 1), 
 
223
                                   revisions[1]:(3, 2),
 
224
                                   revisions_2[3]:(4, 2),
 
225
                                   revisions[0]:(5, 3) }
 
226
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
227
        assert len(expected_ancestors_list) == len(ancestors_list)
 
228
        for key, value in expected_ancestors_list.iteritems():
 
229
            self.assertEqual(ancestors_list[key], value, 
 
230
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
231
                                                    value))
 
232
 
 
233
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
234
                          revisions[0])
 
235
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
236
                          revisions[1])
 
237
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
238
                          revisions[1])
 
239
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
240
                          revisions[2])
 
241
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
242
                          revisions_2[4])
 
243
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
244
                          revisions_2[4])
 
245
        fetch(from_branch=br2, to_branch=br1)
 
246
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
247
                          revisions[4]) # revisions_2[5] is equally valid
 
248
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
249
                          revisions_2[5])
 
250
 
 
251
    def test_common_ancestor(self):
 
252
        """Pick a reasonable merge base"""
 
253
        from bzrlib.revision import common_ancestor
 
254
        br1, br2 = make_branches()
 
255
        revisions = br1.revision_history()
 
256
        revisions_2 = br2.revision_history()
 
257
        sources = MultipleRevisionSources(br1, br2)
 
258
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
259
                                   revisions[2]:(1, 1),
 
260
                                   revisions_2[4]:(2, 1), 
 
261
                                   revisions[1]:(3, 2),
 
262
                                   revisions_2[3]:(4, 2),
 
263
                                   revisions[0]:(5, 3) }
 
264
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
265
        assert len(expected_ancestors_list) == len(ancestors_list)
 
266
        for key, value in expected_ancestors_list.iteritems():
 
267
            self.assertEqual(ancestors_list[key], value, 
 
268
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
269
                                                    value))
 
270
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
271
                          revisions[0])
 
272
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
273
                          revisions[1])
 
274
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
275
                          revisions[1])
 
276
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
277
                          revisions[2])
 
278
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
279
                          revisions_2[4])
 
280
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
281
                          revisions_2[4])
 
282
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
283
                          revisions[4]) # revisions_2[5] is equally valid
 
284
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
285
                          revisions[4]) # revisions_2[5] is equally valid
 
286
 
 
287
    def test_combined(self):
 
288
        """combined_graph
 
289
        Ensure it's not order-sensitive
 
290
        """
 
291
        br1, br2 = make_branches()
 
292
        source = MultipleRevisionSources(br1, br2)
 
293
        combined_1 = combined_graph(br1.last_revision(), 
 
294
                                    br2.last_revision(), source)
 
295
        combined_2 = combined_graph(br2.last_revision(),
 
296
                                    br1.last_revision(), source)
 
297
        assert combined_1[1] == combined_2[1]
 
298
        assert combined_1[2] == combined_2[2]
 
299
        assert combined_1[3] == combined_2[3]
 
300
        assert combined_1 == combined_2