← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

  • Committer: Martin Pool
  • Date: 2005-09-16 09:56:24 UTC
  • Revision ID: mbp@sourcefrog.net-20050916095623-ca0dff452934f21f
- make progress bar more tolerant of out-of-range values

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testrevision.py
17
17
 
18
18
import os
19
19
 
 
20
from bzrlib.selftest import TestCaseInTempDir
20
21
from bzrlib.branch import Branch
21
 
from bzrlib.errors import NoSuchRevision
22
22
from bzrlib.commit import commit
23
23
from bzrlib.fetch import fetch
24
 
from bzrlib.revision import (find_present_ancestors, combined_graph,
25
 
                             is_ancestor, MultipleRevisionSources)
26
 
from bzrlib.tests import TestCaseWithTransport
 
24
from bzrlib.revision import (find_present_ancestors, common_ancestor,
 
25
                             is_ancestor)
27
26
from bzrlib.trace import mutter
28
 
from bzrlib.workingtree import WorkingTree
29
 
 
30
 
# XXX: Make this a method of a merge base case
31
 
def make_branches(self):
32
 
    """Create two branches
33
 
 
34
 
    branch 1 has 6 commits, branch 2 has 3 commits
35
 
    commit 10 was a psuedo merge from branch 1
36
 
    but has been disabled until ghost support is
37
 
    implemented.
38
 
 
39
 
    the object graph is
40
 
    B:     A:
41
 
    a..0   a..0 
42
 
    a..1   a..1
43
 
    a..2   a..2
44
 
    b..3   a..3 merges b..4
45
 
    b..4   a..4
46
 
    b..5   a..5 merges b..5
47
 
    b..6 merges a4
48
 
 
49
 
    so A is missing b6 at the start
50
 
    and B is missing a3, a4, a5
51
 
    """
52
 
    tree1 = self.make_branch_and_tree("branch1")
53
 
    br1 = tree1.branch
 
27
from bzrlib.errors import NoSuchRevision
 
28
 
 
29
def make_branches():
 
30
    os.mkdir("branch1")
 
31
    br1 = Branch("branch1", init=True)
54
32
    
55
 
    tree1.commit("Commit one", rev_id="a@u-0-0")
56
 
    tree1.commit("Commit two", rev_id="a@u-0-1")
57
 
    tree1.commit("Commit three", rev_id="a@u-0-2")
 
33
    commit(br1, "Commit one", rev_id="a@u-0-0")
 
34
    commit(br1, "Commit two", rev_id="a@u-0-1")
 
35
    commit(br1, "Commit three", rev_id="a@u-0-2")
58
36
 
59
 
    tree2 = self.make_branch_and_tree("branch2")
60
 
    br2 = tree2.branch
 
37
    os.mkdir("branch2")
 
38
    br2 = Branch("branch2", init=True)
61
39
    br2.update_revisions(br1)
62
 
    tree2.commit("Commit four", rev_id="b@u-0-3")
63
 
    tree2.commit("Commit five", rev_id="b@u-0-4")
 
40
    commit(br2, "Commit four", rev_id="b@u-0-3")
 
41
    commit(br2, "Commit five", rev_id="b@u-0-4")
64
42
    revisions_2 = br2.revision_history()
65
43
    
66
44
    fetch(from_branch=br2, to_branch=br1)
67
 
    tree1.add_pending_merge(revisions_2[4])
68
 
    self.assertEquals(revisions_2[4], 'b@u-0-4')
69
 
    tree1.commit("Commit six", rev_id="a@u-0-3")
70
 
    tree1.commit("Commit seven", rev_id="a@u-0-4")
71
 
    tree2.commit("Commit eight", rev_id="b@u-0-5")
 
45
    br1.add_pending_merge(revisions_2[4])
 
46
    assert revisions_2[4] == 'b@u-0-4'
 
47
    commit(br1, "Commit six", rev_id="a@u-0-3")
 
48
    commit(br1, "Commit seven", rev_id="a@u-0-4")
 
49
    commit(br2, "Commit eight", rev_id="b@u-0-5")
72
50
    
73
51
    fetch(from_branch=br2, to_branch=br1)
74
 
    tree1.add_pending_merge(br2.revision_history()[5])
