← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

Merged Martin

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testrevision.py
26
26
from bzrlib.trace import mutter
27
27
from bzrlib.errors import NoSuchRevision
28
28
 
29
 
def make_branches():
 
29
# XXX: Make this a method of a merge base case
 
30
def make_branches(self):
30
31
    """Create two branches
31
32
 
32
33
    branch 1 has 6 commits, branch 2 has 3 commits
63
64
    
64
65
    fetch(from_branch=br2, to_branch=br1)
65
66
    br1.add_pending_merge(revisions_2[4])
66
 
    assert revisions_2[4] == 'b@u-0-4'
 
67
    self.assertEquals(revisions_2[4], 'b@u-0-4')
67
68
    commit(br1, "Commit six", rev_id="a@u-0-3")
68
69
    commit(br1, "Commit seven", rev_id="a@u-0-4")
69
70
    commit(br2, "Commit eight", rev_id="b@u-0-5")
82
83
class TestIsAncestor(TestCaseInTempDir):
83
84
    def test_recorded_ancestry(self):
84
85
        """Test that commit records all ancestors"""
85
 
        br1, br2 = make_branches()
 
86
        br1, br2 = make_branches(self)
86
87
        d = [('a@u-0-0', ['a@u-0-0']),
87
88
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
88
89
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
118
119
    
119
120
    def test_is_ancestor(self):
120
121
        """Test checking whether a revision is an ancestor of another revision"""
121
 
        br1, br2 = make_branches()
 
122
        br1, br2 = make_branches(self)
122
123
        revisions = br1.revision_history()
123
124
        revisions_2 = br2.revision_history()
124
125
        sources = br1
125
126
 
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)
 
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))
130
131
        # disabled mbp 20050914, doesn't seem to happen anymore
131
132
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
132
133
        ##                  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)
 
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))
137
138
 
138
139
 
139
140
class TestIntermediateRevisions(TestCaseInTempDir):
141
142
    def setUp(self):
142
143
        from bzrlib.commit import commit
143
144
        TestCaseInTempDir.setUp(self)
144
 
        self.br1, self.br2 = make_branches()
 
145
        self.br1, self.br2 = make_branches(self)
145
146
 
146
147
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
147
148
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
166
167
    def test_intervene(self):
167
168
        """Find intermediate revisions, without requiring history"""
168
169
        from bzrlib.errors import NotAncestor, NoSuchRevision
169
 
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
 
170
        self.assertEquals(len(self.intervene('a@u-0-0', 'a@u-0-0')), 0)
170
171
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
171
172
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
172
173
                         ['a@u-0-1', 'a@u-0-2'])
210
211
    def test_old_common_ancestor(self):
211
212
        """Pick a resonable merge base using the old functionality"""
212
213
        from bzrlib.revision import old_common_ancestor as common_ancestor
213
 
        br1, br2 = make_branches()
 
214
        br1, br2 = make_branches(self)
214
215
        revisions = br1.revision_history()
215
216
        revisions_2 = br2.revision_history()
216
217
        sources = br1
222
223
                                   revisions_2[3]:(4, 2),
223
224
                                   revisions[0]:(5, 3) }
224
225
        ancestors_list = find_present_ancestors(revisions[3], sources)
225
 
        assert len(expected_ancestors_list) == len(ancestors_list)
 
226
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
226
227
        for key, value in expected_ancestors_list.iteritems():
227
228
            self.assertEqual(ancestors_list[key], value, 
228
229
                              "key %r, %r != %r" % (key, ancestors_list[key],
249
250
    def test_common_ancestor(self):
250
251
        """Pick a reasonable merge base"""
251
252
        from bzrlib.revision import common_ancestor
252
 
        br1, br2 = make_branches()
 
253
        br1, br2 = make_branches(self)
253
254
        revisions = br1.revision_history()
254
255
        revisions_2 = br2.revision_history()
255
256
        sources = MultipleRevisionSources(br1, br2)
260
261
                                   revisions_2[3]:(4, 2),
261
262
                                   revisions[0]:(5, 3) }
262
263
        ancestors_list = find_present_ancestors(revisions[3], sources)
263
 
        assert len(expected_ancestors_list) == len(ancestors_list)
 
264
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
264
265
        for key, value in expected_ancestors_list.iteritems():
265
266
            self.assertEqual(ancestors_list[key], value, 
266
267
                              "key %r, %r != %r" % (key, ancestors_list[key],
286
287
        """combined_graph
287
288
        Ensure it's not order-sensitive
288
289
        """
289
 
        br1, br2 = make_branches()
 
290
        br1, br2 = make_branches(self)
290
291
        source = MultipleRevisionSources(br1, br2)
291
292
        combined_1 = combined_graph(br1.last_revision(), 
292
293
                                    br2.last_revision(), source)
293
294
        combined_2 = combined_graph(br2.last_revision(),
294
295
                                    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
 
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)