← 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-13 05:22:41 UTC
  • Revision ID: mbp@sourcefrog.net-20050913052241-52dbd8e8ced620f6
- better BZR_DEBUG trace output

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testrevision.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
 
18
 
import os
19
 
 
20
 
from bzrlib.tests 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
 
# XXX: Make this a method of a merge base case
30
 
def make_branches(self):
31
 
    """Create two branches
32
 
 
33
 
    branch 1 has 6 commits, branch 2 has 3 commits
34
 
    commit 10 was a psuedo merge from branch 1
35
 
    but has been disabled until ghost support is
36
 
    implemented.
37
 
 
38
 
    the object graph is
39
 
    B:     A:
40
 
    a..0   a..0 
41
 
    a..1   a..1
42
 
    a..2   a..2
43
 
    b..3   a..3 merges b..4
44
 
    b..4   a..4
45
 
    b..5   a..5 merges b..5
46
 
    b..6 merges a4
47
 
 
48
 
    so A is missing b6 at the start
49
 
    and B is missing a3, a4, a5
50
 
    """
 
17
from bzrlib.selftest import TestCaseInTempDir
 
18
 
 
19
 
 
20
def make_branches():
 
21
    from bzrlib.branch import Branch
 
22
    from bzrlib.commit import commit
 
23
    import os
51
24
    os.mkdir("branch1")
52
 
    br1 = Branch.initialize("branch1")
 
25
    br1 = Branch("branch1", init=True)
53
26
    
54
27
    commit(br1, "Commit one", rev_id="a@u-0-0")
55
28
    commit(br1, "Commit two", rev_id="a@u-0-1")
56
29
    commit(br1, "Commit three", rev_id="a@u-0-2")
57
30
 
58
31
    os.mkdir("branch2")
59
 
    br2 = Branch.initialize("branch2")
 
32
    br2 = Branch("branch2", init=True)
60
33
    br2.update_revisions(br1)
61
34
    commit(br2, "Commit four", rev_id="b@u-0-3")
62
35
    commit(br2, "Commit five", rev_id="b@u-0-4")
63
36
    revisions_2 = br2.revision_history()
64
 
    
65
 
    fetch(from_branch=br2, to_branch=br1)
66
 
    br1.working_tree().add_pending_merge(revisions_2[4])
67
 
    self.assertEquals(revisions_2[4], 'b@u-0-4')
 
37
    br1.add_pending_merge(revisions_2[4])
68
38
    commit(br1, "Commit six", rev_id="a@u-0-3")
69
39
    commit(br1, "Commit seven", rev_id="a@u-0-4")
70
40
    commit(br2, "Commit eight", rev_id="b@u-0-5")
71
 
    
72
 
    fetch(from_branch=br2, to_branch=br1)
73
 
    br1.working_tree().add_pending_merge(br2.revision_history()[5])
 
41
    br1.add_pending_merge(br2.revision_history()[5])
74
42
    commit(br1, "Commit nine", rev_id="a@u-0-5")
75
 
    # DO NOT FETCH HERE - we WANT a GHOST.
76
 
    #fetch(from_branch=br1, to_branch=br2)
77
 
    br2.working_tree().add_pending_merge(br1.revision_history()[4])
78
 
    commit(br2, "Commit ten - ghost merge", rev_id="b@u-0-6")
79
 
    
 
43
    br2.add_pending_merge(br1.revision_history()[4])
 
44
    commit(br2, "Commit ten", rev_id="b@u-0-6")
80
45
    return br1, br2
81
46
 
82
47
 
83
48
class TestIsAncestor(TestCaseInTempDir):
84
 
    def test_recorded_ancestry(self):
85
 
        """Test that commit records all ancestors"""
86
 
        br1, br2 = make_branches(self)
87
 
        d = [('a@u-0-0', ['a@u-0-0']),
88
 
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
89
 
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
90
 
             ('b@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3']),
91
 
             ('b@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3',
92
 
                          'b@u-0-4']),
93
 
             ('a@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
94
 
                          'a@u-0-3']),
95
 
             ('a@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
96
 
                          'a@u-0-3', 'a@u-0-4']),
97
 
             ('b@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
98
 
                          'b@u-0-5']),
99
 
             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
100
 
                          'b@u-0-3', 'b@u-0-4',