75
 
    tree1.commit("Commit nine", rev_id="a@u-0-5")
76
 
    # DO NOT FETCH HERE - we WANT a GHOST.
77
 
    #fetch(from_branch=br1, to_branch=br2)
78
 
    tree2.add_pending_merge(br1.revision_history()[4])
79
 
    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")
 
52
    br1.add_pending_merge(br2.revision_history()[5])
 
53
    commit(br1, "Commit nine", rev_id="a@u-0-5")
 
54
 
 
55
    fetch(from_branch=br1, to_branch=br2)
 
56
    br2.add_pending_merge(br1.revision_history()[4])
 
57
    commit(br2, "Commit ten", rev_id="b@u-0-6")
 
58
 
 
59
    fetch(from_branch=br2, to_branch=br1)
80
60
    
81
61
    return br1, br2
82
62
 
83
63
 
84
 
class TestIsAncestor(TestCaseWithTransport):
85
 
 
 
64
class TestIsAncestor(TestCaseInTempDir):
86
65
    def test_recorded_ancestry(self):
87
66
        """Test that commit records all ancestors"""
88
 
        br1, br2 = make_branches(self)
 
67
        br1, br2 = make_branches()
89
68
        d = [('a@u-0-0', ['a@u-0-0']),
90
69
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
91
70
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
101
80
             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
102
81
                          'b@u-0-3', 'b@u-0-4',
103
82
                          'b@u-0-5', 'a@u-0-5']),
104
 
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',
 
83
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
105
84
                          'b@u-0-3', 'b@u-0-4',
106
85
                          'b@u-0-5', 'b@u-0-6']),
107
86
             ]
108
 
        br1_only = ('a@u-0-3', 'a@u-0-4', 'a@u-0-5')
109
 
        br2_only = ('b@u-0-6',)
110
87
        for branch in br1, br2:
111
88
            for rev_id, anc in d:
112
 
                if rev_id in br1_only and not branch is br1:
113
 
                    continue
114
 
                if rev_id in br2_only and not branch is br2:
115
 
                    continue
116
89
                mutter('ancestry of {%s}: %r',
117
 
                       rev_id, branch.repository.get_ancestry(rev_id))
118
 
                result = sorted(branch.repository.get_ancestry(rev_id))
119
 
                self.assertEquals(result, [None] + sorted(anc))
 
90
                       rev_id, branch.get_ancestry(rev_id))
 
91
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
 
92
                                  sorted(anc))
120
93
    
121
94
    
122
95
    def test_is_ancestor(self):
123
96
        """Test checking whether a revision is an ancestor of another revision"""
124
 
        br1, br2 = make_branches(self)
 
97
        br1, br2 = make_branches()
125
98
        revisions = br1.revision_history()
126
99
        revisions_2 = br2.revision_history()
127
100
        sources = br1
128
101
 
129
 
        self.assert_(is_ancestor(revisions[0], revisions[0], br1))
130
 
        self.assert_(is_ancestor(revisions[1], revisions[0], sources))
131
 
        self.assert_(not is_ancestor(revisions[0], revisions[1], sources))
132
 
        self.assert_(is_ancestor(revisions_2[3], revisions[0], sources))
133
 
        # disabled mbp 20050914, doesn't seem to happen anymore
 
102
        assert is_ancestor(revisions[0], revisions[0], br1)
 
103
        assert is_ancestor(revisions[1], revisions[0], sources)
 
104
        assert not is_ancestor(revisions[0], revisions[1], sources)
 
105
        assert is_ancestor(revisions_2[3], revisions[0], sources)
 
106
        # disabled mbp 20050914, doesn't seem to happen anymore
134
107
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
135
108
        ##                  revisions[0], br1)        
136
 
        self.assert_(is_ancestor(revisions[3], revisions_2[4], sources))
137
 
        self.assert_(is_ancestor(revisions[3], revisions_2[4], br1))
138
 
        self.assert_(is_ancestor(revisions[3], revisions_2[3], sources))
139
 
        ## self.assert_(not is_ancestor(revisions[3], revisions_2[3], br1))
140
 
 
141
 
 
142
 
class TestIntermediateRevisions(TestCaseWithTransport):
 
