← Back to branch summary

~thumper/bzr/alias-command

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

  • Committer: Tim Penhey
  • Date: 2008-04-20 08:48:04 UTC
  • mfrom: (2900.1.474 +trunk)
  • Revision ID: tim@penhey.net-20080420084804-fw6m8ezw4n7pnmo1
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revision.py
20
20
 
21
21
from bzrlib import (
22
22
    revision,
 
23
    symbol_versioning,
23
24
    )
24
25
from bzrlib.branch import Branch
25
26
from bzrlib.errors import NoSuchRevision
28
29
                             common_ancestor,
29
30
                             is_ancestor, MultipleRevisionSources,
30
31
                             NULL_REVISION)
 
32
from bzrlib.symbol_versioning import one_zero, one_three
31
33
from bzrlib.tests import TestCase, TestCaseWithTransport
32
34
from bzrlib.trace import mutter
33
35
from bzrlib.workingtree import WorkingTree
132
134
        revisions_2 = br2.revision_history()
133
135
        sources = br1
134
136
 
135
 
        self.assert_(is_ancestor(revisions[0], revisions[0], br1))
136
 
        self.assert_(is_ancestor(revisions[1], revisions[0], sources))
137
 
        self.assert_(not is_ancestor(revisions[0], revisions[1], sources))
138
 
        self.assert_(is_ancestor(revisions_2[3], revisions[0], sources))
 
137
        br1.lock_read()
 
138
        br2.lock_read()
 
139
        self.addCleanup(br1.unlock)
 
140
        br2.lock_read()
 
141
        self.addCleanup(br2.unlock)
 
142
 
 
143
        self.assertTrue(self.applyDeprecated(one_zero,
 
144
                        is_ancestor, revisions[0], revisions[0], br1))
 
145
        self.assertTrue(self.applyDeprecated(one_zero,
 
146
                        is_ancestor, revisions[1], revisions[0], sources))
 
147
        self.assertFalse(self.applyDeprecated(one_zero,
 
148
                         is_ancestor, revisions[0], revisions[1], sources))
 
149
        self.assertTrue(self.applyDeprecated(one_zero,
 
150
                        is_ancestor, revisions_2[3], revisions[0], sources))
139
151
        # disabled mbp 20050914, doesn't seem to happen anymore
140
152
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
141
 
        ##                  revisions[0], br1)        
142
 
        self.assert_(is_ancestor(revisions[3], revisions_2[4], sources))
143
 
        self.assert_(is_ancestor(revisions[3], revisions_2[4], br1))
144
 
        self.assert_(is_ancestor(revisions[3], revisions_2[3], sources))
 
153
        ##                  revisions[0], br1)
 
154
        self.assertTrue(self.applyDeprecated(one_zero,
 
155
                        is_ancestor, revisions[3], revisions_2[4], sources))
 
156
        self.assertTrue(self.applyDeprecated(one_zero,
 
157
                        is_ancestor, revisions[3], revisions_2[4], br1))
 
158
        self.assertTrue(self.applyDeprecated(one_zero,
 
159
                        is_ancestor, revisions[3], revisions_2[3], sources))
145
160
        ## self.assert_(not is_ancestor(revisions[3], revisions_2[3], br1))
146
161
 
147
162
 
163
178
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
164
179
 
165
180
        from bzrlib.revision import MultipleRevisionSources
166
 
        self.sources = MultipleRevisionSources(self.br1.repository,
167
 
                                               self.br2.repository)
 
181
        self.sources = self.applyDeprecated(one_three,
 
182
                        MultipleRevisionSources, self.br1.repository,
 
183
                                                 self.br2.repository)
168
184
 
169
185
 
170
186
 
186
202
class TestCommonAncestor(TestCaseWithTransport):
187
203
    """Test checking whether a revision is an ancestor of another revision"""
188
204
 
 
205
    def assertCommonAncestorEqual(self, expected, sources, rev_a, rev_b):
 
206
        self.assertEqual(expected,
 
207
                         self.applyDeprecated(one_three, 
 
208
                         common_ancestor, rev_a, rev_b, sources))
 
209
 
 
210
    def assertCommonAncestorIn(self, possible, sources, rev_a, rev_b):
 
211
        """assert that we pick one among multiple possible common ancestors"""
 
212
        self.assertTrue(self.applyDeprecated(one_three, 
 
213
                            common_ancestor, rev_a, rev_b, sources)
 
214
                        in possible)
 
215
 
189
216
    def test_common_ancestor(self):
190
217
        """Pick a reasonable merge base"""
191
218
        br1, br2 = make_branches(self)
192
219
        revisions = br1.revision_history()
193
220
        revisions_2 = br2.revision_history()
194
 
        sources = MultipleRevisionSources(br1.repository, br2.repository)
 
221
        sources = self.applyDeprecated(one_three, 
 
222
                    MultipleRevisionSources, br1.repository, br2.repository)
195
223
        expected_ancestors_list = {revisions[3]:(0, 0), 
196
224
                                   revisions[2]:(1, 1),
197
225
                                   revisions_2[4]:(2, 1), 
204
232
            self.assertEqual(ancestors_list[key], value, 
205
233
                              "key %r, %r != %r" % (key, ancestors_list[key],
206
234
                                                    value))
207
 
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
208
 
                          revisions[0])
209
 
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
210
 
                          revisions[1])
211
 
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
212
 
                          revisions[1])
