← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

  • Committer: Aaron Bentley
  • Date: 2005-10-20 02:57:55 UTC
  • mto: (1185.25.1)
  • mto: This revision was merged to the branch mainline in revision 1474.
  • Revision ID: aaron.bentley@utoronto.ca-20051020025755-e03df41c52aa3156
tweaked spacing

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
 
17
20
from bzrlib.selftest import TestCaseInTempDir
18
 
 
 
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
19
28
 
20
29
def make_branches():
21
 
    from bzrlib.branch import Branch
22
 
    from bzrlib.commit import commit
23
 
    import os
 
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 merges a4
 
46
 
 
47
    so A is missing b6 at the start
 
48
    and B is missing a3, a4, a5
 
49
    """
24
50
    os.mkdir("branch1")
25
51
    br1 = Branch.initialize("branch1")
26
52
    
34
60
    commit(br2, "Commit four", rev_id="b@u-0-3")
35
61
    commit(br2, "Commit five", rev_id="b@u-0-4")
36
62
    revisions_2 = br2.revision_history()
 
63
    
 
64
    fetch(from_branch=br2, to_branch=br1)
37
65
    br1.add_pending_merge(revisions_2[4])
 
66
    assert revisions_2[4] == 'b@u-0-4'
38
67
    commit(br1, "Commit six", rev_id="a@u-0-3")
39
68
    commit(br1, "Commit seven", rev_id="a@u-0-4")
40
69
    commit(br2, "Commit eight", rev_id="b@u-0-5")
 
70
    
 
71
    fetch(from_branch=br2, to_branch=br1)
41
72
    br1.add_pending_merge(br2.revision_history()[5])
42
73
    commit(br1, "Commit nine", rev_id="a@u-0-5")
 
74
    # DO NOT FETCH HERE - we WANT a GHOST.
 
75
    #fetch(from_branch=br1, to_branch=br2)
43
76
    br2.add_pending_merge(br1.revision_history()[4])
44
 
    commit(br2, "Commit ten", rev_id="b@u-0-6")
 
77
    commit(br2, "Commit ten - ghost merge", rev_id="b@u-0-6")
 
78
    
45
79
    return br1, br2
46
80
 
47
81
 
48
82
class TestIsAncestor(TestCaseInTempDir):
 
83
    def test_recorded_ancestry(self):
 
84
        """Test that commit records all ancestors"""
 
85
        br1, br2 = make_branches()
 
86
        d = [('a@u-0-0', ['a@u-0-0']),
 
87
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
 
88
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
 
89
             ('b@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3']),
 
90
             ('b@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3',
 
91
                          'b@u-0-4']),
 
92
             ('a@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
93
                          'a@u-0-3']),
 
94
             ('a@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
95
                          'a@u-0-3', 'a@u-0-4']),
 
96
             ('b@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
97
                          'b@u-0-5']),
 
98
             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
 
99
                          'b@u-0-3', 'b@u-0-4',
 
100
                          'b@u-0-5', 'a@u-0-5']),
 
101
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',
 
102
                          'b@u-0-3', 'b@u-0-4',
 
103
                          'b@u-0-5', 'b@u-0-6']),
 
104
             ]
 
105
        br1_only = ('a@u-0-3', 'a@u-0-4', 'a@u-0-5')
 
106
        br2_only = ('b@u-0-6',)
 
107
        for branch in br1, br2:
 
108
            for rev_id, anc in d:
 
109
                if rev_id in br1_only and not branch is br1:
 
110
                    continue
 
111
                if rev_id in br2_only and not branch is br2:
 
112
                    continue
 
113
                mutter('ancestry of {%s}: %r',
 
114
                       rev_id, branch.get_ancestry(rev_id))
 
115
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
 
116
                                  [None] + sorted(anc))
 
117
    
 
118
    
49
119
    def test_is_ancestor(self):
50
120
        """Test checking whether a revision is an ancestor of another revision"""
51
 
        from bzrlib.revision import is_ancestor, MultipleRevisionSources
52
 
        from bzrlib.errors import NoSuchRevision
53
121
        br1, br2 = make_branches()
54
122
        revisions = br1.revision_history()
55
123
        revisions_2 = br2.revision_history()
56
 
        sources = MultipleRevisionSources(br1, br2)
 
124
        sources = br1
57
125
 
58
 
        assert is_ancestor(revisions[0], revisions[0], sources)
 
126
        assert is_ancestor(revisions[0], revisions[0], br1)
59
127
        assert is_ancestor(revisions[1], revisions[0], sources)
60
128
        assert not is_ancestor(revisions[0], revisions[1], sources)
61
129
        assert is_ancestor(revisions_2[3], revisions[0], sources)
62
 
        self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
63
 
                          revisions[0], br1)        
 
130
        # disabled mbp 20050914, doesn't seem to happen anymore
 
131
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
132
        ##                  revisions[0], br1)        
64
133
        assert is_ancestor(revisions[3], revisions_2[4], sources)
65
134
        assert is_ancestor(revisions[3], revisions_2[4], br1)
66
135
        assert is_ancestor(revisions[3], revisions_2[3], sources)
67
 
        assert not is_ancestor(revisions[3], revisions_2[3], br1)
68
 
 
69
 
class TestIntermediateRevisions(TestCaseInTempDir):
70
 
 
71
 
    def setUp(self):
72
 
        from bzrlib.commit import commit
73
 
        TestCaseInTempDir.setUp(self)
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")
82
 
 
83
 
        from bzrlib.revision import MultipleRevisionSources
84
 
        self.sources = MultipleRevisionSources(self.br1, self.br2)
85
 
 
86
 
    def intervene(self, ancestor, revision, revision_history=None):
87
 
        from bzrlib.revision import get_intervening_revisions
88
 
        return get_intervening_revisions(ancestor,revision, self.sources, 
89
 
                                         revision_history)
90
 
 
91
 
    def test_intervene(self):
92
 
        """Find intermediate revisions, without requiring history"""
93
 
        from bzrlib.errors import NotAncestor, NoSuchRevision
94
 
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
95
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
96
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
97
 
                         ['a@u-0-1', 'a@u-0-2'])
98
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
99
 
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
100
 
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
101
 
                         ['b@u-0-4', 'a@u-0-3'])
102
 
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
103
 
                                        self.br1.revision_history()), 
104
 
                         ['a@u-0-3'])
105
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
106
 
                                        self.br1.revision_history()), 
107
 
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
108
 
                          'a@u-0-5'])
109
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
110
 
                         self.br1.revision_history()), 
111
 
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
112
 
                          'b@u-0-6'])
113
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
114
 
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
115
 
                          'b@u-0-5'])
116
 
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
117
 
                         self.br2.revision_history()), 
118
 
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
119
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
120
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
121
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
122
 
                                        self.br2.revision_history()), 
123
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
124
 
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
125
 
                          self.br2.revision_history())
126
 
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
127
 
                          'b@u-0-6', self.br2.revision_history())
128
 
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
129
 
                          'c@u-0-6', self.br2.revision_history())
130
 
 
131
 
class TestIntermediateRevisions(TestCaseInTempDir):
132
 
 
133
 
    def setUp(self):
134
 
        from bzrlib.commit import commit
135
 
        TestCaseInTempDir.setUp(self)
136
 
        self.br1, self.br2 = make_branches()
137
 
        commit(self.br2, "Commit eleven", rev_id="b@u-0-7")
138
 
        commit(self.br2, "Commit twelve", rev_id="b@u-0-8")
139
 
        commit(self.br2, "Commit thirtteen", rev_id="b@u-0-9")
140
 
        self.br1.add_pending_merge(self.br2.revision_history()[6])
141
 
        commit(self.br1, "Commit fourtten", rev_id="a@u-0-6")
142
 
        self.br2.add_pending_merge(self.br1.revision_history()[6])
143
 
        commit(self.br2, "Commit fifteen", rev_id="b@u-0-10")
 
136
        ## assert not is_ancestor(revisions[3], revisions_2[3], br1)
 
137
 
 
138
 
 
139
class TestIntermediateRevisions(TestCaseInTempDir):
 
140
 
 
141
    def setUp(self):
 
142
        from bzrlib.commit import commit
 
143
        TestCaseInTempDir.setUp(self)
 
144
        self.br1, self.br2 = make_branches()
 
145
 
 
146
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
 
147
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
 
148
        self.br2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
149
 
 
150
        fetch(from_branch=self.br2, to_branch=self.br1)
 
151
        self.br1.add_pending_merge(self.br2.revision_history()[6])
 
152
        self.br1.commit("Commit fourtten", rev_id="a@u-0-6")
 
153
 
 
154
        fetch(from_branch=self.br1, to_branch=self.br2)
 
155
        self.br2.add_pending_merge(self.br1.revision_history()[6])
 
156
        self.br2.commit("Commit fifteen", rev_id="b@u-0-10")
144
157
 
145
158
        from bzrlib.revision import MultipleRevisionSources
146
159
        self.sources = MultipleRevisionSources(self.br1, self.br2)
196
209
 
197
210
    def test_old_common_ancestor(self):
198
211
        """Pick a resonable merge base using the old functionality"""
199
 
        from bzrlib.revision import find_present_ancestors
200
212
        from bzrlib.revision import old_common_ancestor as common_ancestor
201
 
        from bzrlib.revision import MultipleRevisionSources
202
213
        br1, br2 = make_branches()
203
214
        revisions = br1.revision_history()
204
215
        revisions_2 = br2.revision_history()
205
 
        sources = MultipleRevisionSources(br1, br2)
 
216
        sources = br1
206
217
 
207
218
        expected_ancestors_list = {revisions[3]:(0, 0), 
208
219
                                   revisions[2]:(1, 1),
229
240
                          revisions_2[4])
230
241
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
231
242
                          revisions_2[4])
 
243
        fetch(from_branch=br2, to_branch=br1)
232
244
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
233
 
                          revisions[4])
 
245
                          revisions[4]) # revisions_2[5] is equally valid
234
246
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
235
247
                          revisions_2[5])
236
248
 
237
249
    def test_common_ancestor(self):
238
250
        """Pick a reasonable merge base"""
239
 
        from bzrlib.revision import find_present_ancestors
240
251
        from bzrlib.revision import common_ancestor
241
 
        from bzrlib.revision import MultipleRevisionSources
242
252
        br1, br2 = make_branches()
243
253
        revisions = br1.revision_history()
244
254
        revisions_2 = br2.revision_history()
245
255
        sources = MultipleRevisionSources(br1, br2)
246
 
 
247
256
        expected_ancestors_list = {revisions[3]:(0, 0), 
248
257
                                   revisions[2]:(1, 1),
249
258
                                   revisions_2[4]:(2, 1), 
256
265
            self.assertEqual(ancestors_list[key], value, 
257
266
                              "key %r, %r != %r" % (key, ancestors_list[key],
258
267
                                                    value))
259
 
 
260
268
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
261
269
                          revisions[0])
262
270
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
270
278
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
271
279
                          revisions_2[4])
272
280
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
273
 
                          revisions[4])
 
281
                          revisions[4]) # revisions_2[5] is equally valid
274
282
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
275
 
                          revisions[4])
 
283
                          revisions[4]) # revisions_2[5] is equally valid
276
284
 
 
285
    def test_combined(self):
 
286
        """combined_graph
 
287
        Ensure it's not order-sensitive
 
288
        """
 
289
        br1, br2 = make_branches()
 
290
        source = MultipleRevisionSources(br1, br2)
 
291
        combined_1 = combined_graph(br1.last_revision(), 
 
292
                                    br2.last_revision(), source)
 
293
        combined_2 = combined_graph(br2.last_revision(),
 
294
                                    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