109
        assert is_ancestor(revisions[3], revisions_2[4], sources)
 
110
        assert is_ancestor(revisions[3], revisions_2[4], br1)
 
111
        assert is_ancestor(revisions[3], revisions_2[3], sources)
 
112
        ## assert not is_ancestor(revisions[3], revisions_2[3], br1)
 
113
 
 
114
 
 
115
 
 
116
class TestIntermediateRevisions(TestCaseInTempDir):
143
117
 
144
118
    def setUp(self):
145
119
        from bzrlib.commit import commit
146
 
        TestCaseWithTransport.setUp(self)
147
 
        self.br1, self.br2 = make_branches(self)
148
 
        wt1 = self.br1.bzrdir.open_workingtree()
149
 
        wt2 = self.br2.bzrdir.open_workingtree()
150
 
        wt2.commit("Commit eleven", rev_id="b@u-0-7")
151
 
        wt2.commit("Commit twelve", rev_id="b@u-0-8")
152
 
        wt2.commit("Commit thirtteen", rev_id="b@u-0-9")
153
 
 
154
 
        fetch(from_branch=self.br2, to_branch=self.br1)
155
 
        wt1.add_pending_merge(self.br2.revision_history()[6])
156
 
        wt1.commit("Commit fourtten", rev_id="a@u-0-6")
157
 
 
158
 
        fetch(from_branch=self.br1, to_branch=self.br2)
159
 
        wt2.add_pending_merge(self.br1.revision_history()[6])
160
 
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
 
120
        TestCaseInTempDir.setUp(self)
 
121
        self.br1, self.br2 = make_branches()
 
122
 
 
123
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
 
124
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
 
125
        self.br2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
126
 
 
127
        fetch(from_branch=self.br2, to_branch=self.br1)
 
128
        self.br1.add_pending_merge(self.br2.revision_history()[6])
 
129
        self.br1.commit("Commit fourtten", rev_id="a@u-0-6")
 
130
 
 
131
        fetch(from_branch=self.br1, to_branch=self.br2)
 
132
        self.br2.add_pending_merge(self.br1.revision_history()[6])
 
133
        self.br2.commit("Commit fifteen", rev_id="b@u-0-10")
161
134
 
162
135
        from bzrlib.revision import MultipleRevisionSources
163
 
        self.sources = MultipleRevisionSources(self.br1.repository,
164
 
                                               self.br2.repository)
 
136
        self.sources = MultipleRevisionSources(self.br1, self.br2)
165
137
 
166
138
    def intervene(self, ancestor, revision, revision_history=None):
167
139
        from bzrlib.revision import get_intervening_revisions
171
143
    def test_intervene(self):
172
144
        """Find intermediate revisions, without requiring history"""
173
145
        from bzrlib.errors import NotAncestor, NoSuchRevision
174
 
        self.assertEquals(len(self.intervene('a@u-0-0', 'a@u-0-0')), 0)
 
146
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
175
147
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
176
148
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
177
149
                         ['a@u-0-1', 'a@u-0-2'])
209
181
                          'c@u-0-6', self.br2.revision_history())
210
182
 
211
183
 
212
 
class TestCommonAncestor(TestCaseWithTransport):
 
184
class TestCommonAncestor(TestCaseInTempDir):
213
185
    """Test checking whether a revision is an ancestor of another revision"""
214
186
 
215
 
    def test_old_common_ancestor(self):
216
 
        """Pick a resonable merge base using the old functionality"""
217
 
        from bzrlib.revision import old_common_ancestor as common_ancestor
218
 
        br1, br2 = make_branches(self)
 
187
    def test_common_ancestor(self):
 
188
        br1, br2 = make_branches()
219
189
        revisions = br1.revision_history()
220
190
        revisions_2 = br2.revision_history()
221
 
        sources = br1.repository
 
191
        sources = br1
222
192
 
223
193
        expected_ancestors_list = {revisions[3]:(0, 0), 
224
194
                                   revisions[2]:(1, 1),
227
197
                                   revisions_2[3]:(4, 2),
228
198
                                   revisions[0]:(5, 3) }
229
199
        ancestors_list = find_present_ancestors(revisions[3], sources)
230
 
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
 