101
 
                          'b@u-0-5', 'a@u-0-5']),
102
 
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',
103
 
                          'b@u-0-3', 'b@u-0-4',
104
 
                          'b@u-0-5', 'b@u-0-6']),
105
 
             ]
106
 
        br1_only = ('a@u-0-3', 'a@u-0-4', 'a@u-0-5')
107
 
        br2_only = ('b@u-0-6',)
108
 
        for branch in br1, br2:
109
 
            for rev_id, anc in d:
110
 
                if rev_id in br1_only and not branch is br1:
111
 
                    continue
112
 
                if rev_id in br2_only and not branch is br2:
113
 
                    continue
114
 
                mutter('ancestry of {%s}: %r',
115
 
                       rev_id, branch.get_ancestry(rev_id))
116
 
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
117
 
                                  [None] + sorted(anc))
118
 
    
119
 
    
120
49
    def test_is_ancestor(self):
121
50
        """Test checking whether a revision is an ancestor of another revision"""
122
 
        br1, br2 = make_branches(self)
 
51
        from bzrlib.revision import is_ancestor, MultipleRevisionSources
 
52
        from bzrlib.errors import NoSuchRevision
 
53
        br1, br2 = make_branches()
123
54
        revisions = br1.revision_history()
124
55
        revisions_2 = br2.revision_history()
125
 
        sources = br1
126
 
 
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))
131
 
        # disabled mbp 20050914, doesn't seem to happen anymore
132
 
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
133
 
        ##                  revisions[0], 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))
138
 
 
 
56
        sources = MultipleRevisionSources(br1, br2)
 
57
 
 
58
        assert is_ancestor(revisions[0], revisions[0], sources)
 
59
        assert is_ancestor(revisions[1], revisions[0], sources)
 
60
        assert not is_ancestor(revisions[0], revisions[1], sources)
 
61
        assert is_ancestor(revisions_2[3], revisions[0], sources)
 
62
        self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
63
                          revisions[0], br1)        
 
64
        assert is_ancestor(revisions[3], revisions_2[4], sources)
 
65
        assert is_ancestor(revisions[3], revisions_2[4], br1)
 
66
        assert is_ancestor(revisions[3], revisions_2[3], sources)
 
67
        assert not is_ancestor(revisions[3], revisions_2[3], br1)
139
68
 
140
69
class TestIntermediateRevisions(TestCaseInTempDir):
141
70
 
142
71
    def setUp(self):
143
72
        from bzrlib.commit import commit
144
73
        TestCaseInTempDir.setUp(self)
145
 
        self.br1, self.br2 = make_branches(self)
146
 
 
147
 
        self.br2.working_tree().commit("Commit eleven", rev_id="b@u-0-7")
148
 
        self.br2.working_tree().commit("Commit twelve", rev_id="b@u-0-8")
149
 
        self.br2.working_tree().commit("Commit thirtteen", rev_id="b@u-0-9")
150
 
 
151
 
        fetch(from_branch=self.br2, to_branch=self.br1)
152
 
        self.br1.working_tree().add_pending_merge(self.br2.revision_history()[6])
153
 
        self.br1.working_tree().commit("Commit fourtten", rev_id="a@u-0-6")
154
 
 
155
 
        fetch(from_branch=self.br1, to_branch=self.br2)
156
 
        self.br2.working_tree().add_pending_merge(self.br1.revision_history()[6])
157
 
        self.br2.working_tree().commit("Commit fifteen", rev_id="b@u-0-10")
 
74
        self.br1, self.br2 = make_branches()
 
75
        commit(self.br2, "Commit eleven", rev_id="b@u-0-7")
 
76
        commit(self.br2, "Commit twelve", rev_id="b@u-0-8")
 
77
        commit(self.br2, "Commit thirtteen", rev_id="b@u-0-9")
 
78
        self.br1.add_pending_merge(self.br2.revision_history()[6])
 
79
        commit(self.br1, "Commit fourtten", rev_id="a@u-0-6")
 
80
        self.br2.add_pending_merge(self.br1.revision_history()[6])
 
81
        commit(self.br2, "Commit fifteen", rev_id="b@u-0-10")
158
82
 
159
83
        from bzrlib.revision import MultipleRevisionSources
