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)
287
class TestCopyInstruction(tests.TestCase):
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])
295
def assertDecode(self, exp_offset, exp_length, exp_newpos, bytes, pos):
296
cmd = ord(bytes[pos])
298
out = _groupcompress_py.decode_copy_instruction(bytes, cmd, pos)
299
self.assertEqual((exp_offset, exp_length, exp_newpos), out)
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)
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)
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)
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)
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)
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)
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)
381
class TestBase128Int(tests.TestCase):
383
def assertEqualEncode(self, bytes, val):
384
self.assertEqual(bytes, _groupcompress_py.encode_base128_int(val))
386
def assertEqualDecode(self, val, num_decode, bytes):
387
self.assertEqual((val, num_decode),
388
_groupcompress_py.decode_base128_int(bytes))
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)
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')
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')