← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

  • Committer: Robert Collins
  • Date: 2005-10-22 13:27:47 UTC
  • Revision ID: robertc@robertcollins.net-20051022132747-706eed356bb1a11e
convert versioning tests to use self.run_bzr, making the test suite quieter

Show diffs side-by-side

added added

removed removed

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