← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test__groupcompress.py

  • Committer: John Arbash Meinel
  • Date: 2009-03-27 20:12:12 UTC
  • mto: (3735.39.2 clean)
  • mto: This revision was merged to the branch mainline in revision 4280.
  • Revision ID: john@arbash-meinel.com-20090327201212-1ykalx15yr1cquxt
Implement make_delta and apply_delta.

Update the permuted tests so that both implementations are tested.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test__groupcompress.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
 
"""Tests for the pyrex extension of groupcompress"""
 
17
"""Tests for the python and pyrex extensions of groupcompress"""
18
18
 
19
19
from bzrlib import (
20
20
    groupcompress,
138
138
        ident_delta = self.make_delta(_text3, _text3)
139
139
        self.assertEqual('\x87\x01\x90\x87', ident_delta)
140
140
 
 
141
    def assertDeltaIn(self, delta1, delta2, delta):
 
142
        """Make sure that the delta bytes match one of the expectations."""
 
143
        # In general, the python delta matcher gives different results than the
 
144
        # pyrex delta matcher. Both should be valid deltas, though.
 
145
        if delta not in (delta1, delta2):
 
146
            self.fail("Delta bytes:\n"
 
147
                      "       %r\n"
 
148
                      "not in %r\n"
 
149
                      "    or %r"
 
150
                      % (delta, delta1, delta2))
 
151
 
141
152
    def test_make_delta(self):
142
153
        delta = self.make_delta(_text1, _text2)
143
 
        self.assertEqual('N\x90/\x1fdiffer from\nagainst other text\n', delta)
 
154
        self.assertDeltaIn(
 
155
            'N\x90/\x1fdiffer from\nagainst other text\n',
 
156
            'N\x90\x1d\x1ewhich is meant to differ from\n\x91:\x13',
 
157
            delta)
144
158
        delta = self.make_delta(_text2, _text1)
145
 
        self.assertEqual('M\x90/\x1ebe matched\nagainst other text\n', delta)
 
159
        self.assertDeltaIn(
 
160
            'M\x90/\x1ebe matched\nagainst other text\n',
 
161
            'M\x90\x1d\x1dwhich is meant to be matched\n\x91;\x13',
 
162
            delta)
146
163
        delta = self.make_delta(_text3, _text1)
147
164
        self.assertEqual('M\x90M', delta)
148
165
        delta = self.make_delta(_text3, _text2)
149
 
        self.assertEqual('N\x90/\x1fdiffer from\nagainst other text\n',
150
 
                         delta)
 
166
        self.assertDeltaIn(
 
167
            'N\x90/\x1fdiffer from\nagainst other text\n',
 
168
            'N\x90\x1d\x1ewhich is meant to differ from\n\x91:\x13',
 
169
            delta)
151
170
 
152
171
    def test_apply_delta_is_typesafe(self):
153
172
        self.apply_delta(_text1, 'M\x90M')
263
282
        self.assertEqual(_fourth_text,
264
283
                         self._gc_module.apply_delta(source, fifth_delta))
265
284
        self.assertEqual('\x80\x01\x91\xa7\x7f\x01\n', fifth_delta)
 
285
 
 
286
 
 
287
class TestCopyInstruction(tests.TestCase):
 
288
 
 
289
    def assertEncode(self, expected, offset, length):
 
290
        bytes = _groupcompress_py.encode_copy_instruction(offset, length)
 
291
        if expected != bytes:
 
292
            self.assertEqual([hex(ord(e)) for e in expected],
 
293
                             [hex(ord(b)) for b in bytes])
 
294
 
 
295
    def assertDecode(self, exp_offset, exp_length, exp_newpos, bytes, pos):
 
296
        cmd = ord(bytes[pos])
 
297
        pos += 1
 
298
        out = _groupcompress_py.decode_copy_instruction(bytes, cmd, pos)
 
299
        self.assertEqual((exp_offset, exp_length, exp_newpos), out)
 
300
 
 
301
    def test_encode_no_length(self):
 
302
        self.assertEncode('\x80', 0, None)
 
303
        self.assertEncode('\x81\x01', 1, None)
 
304
        self.assertEncode('\x81\x0a', 10, None)
 
305
        self.assertEncode('\x81\xff', 255, None)
 
306
        self.assertEncode('\x82\x01', 256, None)
 
307
        self.assertEncode('\x83\x01\x01', 257, None)
 
308
        self.assertEncode('\x8F\xff\xff\xff\xff', 0xFFFFFFFF, None)
 
309
        self.assertEncode('\x8E\xff\xff\xff', 0xFFFFFF00, None)
 
310
        self.assertEncode('\x8D\xff\xff\xff', 0xFFFF00FF, None)
 
311
        self.assertEncode('\x8B\xff\xff\xff', 0xFF00FFFF, None)
 
312
        self.assertEncode('\x87\xff\xff\xff', 0x00FFFFFF, None)
 
313
        self.assertEncode('\x8F\x04\x03\x02\x01', 0x01020304, None)
 
314
 
 
315
    def test_encode_no_offset(self):
 
316
        self.assertEncode('\x90\x01', 0, 1)
 
317
        self.assertEncode('\x90\x0a', 0, 10)
 
318
        self.assertEncode('\x90\xff', 0, 255)
 
319
        self.assertEncode('\xA0\x01', 0, 256)
 
320
        self.assertEncode('\xB0\x01\x01', 0, 257)
 
321
        self.assertEncode('\xB0\xff\xff', 0, 0xFFFF)
 
322
        # Special case, if copy == 64KiB, then we store exactly 0
 
323
        # Note that this puns with a copy of exactly 0 bytes, but we don't care
 
324
        # about that, as we would never actually copy 0 bytes
 
325
        self.assertEncode('\x80', 0, 64*1024)
 
326
 
 
327
    def test_encode(self):
 
328
        self.assertEncode('\x91\x01\x01', 1, 1)
 
329
        self.assertEncode('\x91\x09\x0a', 9, 10)
 
330
        self.assertEncode('\x91\xfe\xff', 254, 255)
 
331
        self.assertEncode('\xA2\x02\x01', 512, 256)
 
332
        self.assertEncode('\xB3\x02\x01\x01\x01', 258, 257)
 
333
        self.assertEncode('\xB0\x01\x01', 0, 257)
 
334
        # Special case, if copy == 64KiB, then we store exactly 0
 
335
        # Note that this puns with a copy of exactly 0 bytes, but we don't care
 
336
        # about that, as we would never actually copy 0 bytes
 
337
        self.assertEncode('\x81\x0a', 10, 64*1024)
 
338
 
 
339
    def test_decode_no_length(self):
 
340
        # If length is 0, it is interpreted as 64KiB
 
341
        # The shortest possible instruction is a copy of 64KiB from offset 0
 
342
        self.assertDecode(0, 65536, 1, '\x80', 0)
 
343
        self.assertDecode(1, 65536, 2, '\x81\x01', 0)
 
344
        self.assertDecode(10, 65536, 2, '\x81\x0a', 0)
 
345
        self.assertDecode(255, 65536, 2, '\x81\xff', 0)
 
346
        self.assertDecode(256, 65536, 2, '\x82\x01', 0)
 
347
        self.assertDecode(257, 65536, 3, '\x83\x01\x01', 0)
 
348
        self.assertDecode(0xFFFFFFFF, 65536, 5, '\x8F\xff\xff\xff\xff', 0)
 
349
        self.assertDecode(0xFFFFFF00, 65536, 4, '\x8E\xff\xff\xff', 0)
 
350
        self.assertDecode(0xFFFF00FF, 65536, 4, '\x8D\xff\xff\xff', 0)
 
351
        self.assertDecode(0xFF00FFFF, 65536, 4, '\x8B\xff\xff\xff', 0)
 
352
        self.assertDecode(0x00FFFFFF, 65536, 4, '\x87\xff\xff\xff', 0)
 
353
        self.assertDecode(0x01020304, 65536, 5, '\x8F\x04\x03\x02\x01', 0)
 
354
 
 
355
    def test_decode_no_offset(self):
 
356
        self.assertDecode(0, 1, 2, '\x90\x01', 0)
 
357
        self.assertDecode(0, 10, 2, '\x90\x0a', 0)
 
358
        self.assertDecode(0, 255, 2, '\x90\xff', 0)
 
359
        self.assertDecode(0, 256, 2, '\xA0\x01', 0)
 
360
        self.assertDecode(0, 257, 3, '\xB0\x01\x01', 0)
 
361
        self.assertDecode(0, 65535, 3, '\xB0\xff\xff', 0)
 
362
        # Special case, if copy == 64KiB, then we store exactly 0
 
363
        # Note that this puns with a copy of exactly 0 bytes, but we don't care
 
364
        # about that, as we would never actually copy 0 bytes
 
365
        self.assertDecode(0, 65536, 1, '\x80', 0)
 
366
 
 
367
    def test_decode(self):
 
368
        self.assertDecode(1, 1, 3, '\x91\x01\x01', 0)
 
369
        self.assertDecode(9, 10, 3, '\x91\x09\x0a', 0)
 
370
        self.assertDecode(254, 255, 3, '\x91\xfe\xff', 0)
 
371
        self.assertDecode(512, 256, 3, '\xA2\x02\x01', 0)
 
372
        self.assertDecode(258, 257, 5, '\xB3\x02\x01\x01\x01', 0)
 
373
        self.assertDecode(0, 257, 3, '\xB0\x01\x01', 0)
 
374
 
 
375
    def test_decode_not_start(self):
 
376
        self.assertDecode(1, 1, 6, 'abc\x91\x01\x01def', 3)
 
377
        self.assertDecode(9, 10, 5, 'ab\x91\x09\x0ade', 2)
 
378
        self.assertDecode(254, 255, 6, 'not\x91\xfe\xffcopy', 3)
 
379
 
 
380
 
 
381
class TestBase128Int(tests.TestCase):
 
382
 
 
383
    def assertEqualEncode(self, bytes, val):
 
384
        self.assertEqual(bytes, _groupcompress_py.encode_base128_int(val))
 
385
 
 
386
    def assertEqualDecode(self, val, num_decode, bytes):
 
387
        self.assertEqual((val, num_decode),
 
388
                         _groupcompress_py.decode_base128_int(bytes))
 
389
 
 
390
    def test_encode(self):
 
391
        self.assertEqualEncode('\x01', 1)
 
392
        self.assertEqualEncode('\x02', 2)
 
393
        self.assertEqualEncode('\x7f', 127)
 
394
        self.assertEqualEncode('\x80\x01', 128)
 
395
        self.assertEqualEncode('\xff\x01', 255)
 
396
        self.assertEqualEncode('\x80\x02', 256)
 
397
        self.assertEqualEncode('\xff\xff\xff\xff\x0f', 0xFFFFFFFF)
 
398
 
 
399
    def test_decode(self):
 
400
        self.assertEqualDecode(1, 1, '\x01')
 
401
        self.assertEqualDecode(2, 1, '\x02')
 
402
        self.assertEqualDecode(127, 1, '\x7f')
 
403
        self.assertEqualDecode(128, 2, '\x80\x01')
 
404
        self.assertEqualDecode(255, 2, '\xff\x01')
 
405
        self.assertEqualDecode(256, 2, '\x80\x02')
 
406
        self.assertEqualDecode(0xFFFFFFFF, 5, '\xff\xff\xff\xff\x0f')
 
407
 
 
408
    def test_decode_with_trailing_bytes(self):
 
409
        self.assertEqualDecode(1, 1, '\x01abcdef')
 
410
        self.assertEqualDecode(127, 1, '\x7f\x01')
 
411
        self.assertEqualDecode(128, 2, '\x80\x01abcdef')
 
412
        self.assertEqualDecode(255, 2, '\xff\x01\xff')
 
413
 
 
414