← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

  • Committer: Robert Collins
  • Date: 2005-09-12 12:42:30 UTC
  • mfrom: (1092.2.9)
  • mto: (1092.2.15)
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20050912124229-abcadea71750e4ab
revision eq operators

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
 
17
from bzrlib.selftest import TestCaseInTempDir, TestCase
18
18
 
19
19
 
20
20
def make_branches():
23
23
    import os
24
24
    os.mkdir("branch1")
25
25
    br1 = Branch("branch1", init=True)
26
 
    commit(br1, "Commit one")
27
 
    commit(br1, "Commit two")
28
 
    commit(br1, "Commit three")
 
26
    
 
27
    commit(br1, "Commit one", rev_id="a@u-0-0")
 
28
    commit(br1, "Commit two", rev_id="a@u-0-1")
 
29
    commit(br1, "Commit three", rev_id="a@u-0-2")
29
30
 
30
31
    os.mkdir("branch2")
31
32
    br2 = Branch("branch2", init=True)
32
33
    br2.update_revisions(br1)
33
 
    commit(br2, "Commit four")
34
 
    commit(br2, "Commit five")
 
34
    commit(br2, "Commit four", rev_id="b@u-0-3")
 
35
    commit(br2, "Commit five", rev_id="b@u-0-4")
35
36
    revisions_2 = br2.revision_history()
36
37
    br1.add_pending_merge(revisions_2[4])
37
 
    commit(br1, "Commit six")
 
38
    commit(br1, "Commit six", rev_id="a@u-0-3")
 
39
    commit(br1, "Commit seven", rev_id="a@u-0-4")
 
40
    commit(br2, "Commit eight", rev_id="b@u-0-5")
 
41
    br1.add_pending_merge(br2.revision_history()[5])
 
42
    commit(br1, "Commit nine", rev_id="a@u-0-5")
 
43
    br2.add_pending_merge(br1.revision_history()[4])
 
44
    commit(br2, "Commit ten", rev_id="b@u-0-6")
38
45
    return br1, br2
39
46
 
40
47
 
41
 
class TestIsAncestor(InTempDir):
42
 
    """Test checking whether a revision is an ancestor of another revision"""
43
 
    def runTest(self):
 
48
class TestIsAncestor(TestCaseInTempDir):
 
49
    def test_is_ancestor(self):
 
50
        """Test checking whether a revision is an ancestor of another revision"""
44
51
        from bzrlib.revision import is_ancestor, MultipleRevisionSources
45
52
        from bzrlib.errors import NoSuchRevision
46
53
        br1, br2 = make_branches()
59
66
        assert is_ancestor(revisions[3], revisions_2[3], sources)
60
67
        assert not is_ancestor(revisions[3], revisions_2[3], br1)
61
68
 
62
 
 
63
 
TEST_CLASSES = [
64
 
    TestIsAncestor,
65
 
    ]
 
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
 
 
132
class TestCommonAncestor(TestCaseInTempDir):
 
133
    """Test checking whether a revision is an ancestor of another revision"""
 
134
 
 
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()
 
139
        revisions = br1.revision_history()
 
140
        revisions_2 = br2.revision_history()
 
141
        sources = MultipleRevisionSources(br1, br2)
 
142
 
 
143
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
144
                                   revisions[2]:(1, 1),
 
145
                                   revisions_2[4]:(2, 1), 
 
146
                                   revisions[1]:(3, 2),
 
147
                                   revisions_2[3]:(4, 2),
 
148
                                   revisions[0]:(5, 3) }
 
149
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
150
        assert len(expected_ancestors_list) == len(ancestors_list)
 
151
        for key, value in expected_ancestors_list.iteritems():
 
152
            self.assertEqual(ancestors_list[key], value, 
 
153
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
154
                                                    value))
 
155
 
 
156
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
157
                          revisions[0])
 
158
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
159
                          revisions[1])
 
160
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
161
                          revisions[1])
 
162
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
163
                          revisions[2])
 
164
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
165
                          revisions_2[4])
 
166
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
167
                          revisions_2[4])
 
168
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
169
                          revisions[4])
 
170
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
171
                          revisions_2[5])
 
172
 
 
173
class TestCreateSignedRevision(TestCaseInTempDir):
 
174
 
 
175
    def test_create_signed_revision(self):
 
176
        # create a store
 
177
        # create a revision, sign it, apply to the store.
 
178
        pass
 
179
 
 
180
class TestOperators(TestCase):
 
181
 
 
182
    def test___eq__(self):
 
183
        from bzrlib.revision import Revision, RevisionReference
 
184
        revision1 = Revision("invid", "sha", "revid", 100, "boo", "john", [])
 
185
        revision2 = Revision("invid", "sha", "revid", 100, "boo", "john", [])
 
186
        revision3 = Revision("invid", "sha", "rev2id", 100, "bp", "john", 
 
187
                             [RevisionReference("revid")])
 
188
        self.assertEqual(revision1, revision1)
 
189
        self.assertEqual(revision1, revision2)
 
190
        self.assertNotEqual(revision1, revision3)
 
191
        self.assertEqual(revision2, revision1)
 
192
        self.assertEqual(revision2, revision2)
 
193
        self.assertNotEqual(revision2, revision3)
 
194
        self.assertNotEqual(revision3, revision1)
 
195
        self.assertNotEqual(revision3, revision2)
 
196
        self.assertEqual(revision3, revision3)
 
197
 
 
198
    def test__eq__reference(self):
 
199
        from bzrlib.revision import Revision, RevisionReference
 
200
        ref1 = RevisionReference('revid', '1'*40)
 
201
        ref2 = RevisionReference('revid', '1'*40)
 
202
        ref3 = RevisionReference('revid', '2'*40)
 
203
        ref4 = RevisionReference('revid2', '3'*40)
 
204
        self.assertEqual(ref1, ref1)
 
205
        self.assertEqual(ref1, ref2)
 
206
        self.assertNotEqual(ref1, ref3)
 
207
        self.assertNotEqual(ref1, ref4)
 
208
        self.assertEqual(ref2, ref1)
 
209
        self.assertEqual(ref2, ref2)
 
210
        self.assertNotEqual(ref2, ref3)
 
211
        self.assertNotEqual(ref2, ref4)
 
212
        self.assertNotEqual(ref3, ref1)
 
213
        self.assertNotEqual(ref3, ref2)
 
214
        self.assertEqual(ref3, ref3)
 
215
        self.assertNotEqual(ref3, ref4)
 
216
        self.assertNotEqual(ref4, ref1)
 
217
        self.assertNotEqual(ref4, ref2)
 
218
        self.assertNotEqual(ref4, ref3)
 
219
        self.assertEqual(ref4, ref4)