200
        assert len(expected_ancestors_list) == len(ancestors_list)
231
201
        for key, value in expected_ancestors_list.iteritems():
232
202
            self.assertEqual(ancestors_list[key], value, 
233
203
                              "key %r, %r != %r" % (key, ancestors_list[key],
245
215
                          revisions_2[4])
246
216
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
247
217
                          revisions_2[4])
248
 
        fetch(from_branch=br2, to_branch=br1)
249
218
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
250
 
                          revisions[4]) # revisions_2[5] is equally valid
 
219
                          revisions[4])
251
220
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
252
221
                          revisions_2[5])
253
222
 
254
 
    def test_common_ancestor(self):
255
 
        """Pick a reasonable merge base"""
256
 
        from bzrlib.revision import common_ancestor
257
 
        br1, br2 = make_branches(self)
258
 
        revisions = br1.revision_history()
259
 
        revisions_2 = br2.revision_history()
260
 
        sources = MultipleRevisionSources(br1.repository, br2.repository)
261
 
        expected_ancestors_list = {revisions[3]:(0, 0), 
262
 
                                   revisions[2]:(1, 1),
263
 
                                   revisions_2[4]:(2, 1), 
264
 
                                   revisions[1]:(3, 2),
265
 
                                   revisions_2[3]:(4, 2),
266
 
                                   revisions[0]:(5, 3) }
267
 
        ancestors_list = find_present_ancestors(revisions[3], sources)
268
 
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
269
 
        for key, value in expected_ancestors_list.iteritems():
270
 
            self.assertEqual(ancestors_list[key], value, 
271
 
                              "key %r, %r != %r" % (key, ancestors_list[key],
272
 
                                                    value))
273
 
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
274
 
                          revisions[0])
275
 
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
276
 
                          revisions[1])
277
 
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
278
 
                          revisions[1])
279
 
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
280
 
                          revisions[2])
281
 
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
282
 
                          revisions_2[4])
283
 
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
284
 
                          revisions_2[4])
285
 
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
286
 
                          revisions[4]) # revisions_2[5] is equally valid
287
 
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
288
 
                          revisions[4]) # revisions_2[5] is equally valid
289
 
 
290
 
    def test_combined(self):
291
 
        """combined_graph
292
 
        Ensure it's not order-sensitive
293
 
        """
294
 
        br1, br2 = make_branches(self)
295
 
        source = MultipleRevisionSources(br1.repository, br2.repository)
296
 
        combined_1 = combined_graph(br1.last_revision(), 
297
 
                                    br2.last_revision(), source)
298
 
        combined_2 = combined_graph(br2.last_revision(),
299
 
                                    br1.last_revision(), source)
300
 
        self.assertEquals(combined_1[1], combined_2[1])
301
 
        self.assertEquals(combined_1[2], combined_2[2])
302
 
        self.assertEquals(combined_1[3], combined_2[3])
303
 
        self.assertEquals(combined_1, combined_2)
304
 
 
305
 
    def test_get_history(self):
306
 
        # TODO: test ghosts on the left hand branch's impact
307
 
        # TODO: test ghosts on all parents, we should get some
308
 
        # indicator. i.e. NULL_REVISION
309
 
        # RBC 20060608
310
 
        tree = self.make_branch_and_tree('.')
311
 
        tree.commit('1', rev_id = '1', allow_pointless=True)
312
 
        tree.commit('2', rev_id = '2', allow_pointless=True)
313
 
        tree.commit('3', rev_id = '3', allow_pointless=True)
314
 
        rev = tree.branch.repository.get_revision('1')
315
 
        history = rev.get_history(tree.branch.repository)
316
 
        self.assertEqual([None, '1'], history)
317
 
        rev = tree.branch.repository.get_revision('2')
318
 
        history = rev.get_history(tree.branch.repository)
319
 
        self.assertEqual([None, '1', '2'], history)
320
 
        rev = tree.branch.repository.get_revision('3')
321
 
        history = rev.get_history(tree.branch.repository)
322
 
        self.assertEqual([None, '1', '2' ,'3'], history)
 
223
 
 
224
if __name__ == '__main__':
 
225
    import unittest, sys
 
226
    unittest.main()
 
227