/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 breezy/tests/test_multiparent.py

  • Committer: Jelmer Vernooij
  • Date: 2019-06-02 02:35:46 UTC
  • mfrom: (7309 work)
  • mto: This revision was merged to the branch mainline in revision 7319.
  • Revision ID: jelmer@jelmer.uk-20190602023546-lqco868tnv26d8ow
merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_multiparent.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
import patiencediff
17
18
from unittest import TestCase
18
19
 
19
20
from .. import (
20
21
    multiparent,
21
 
    patiencediff,
22
22
    tests,
23
23
    )
24
24
from ..sixish import int2byte
102
102
 
103
103
    def test_to_patch(self):
104
104
        self.assertEqual([b'i 1\n', b'a\n', b'\n', b'c 0 1 2 3\n'],
105
 
            list(multiparent.MultiParent([multiparent.NewText([b'a\n']),
106
 
            multiparent.ParentText(0, 1, 2, 3)]).to_patch()))
 
105
                         list(multiparent.MultiParent([multiparent.NewText([b'a\n']),
 
106
                                                       multiparent.ParentText(0, 1, 2, 3)]).to_patch()))
107
107
 
108
108
    def test_from_patch(self):
109
109
        self.assertEqual(multiparent.MultiParent(
110
110
            [multiparent.NewText([b'a\n']),
111
111
             multiparent.ParentText(0, 1, 2, 3)]),
112
 
             multiparent.MultiParent.from_patch(b'i 1\na\n\nc 0 1 2 3'))
 
112
            multiparent.MultiParent.from_patch(b'i 1\na\n\nc 0 1 2 3'))
113
113
        self.assertEqual(multiparent.MultiParent(
114
114
            [multiparent.NewText([b'a']),
115
115
             multiparent.ParentText(0, 1, 2, 3)]),
116
 
             multiparent.MultiParent.from_patch(b'i 1\na\nc 0 1 2 3\n'))
 
116
            multiparent.MultiParent.from_patch(b'i 1\na\nc 0 1 2 3\n'))
117
117
 
118
118
    def test_binary_content(self):
119
119
        patch = list(
146
146
 
147
147
    def test_eq(self):
148
148
        self.assertEqual(multiparent.NewText([]), multiparent.NewText([]))
149
 
        self.assertFalse(multiparent.NewText([b'a']) ==
150
 
                         multiparent.NewText([b'b']))
 
149
        self.assertFalse(multiparent.NewText([b'a'])
 
150
                         == multiparent.NewText([b'b']))
151
151
        self.assertFalse(multiparent.NewText([b'a']) == Mock(lines=[b'a']))
152
152
 
153
153
    def test_to_patch(self):
164
164
    def test_eq(self):
165
165
        self.assertEqual(multiparent.ParentText(1, 2, 3, 4),
166
166
                         multiparent.ParentText(1, 2, 3, 4))
167
 
        self.assertFalse(multiparent.ParentText(1, 2, 3, 4) ==
168
 
                         multiparent.ParentText(2, 2, 3, 4))
169
 
        self.assertFalse(multiparent.ParentText(1, 2, 3, 4) ==
170
 
                         Mock(parent=1, parent_pos=2, child_pos=3,
171
 
                              num_lines=4))
 
167
        self.assertFalse(multiparent.ParentText(1, 2, 3, 4)
 
168
                         == multiparent.ParentText(2, 2, 3, 4))
 
169
        self.assertFalse(multiparent.ParentText(1, 2, 3, 4)
 
170
                         == Mock(parent=1, parent_pos=2, child_pos=3,
 
171
                                 num_lines=4))
172
172
 
173
173
    def test_to_patch(self):
174
174
        self.assertEqual([b'c 0 1 2 3\n'],
184
184
 
185
185
    def add_version(self, vf, text, version_id, parent_ids):
186
186
        vf.add_version(
187
 
                [(int2byte(t)+b'\n') for t in bytearray(text)],
188
 
                version_id, parent_ids)
 
187
            [(int2byte(t) + b'\n') for t in bytearray(text)],
 
188
            version_id, parent_ids)
189
189
 
190
190
    def make_vf(self):
191
191
        vf = multiparent.MultiMemoryVersionedFile()
204
204
        vf = self.make_vf()
205
205
        vf.clear_cache()
206
206
        self.assertEqual(REV_A, vf.get_line_list([b'rev-a'])[0])
207
 
        self.assertEqual([REV_B, REV_C], vf.get_line_list([b'rev-b', b'rev-c']))
 
207
        self.assertEqual(
 
208
            [REV_B, REV_C], vf.get_line_list([b'rev-b', b'rev-c']))
208
209
 
209
210
    def test_reconstruct_empty(self):
210
211
        vf = multiparent.MultiMemoryVersionedFile()
229
230
 
230
231
    def test_reconstructor(self):
231
232
        vf = self.make_vf()
232
 
        self.assertEqual([b'a\n', b'b\n'], self.reconstruct(vf, b'rev-a',  0, 2))
233
 
        self.assertEqual([b'c\n', b'd\n'], self.reconstruct(vf, b'rev-a',  2, 4))
234
 
        self.assertEqual([b'e\n', b'f\n'], self.reconstruct(vf, b'rev-c',  2, 4))
235
 
        self.assertEqual([b'a\n', b'b\n', b'e\n', b'f\n'],
236
 
                          self.reconstruct(vf, b'rev-c',  0, 4))
237
 
        self.assertEqual([b'a\n', b'b\n', b'e\n', b'f\n'],
238
 
                          self.reconstruct_version(vf, b'rev-c'))
 
233
        self.assertEqual([b'a\n', b'b\n'],
 
234
                         self.reconstruct(vf, b'rev-a', 0, 2))
 
235
        self.assertEqual([b'c\n', b'd\n'],
 
236
                         self.reconstruct(vf, b'rev-a', 2, 4))
 
237
        self.assertEqual([b'e\n', b'f\n'],
 
238
                         self.reconstruct(vf, b'rev-c', 2, 4))
 
239
        self.assertEqual([b'a\n', b'b\n', b'e\n', b'f\n'],
 
240
                         self.reconstruct(vf, b'rev-c', 0, 4))
 
241
        self.assertEqual([b'a\n', b'b\n', b'e\n', b'f\n'],
 
242
                         self.reconstruct_version(vf, b'rev-c'))
239
243
 
240
244
    def test_reordered(self):
241
245
        """Check for a corner case that requires re-starting the cursor"""
262
266
        vf.save()
263
267
        newvf = multiparent.MultiVersionedFile('foop')
264
268
        newvf.load()
265
 
        self.assertEqual(b'a\nb\nc\nd', b''.join(newvf.get_line_list([b'a'])[0]))
266
 
        self.assertEqual(b'a\ne\nd\n', b''.join(newvf.get_line_list([b'b'])[0]))
 
269
        self.assertEqual(b'a\nb\nc\nd', b''.join(
 
270
            newvf.get_line_list([b'a'])[0]))
 
271
        self.assertEqual(b'a\ne\nd\n', b''.join(
 
272
            newvf.get_line_list([b'b'])[0]))
267
273
 
268
274
    def test_filenames(self):
269
275
        vf = multiparent.MultiVersionedFile('foop')