/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

  • Committer: Martin Pool
  • Date: 2005-09-16 05:16:21 UTC
  • Revision ID: mbp@sourcefrog.net-20050916051621-cce671c80eb57be2
- fix recording of merged ancestry lines

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
import os
 
19
 
 
20
from bzrlib.selftest 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, common_ancestor,
 
25
                             is_ancestor)
 
26
from bzrlib.trace import mutter
 
27
from bzrlib.errors import NoSuchRevision
 
28
 
 
29
def make_branches():
 
30
    os.mkdir("branch1")
 
31
    br1 = Branch("branch1", init=True)
 
32
    
 
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")
 
36
 
 
37
    os.mkdir("branch2")
 
38
    br2 = Branch("branch2", init=True)
 
39
    br2.update_revisions(br1)
 
40
    commit(br2, "Commit four", rev_id="b@u-0-3")
 
41
    commit(br2, "Commit five", rev_id="b@u-0-4")
 
42
    revisions_2 = br2.revision_history()
 
43
    
 
44
    fetch(from_branch=br2, to_branch=br1)
 
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")
 
50
    
 
51
    fetch(from_branch=br2, to_branch=br1)
 
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)
 
60
    
 
61
    return br1, br2
 
62
 
 
63
 
 
64
class TestIsAncestor(TestCaseInTempDir):
 
65
    def test_recorded_ancestry(self):
 
66
        """Test that commit records all ancestors"""
 
67
        br1, br2 = make_branches()
 
68
        d = [('a@u-0-0', ['a@u-0-0']),
 
69
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
 
70
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
 
71
             ('b@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3']),
 
72
             ('b@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3',
 
73
                          'b@u-0-4']),
 
74
             ('a@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
75
                          'a@u-0-3']),
 
76
##             ('a@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
77
##                          'a@u-0-3', 'a@u-0-4']),
 
78
##             ('b@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3',
 
79
##                          'b@u-0-4']),
 
80
             ]
 
81
        for branch in br1, br2:
 
82
            for rev_id, anc in d:
 
83
                mutter('ancestry of {%s}: %r',
 
84
                       rev_id, branch.get_ancestry(rev_id))
 
85
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
 
86
                                  sorted(anc))
 
87
    
 
88
    
 
89
    def SKIPPED_is_ancestor(self):
 
90
        """Test checking whether a revision is an ancestor of another revision"""
 
91
        br1, br2 = make_branches()
 
92
        revisions = br1.revision_history()
 
93
        revisions_2 = br2.revision_history()
 
94
        sources = br1
 
95
 
 
96
        assert is_ancestor(revisions[0], revisions[0], br1)
 
97
        assert is_ancestor(revisions[1], revisions[0], sources)
 
98
        assert not is_ancestor(revisions[0], revisions[1], sources)
 
99
        assert is_ancestor(revisions_2[3], revisions[0], sources)
 
100
        # disabled mbp 20050914, doesn't seem to happen anymore
 
101
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
102
        ##                  revisions[0], br1)        
 
103
        assert is_ancestor(revisions[3], revisions_2[4], sources)
 
104
        assert is_ancestor(revisions[3], revisions_2[4], br1)
 
105
        assert is_ancestor(revisions[3], revisions_2[3], sources)
 
106
        assert not is_ancestor(revisions[3], revisions_2[3], br1)
 
107
 
 
108
 
 
109
 
 
110
class TestIntermediateRevisions(TestCaseInTempDir):
 
111
 
 
112
    def setUp(self):
 
113
        from bzrlib.commit import commit
 
114
        TestCaseInTempDir.setUp(self)
 
115
        self.br1, self.br2 = make_branches()
 
116
 
 
117
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
 
118
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
 
119
        self.br2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
120
 
 
121
        fetch(from_branch=self.br2, to_branch=self.br1)
 
122
        self.br1.add_pending_merge(self.br2.revision_history()[6])
 
123
        self.br1.commit("Commit fourtten", rev_id="a@u-0-6")
 
124
 
 
125
        fetch(from_branch=self.br1, to_branch=self.br2)
 
126
        self.br2.add_pending_merge(self.br1.revision_history()[6])
 
127
        self.br2.commit("Commit fifteen", rev_id="b@u-0-10")
 
128
 
 
129
        from bzrlib.revision import MultipleRevisionSources
 
130
        self.sources = MultipleRevisionSources(self.br1, self.br2)
 
131
 
 
132
    def intervene(self, ancestor, revision, revision_history=None):
 
133
        from bzrlib.revision import get_intervening_revisions
 
134
        return get_intervening_revisions(ancestor,revision, self.sources, 
 
135
                                         revision_history)
 
136
 
 
137
    def test_intervene(self):
 
138
        """Find intermediate revisions, without requiring history"""
 
139
        from bzrlib.errors import NotAncestor, NoSuchRevision
 
140
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
 
141
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
 
142
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
 
143
                         ['a@u-0-1', 'a@u-0-2'])
 
144
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
 
145
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
 
146
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
 
147
                         ['b@u-0-4', 'a@u-0-3'])
 
148
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
 
149
                                        self.br1.revision_history()), 
 
150
                         ['a@u-0-3'])
 
151
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
 
152
                                        self.br1.revision_history()), 
 
153
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
154
                          'a@u-0-5'])
 
155
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
 
156
                         self.br1.revision_history()), 
 
157
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
158
                          'b@u-0-6'])
 
159
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
 
160
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
 
161
                          'b@u-0-5'])
 
162
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
 
163
                         self.br2.revision_history()), 
 
164
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
 
165
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
 
166
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
167
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
 
168
                                        self.br2.revision_history()), 
 
169
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
170
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
 
171
                          self.br2.revision_history())
 
172
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
 
173
                          'b@u-0-6', self.br2.revision_history())
 
174
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
 
175
                          'c@u-0-6', self.br2.revision_history())
 
176
 
 
177
 
 
178
class TestCommonAncestor(TestCaseInTempDir):
 
179
    """Test checking whether a revision is an ancestor of another revision"""
 
180
 
 
181
    def test_common_ancestor(self):
 
182
        br1, br2 = make_branches()
 
183
        revisions = br1.revision_history()
 
184
        revisions_2 = br2.revision_history()
 
185
        sources = br1
 
186
 
 
187
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
188
                                   revisions[2]:(1, 1),
 
189
                                   revisions_2[4]:(2, 1), 
 
190
                                   revisions[1]:(3, 2),
 
191
                                   revisions_2[3]:(4, 2),
 
192
                                   revisions[0]:(5, 3) }
 
193
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
194
        assert len(expected_ancestors_list) == len(ancestors_list)
 
195
        for key, value in expected_ancestors_list.iteritems():
 
196
            self.assertEqual(ancestors_list[key], value, 
 
197
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
198
                                                    value))
 
199
 
 
200
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
201
                          revisions[0])
 
202
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
203
                          revisions[1])
 
204
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
205
                          revisions[1])
 
206
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
207
                          revisions[2])
 
208
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
209
                          revisions_2[4])
 
210
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
211
                          revisions_2[4])
 
212
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
213
                          revisions[4])
 
214
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
215
                          revisions_2[5])
 
216
 
 
217
 
 
218
if __name__ == '__main__':
 
219
    import unittest, sys
 
220
    unittest.main()
 
221