/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

[merge] robertc's integration, updated tests to check for retcode=3

Show diffs side-by-side

added added

removed removed

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