/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-02 21:51:29 UTC
  • mfrom: (1396)
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20051002215128-5686c7d24bf9bdb9
merge from martins newformat branch - brings in transport abstraction

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testrevision.py
 
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
class TestIntermediateRevisions(TestCaseInTempDir):
 
144
 
 
145
    def setUp(self):
 
146
        from bzrlib.commit import commit
 
147
        TestCaseInTempDir.setUp(self)
 
148
        self.br1, self.br2 = make_branches()
 
149
 
 
150
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
 
151
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
 
152
        self.br2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
153
 
 
154
        fetch(from_branch=self.br2, to_branch=self.br1)
 
155
        self.br1.add_pending_merge(self.br2.revision_history()[6])
 
156
        self.br1.commit("Commit fourtten", rev_id="a@u-0-6")
 
157
 
 
158
        fetch(from_branch=self.br1, to_branch=self.br2)
 
159
        self.br2.add_pending_merge(self.br1.revision_history()[6])
 
160
        self.br2.commit("Commit fifteen", rev_id="b@u-0-10")
 
161
 
 
162
        from bzrlib.revision import MultipleRevisionSources
 
163
        self.sources = MultipleRevisionSources(self.br1, self.br2)
 
164
 
 
165
    def intervene(self, ancestor, revision, revision_history=None):
 
166
        from bzrlib.revision import get_intervening_revisions
 
167
        return get_intervening_revisions(ancestor,revision, self.sources, 
 
168
                                         revision_history)
 
169
 
 
170
    def test_intervene(self):
 
171
        """Find intermediate revisions, without requiring history"""
 
172
        from bzrlib.errors import NotAncestor, NoSuchRevision
 
173
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
 
174
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
 
175
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
 
176
                         ['a@u-0-1', 'a@u-0-2'])
 
177
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
 
178
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
 
179
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
 
180
                         ['b@u-0-4', 'a@u-0-3'])
 
181
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
 
182
                                        self.br1.revision_history()), 
 
183
                         ['a@u-0-3'])
 
184
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
 
185
                                        self.br1.revision_history()), 
 
186
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
187
                          'a@u-0-5'])
 
188
        print ("testrevision.py 191 - intervene appears to return b..6 even"
 
189
               "though it is not reachable!")
 
190
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
 
191
#                         self.br1.revision_history()), 
 
192
#                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
193
#                          'b@u-0-6'])
 
194
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
 
195
#                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
 
196
#                          'b@u-0-5'])
 
197
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
 
198
                         self.br2.revision_history()), 
 
199
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
 
200
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
 
201
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
202
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
 
203
                                        self.br2.revision_history()), 
 
204
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
205
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
 
206
                          self.br2.revision_history())
 
207
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
 
208
                          'b@u-0-6', self.br2.revision_history())
 
209
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
 
210
                          'c@u-0-6', self.br2.revision_history())
 
211
 
 
212
 
 
213
class TestCommonAncestor(TestCaseInTempDir):
 
214
    """Test checking whether a revision is an ancestor of another revision"""
 
215
 
 
216
    def test_old_common_ancestor(self):
 
217
        """Pick a resonable merge base using the old functionality"""
 
218
        from bzrlib.revision import old_common_ancestor as common_ancestor
 
219
        br1, br2 = make_branches()
 
220
        revisions = br1.revision_history()
 
221
        revisions_2 = br2.revision_history()
 
222
        sources = br1
 
223
 
 
224
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
225
                                   revisions[2]:(1, 1),
 
226
                                   revisions_2[4]:(2, 1), 
 
227
                                   revisions[1]:(3, 2),
 
228
                                   revisions_2[3]:(4, 2),
 
229
                                   revisions[0]:(5, 3) }
 
230
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
231
        assert len(expected_ancestors_list) == len(ancestors_list)
 
232
        for key, value in expected_ancestors_list.iteritems():
 
233
            self.assertEqual(ancestors_list[key], value, 
 
234
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
235
                                                    value))
 
236
 
 
237
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
238
                          revisions[0])
 
239
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
240
                          revisions[1])
 
241
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
242
                          revisions[1])
 
243
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
244
                          revisions[2])
 
245
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
246
                          revisions_2[4])
 
247
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
248
                          revisions_2[4])
 
249
        fetch(from_branch=br2, to_branch=br1)
 
250
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
251
                          revisions_2[5])
 
252
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
253
                          revisions_2[5])
 
254
 
 
255
    def test_common_ancestor(self):
 
256
        """Pick a reasonable merge base"""
 
257
        from bzrlib.revision import common_ancestor
 
258
        br1, br2 = make_branches()
 
259
        revisions = br1.revision_history()
 
260
        revisions_2 = br2.revision_history()
 
261
        sources = MultipleRevisionSources(br1, br2)
 
262
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
263
                                   revisions[2]:(1, 1),
 
264
                                   revisions_2[4]:(2, 1), 
 
265
                                   revisions[1]:(3, 2),
 
266
                                   revisions_2[3]:(4, 2),
 
267
                                   revisions[0]:(5, 3) }
 
268
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
269
        assert len(expected_ancestors_list) == len(ancestors_list)
 
270
        for key, value in expected_ancestors_list.iteritems():
 
271
            self.assertEqual(ancestors_list[key], value, 
 
272
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
273
                                                    value))
 
274
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
275
                          revisions[0])
 
276
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
277
                          revisions[1])
 
278
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
279
                          revisions[1])
 
280
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
281
                          revisions[2])
 
282
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
283
                          revisions_2[4])
 
284
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
285
                          revisions_2[4])
 
286
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
287
                          revisions_2[5])
 
288
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
289
                          revisions_2[5])
 
290
 
 
291
    def test_combined(self):
 
292
        """combined_graph
 
293
        Ensure it's not order-sensitive
 
294
        """
 
295
        br1, br2 = make_branches()
 
296
        source = MultipleRevisionSources(br1, br2)
 
297
        combined_1 = combined_graph(br1.last_revision(), 
 
298
                                    br2.last_revision(), source)
 
299
        combined_2 = combined_graph(br2.last_revision(),
 
300
                                    br1.last_revision(), source)
 
301
        assert combined_1[1] == combined_2[1]
 
302
        assert combined_1[2] == combined_2[2]
 
303
        assert combined_1[3] == combined_2[3]
 
304
        assert combined_1 == combined_2