pyfastcdc 0.2.1__tar.gz → 0.3.0__tar.gz

{pyfastcdc-0.2.1/pyfastcdc.egg-info → pyfastcdc-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfastcdc
-Version: 0.2.1
+Version: 0.3.0
 Summary: A high-performance FastCDC 2020 implementation written in Python + Cython
 Author: Fallen_Breath
 License: MIT

{pyfastcdc-0.2.1 → pyfastcdc-0.3.0}/pyfastcdc/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.2.1'
+__version__ = '0.3.0'
 
 __all__ = [
 	'BinaryStreamReader',

{pyfastcdc-0.2.1 → pyfastcdc-0.3.0}/pyfastcdc/cy/fastcdc.pyx

@@ -66,7 +66,7 @@ cdef class FastCDC:
 		self.config.min_size = min_size
 		self.config.max_size = max_size
 
-		bits = avg_size.bit_length() - 1
+		bits = utils.logarithm2(avg_size)
 		self.config.mask_s = MASKS[bits + normalized_chunking]
 		self.config.mask_l = MASKS[bits - normalized_chunking]
 		self.config.mask_s_ls = self.config.mask_s << 1

{pyfastcdc-0.2.1 → pyfastcdc-0.3.0}/pyfastcdc/py/fastcdc.py

@@ -81,7 +81,7 @@ class FastCDC:
 		if not (0 <= normalized_chunking <= 3):
 			raise ValueError(f'normalized_chunking {normalized_chunking} is out of range [0, 3]')
 
-		bits = avg_size.bit_length() - 1
+		bits = utils.logarithm2(avg_size)
 		mask_s = MASKS[bits + normalized_chunking]
 		mask_l = MASKS[bits - normalized_chunking]
 		mask_s_ls = (mask_s << 1) & _UINT64_MASK

{pyfastcdc-0.2.1 → pyfastcdc-0.3.0}/pyfastcdc/utils.py

@@ -1,3 +1,4 @@
+import math
 import mmap
 import os
 from pathlib import Path
@@ -8,6 +9,15 @@ from pyfastcdc.common import BinaryStreamReader
 ReadintoFunc = Callable[[memoryview], int]
 
 
+def logarithm2(value: int) -> int:
+	# The same as the nlfiedler/fastcdc-rs v4.0.1 Rust implementation: (value as f64).log2().round() as u32
+	if value < 0:
+		raise ValueError(f'value must be non-negative, got {value}')
+	if value == 0:
+		return 0
+	return math.floor(math.log2(value) + 0.5)
+
+
 def create_memoryview_from_buffer(buf: Union[bytes, bytearray, memoryview]) -> memoryview:
 	if isinstance(buf, (bytes, bytearray, memoryview)):
 		return memoryview(buf)

{pyfastcdc-0.2.1 → pyfastcdc-0.3.0/pyfastcdc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfastcdc
-Version: 0.2.1
+Version: 0.3.0
 Summary: A high-performance FastCDC 2020 implementation written in Python + Cython
 Author: Fallen_Breath
 License: MIT

{pyfastcdc-0.2.1 → pyfastcdc-0.3.0}/pyfastcdc.egg-info/SOURCES.txt

@@ -26,4 +26,5 @@ pyfastcdc/py/chunk.py
 pyfastcdc/py/constants.py
 pyfastcdc/py/fastcdc.py
 tests/test_arguments.py
-tests/test_correctness.py
+tests/test_correctness.py
+tests/test_utils.py

{pyfastcdc-0.2.1 → pyfastcdc-0.3.0}/tests/test_arguments.py

@@ -102,4 +102,4 @@ class TestAvgSize:
 
 		# larger avg_size means fewer chunks
 		for i in range(1, len(chunk_counts)):
-			assert chunk_counts[i] <= chunk_counts[i - 1]
+			assert chunk_counts[i] <= chunk_counts[i - 1]

pyfastcdc-0.3.0/tests/test_correctness.py

@@ -0,0 +1,679 @@
+import hashlib
+import io
+import random
+from io import BytesIO
+from pathlib import Path
+from typing import Dict, Tuple, List, NamedTuple
+
+import pytest
+
+from pyfastcdc.common import NormalizedChunking
+from pyfastcdc.cy import FastCDC as FastCDC_cy
+from pyfastcdc.py import FastCDC as FastCDC_py
+from tests.utils import FastCDCType
+
+
+class TestSekienAkashitaImage:
+	class Param(NamedTuple):
+		avg_size: int
+		seed: int = 0
+		nc: NormalizedChunking = 1
+
+		def pytest_id(self) -> str:
+			return f'avg{self.avg_size}_seed{self.seed}_nc{self.nc}'
+
+	# Param -> [(gear_hash, length), ...]
+	EXPECTED_RESULT: Dict[Param, List[Tuple[int, int]]] = {}
+
+	@pytest.mark.parametrize('cut_func', ['buf', 'stream'])
+	@pytest.mark.parametrize('case_param', EXPECTED_RESULT.keys(), ids=Param.pytest_id)
+	def test_sekien_akashita(self, fastcdc_impl: FastCDCType, sekien_akashita_bytes: bytes, case_param: Param, cut_func: str):
+		expected = self.EXPECTED_RESULT[case_param]
+
+		cdc = fastcdc_impl(avg_size=case_param.avg_size, seed=case_param.seed, normalized_chunking=case_param.nc)
+
+		if cut_func == 'buf':
+			chunk_gen = cdc.cut_stream(BytesIO(sekien_akashita_bytes))
+		elif cut_func == 'stream':
+			chunk_gen = cdc.cut_buf(sekien_akashita_bytes)
+		else:
+			raise ValueError(cut_func)
+
+		h = hashlib.sha256()
+		chunk_cnt = 0
+		for i, chunk in enumerate(chunk_gen):
+			assert i < len(expected)
+			assert chunk.gear_hash == expected[i][0]
+			assert chunk.length == expected[i][1]
+			h.update(chunk.data)
+			chunk_cnt += 1
+		assert chunk_cnt == len(expected)
+		assert h.hexdigest() == hashlib.sha256(sekien_akashita_bytes).hexdigest()
+
+
+class TestPyCyConsistency:
+	DATA_SIZES = [
+		*range(100),
+		*[i * 100 for i in range(1, 10)],
+		*[i * 1024 for i in range(1, 10)],
+		*[i * 10 * 1024 for i in range(1, 5)],
+		*[i * 100 * 1024 for i in range(1, 4)],
+		*[i * 1024 * 1024 for i in range(1, 3)],
+	]
+	AVG_SIZES = [1024, 4096, 8192, 12345, 16384, 65536]
+
+	@pytest.fixture(scope="class")
+	def random_data_by_size(self) -> Dict[int, bytes]:
+		data_cache = {}
+		for size in self.DATA_SIZES:
+			rnd = random.Random(size)
+			data_cache[size] = bytes(rnd.getrandbits(8) for _ in range(size))
+		return data_cache
+
+	@pytest.mark.parametrize('avg_size', AVG_SIZES)
+	@pytest.mark.parametrize('data_size', DATA_SIZES)
+	@pytest.mark.parametrize('normalized_chunking', [0, 1, 2, 3])
+	@pytest.mark.parametrize('seed', [0, 1])
+	def test_py_cy_consistency(self, avg_size: int, data_size: int, normalized_chunking: NormalizedChunking, seed: int, random_data_by_size: Dict[int, bytes]):
+		data = random_data_by_size[data_size]
+
+		cdc_py = FastCDC_py(avg_size=avg_size, normalized_chunking=normalized_chunking, seed=seed)
+		cdc_cy = FastCDC_cy(avg_size=avg_size, normalized_chunking=normalized_chunking, seed=seed)
+		assert cdc_py.avg_size == cdc_cy.avg_size
+		assert cdc_py.min_size == cdc_cy.min_size
+		assert cdc_py.max_size == cdc_cy.max_size
+
+		chunks_py = list(cdc_py.cut_buf(data))
+		chunks_cy = list(cdc_cy.cut_buf(data))
+
+		assert len(chunks_py) == len(chunks_cy)
+
+		for py_chunk, cy_chunk in zip(chunks_py, chunks_cy):
+			assert py_chunk.offset == cy_chunk.offset
+			assert py_chunk.length == cy_chunk.length
+			assert py_chunk.gear_hash == cy_chunk.gear_hash
+			assert bytes(py_chunk.data) == bytes(cy_chunk.data)
+
+		reconstructed_py = b''.join(bytes(chunk.data) for chunk in chunks_py)
+		reconstructed_cy = b''.join(bytes(chunk.data) for chunk in chunks_cy)
+		assert reconstructed_py == data
+		assert reconstructed_cy == data
+
+
+class TestCutMethods:
+	def test_chunk_properties(self, fastcdc_instance, random_data_1m: bytes):
+		prev_offset = None
+		prev_size = None
+		for chunk in fastcdc_instance.cut_buf(random_data_1m):
+			assert isinstance(chunk.gear_hash, int)
+			assert isinstance(chunk.offset, int)
+			assert isinstance(chunk.length, int)
+			assert isinstance(chunk.data, memoryview)
+
+			assert len(chunk.data) == chunk.length
+
+			if prev_offset is not None:
+				assert chunk.offset == prev_offset + prev_size
+			prev_offset = chunk.offset
+			prev_size = chunk.length
+
+	def test_cut_buf_vs_cut_file_consistency(self, fastcdc_impl: FastCDCType, random_data_1m: bytes, tmp_path: Path):
+		cdc = fastcdc_impl(avg_size=8192)
+		chunks_memory = list(cdc.cut_buf(random_data_1m))
+
+		temp_file = tmp_path / 'test.bin'
+		temp_file.write_bytes(random_data_1m)
+
+		chunk_cnt = 0
+		for i, chunk in enumerate(cdc.cut_file(temp_file)):
+			chunk_cnt += 1
+			assert chunk_cnt <= len(chunks_memory)
+			assert chunk.offset == chunks_memory[i].offset
+			assert chunk.length == chunks_memory[i].length
+			assert chunk.gear_hash == chunks_memory[i].gear_hash
+			assert bytes(chunk.data) == bytes(chunks_memory[i].data)
+		assert len(chunks_memory) == chunk_cnt
+
+	def test_cut_buf_vs_cut_stream_consistency_read(self, fastcdc_impl: FastCDCType, random_data_1m: bytes):
+		cdc = fastcdc_impl(avg_size=8192)
+		chunks_memory = list(cdc.cut_buf(random_data_1m))
+		bytes_io = io.BytesIO(random_data_1m)
+
+		class MyStream:
+			def read(self, n: int) -> bytes:
+				return bytes_io.read(n)
+
+		chunk_cnt = 0
+		for i, chunk in enumerate(cdc.cut_stream(MyStream())):
+			chunk_cnt += 1
+			assert chunk_cnt <= len(chunks_memory)
+			assert chunk.offset == chunks_memory[i].offset
+			assert chunk.length == chunks_memory[i].length
+			assert chunk.gear_hash == chunks_memory[i].gear_hash
+			assert bytes(chunk.data) == bytes(chunks_memory[i].data)
+		assert len(chunks_memory) == chunk_cnt
+
+	def test_cut_buf_vs_cut_stream_consistency_readinto(self, fastcdc_impl: FastCDCType, random_data_1m: bytes):
+		cdc = fastcdc_impl(avg_size=8192)
+		chunks_memory = list(cdc.cut_buf(random_data_1m))
+		bytes_io = io.BytesIO(random_data_1m)
+
+		class MyStream:
+			def readinto(self, buf) -> int:
+				return bytes_io.readinto(buf)
+
+		chunk_cnt = 0
+		for i, chunk in enumerate(cdc.cut_stream(MyStream())):
+			chunk_cnt += 1
+			assert chunk_cnt <= len(chunks_memory)
+			assert chunk.offset == chunks_memory[i].offset
+			assert chunk.length == chunks_memory[i].length
+			assert chunk.gear_hash == chunks_memory[i].gear_hash
+			assert bytes(chunk.data) == bytes(chunks_memory[i].data)
+		assert len(chunks_memory) == chunk_cnt
+
+
+class TestSeed:
+	def test_different_seeds_produce_different_chunks(self, random_data_1m: bytes):
+		cdc1 = FastCDC_cy(avg_size=8192, seed=1)
+		cdc2 = FastCDC_cy(avg_size=8192, seed=2)
+
+		chunks1 = list(cdc1.cut_buf(random_data_1m))
+		chunks2 = list(cdc2.cut_buf(random_data_1m))
+
+		hashes1 = [chunk.gear_hash for chunk in chunks1]
+		hashes2 = [chunk.gear_hash for chunk in chunks2]
+
+		assert hashes1 != hashes2 or len(chunks1) == 0
+
+
+class TestChunkProperties:
+	def test_chunk_data_integrity(self, fastcdc_instance, random_data_1m: bytes):
+		data_list = []
+		for chunk in fastcdc_instance.cut_buf(random_data_1m):
+			data_list.append(bytes(chunk.data))
+		assert b''.join(data_list) == random_data_1m
+
+	def test_chunk_size_constraints(self, fastcdc_impl: FastCDCType, random_data_1m: bytes):
+		avg_size = 16384
+		min_size = avg_size // 4  # 4096
+		max_size = avg_size * 4  # 65536
+
+		cdc = fastcdc_impl(avg_size=avg_size)
+		chunks = list(cdc.cut_buf(random_data_1m))
+
+		for chunk in chunks:
+			if chunk != chunks[-1]:
+				assert min_size <= chunk.length <= max_size
+
+
+
+def __build_test_data():
+	cases = TestSekienAkashitaImage.EXPECTED_RESULT
+	key = TestSekienAkashitaImage.Param
+	cases[key(16384, 0)] = [
+		(17968276318003433923, 21325),
+		(8197189939299398838, 17140),
+		(13019990849178155730, 28084),
+		(4509236223063678303, 18217),
+		(2504464741100432583, 24700),
+	]
+	cases[key(16384, 555, 0)] = [
+		(11912081672558759016, 65536),
+		(4429013657701329409, 15481),
+		(4617353815122521848, 25471),
+		(0, 2978),
+	]
+	cases[key(16384, 666, 1)] = [
+        (9312357714466240148, 10605),
+        (226910853333574584, 55745),
+        (12271755243986371352, 11346),
+        (14153975939352546047, 5883),
+        (5890158701071314778, 11586),
+        (8981594897574481255, 14301),
+	]
+	cases[key(16384, 777, 2)] = [
+		(5756766315125948951, 35163),
+		(17831515366867633926, 16422),
+		(3216207887329694204, 17470),
+		(1561632489531769228, 10294),
+		(10369060306646295092, 18786),
+		(14655496504067886486, 11331),
+	]
+	cases[key(16384, 888, 3)] = [
+		(3158156329559295338, 17507),
+		(5701878486563355731, 18589),
+		(4529013630687100674, 17996),
+		(3219799010358125664, 17281),
+		(9266722211030107244, 15987),
+		(7683217499559119532, 19292),
+		(0, 2814),
+	]
+	cases[key(32768, 0)] = [
+		(15733367461443853673, 66549),
+		(6321136627705800457, 42917),
+	]
+	cases[key(65536, 0)] = [
+		(2504464741100432583, 109466),
+	]
+	cases[key(1000, 0)] = [
+		(15141981586395774332, 577),
+		(8477613194938993865, 2025),
+		(2735959075179562048, 1118),
+		(18115765646671285894, 1458),
+		(9500110725479242474, 1122),
+		(443122261039895162, 334),
+		(393511086818658384, 268),
+		(16955226389877987730, 2234),
+		(2735959075179562048, 1118),
+		(18115765646671285894, 1458),
+		(13954488060845043336, 616),
+		(4626797161746623835, 4000),
+		(11465206466110030982, 1108),
+		(3877185904066068587, 1457),
+		(5881250651602209508, 1321),
+		(16925411787380621381, 251),
+		(17489808562297316230, 860),
+		(18129948957563258366, 1158),
+		(13002932706949647172, 1369),
+		(3370452418750950046, 258),
+		(17998343902007936034, 1641),
+		(11508990849237690054, 819),
+		(5207468236900142596, 1090),
+		(8284690672242526937, 1257),
+		(16861457263863958963, 1179),
+		(10960864681938687892, 1386),
+		(6054483394976617000, 1068),
+		(2386775949661439840, 1224),
+		(9765031068850768480, 1037),
+		(16719281564143894808, 1313),
+		(17393396865315244987, 2021),
+		(8197189939299398838, 320),
+		(6871126333188003048, 885),
+		(16972716804835771241, 1179),
+		(12808154220016437278, 2139),
+		(15385422482022415630, 356),
+		(6844292880670166480, 1776),
+		(13355204841389267792, 1168),
+		(9374847859024726178, 971),
+		(17084607867749926034, 1142),
+		(10103105113398742526, 1278),
+		(6254902090653532395, 2043),
+		(7952073558027502250, 1534),
+		(9616506964461227050, 1115),
+		(12322483109039221194, 636),
+		(8958286662040306431, 1341),
+		(12554149114625989198, 1740),
+		(16207690376253020852, 1006),
+		(16248939738969512408, 1468),
+		(14270957677345163169, 1299),
+		(1551239710381196832, 1429),
+		(14312347838531863880, 2478),
+		(1335322050285636652, 1786),
+		(1944458194743591353, 2275),
+		(12039817357202303956, 949),
+		(11820880714810263869, 1377),
+		(16009206469796846404, 371),
+		(14283166369001529626, 337),
+		(15911323414792572684, 1076),
+		(16417310421356693358, 868),
+		(18147769296913861510, 1011),
+		(15334853639705628667, 1769),
+		(7045320843275616092, 482),
+		(3743371431493807673, 665),
+		(975175087488798292, 2264),
+		(9731900868009236632, 1116),
+		(7899942747347358014, 1264),
+		(478520673225540621, 1025),
+		(4509236223063678303, 683),
+		(7911353879014065725, 1033),
+		(17211447357795894654, 1597),
+		(9814968862893591415, 1711),
+		(6643495946427635752, 1356),
+		(14635965274794233990, 1456),
+		(17951524945264971610, 1006),
+		(12407786606147719096, 1663),
+		(8379360585841640134, 1234),
+		(4798022593009727916, 291),
+		(10955710641692053612, 1094),
+		(457762767568428136, 344),
+		(82832907034692228, 1444),
+		(5774103846722045964, 1168),
+		(17563493800282002670, 1450),
+		(2724044535410791590, 1050),
+		(9389354643814908759, 1085),
+		(9132161234032204682, 1848),
+		(16231621261041204310, 254),
+		(261151940358997096, 1069),
+		(9613379839789125245, 1323),
+		(16119826487342861060, 1088),
+		(0, 136),
+	]
+	cases[key(4096, 123)] = [
+		(17640604251071308688, 5626),
+		(17640604251071308688, 6534),
+		(1164779717113740270, 5375),
+		(1630317330713120546, 2204),
+		(15925855439796383684, 7352),
+		(14038325076263464756, 4459),
+		(10372641652373760866, 2757),
+		(6632718265737316290, 4345),
+		(13547989595704043725, 13255),
+		(5085413808508269073, 6871),
+		(2088831145520463002, 1867),
+		(17282638805110740002, 7908),
+		(10392127899000403174, 4664),
+		(12682705380171701888, 3262),
+		(14163264652508939164, 4595),
+		(11317546923098927019, 10371),
+		(5442637979354971713, 5365),
+		(918741369407724947, 3523),
+		(11012502959421423036, 2886),
+		(16443206251033749990, 4470),
+		(18389377892984539132, 1777),
+	]
+	cases[key(3333, 456)] = [
+		(10244635572917292382, 5352),
+		(10244635572917292382, 6534),
+		(6506656886334461048, 8428),
+		(1568981245086988673, 4055),
+		(976165388776206262, 8246),
+		(227474149701075941, 1705),
+		(15597163692867778936, 8896),
+		(8853802354309906299, 1703),
+		(7846154730496643533, 2469),
+		(12579192060780867954, 876),
+		(16367212629893111190, 6710),
+		(11084210301959466778, 6617),
+		(17216215298576800968, 2290),
+		(2745509010730917144, 3990),
+		(11949739281024563184, 2157),
+		(11802567455667178519, 7639),
+		(15836350909598670374, 3458),
+		(3598944074651431428, 4450),
+		(14136883845736820776, 6320),
+		(3381712722571947258, 8934),
+		(1258510376350532739, 1315),
+		(1125375003867751948, 3341),
+		(6560578492574969505, 3981),
+	]
+	cases[key(7696, 789)] = [
+		(11334448432782874778, 8194),
+		(12589329716764299352, 20178),
+		(9249278391062916766, 8282),
+		(17112004270336100794, 7728),
+		(10241186054488990483, 11587),
+		(13131687877381749692, 7247),
+		(4691067104701485054, 13922),
+		(14573090550801024034, 10300),
+		(4483911677009026884, 3884),
+		(16657773305248393930, 2912),
+		(11098559764229607138, 8020),
+		(15951496705909269620, 7212),
+	]
+
+	cases[key(724, 9)] = [  # logarithm2(724) == 9
+		(6210182461912837442, 437),
+		(15823412212426401040, 536),
+		(7564542701233810453, 1491),
+		(11734395491080755364, 758),
+		(4652611913553545461, 865),
+		(9396519209846734759, 229),
+		(14724133904636706898, 776),
+		(14179978172047068347, 1585),
+		(12420364923825674884, 294),
+		(15823412212426401040, 536),
+		(7564542701233810453, 1491),
+		(11734395491080755364, 758),
+		(4652611913553545461, 865),
+		(9396519209846734759, 229),
+		(14724133904636706898, 776),
+		(6679608208662765719, 1009),
+		(7970508778836684116, 2896),
+		(588782165723983073, 1757),
+		(9355144489785944531, 233),
+		(7270358463936224191, 319),
+		(10753677279385161822, 730),
+		(14878908755424596036, 693),
+		(17252729894520766000, 199),
+		(2557031429687478504, 742),
+		(11154471105488776204, 511),
+		(6241044147716496561, 479),
+		(1528829558651627719, 1119),
+		(15819821700176001938, 690),
+		(14864412389671971154, 368),
+		(16770710277328743660, 805),
+		(6677815027125987531, 765),
+		(3130290060913031247, 613),
+		(7848687156715069461, 931),
+		(17047677119083606015, 261),
+		(386826127241435034, 286),
+		(13186826917161993786, 462),
+		(11921066640454513798, 221),
+		(17813634603948247098, 776),
+		(208283819332894784, 1585),
+		(3828817839447427386, 800),
+		(4410297577497966787, 509),
+		(15915646898486727054, 776),
+		(12606911033279791588, 936),
+		(2317245335378339546, 279),
+		(11899481234140602421, 731),
+		(541281491629941110, 336),
+		(13930607010442119242, 1012),
+		(10043439370713735358, 1443),
+		(4351904982129715350, 783),
+		(10272470512678469758, 1768),
+		(13811592930557436145, 199),
+		(3835830484370282898, 1598),
+		(16478342864273230318, 738),
+		(848712800904677626, 724),
+		(7089126568427585890, 1680),
+		(11588799795439342024, 748),
+		(6517184361581775911, 741),
+		(2581329261736055218, 996),
+		(1438472251255850114, 797),
+		(2040918757124669446, 1050),
+		(12710486653819945042, 958),
+		(3577694700869568713, 529),
+		(5540893603527656618, 885),
+		(312595612891107520, 938),
+		(2754121658008144322, 726),
+		(7308113600980769340, 223),
+		(12624207711036016704, 741),
+		(18278303734565733423, 1127),
+		(3416967846417400033, 887),
+		(16597395760763373822, 779),
+		(11517746268471340466, 658),
+		(330536455930203400, 188),
+		(14346035238419306508, 964),
+		(11851015761706437850, 652),
+		(2207968762155534473, 1067),
+		(4300209225473755288, 795),
+		(16079828354387167342, 393),
+		(11074900721964437734, 1002),
+		(15850308162951321652, 812),
+		(16189354393452719094, 701),
+		(5872528194289029586, 1596),
+		(2438982074523730154, 932),
+		(7457200155121522294, 676),
+		(67373542593277148, 1195),
+		(6416504404064643776, 490),
+		(13048281498366780615, 741),
+		(6491312012001838137, 1031),
+		(6403314040556224779, 263),
+		(5966668646084264096, 730),
+		(7618965489272260256, 581),
+		(1698496630771737232, 324),
+		(6272792483812909132, 1157),
+		(14099154068530824346, 376),
+		(8036575980860559560, 780),
+		(9922279172859505867, 635),
+		(13167110527530567759, 795),
+		(11850586376745257027, 1013),
+		(7046096067745630262, 1250),
+		(17794651536343781444, 1136),
+		(8908771862940031268, 1096),
+		(5050182300921299158, 794),
+		(2020723957054363976, 588),
+		(3325484325892565060, 973),
+		(17337365858043038764, 1507),
+		(753368741273692028, 215),
+		(3512003076754004550, 283),
+		(2265043035317403640, 526),
+		(16793717987136300110, 228),
+		(3741116656027469037, 941),
+		(16225024565176477711, 729),
+		(10008765342384935360, 1112),
+		(7891613205322036999, 465),
+		(7474923846557769781, 827),
+		(9383267966041790494, 1036),
+		(5444012540148356076, 438),
+		(12123398032021590048, 1110),
+		(2966615689224291352, 1347),
+		(9979705022142839714, 246),
+		(11728505674497348048, 1062),
+		(10197500089416620450, 736),
+		(17336138819815902386, 847),
+		(16442276383220580678, 834),
+		(7224900734343987180, 207),
+		(3030712618198892048, 432),
+		(8091423245119018858, 551),
+		(970234113364082694, 834),
+		(10080364783653397770, 195),
+		(11220676464059947108, 1862),
+		(18400029108298858430, 230),
+		(11748286201114699520, 260),
+		(11023492533541935362, 1238),
+		(1979512512097582824, 359),
+		(1889718952600535126, 1019),
+		(7215615887733475334, 627),
+		(4459541957027827716, 742),
+		(16447634892420350148, 1046),
+		(12384333288239022322, 1522),
+		(8742062182533134312, 956),
+	]
+	cases[key(725, 10)] = [  # logarithm2(725) == 10
+		(3880200791445358170, 1171),
+		(5658294207238396694, 476),
+		(1986145496423499562, 1752),
+		(4291161420613030454, 1032),
+		(2570315465402502055, 939),
+		(13607912940956345208, 333),
+		(17847537199891125810, 1504),
+		(5932397945798563614, 764),
+		(14521897173053881527, 361),
+		(10216444785066525589, 1601),
+		(4291161420613030454, 1032),
+		(2570315465402502055, 939),
+		(8050782876685575453, 447),
+		(13302770737643351377, 2900),
+		(14663859402684139382, 2333),
+		(12183996374588754964, 871),
+		(12719892389018513871, 231),
+		(3891719624479213180, 1565),
+		(14651348969435727241, 899),
+		(13017162958173657478, 666),
+		(355366611350493046, 1024),
+		(8975997613858408118, 975),
+		(12346944422348624424, 1632),
+		(17121775793317715396, 818),
+		(8735300905794665892, 288),
+		(1593109120621282946, 918),
+		(3636164904145165176, 712),
+		(4963895604217385630, 876),
+		(17063897432159488626, 1824),
+		(12722273962190769990, 908),
+		(3786605912018387702, 1593),
+		(8109461640426192974, 757),
+		(3159992682178447490, 2026),
+		(4546850680761030892, 1144),
+		(6540955558319623319, 1369),
+		(339630999250211216, 788),
+		(11185666916059514410, 1336),
+		(10655877686637416176, 1971),
+		(12721905901213615624, 833),
+		(14066897360568717938, 754),
+		(11212252888158967820, 1036),
+		(7159074416532427876, 732),
+		(14930792122386848472, 1346),
+		(8468966750367534944, 1871),
+		(13402150570819703574, 710),
+		(15825368515155591746, 820),
+		(13417749480250952531, 943),
+		(1621894964071905100, 509),
+		(7925783383027301942, 706),
+		(12559986661817166516, 226),
+		(4964616519763020901, 1407),
+		(3873577331692030894, 903),
+		(17621425153818828532, 1318),
+		(16290934634368242021, 311),
+		(16958772797381986928, 889),
+		(5365141795369192612, 1300),
+		(17769023687988720468, 674),
+		(2250458466579792345, 1237),
+		(14584358719494663026, 346),
+		(5717040536230332101, 515),
+		(5316380896310853805, 741),
+		(9007463591917437538, 983),
+		(5518484945376478388, 996),
+		(12810471851541676335, 2177),
+		(13264222816481349316, 1260),
+		(2161345495062028080, 1026),
+		(16771665155150908002, 808),
+		(4054366689955984488, 472),
+		(14487455770406964220, 1289),
+		(14550807423624594204, 877),
+		(4788670350554726882, 1353),
+		(6574134102965381932, 372),
+		(16504855675512305190, 405),
+		(9088365967746888780, 2900),
+		(14596247611905770804, 682),
+		(12911613994967767354, 758),
+		(12634321617313432304, 1224),
+		(15207794529635932600, 1122),
+		(7511305357194071387, 1065),
+		(12189587028669927526, 1048),
+		(4177934069308589140, 319),
+		(7569676053598539570, 1646),
+		(16173403249582546592, 2602),
+		(7088138500417580436, 387),
+		(17005641209635772934, 1950),
+		(11058910209362914707, 337),
+		(11086789351781338680, 735),
+		(6039279362010812718, 884),
+		(8044605568175964902, 933),
+		(14639839282236278972, 2193),
+		(13667334481093640681, 593),
+		(8229075153661986514, 2038),
+		(11671963030460304732, 1250),
+		(5431176519429573497, 1323),
+		(16007310708128089160, 1365),
+		(8155414491064993052, 805),
+		(13739322222304365424, 1548),
+		(15038706754656408926, 1084),
+		(7516815982880017639, 959),
+		(6676390934596324937, 871),
+		(14873914439199393400, 753),
+		(18275621106261248557, 1172),
+	]
+	cases[key(11585, 13)] = [  # logarithm2(11585) == 13
+		(5283862320262956126, 6784),
+		(11025388708907034538, 17576),
+		(6660909496720783874, 18720),
+		(17270784194951261795, 5889),
+		(13967635376301421897, 13789),
+		(2544012647058660924, 14881),
+		(17731551937985281530, 16441),
+		(9757367471876633230, 13893),
+		(0, 1493),
+	]
+	cases[key(11586, 14)] = [  # logarithm2(11586) == 14
+		(9647594720494668858, 11853),
+		(15785684128034222449, 45969),
+		(2654885834306702464, 18990),
+		(11599035070615737710, 27020),
+		(5712156089341372705, 5634),
+	]
+
+
+__build_test_data()

pyfastcdc-0.3.0/tests/test_utils.py

@@ -0,0 +1,61 @@
+import pytest
+
+from pyfastcdc import utils
+
+
+class TestLogarithm2:
+	def test_negative_input(self):
+		with pytest.raises(ValueError):
+			utils.logarithm2(-1)
+
+	def test_zero(self):
+		assert utils.logarithm2(0) == 0
+
+	@pytest.mark.parametrize('result, lower, upper', [
+		(0, 0, 2),
+		(1, 2, 3),
+		(2, 3, 6),
+		(3, 6, 12),
+		(4, 12, 23),
+		(5, 23, 46),
+		(6, 46, 91),
+		(7, 91, 182),
+		(8, 182, 363),
+		(9, 363, 725),
+		(10, 725, 1449),
+		(11, 1449, 2897),
+		(12, 2897, 5793),
+		(13, 5793, 11586),
+		(14, 11586, 23171),
+		(15, 23171, 46341),
+		(16, 46341, 92682),
+		(17, 92682, 185364),
+		(18, 185364, 370728),
+		(19, 370728, 741456),
+		(20, 741456, 1482911),
+		(21, 1482911, 2965821),
+		(22, 2965821, 5931642),
+		(23, 5931642, 11863284),
+		(24, 11863284, 23726567),
+		(25, 23726567, 47453133),
+		(26, 47453133, 94906266),
+		(27, 94906266, 189812532),
+		(28, 189812532, 379625063),
+		(29, 379625063, 759250125),
+		(30, 759250125, 1518500250),
+		(31, 1518500250, 3037000500),
+		(32, 3037000500, 6074001000),
+	])
+	def test_logarithm2_boundaries(self, result: int, lower: int, upper: int):
+		if upper - lower < 30000:
+			for i in range(lower, upper):
+				assert utils.logarithm2(i) == result
+		else:
+			for i in range(lower, lower + 10000):
+				assert utils.logarithm2(i) == result
+			for i in range(upper - 10000, upper):
+				assert utils.logarithm2(i) == result
+			for i in range(100):
+				mid = lower + (upper - lower) * i // 100
+				assert utils.logarithm2(mid) == result
+		assert utils.logarithm2(upper) == result + 1

pyfastcdc-0.2.1/tests/test_correctness.py

@@ -1,454 +0,0 @@
-import hashlib
-import io
-import random
-from io import BytesIO
-from pathlib import Path
-from typing import Dict, Tuple, List, NamedTuple
-
-import pytest
-
-from pyfastcdc.common import NormalizedChunking
-from pyfastcdc.cy import FastCDC as FastCDC_cy
-from pyfastcdc.py import FastCDC as FastCDC_py
-from tests.utils import FastCDCType
-
-
-class TestSekienAkashitaImage:
-	class Param(NamedTuple):
-		avg_size: int
-		seed: int = 0
-		nc: NormalizedChunking = 1
-	# Param -> [(gear_hash, length), ...]
-	EXPECTED_RESULT: Dict[Param, List[Tuple[int, int]]] = {}
-
-	@pytest.mark.parametrize('cut_func', ['buf', 'stream'])
-	@pytest.mark.parametrize('case_param', EXPECTED_RESULT.keys())
-	def test_sekien_akashita(self, fastcdc_impl: FastCDCType, sekien_akashita_bytes: bytes, case_param: Param, cut_func: str):
-		expected = self.EXPECTED_RESULT[case_param]
-
-		cdc = fastcdc_impl(avg_size=case_param.avg_size, seed=case_param.seed, normalized_chunking=case_param.nc)
-
-		if cut_func == 'buf':
-			chunk_gen = cdc.cut_stream(BytesIO(sekien_akashita_bytes))
-		elif cut_func == 'stream':
-			chunk_gen = cdc.cut_buf(sekien_akashita_bytes)
-		else:
-			raise ValueError(cut_func)
-
-		h = hashlib.sha256()
-		chunk_cnt = 0
-		for i, chunk in enumerate(chunk_gen):
-			assert i < len(expected)
-			assert chunk.gear_hash == expected[i][0]
-			assert chunk.length == expected[i][1]
-			h.update(chunk.data)
-			chunk_cnt += 1
-		assert chunk_cnt == len(expected)
-		assert h.hexdigest() == hashlib.sha256(sekien_akashita_bytes).hexdigest()
-
-
-class TestPyCyConsistency:
-	DATA_SIZES = [
-		*range(100),
-		*[i * 100 for i in range(1, 10)],
-		*[i * 1024 for i in range(1, 10)],
-		*[i * 10 * 1024 for i in range(1, 5)],
-		*[i * 100 * 1024 for i in range(1, 4)],
-		*[i * 1024 * 1024 for i in range(1, 3)],
-	]
-	AVG_SIZES = [1024, 4096, 8192, 12345, 16384, 65536]
-
-	@pytest.fixture(scope="class")
-	def random_data_by_size(self) -> Dict[int, bytes]:
-		data_cache = {}
-		for size in self.DATA_SIZES:
-			rnd = random.Random(size)
-			data_cache[size] = bytes(rnd.getrandbits(8) for _ in range(size))
-		return data_cache
-
-	@pytest.mark.parametrize('avg_size', AVG_SIZES)
-	@pytest.mark.parametrize('data_size', DATA_SIZES)
-	@pytest.mark.parametrize('normalized_chunking', [0, 1, 2, 3])
-	@pytest.mark.parametrize('seed', [0, 1])
-	def test_py_cy_consistency(self, avg_size: int, data_size: int, normalized_chunking: NormalizedChunking, seed: int, random_data_by_size: Dict[int, bytes]):
-		data = random_data_by_size[data_size]
-
-		cdc_py = FastCDC_py(avg_size=avg_size, normalized_chunking=normalized_chunking, seed=seed)
-		cdc_cy = FastCDC_cy(avg_size=avg_size, normalized_chunking=normalized_chunking, seed=seed)
-		assert cdc_py.avg_size == cdc_cy.avg_size
-		assert cdc_py.min_size == cdc_cy.min_size
-		assert cdc_py.max_size == cdc_cy.max_size
-
-		chunks_py = list(cdc_py.cut_buf(data))
-		chunks_cy = list(cdc_cy.cut_buf(data))
-
-		assert len(chunks_py) == len(chunks_cy)
-
-		for py_chunk, cy_chunk in zip(chunks_py, chunks_cy):
-			assert py_chunk.offset == cy_chunk.offset
-			assert py_chunk.length == cy_chunk.length
-			assert py_chunk.gear_hash == cy_chunk.gear_hash
-			assert bytes(py_chunk.data) == bytes(cy_chunk.data)
-
-		reconstructed_py = b''.join(bytes(chunk.data) for chunk in chunks_py)
-		reconstructed_cy = b''.join(bytes(chunk.data) for chunk in chunks_cy)
-		assert reconstructed_py == data
-		assert reconstructed_cy == data
-
-
-class TestCutMethods:
-	def test_chunk_properties(self, fastcdc_instance, random_data_1m: bytes):
-		prev_offset = None
-		prev_size = None
-		for chunk in fastcdc_instance.cut_buf(random_data_1m):
-			assert isinstance(chunk.gear_hash, int)
-			assert isinstance(chunk.offset, int)
-			assert isinstance(chunk.length, int)
-			assert isinstance(chunk.data, memoryview)
-
-			assert len(chunk.data) == chunk.length
-
-			if prev_offset is not None:
-				assert chunk.offset == prev_offset + prev_size
-			prev_offset = chunk.offset
-			prev_size = chunk.length
-
-	def test_cut_buf_vs_cut_file_consistency(self, fastcdc_impl: FastCDCType, random_data_1m: bytes, tmp_path: Path):
-		cdc = fastcdc_impl(avg_size=8192)
-		chunks_memory = list(cdc.cut_buf(random_data_1m))
-
-		temp_file = tmp_path / 'test.bin'
-		temp_file.write_bytes(random_data_1m)
-
-		chunk_cnt = 0
-		for i, chunk in enumerate(cdc.cut_file(temp_file)):
-			chunk_cnt += 1
-			assert chunk_cnt <= len(chunks_memory)
-			assert chunk.offset == chunks_memory[i].offset
-			assert chunk.length == chunks_memory[i].length
-			assert chunk.gear_hash == chunks_memory[i].gear_hash
-			assert bytes(chunk.data) == bytes(chunks_memory[i].data)
-		assert len(chunks_memory) == chunk_cnt
-
-	def test_cut_buf_vs_cut_stream_consistency_read(self, fastcdc_impl: FastCDCType, random_data_1m: bytes):
-		cdc = fastcdc_impl(avg_size=8192)
-		chunks_memory = list(cdc.cut_buf(random_data_1m))
-		bytes_io = io.BytesIO(random_data_1m)
-
-		class MyStream:
-			def read(self, n: int) -> bytes:
-				return bytes_io.read(n)
-
-		chunk_cnt = 0
-		for i, chunk in enumerate(cdc.cut_stream(MyStream())):
-			chunk_cnt += 1
-			assert chunk_cnt <= len(chunks_memory)
-			assert chunk.offset == chunks_memory[i].offset
-			assert chunk.length == chunks_memory[i].length
-			assert chunk.gear_hash == chunks_memory[i].gear_hash
-			assert bytes(chunk.data) == bytes(chunks_memory[i].data)
-		assert len(chunks_memory) == chunk_cnt
-
-	def test_cut_buf_vs_cut_stream_consistency_readinto(self, fastcdc_impl: FastCDCType, random_data_1m: bytes):
-		cdc = fastcdc_impl(avg_size=8192)
-		chunks_memory = list(cdc.cut_buf(random_data_1m))
-		bytes_io = io.BytesIO(random_data_1m)
-
-		class MyStream:
-			def readinto(self, buf) -> int:
-				return bytes_io.readinto(buf)
-
-		chunk_cnt = 0
-		for i, chunk in enumerate(cdc.cut_stream(MyStream())):
-			chunk_cnt += 1
-			assert chunk_cnt <= len(chunks_memory)
-			assert chunk.offset == chunks_memory[i].offset
-			assert chunk.length == chunks_memory[i].length
-			assert chunk.gear_hash == chunks_memory[i].gear_hash
-			assert bytes(chunk.data) == bytes(chunks_memory[i].data)
-		assert len(chunks_memory) == chunk_cnt
-
-
-class TestSeed:
-	def test_different_seeds_produce_different_chunks(self, random_data_1m: bytes):
-		cdc1 = FastCDC_cy(avg_size=8192, seed=1)
-		cdc2 = FastCDC_cy(avg_size=8192, seed=2)
-
-		chunks1 = list(cdc1.cut_buf(random_data_1m))
-		chunks2 = list(cdc2.cut_buf(random_data_1m))
-
-		hashes1 = [chunk.gear_hash for chunk in chunks1]
-		hashes2 = [chunk.gear_hash for chunk in chunks2]
-
-		assert hashes1 != hashes2 or len(chunks1) == 0
-
-
-class TestChunkProperties:
-	def test_chunk_data_integrity(self, fastcdc_instance, random_data_1m: bytes):
-		data_list = []
-		for chunk in fastcdc_instance.cut_buf(random_data_1m):
-			data_list.append(bytes(chunk.data))
-		assert b''.join(data_list) == random_data_1m
-
-	def test_chunk_size_constraints(self, fastcdc_impl: FastCDCType, random_data_1m: bytes):
-		avg_size = 16384
-		min_size = avg_size // 4  # 4096
-		max_size = avg_size * 4  # 65536
-
-		cdc = fastcdc_impl(avg_size=avg_size)
-		chunks = list(cdc.cut_buf(random_data_1m))
-
-		for chunk in chunks:
-			if chunk != chunks[-1]:
-				assert min_size <= chunk.length <= max_size
-
-
-
-def __build_test_data():
-	cases = TestSekienAkashitaImage.EXPECTED_RESULT
-	key = TestSekienAkashitaImage.Param
-	cases[key(16384, 0)] = [
-		(17968276318003433923, 21325),
-		(8197189939299398838, 17140),
-		(13019990849178155730, 28084),
-		(4509236223063678303, 18217),
-		(2504464741100432583, 24700),
-	]
-	cases[key(16384, 555, 0)] = [
-		(11912081672558759016, 65536),
-		(4429013657701329409, 15481),
-		(4617353815122521848, 25471),
-		(0, 2978),
-	]
-	cases[key(16384, 666, 1)] = [
-        (9312357714466240148, 10605),
-        (226910853333574584, 55745),
-        (12271755243986371352, 11346),
-        (14153975939352546047, 5883),
-        (5890158701071314778, 11586),
-        (8981594897574481255, 14301),
-	]
-	cases[key(16384, 777, 2)] = [
-		(5756766315125948951, 35163),
-		(17831515366867633926, 16422),
-		(3216207887329694204, 17470),
-		(1561632489531769228, 10294),
-		(10369060306646295092, 18786),
-		(14655496504067886486, 11331),
-	]
-	cases[key(16384, 888, 3)] = [
-		(3158156329559295338, 17507),
-		(5701878486563355731, 18589),
-		(4529013630687100674, 17996),
-		(3219799010358125664, 17281),
-		(9266722211030107244, 15987),
-		(7683217499559119532, 19292),
-		(0, 2814),
-	]
-	cases[key(32768, 0)] = [
-		(15733367461443853673, 66549),
-		(6321136627705800457, 42917),
-	]
-	cases[key(65536, 0)] = [
-		(2504464741100432583, 109466),
-	]
-	cases[key(1000, 0)] = [
-		(2890614758789387787, 359),
-		(4044080065227531274, 1501),
-		(9649269133818233035, 1087),
-		(2854337592871656094, 589),
-		(4465407710123297832, 1307),
-		(13038202513543136492, 944),
-		(221561130519947581, 847),
-		(393511086818658384, 268),
-		(8088160130455062548, 1492),
-		(9649269133818233035, 1087),
-		(2854337592871656094, 589),
-		(4465407710123297832, 1307),
-		(6977244030422521668, 951),
-		(14622491748227350624, 497),
-		(3757277802856017243, 4000),
-		(14582375164208481996, 525),
-		(15870580120602364088, 1122),
-		(17583755766661134474, 714),
-		(11818998251676538346, 267),
-		(4691013873021002775, 1135),
-		(17968276318003433923, 737),
-		(7923522120571464808, 1245),
-		(1606623465266480327, 1033),
-		(14432714177272874680, 274),
-		(9475721149199180143, 627),
-		(13127205120246874280, 1226),
-		(4571237624765828492, 840),
-		(13107907174429668598, 779),
-		(8865631699531232422, 256),
-		(12688194934178599784, 521),
-		(6160462813037351348, 1038),
-		(4590271154362536204, 1774),
-		(11432121548796343504, 674),
-		(12472017965383948508, 1114),
-		(11136788103843283336, 1086),
-		(14747293179156137189, 1135),
-		(4155943948347508955, 1575),
-		(13104072099671895560, 739),
-		(12639643500133003296, 978),
-		(6291550675693738136, 1014),
-		(12146666992319875138, 1754),
-		(867790609525255823, 823),
-		(7795831017548588040, 1197),
-		(6071878725246451920, 1128),
-		(9006935664263516606, 1230),
-		(10730962063819841566, 1243),
-		(13986533877452114082, 311),
-		(11213593662057882791, 1563),
-		(8419216051635751960, 2535),
-		(17824018122213720558, 649),
-		(7691821336090384658, 1058),
-		(15627606194869835864, 1006),
-		(6161241554519610597, 937),
-		(6941914075316668026, 399),
-		(1182793066038454380, 733),
-		(12071179740026769918, 1016),
-		(4347472036401076612, 1016),
-		(2230176819808087171, 1437),
-		(13643730949769321254, 970),
-		(11037552763304977452, 1497),
-		(5378144661922417606, 887),
-		(1077206070806454392, 474),
-		(15663206445926121842, 1020),
-		(10340633799421599932, 1189),
-		(10670100924980276327, 1005),
-		(17729339453970921664, 314),
-		(16991238872615146150, 790),
-		(6422874623524250261, 479),
-		(12672356704810770552, 442),
-		(11984928221549859605, 395),
-		(2097593348099185500, 491),
-		(14878246610844549137, 519),
-		(5632890640695056296, 698),
-		(234053196780936967, 485),
-		(6405742965701021702, 1168),
-		(10119588664293507636, 432),
-		(3677460465457318012, 1892),
-		(2929707338101168456, 1200),
-		(14759779960424595626, 492),
-		(8961005490888315294, 1076),
-		(7045320843275616092, 546),
-		(14573796348018082636, 613),
-		(5720125013745730749, 1003),
-		(9959758967528298632, 1240),
-		(5498194506803611575, 655),
-		(14533574346244646128, 685),
-		(2286118599908196562, 1132),
-		(12141987400064210298, 706),
-		(11697621655555146678, 262),
-		(4509236223063678303, 721),
-		(9379039799252626497, 1991),
-		(14161603951508589000, 1058),
-		(3798969362984554894, 1462),
-		(2208804812521734162, 1387),
-		(743230986619455593, 1117),
-		(10460176299449652894, 365),
-		(16295441167671743576, 426),
-		(12602762712196340732, 256),
-		(6892378923297184865, 815),
-		(2803535595082170474, 1100),
-		(12936956031161931870, 328),
-		(18083927691172312036, 703),
-		(17523284212269230251, 1225),
-		(12395604404862019884, 384),
-		(15603180924257441853, 991),
-		(10309388002691473494, 438),
-		(11759658943204820007, 1203),
-		(38352910123852128, 298),
-		(839329000209336340, 1032),
-		(17995146755519841483, 1323),
-		(11992699556916938274, 265),
-		(14564955722602338370, 1204),
-		(9433076059681066661, 269),
-		(4983236323095609658, 1054),
-		(3633433896241630446, 1351),
-		(1233903317720007796, 1725),
-		(15335462755167671769, 633),
-		(11585985329590265609, 297),
-	]
-	cases[key(4096, 123)] = [
-		(17640604251071308688, 5626),
-		(17640604251071308688, 6534),
-		(1164779717113740270, 5375),
-		(1630317330713120546, 2204),
-		(15925855439796383684, 7352),
-		(14038325076263464756, 4459),
-		(10372641652373760866, 2757),
-		(6632718265737316290, 4345),
-		(13547989595704043725, 13255),
-		(5085413808508269073, 6871),
-		(2088831145520463002, 1867),
-		(17282638805110740002, 7908),
-		(10392127899000403174, 4664),
-		(12682705380171701888, 3262),
-		(14163264652508939164, 4595),
-		(11317546923098927019, 10371),
-		(5442637979354971713, 5365),
-		(918741369407724947, 3523),
-		(11012502959421423036, 2886),
-		(16443206251033749990, 4470),
-		(18389377892984539132, 1777),
-	]
-	cases[key(3333, 456)] = [
-		(10244635572917292382, 5352),
-		(9863741455868196496, 3576),
-		(7958227187487219312, 11348),
-		(1568981245086988673, 4093),
-		(6960773682648885580, 3339),
-		(774338163733218710, 3524),
-		(8689733537919960031, 1741),
-		(227474149701075941, 1347),
-		(10343926834217379667, 2919),
-		(16005375745858244513, 3381),
-		(15597163692867778936, 2596),
-		(10144991532768329190, 1426),
-		(15692309460993287066, 2746),
-		(12579192060780867954, 876),
-		(15819814174051610080, 4398),
-		(9470794240134493114, 4224),
-		(1527989898970725766, 4315),
-		(17216215298576800968, 2680),
-		(2745509010730917144, 3990),
-		(11949739281024563184, 2157),
-		(8728826904842968300, 4092),
-		(11802567455667178519, 3547),
-		(16911338182963405550, 2591),
-		(5388599717664141562, 849),
-		(3598944074651431428, 4468),
-		(14136883845736820776, 6320),
-		(16089431095887575320, 2393),
-		(932034647479080538, 4950),
-		(1690856361285973629, 1591),
-		(1258510376350532739, 1315),
-		(12835826922199546104, 1612),
-		(1125375003867751948, 1729),
-		(6560578492574969505, 3981),
-	]
-	cases[key(7696, 789)] = [
-		(3635570818360047716, 7841),
-		(3361977302863881087, 12645),
-		(12589329716764299352, 7886),
-		(9249278391062916766, 8282),
-		(3136269063085371990, 2172),
-		(2076160877505623160, 3592),
-		(3919332495791756340, 7766),
-		(10241186054488990483, 5785),
-		(2179260573026396498, 5640),
-		(9176127053874656948, 4879),
-		(16197834508891865920, 8870),
-		(9292621146426491660, 8566),
-		(1003212569724862660, 6473),
-		(17552258689478972773, 3837),
-		(11098559764229607138, 8020),
-		(14721988269191742682, 2207),
-		(13044652610110219114, 5005),
-	]
-
-
-__build_test_data()