/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 04:53:19 UTC
  • Revision ID: mbp@sourcefrog.net-20050916045318-95c77d043752ab60
- some weave operations automatically look up symbolic names if supplied

  I think it's better to mostly keep weave indexes hidden in that
  object

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
 
from bzrlib.selftest import InTempDir
18
 
 
 
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.errors import NoSuchRevision
19
27
 
20
28
def make_branches():
21
 
    from bzrlib.branch import Branch
22
 
    from bzrlib.commit import commit
23
 
    import os
24
29
    os.mkdir("branch1")
25
30
    br1 = Branch("branch1", init=True)
26
 
    commit(br1, "Commit one")
27
 
    commit(br1, "Commit two")
28
 
    commit(br1, "Commit three")
 
31
    
 
32
    commit(br1, "Commit one", rev_id="a@u-0-0")
 
33
    commit(br1, "Commit two", rev_id="a@u-0-1")
 
34
    commit(br1, "Commit three", rev_id="a@u-0-2")
29
35
 
30
36
    os.mkdir("branch2")
31
37
    br2 = Branch("branch2", init=True)
32
38
    br2.update_revisions(br1)
33
 
    commit(br2, "Commit four")
34
 
    commit(br2, "Commit five")
 
39
    commit(br2, "Commit four", rev_id="b@u-0-3")
 
40
    commit(br2, "Commit five", rev_id="b@u-0-4")
35
41
    revisions_2 = br2.revision_history()
 
42
    
 
43
    fetch(from_branch=br2, to_branch=br1)
36
44
    br1.add_pending_merge(revisions_2[4])
37
 
    commit(br1, "Commit six")
 
45
    commit(br1, "Commit six", rev_id="a@u-0-3")
 
46
    commit(br1, "Commit seven", rev_id="a@u-0-4")
 
47
    commit(br2, "Commit eight", rev_id="b@u-0-5")
 
48
    
 
49
    fetch(from_branch=br2, to_branch=br1)
 
50
    br1.add_pending_merge(br2.revision_history()[5])
 
51
    commit(br1, "Commit nine", rev_id="a@u-0-5")
 
52
 
 
53
    fetch(from_branch=br1, to_branch=br2)
 
54
    br2.add_pending_merge(br1.revision_history()[4])
 
55
    commit(br2, "Commit ten", rev_id="b@u-0-6")
 
56
 
 
57
    fetch(from_branch=br2, to_branch=br1)
 
58
    
38
59
    return br1, br2
39
60
 
40
61
 
41
 
class TestIsAncestor(InTempDir):
42
 
    """Test checking whether a revision is an ancestor of another revision"""
43
 
    def runTest(self):
44
 
        from bzrlib.revision import is_ancestor, MultipleRevisionSources
45
 
        from bzrlib.errors import NoSuchRevision
 
62
class TestIsAncestor(TestCaseInTempDir):
 
63
    def test_recorded_ancestry(self):
 
64
        """Test that commit records all ancestors"""
 
65
        br1, br2 = make_branches()
 
66
        d = [('a@u-0-0', ['a@u-0-0']),
 
67
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
 
68
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
 
69
             ('b@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3']),
 
70
             ('b@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-3', 'b@u-0-4']),
 
71
             ]
 
72
        for branch in br1, br2:
 
73
            for rev_id, anc in d:
 
74
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
 
75
                                  sorted(anc))
 
76
    
 
77
    
 
78
    def test_is_ancestor(self):
 
79
        """Test checking whether a revision is an ancestor of another revision"""
46
80
        br1, br2 = make_branches()
47
81
        revisions = br1.revision_history()
48
82
        revisions_2 = br2.revision_history()
49
 
        sources = MultipleRevisionSources(br1, br2)
 
83
        sources = br1
50
84
 
51
 
        assert is_ancestor(revisions[0], revisions[0], sources)
 
85
        assert is_ancestor(revisions[0], revisions[0], br1)
52
86
        assert is_ancestor(revisions[1], revisions[0], sources)
53
87
        assert not is_ancestor(revisions[0], revisions[1], sources)
54
88
        assert is_ancestor(revisions_2[3], revisions[0], sources)
55
 
        self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
56
 
                          revisions[0], br1)        
 
89
        # disabled mbp 20050914, doesn't seem to happen anymore
 
90
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
91
        ##                  revisions[0], br1)        
57
92
        assert is_ancestor(revisions[3], revisions_2[4], sources)
