~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

  • Committer: mbp at sourcefrog
  • Date: 2005-04-05 08:24:51 UTC
  • Revision ID: mbp@sourcefrog.net-20050405082451-408ebb0fd108440f
start adding quotes

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# (C) 2005 Canonical Ltd
2
 
 
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
 
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
 
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
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():
30
 
    """Create two branches
31
 
 
32
 
    branch 1 has 6 commits, branch 2 has 3 commits
33
 
    commit 10 was a psuedo merge from branch 1
34
 
    but has been disabled until ghost support is
35
 
    implemented.
36
 
 
37
 
    the object graph is
38
 
    B:     A:
39
 
    a..0   a..0 
40
 
    a..1   a..1
41
 
    a..2   a..2
42
 
    b..3   a..3 merges b..4
43
 
    b..4   a..4
44
 
    b..5   a..5 merges b..5
45
 
    b..6
46
 
 
47
 
    so A is missing b6 at the start
48
 
    and B is missing a3, a4, a5
49
 
    """
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")
62
 
    revisions_2 = br2.revision_history()
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
 
    # disabled - it makes testing fetch too hard,
75
 
    # but can be easily reenabled (without the fetch
76
 
    # when GHOSTS are supported. RBC 20050928
77
 
    #fetch(from_branch=br1, to_branch=br2)
78
 
    #br2.add_pending_merge(br1.revision_history()[4])
79
 
    commit(br2, "Commit ten - no merge", rev_id="b@u-0-6")
80
 
 
81
 
    #fetch(from_branch=br2, to_branch=br1)
82
 
    
83
 
    return br1, br2
84
 
 
85
 
 
86
 
class TestIsAncestor(TestCaseInTempDir):
87
 
    def test_recorded_ancestry(self):
88
 
        """Test that commit records all ancestors"""
89
 
        br1, br2 = make_branches()
90
 
        d = [('a@u-0-0', ['a@u-0-0']),
91
 
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
92
 
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
93
 
             ('b@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3']),
94
 
             ('b@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3',
95
 
                          'b@u-0-4']),
96
 
             ('a@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
97
 
                          'a@u-0-3']),
98
 
             ('a@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
99
 
                          'a@u-0-3', 'a@u-0-4']),
100
 
             ('b@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
101
 
                          'b@u-0-5']),
102
 
             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
103
 
                          'b@u-0-3', 'b@u-0-4',
104
 
                          'b@u-0-5', 'a@u-0-5']),
105
 
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',
106
 
                          'b@u-0-3', 'b@u-0-4',
107
 
                          'b@u-0-5', 'b@u-0-6']),
108
 
             ]
109
 
        br1_only = ('a@u-0-3', 'a@u-0-4', 'a@u-0-5')
110
 
        br2_only = ('b@u-0-6',)
111
 
        for branch in br1, br2:
112
 
            for rev_id, anc in d:
113
 
                if rev_id in br1_only and not branch is br1:
114
 
                    continue
115
 
                if rev_id in br2_only and not branch is br2:
116
 
                    continue
117
 
                mutter('ancestry of {%s}: %r',
118
 
                       rev_id, branch.get_ancestry(rev_id))
119
 
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
120
 
                                  [None] + sorted(anc))
121
 
    
122
 
    
123
 
    def test_is_ancestor(self):
124
 
        """Test checking whether a revision is an ancestor of another revision"""
125
 
        br1, br2 = make_branches()
126
 
        revisions = br1.revision_history()
127
 
        revisions_2 = br2.revision_history()
128
 
        sources = br1
129
 
 
130
 
        assert is_ancestor(revisions[0], revisions[0], br1)
131
 
        assert is_ancestor(revisions[1], revisions[0], sources)
132
 
        assert not is_ancestor(revisions[0], revisions[1], sources)
133
 
        assert is_ancestor(revisions_2[3], revisions[0], sources)
134
 
        # disabled mbp 20050914, doesn't seem to happen anymore
135
 
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
136
 
        ##                  revisions[0], br1)        
137
 
        assert is_ancestor(revisions[3], revisions_2[4], sources)
138
 
        assert is_ancestor(revisions[3], revisions_2[4], br1)
139
 
        assert is_ancestor(revisions[3], revisions_2[3], sources)
140
 
        ## assert not is_ancestor(revisions[3], revisions_2[3], br1)
141
 
 
142
 
 
143
 
 
144
 
class TestIntermediateRevisions(TestCaseInTempDir):
145
 
 
146
 
    def setUp(self):
147
 
        from bzrlib.commit import commit
148
 
        TestCaseInTempDir.setUp(self)
149
 
        self.br1, self.br2 = make_branches()
150
 
 
151
 
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
152
 
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
153
 
        self.br2.commit("Commit thirtteen", rev_id="b@u-0-9")
154
 
 
155
 
        fetch(from_branch=self.br2, to_branch=self.br1)
156
 
        self.br1.add_pending_merge(self.br2.revision_history()[6])
157
 
        self.br1.commit("Commit fourtten", rev_id="a@u-0-6")
158
 
 
159
 
        fetch(from_branch=self.br1, to_branch=self.br2)
160
 
        self.br2.add_pending_merge(self.br1.revision_history()[6])
161
 
        self.br2.commit("Commit fifteen", rev_id="b@u-0-10")
162
 
 
163
 
        from bzrlib.revision import MultipleRevisionSources
164
 
        self.sources = MultipleRevisionSources(self.br1, self.br2)
165
 
 
166
 
    def intervene(self, ancestor, revision, revision_history=None):