160
84
        self.sources = MultipleRevisionSources(self.br1, self.br2)
167
91
    def test_intervene(self):
168
92
        """Find intermediate revisions, without requiring history"""
169
93
        from bzrlib.errors import NotAncestor, NoSuchRevision
170
 
        self.assertEquals(len(self.intervene('a@u-0-0', 'a@u-0-0')), 0)
 
94
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
171
95
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
172
96
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
173
97
                         ['a@u-0-1', 'a@u-0-2'])
208
132
class TestCommonAncestor(TestCaseInTempDir):
209
133
    """Test checking whether a revision is an ancestor of another revision"""
210
134
 
211
 
    def test_old_common_ancestor(self):
212
 
        """Pick a resonable merge base using the old functionality"""
213
 
        from bzrlib.revision import old_common_ancestor as common_ancestor
214
 
        br1, br2 = make_branches(self)
 
135
    def test_common_ancestor(self):
 
136
        from bzrlib.revision import find_present_ancestors, common_ancestor
 
137
        from bzrlib.revision import MultipleRevisionSources
 
138
        br1, br2 = make_branches()
215
139
        revisions = br1.revision_history()
216
140
        revisions_2 = br2.revision_history()
217
 
        sources = br1
 
141
        sources = MultipleRevisionSources(br1, br2)
218
142
 
219
143
        expected_ancestors_list = {revisions[3]:(0, 0), 
220
144
                                   revisions[2]:(1, 1),
223
147
                                   revisions_2[3]:(4, 2),
224
148
                                   revisions[0]:(5, 3) }
225
149
        ancestors_list = find_present_ancestors(revisions[3], sources)
226
 
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
 
150
        assert len(expected_ancestors_list) == len(ancestors_list)
227
151
        for key, value in expected_ancestors_list.iteritems():
228
152
            self.assertEqual(ancestors_list[key], value, 
229
153
                              "key %r, %r != %r" % (key, ancestors_list[key],
241
165
                          revisions_2[4])
242
166
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
243
167
                          revisions_2[4])
244
 
        fetch(from_branch=br2, to_branch=br1)
245
168
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
246
 
                          revisions[4]) # revisions_2[5] is equally valid
 
169
                          revisions[4])
247
170
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
248
171
                          revisions_2[5])
249
 
 
250
 
    def test_common_ancestor(self):
251
 
        """Pick a reasonable merge base"""
252
 
        from bzrlib.revision import common_ancestor
253
 
        br1, br2 = make_branches(self)
254
 
        revisions = br1.revision_history()
255
 
        revisions_2 = br2.revision_history()
256
 
        sources = MultipleRevisionSources(br1, br2)
257
 
        expected_ancestors_list = {revisions[3]:(0, 0), 
258
 
                                   revisions[2]:(1, 1),
259
 
                                   revisions_2[4]:(2, 1), 
260
 
                                   revisions[1]:(3, 2),
261
 
                                   revisions_2[3]:(4, 2),
262
 
                                   revisions[0]:(5, 3) }
263
 
        ancestors_list = find_present_ancestors(revisions[3], sources)
264
 
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
265
 
        for key, value in expected_ancestors_list.iteritems():
266
 
            self.assertEqual(ancestors_list[key], value, 
267
 
                              "key %r, %r != %r" % (key, ancestors_list[key],
268
 
                                                    value))
269
 
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
270
 
                          revisions[0])
271
 
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
272
 
                          revisions[1])
273
 
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
274
 
                          revisions[1])
275
 
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
276
 
                          revisions[2])
277
 
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
278
 
                          revisions_2[4])
279
 
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
280
 
                          revisions_2[4])
281
 
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
282
 
                          revisions[4]) # revisions_2[5] is equally valid
283
 
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
284
 
                          revisions[4]) # revisions_2[5] is equally valid
285
 
 
286
 
    def test_combined(self):
287
 
        """combined_graph
288
 
        Ensure it's not order-sensitive
289
 
        """
290
 
        br1, br2 = make_branches(self)
291
 
        source = MultipleRevisionSources(br1, br2)
292
 
        combined_1 = combined_graph(br1.last_revision(), 
293
 
                                    br2.last_revision(), source)
294
 
        combined_2 = combined_graph(br2.last_revision(),
295
 
                                    br1.last_revision(), source)
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)