58
93
        assert is_ancestor(revisions[3], revisions_2[4], br1)
59
94
        assert is_ancestor(revisions[3], revisions_2[3], sources)
60
95
        assert not is_ancestor(revisions[3], revisions_2[3], br1)
61
96
 
62
97
 
63
 
TEST_CLASSES = [
64
 
    TestIsAncestor,
65
 
    ]
 
98
 
 
99
class TestIntermediateRevisions(TestCaseInTempDir):
 
100
 
 
101
    def setUp(self):
 
102
        from bzrlib.commit import commit
 
103
        TestCaseInTempDir.setUp(self)
 
104
        self.br1, self.br2 = make_branches()
 
105
 
 
106
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
 
107
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
 
108
        self.br2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
109
 
 
110
        fetch(from_branch=self.br2, to_branch=self.br1)
 
111
        self.br1.add_pending_merge(self.br2.revision_history()[6])
 
112
        self.br1.commit("Commit fourtten", rev_id="a@u-0-6")
 
113
 
 
114
        fetch(from_branch=self.br1, to_branch=self.br2)
 
115
        self.br2.add_pending_merge(self.br1.revision_history()[6])
 
116
        self.br2.commit("Commit fifteen", rev_id="b@u-0-10")
 
117
 
 
118
        from bzrlib.revision import MultipleRevisionSources
 
119
        self.sources = MultipleRevisionSources(self.br1, self.br2)
 
120
 
 
121
    def intervene(self, ancestor, revision, revision_history=None):
 
122
        from bzrlib.revision import get_intervening_revisions
 
123
        return get_intervening_revisions(ancestor,revision, self.sources, 
 
124
                                         revision_history)
 
125
 
 
126
    def test_intervene(self):
 
127
        """Find intermediate revisions, without requiring history"""
 
128
        from bzrlib.errors import NotAncestor, NoSuchRevision
 
129
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
 
130
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
 
131
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
 
132
                         ['a@u-0-1', 'a@u-0-2'])
 
133
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
 
134
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
 
135
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
 
136
                         ['b@u-0-4', 'a@u-0-3'])
 
137
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
 
138
                                        self.br1.revision_history()), 
 
139
                         ['a@u-0-3'])
 
140
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
 
141
                                        self.br1.revision_history()), 
 
142
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
143
                          'a@u-0-5'])
 
144
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
 
145
                         self.br1.revision_history()), 
 
146
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
147
                          'b@u-0-6'])
 
148
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
 
149
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
 
150
                          'b@u-0-5'])
 
151
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
 
152
                         self.br2.revision_history()), 
 
153
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
 
154
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
 
155
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
156
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
 
157
                                        self.br2.revision_history()), 
 
158
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
159
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
 
160
                          self.br2.revision_history())
 
161
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
 
162
                          'b@u-0-6', self.br2.revision_history())
 
163
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
 
164
                          'c@u-0-6', self.br2.revision_history())
 
165
 
 
166
 
 
167
class TestCommonAncestor(TestCaseInTempDir):
 
168
    """Test checking whether a revision is an ancestor of another revision"""
 
169
 
 
170
    def test_common_ancestor(self):
 
171
        br1, br2 = make_branches()
 
172
        revisions = br1.revision_history()
 
173
        revisions_2 = br2.revision_history()
 
174
        sources = br1
 
175
 
 
176
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
177
                                   revisions[2]:(1, 1),
 
178
                                   revisions_2[4]:(2, 1), 
 
179
                                   revisions[1]:(3, 2),
 
180
                                   revisions_2[3]:(4, 2),
 
181
                                   revisions[0]:(5, 3) }
 
182
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
183
        assert len(expected_ancestors_list) == len(ancestors_list)
 
184
        for key, value in expected_ancestors_list.iteritems():
 
185
            self.assertEqual(ancestors_list[key], value, 
 
186
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
187
                                                    value))
 
188
 
 
189
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
190
                          revisions[0])
 
191
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
192
                          revisions[1])
 
193
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
194
                          revisions[1])
 
195
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
196
                          revisions[2])
 
197
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
198
                          revisions_2[4])
 
199
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
200
                          revisions_2[4])
 
201
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
202
                          revisions[4])
 
203
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
204
                          revisions_2[5])
 
205
 
 
206
 
 
207
if __name__ == '__main__':
 
208
    import unittest, sys
 
209
    unittest.main()
 
210