"""Worked Adler-32 examples, not an error-rate study. Sources: RFC 1950 sections 2.2-2.3 and https://zlib.net/manual.html. Run: python3 -B adler32-contract.py Only the small reference recurrence is implemented here; compression, decompression and the comparison checksum use the installed zlib library. """ import json import platform import unittest import zlib def reference(data): s1, s2 = 1, 0 for byte in data: s1 = (s1 + byte) % 65521 s2 = (s2 + s1) % 65521 return (s2 << 16) | s1 class Adler32Contract(unittest.TestCase): def test_empty_initial_value(self): self.assertEqual(reference(b""), 1) self.assertEqual(zlib.adler32(b""), 1) def test_native_reference_vectors(self): for data in [bytes([n]) for n in range(256)] + [ bytes(range(256)), bytes(range(256)) * 300, b"\xff" * 65521 ]: with self.subTest(length=len(data), first=data[:1]): self.assertEqual(reference(data), zlib.adler32(data)) def test_short_message_sum_bounds(self): for value in [0, 1, 127, 255]: data = bytes([value]) * 128 expected_s1 = 1 + 128 * value self.assertLess(expected_s1, 65521) self.assertEqual(reference(data) & 0xffff, expected_s1) self.assertEqual(zlib.adler32(data) & 0xffff, expected_s1) self.assertEqual(zlib.adler32(b"\xff" * 128) & 0xffff, 32641) def test_all_two_byte_inputs_are_distinct(self): checksums = set() for first in range(256): for second in range(256): data = bytes([first, second]) value = zlib.adler32(data) self.assertEqual(value, reference(data)) s1, s2 = value & 0xffff, value >> 16 self.assertEqual(s2 - s1 - 1, first) self.assertEqual(2 * s1 - s2, second) checksums.add(value) self.assertEqual(len(checksums), 65536) def test_constructed_collision(self): left, right = bytes([0, 2, 0]), bytes([1, 0, 1]) self.assertNotEqual(left, right) for data in [left, right]: self.assertEqual(reference(data), 0x00070003) self.assertEqual(zlib.adler32(data), 0x00070003) def test_balanced_change_with_context(self): for prefix in [b"", b"prefix", bytes(range(256))]: for suffix in [b"", b"suffix", bytes(range(255, -1, -1))]: left = prefix + bytes([0, 2, 0]) + suffix right = prefix + bytes([1, 0, 1]) + suffix self.assertEqual(zlib.adler32(left), zlib.adler32(right)) def test_single_byte_negative_control(self): self.assertNotEqual(zlib.adler32(bytes([0, 2, 0])), zlib.adler32(bytes([0, 2, 1]))) def test_incremental_update(self): data = bytes(range(256)) * 300 for chunk in [1, 7, 255, 65536]: value = 1 for start in range(0, len(data), chunk): value = zlib.adler32(data[start:start + chunk], value) self.assertEqual(value, zlib.adler32(data)) def test_zlib_trailer_and_corruption_rejection(self): data = bytes([0, 2, 0]) stream = zlib.compress(data) self.assertEqual(stream[-4:], bytes.fromhex("00070003")) self.assertEqual(zlib.decompress(stream), data) damaged = stream[:-1] + bytes([stream[-1] ^ 1]) with self.assertRaises(zlib.error): zlib.decompress(damaged) def test_wrapper_scope(self): data = b"wrapper scope" * 20 for wbits in [-15, 15, 31]: encoder = zlib.compressobj(wbits=wbits) stream = encoder.compress(data) + encoder.flush() self.assertEqual(zlib.decompress(stream, wbits), data) if wbits == 15: self.assertEqual(int.from_bytes(stream[-4:], "big"), zlib.adler32(data)) elif wbits == 31: self.assertEqual(int.from_bytes(stream[-8:-4], "little"), zlib.crc32(data)) self.assertEqual(int.from_bytes(stream[-4:], "little"), len(data)) else: with self.assertRaises(zlib.error): zlib.decompress(stream) if __name__ == "__main__": print(json.dumps({"python": platform.python_version(), "zlib_build": zlib.ZLIB_VERSION, "zlib_runtime": zlib.ZLIB_RUNTIME_VERSION, "collision_hex": ["000200", "010001"], "adler32_hex": "00070003", "scope": "deterministic arithmetic and API controls"})) unittest.main(verbosity=2)