213
 
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
214
 
                          revisions[2])
215
 
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
216
 
                          revisions_2[4])
217
 
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
218
 
                          revisions_2[4])
219
 
        self.assertTrue(common_ancestor(revisions[5], revisions_2[6], sources) in
220
 
                        (revisions[4], revisions_2[5]))
221
 
        self.assertTrue(common_ancestor(revisions_2[6], revisions[5], sources),
222
 
                        (revisions[4], revisions_2[5]))
223
 
        self.assertEqual(None, common_ancestor(None, revisions[5], sources))
224
 
        self.assertEqual(NULL_REVISION,
225
 
            common_ancestor(NULL_REVISION, NULL_REVISION, sources))
226
 
        self.assertEqual(NULL_REVISION,
227
 
            common_ancestor(revisions[0], NULL_REVISION, sources))
228
 
        self.assertEqual(NULL_REVISION,
229
 
            common_ancestor(NULL_REVISION, revisions[0], sources))
 
235
        self.assertCommonAncestorEqual(revisions[0], sources,
 
236
                                       revisions[0], revisions[0])
 
237
        self.assertCommonAncestorEqual(revisions[1], sources,
 
238
                                       revisions[1], revisions[2])
 
239
        self.assertCommonAncestorEqual(revisions[1], sources,
 
240
                                       revisions[1], revisions[1])
 
241
        self.assertCommonAncestorEqual(revisions[2], sources,
 
242
                                       revisions[2], revisions_2[4])
 
243
        self.assertCommonAncestorEqual(revisions_2[4], sources,
 
244
                                       revisions[3], revisions_2[4])
 
245
        self.assertCommonAncestorEqual(revisions_2[4], sources,
 
246
                                       revisions[4], revisions_2[5])
 
247
        self.assertCommonAncestorIn((revisions[4], revisions_2[5]), sources,
 
248
                                     revisions[5], revisions_2[6])
 
249
        self.assertCommonAncestorIn((revisions[4], revisions_2[5]), sources,
 
250
                                     revisions_2[6], revisions[5])
 
251
        self.assertCommonAncestorEqual(None, sources,
 
252
                                       None, revisions[5])
 
253
        self.assertCommonAncestorEqual(NULL_REVISION, sources,
 
254
                                       NULL_REVISION, NULL_REVISION)
 
255
        self.assertCommonAncestorEqual(NULL_REVISION, sources,
 
256
                                       revisions[0], NULL_REVISION)
 
257
        self.assertCommonAncestorEqual(NULL_REVISION, sources,
 
258
                                       NULL_REVISION, revisions[0])
230
259
 
231
260
    def test_combined(self):
232
261
        """combined_graph
233
262
        Ensure it's not order-sensitive
234
263
        """
235
264
        br1, br2 = make_branches(self)
236
 
        source = MultipleRevisionSources(br1.repository, br2.repository)
237
 
        combined_1 = combined_graph(br1.last_revision(),
238
 
                                    br2.last_revision(), source)
239
 
        combined_2 = combined_graph(br2.last_revision(),
240
 
                                    br1.last_revision(), source)
 
265
        source = self.applyDeprecated(one_three,
 
266
                    MultipleRevisionSources, br1.repository, br2.repository)
 
267
        combined_1 = self.applyDeprecated(one_three,
 
268
                        combined_graph, br1.last_revision(),
 
269
                                        br2.last_revision(), source)
 
270
        combined_2 = self.applyDeprecated(one_three,
 
271
                        combined_graph, br2.last_revision(),
 
272
                                        br1.last_revision(), source)
241
273
        self.assertEquals(combined_1[1], combined_2[1])
242
274
        self.assertEquals(combined_1[2], combined_2[2])
243
275
        self.assertEquals(combined_1[3], combined_2[3])
275
307
        # add a right-branch revision
276
308
        graph.add_node('right', ['rev1'])
277
309
        source = MockRevisionSource(graph)
278
 
        self.assertEqual('rev1', common_ancestor('left', 'right', source))
 
310
        self.assertCommonAncestorEqual('rev1', source, 'left', 'right')
279
311
 
280
312
 
281
313
class TestMultipleRevisionSources(TestCaseWithTransport):
291
323
        tree_1.commit('foo', rev_id='B', allow_pointless=True)
292
324
        tree_2 = self.make_branch_and_tree('2')
293
325
        tree_2.commit('bar', rev_id='A', allow_pointless=True)
294
 
        source = MultipleRevisionSources(tree_1.branch.repository,
295
 
                                         tree_2.branch.repository)
 
326
        source = self.applyDeprecated(one_three,
 
327
                    MultipleRevisionSources, tree_1.branch.repository,
 
328
                                             tree_2.branch.repository)
 
329
        # get_revision_graph calls the deprecated
 
330
        # get_revision_graph_with_ghosts once for each repository.
 
331
        expected_warning = symbol_versioning.deprecation_string(
 
332
            tree_1.branch.repository.get_revision_graph_with_ghosts,
 
333
            one_three)
 
334
        rev_graph = self.callDeprecated([expected_warning, expected_warning],
 
335
                        source.get_revision_graph, 'B')
296
336
        self.assertEqual({'B':['A'],
297
 
                          'A':[]},
298
 
                         source.get_revision_graph('B'))
 
337
                          'A':[]}, rev_graph)
299
338
 
300
339
 
301
340
class TestReservedId(TestCase):