167
 
        from bzrlib.revision import get_intervening_revisions
168
 
        return get_intervening_revisions(ancestor,revision, self.sources, 
169
 
                                         revision_history)
170
 
 
171
 
    def test_intervene(self):
172
 
        """Find intermediate revisions, without requiring history"""
173
 
        from bzrlib.errors import NotAncestor, NoSuchRevision
174
 
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
175
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
176
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
177
 
                         ['a@u-0-1', 'a@u-0-2'])
178
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
179
 
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
180
 
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
181
 
                         ['b@u-0-4', 'a@u-0-3'])
182
 
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
183
 
                                        self.br1.revision_history()), 
184
 
                         ['a@u-0-3'])
185
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
186
 
                                        self.br1.revision_history()), 
187
 
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
188
 
                          'a@u-0-5'])
189
 
        print ("testrevision.py 191 - intervene appears to return b..6 even"
190
 
               "though it is not reachable!")
191
 
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
192
 
#                         self.br1.revision_history()), 
193
 
#                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
194
 
#                          'b@u-0-6'])
195
 
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
196
 
#                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
197
 
#                          'b@u-0-5'])
198
 
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
199
 
                         self.br2.revision_history()), 
200
 
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
201
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
202
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
203
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
204
 
                                        self.br2.revision_history()), 
205
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
206
 
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
207
 
                          self.br2.revision_history())
208
 
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
209
 
                          'b@u-0-6', self.br2.revision_history())
210
 
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
211
 
                          'c@u-0-6', self.br2.revision_history())
212
 
 
213
 
 
214
 
class TestCommonAncestor(TestCaseInTempDir):
215
 
    """Test checking whether a revision is an ancestor of another revision"""
216
 
 
217
 
    def test_old_common_ancestor(self):
218
 
        """Pick a resonable merge base using the old functionality"""
219
 
        from bzrlib.revision import old_common_ancestor as common_ancestor
220
 
        br1, br2 = make_branches()
221
 
        revisions = br1.revision_history()
222
 
        revisions_2 = br2.revision_history()
223
 
        sources = br1
224
 
 
225
 
        expected_ancestors_list = {revisions[3]:(0, 0), 
226
 
                                   revisions[2]:(1, 1),
227
 
                                   revisions_2[4]:(2, 1), 
228
 
                                   revisions[1]:(3, 2),
229
 
                                   revisions_2[3]:(4, 2),
230
 
                                   revisions[0]:(5, 3) }
231
 
        ancestors_list = find_present_ancestors(revisions[3], sources)
232
 
        assert len(expected_ancestors_list) == len(ancestors_list)
233
 
        for key, value in expected_ancestors_list.iteritems():
234
 
            self.assertEqual(ancestors_list[key], value, 
235
 
                              "key %r, %r != %r" % (key, ancestors_list[key],
236
 
                                                    value))
237
 
 
238
 
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
239
 
                          revisions[0])
240
 
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
241
 
                          revisions[1])
242
 
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
243
 
                          revisions[1])
244
 
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
245
 
                          revisions[2])
246
 
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
247
 
                          revisions_2[4])
248
 
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
249
 
                          revisions_2[4])
250
 
        fetch(from_branch=br2, to_branch=br1)
251
 
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
252
 
                          revisions_2[5])
253
 
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
254
 
                          revisions_2[5])
255
 
 
256
 
    def test_common_ancestor(self):
257
 
        """Pick a reasonable merge base"""
258
 
        from bzrlib.revision import common_ancestor
259
 
        br1, br2 = make_branches()
260
 
        revisions = br1.revision_history()
261
 
        revisions_2 = br2.revision_history()
262
 
        sources = MultipleRevisionSources(br1, br2)
263
 
 
264
 
        expected_ancestors_list = {revisions[3]:(0, 0), 
265
 
                                   revisions[2]:(1, 1),
266
 
                                   revisions_2[4]:(2, 1), 
267
 
                                   revisions[1]:(3, 2),
268
 
                                   revisions_2[3]:(4, 2),
269
 
                                   revisions[0]:(5, 3) }
270
 
        ancestors_list = find_present_ancestors(revisions[3], sources)
271
 
        assert len(expected_ancestors_list) == len(ancestors_list)
272
 
        for key, value in expected_ancestors_list.iteritems():
273
 
            self.assertEqual(ancestors_list[key], value, 
274
 
                              "key %r, %r != %r" % (key, ancestors_list[key],
275
 
                                                    value))
276
 
 
277
 
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
278
 
                          revisions[0])
279
 
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
280
 
                          revisions[1])
281
 
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
282
 
                          revisions[1])
283
 
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
284
 
                          revisions[2])
285
 
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
286
 
                          revisions_2[4])
287
 
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
288
 
                          revisions_2[4])
289
 
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
290
 
                          revisions_2[5])
291
 
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
292
 
                          revisions_2[5])
293
 
 
294
 
    def test_combined(self):
295
 
        """combined_graph
296
 
        Ensure it's not order-sensitive
297
 
        """
298
 
        br1, br2 = make_branches()
299
 
        source = MultipleRevisionSources(br1, br2)
300
 
        combined_1 = combined_graph(br1.last_revision(), 
301
 
                                    br2.last_revision(), source)
302
 
        combined_2 = combined_graph(br2.last_revision(),
303
 
                                    br1.last_revision(), source)
304
 
        assert combined_1[1] == combined_2[1]
305
 
        assert combined_1[2] == combined_2[2]
306
 
        assert combined_1[3] == combined_2[3]
307
 
        assert combined_1 == combined_2