mapFolding 0.17.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

mapFolding/tests/test_e_measurements.py

@@ -0,0 +1,257 @@
+"""Tests for mapFolding._e._measure module.
+
+Tests verify each function against pre-computed verification data stored in
+dataSamples/measurementData.py. The verification data was independently validated
+using pure Python implementations without gmpy2 dependencies.
+
+Each function is tested across its valid input range (0-256 inclusive for most,
+2-256 for leafInSubHyperplane, 5-256 for ptount) and also tested for proper
+exception handling on invalid inputs.
+"""
+
+from mapFolding._e import (
+	dimensionNearestTail, dimensionNearest首, dimensionSecondNearest首, dimensionThirdNearest首,
+	howManyDimensionsHaveOddParity, leafInSubHyperplane, ptount)
+from mapFolding.tests.conftest import standardizedEqualToCallableReturn
+from mapFolding.tests.dataSamples.measurementData import (
+	dataDimensionNearest, dataDimensionSecondNearest, dataDimensionThirdNearest, dataHowMany0coordinatesAtTail,
+	dataHowManyDimensionsHaveOddParity, dataLeafInSubHyperplane, dataPtount)
+import pytest
+
+@pytest.fixture
+def dataMeasurementDimensionNearest() -> dict[int, int]:
+	"""Provide verification data for dimensionNearest首."""
+	return dataDimensionNearest
+
+@pytest.fixture
+def dataMeasurementDimensionSecondNearest() -> dict[int, int | None]:
+	"""Provide verification data for dimensionSecondNearest首."""
+	return dataDimensionSecondNearest
+
+@pytest.fixture
+def dataMeasurementDimensionThirdNearest() -> dict[int, int | None]:
+	"""Provide verification data for dimensionThirdNearest首."""
+	return dataDimensionThirdNearest
+
+@pytest.fixture
+def dataMeasurementLeafInSubHyperplane() -> dict[int, int]:
+	"""Provide verification data for leafInSubHyperplane."""
+	return dataLeafInSubHyperplane
+
+@pytest.fixture
+def dataMeasurementHowMany0coordinatesAtTail() -> dict[int, int]:
+	"""Provide verification data for howMany0coordinatesAtTail."""
+	return dataHowMany0coordinatesAtTail
+
+@pytest.fixture
+def dataMeasurementHowManyDimensionsHaveOddParity() -> dict[int, int]:
+	"""Provide verification data for howManyDimensionsHaveOddParity."""
+	return dataHowManyDimensionsHaveOddParity
+
+@pytest.fixture
+def dataMeasurementPtount() -> dict[int, int]:
+	"""Provide verification data for ptount."""
+	return dataPtount
+
+class TestDimensionNearest:
+	"""Tests for dimensionNearest首: finds 0-indexed position of MSB."""
+
+	@pytest.mark.parametrize(
+		"inputValue,expectedResult",
+		[
+			(inputValue, expectedResult)
+			for inputValue, expectedResult in dataDimensionNearest.items()
+		],
+		ids=[f"n={inputValue}" for inputValue in dataDimensionNearest],
+	)
+	def test_dimensionNearest_validInputs(
+		self,
+		inputValue: int,
+		expectedResult: int,
+	) -> None:
+		standardizedEqualToCallableReturn(expectedResult, dimensionNearest首, inputValue)
+
+	@pytest.mark.parametrize(
+		"invalidInput",
+		[-1, -7, -13, -256],
+		ids=["n=-1", "n=-7", "n=-13", "n=-256"],
+	)
+	def test_dimensionNearest_negativeInputsRaiseValueError(
+		self,
+		invalidInput: int,
+	) -> None:
+		standardizedEqualToCallableReturn(ValueError, dimensionNearest首, invalidInput)
+
+class TestDimensionSecondNearest:
+	"""Tests for dimensionSecondNearest首: finds 0-indexed position of second MSB."""
+
+	@pytest.mark.parametrize(
+		"inputValue,expectedResult",
+		[
+			(inputValue, expectedResult)
+			for inputValue, expectedResult in dataDimensionSecondNearest.items()
+		],
+		ids=[f"n={inputValue}" for inputValue in dataDimensionSecondNearest],
+	)
+	def test_dimensionSecondNearest_validInputs(
+		self,
+		inputValue: int,
+		expectedResult: int | None,
+	) -> None:
+		standardizedEqualToCallableReturn(expectedResult, dimensionSecondNearest首, inputValue)
+
+	@pytest.mark.parametrize(
+		"invalidInput",
+		[-1, -5, -11, -128],
+		ids=["n=-1", "n=-5", "n=-11", "n=-128"],
+	)
+	def test_dimensionSecondNearest_negativeInputsRaiseValueError(
+		self,
+		invalidInput: int,
+	) -> None:
+		standardizedEqualToCallableReturn(ValueError, dimensionSecondNearest首, invalidInput)
+
+class TestDimensionThirdNearest:
+	"""Tests for dimensionThirdNearest首: finds 0-indexed position of third MSB."""
+
+	@pytest.mark.parametrize(
+		"inputValue,expectedResult",
+		[
+			(inputValue, expectedResult)
+			for inputValue, expectedResult in dataDimensionThirdNearest.items()
+		],
+		ids=[f"n={inputValue}" for inputValue in dataDimensionThirdNearest],
+	)
+	def test_dimensionThirdNearest_validInputs(
+		self,
+		inputValue: int,
+		expectedResult: int | None,
+	) -> None:
+		standardizedEqualToCallableReturn(expectedResult, dimensionThirdNearest首, inputValue)
+
+	@pytest.mark.parametrize(
+		"invalidInput",
+		[-1, -3, -17, -64],
+		ids=["n=-1", "n=-3", "n=-17", "n=-64"],
+	)
+	def test_dimensionThirdNearest_negativeInputsRaiseValueError(
+		self,
+		invalidInput: int,
+	) -> None:
+		standardizedEqualToCallableReturn(ValueError, dimensionThirdNearest首, invalidInput)
+
+class TestLeafInSubHyperplane:
+	"""Tests for leafInSubHyperplane: projects hyperplane leaf onto sub-hyperplane."""
+
+	@pytest.mark.parametrize(
+		"inputValue,expectedResult",
+		[
+			(inputValue, expectedResult)
+			for inputValue, expectedResult in dataLeafInSubHyperplane.items()
+		],
+		ids=[f"n={inputValue}" for inputValue in dataLeafInSubHyperplane],
+	)
+	def test_leafInSubHyperplane_validInputs(
+		self,
+		inputValue: int,
+		expectedResult: int,
+	) -> None:
+		standardizedEqualToCallableReturn(expectedResult, leafInSubHyperplane, inputValue)
+
+	@pytest.mark.parametrize(
+		"invalidInput",
+		[0, -1, -7, -19],
+		ids=["n=0", "n=-1", "n=-7", "n=-19"],
+	)
+	def test_leafInSubHyperplane_invalidInputsRaiseValueError(
+		self,
+		invalidInput: int,
+	) -> None:
+		standardizedEqualToCallableReturn(ValueError, leafInSubHyperplane, invalidInput)
+
+class TestHowMany0coordinatesAtTail:
+	"""Tests for howMany0coordinatesAtTail: counts trailing zeros (CTZ)."""
+
+	@pytest.mark.parametrize(
+		"inputValue,expectedResult",
+		[
+			(inputValue, expectedResult)
+			for inputValue, expectedResult in dataHowMany0coordinatesAtTail.items()
+		],
+		ids=[f"n={inputValue}" for inputValue in dataHowMany0coordinatesAtTail],
+	)
+	def test_howMany0coordinatesAtTail_validInputs(
+		self,
+		inputValue: int,
+		expectedResult: int,
+	) -> None:
+		standardizedEqualToCallableReturn(expectedResult, dimensionNearestTail, inputValue)
+
+	@pytest.mark.parametrize(
+		"invalidInput",
+		[-1, -2, -8, -37],
+		ids=["n=-1", "n=-2", "n=-8", "n=-37"],
+	)
+	def test_howMany0coordinatesAtTail_negativeInputsRaiseValueError(
+		self,
+		invalidInput: int,
+	) -> None:
+		standardizedEqualToCallableReturn(ValueError, dimensionNearestTail, invalidInput)
+
+class TestHowManyDimensionsHaveOddParity:
+	"""Tests for howManyDimensionsHaveOddParity: bit_count - 1, minimum 0."""
+
+	@pytest.mark.parametrize(
+		"inputValue,expectedResult",
+		[
+			(inputValue, expectedResult)
+			for inputValue, expectedResult in dataHowManyDimensionsHaveOddParity.items()
+		],
+		ids=[f"n={inputValue}" for inputValue in dataHowManyDimensionsHaveOddParity],
+	)
+	def test_howManyDimensionsHaveOddParity_validInputs(
+		self,
+		inputValue: int,
+		expectedResult: int,
+	) -> None:
+		standardizedEqualToCallableReturn(expectedResult, howManyDimensionsHaveOddParity, inputValue)
+
+	@pytest.mark.parametrize(
+		"invalidInput",
+		[-1, -5, -23, -89],
+		ids=["n=-1", "n=-5", "n=-23", "n=-89"],
+	)
+	def test_howManyDimensionsHaveOddParity_negativeInputsRaiseValueError(
+		self,
+		invalidInput: int,
+	) -> None:
+		standardizedEqualToCallableReturn(ValueError, howManyDimensionsHaveOddParity, invalidInput)
+
+class TestPtount:
+	"""Tests for ptount: measures distance from power of two's bit count after subtracting 3."""
+
+	@pytest.mark.parametrize(
+		"inputValue,expectedResult",
+		[
+			(inputValue, expectedResult)
+			for inputValue, expectedResult in dataPtount.items()
+		],
+		ids=[f"n={inputValue}" for inputValue in dataPtount],
+	)
+	def test_ptount_validInputs(
+		self,
+		inputValue: int,
+		expectedResult: int,
+	) -> None:
+		standardizedEqualToCallableReturn(expectedResult, ptount, inputValue)
+
+	@pytest.mark.parametrize(
+		"invalidInput",
+		[0, 1, 2, -1, -7, -41],
+		ids=["n=0", "n=1", "n=2", "n=-1", "n=-7", "n=-41"],
+	)
+	def test_ptount_invalidInputsRaiseValueError(
+		self,
+		invalidInput: int,
+	) -> None:
+		standardizedEqualToCallableReturn(ValueError, ptount, invalidInput)

mapFolding/tests/test_e_pinning.py

@@ -0,0 +1,61 @@
+from collections.abc import Callable
+from gmpy2 import xmpz
+from mapFolding._e.dataBaskets import EliminationState
+from mapFolding._e.filters import extractPinnedLeaves
+from mapFolding._e.pin2上nDimensions import (
+	pinLeavesDimension一, pinLeavesDimension二, pinLeavesDimension首二, pinPilesAtEnds)
+from numpy.typing import NDArray
+import numpy
+import pytest
+
+@pytest.mark.parametrize("dimensionsTotal", [5, 6], ids=lambda dimensionsTotal: f"2d{dimensionsTotal}")
+@pytest.mark.parametrize("pinningFunction", [pinPilesAtEnds, pinLeavesDimension一, pinLeavesDimension二, pinLeavesDimension首二], ids=lambda pinningFunction: pinningFunction.__name__)
+def test_pinningFunctions(loadArrayFoldings: Callable[[int], NDArray[numpy.uint8]], pinningFunction: Callable[[EliminationState], EliminationState], dimensionsTotal: int) -> None:
+	mapShape: tuple[int, ...] = (2,) * dimensionsTotal
+	state: EliminationState = EliminationState(mapShape=mapShape)
+	arrayFoldings: NDArray[numpy.uint8] = loadArrayFoldings(dimensionsTotal)
+
+	state = pinningFunction(state)
+	functionName: str = getattr(pinningFunction, "__name__", pinningFunction.__class__.__name__)
+
+	rowsTotal: int = int(arrayFoldings.shape[0])
+	listRowMasks: list[numpy.ndarray] = []
+
+	for permutationSpace in state.listPermutationSpace:
+		maskRowsMatchThisDictionary: numpy.ndarray = numpy.ones(rowsTotal, dtype=bool)
+		for pile, leafOrPileRangeOfLeaves in extractPinnedLeaves(permutationSpace).items():
+			if isinstance(leafOrPileRangeOfLeaves, int):
+				maskRowsMatchThisDictionary = maskRowsMatchThisDictionary & (arrayFoldings[:, pile] == leafOrPileRangeOfLeaves)
+				continue
+			if isinstance(leafOrPileRangeOfLeaves, xmpz):
+				allowedLeaves: numpy.ndarray = numpy.fromiter(
+					(bool(leafOrPileRangeOfLeaves[leaf]) for leaf in range(state.leavesTotal)),
+					dtype=bool,
+					count=state.leavesTotal,
+				)
+				maskRowsMatchThisDictionary = maskRowsMatchThisDictionary & allowedLeaves[arrayFoldings[:, pile]]
+		listRowMasks.append(maskRowsMatchThisDictionary)
+
+	masksStacked: numpy.ndarray = numpy.column_stack(listRowMasks)
+	coverageCountPerRow: numpy.ndarray = masksStacked.sum(axis=1)
+	indicesOverlappedRows: numpy.ndarray = numpy.nonzero(coverageCountPerRow >= 2)[0]
+
+	countOverlappingDictionaries: int = 0
+	if indicesOverlappedRows.size > 0:
+		for maskRowsMatchThisDictionary in listRowMasks:
+			if bool(maskRowsMatchThisDictionary[indicesOverlappedRows].any()):
+				countOverlappingDictionaries += 1
+
+	maskUnion: numpy.ndarray = numpy.logical_or.reduce(listRowMasks)
+	rowsCovered: int = int(maskUnion.sum())
+
+	assert rowsCovered == rowsTotal, (
+		f"{functionName} expected rowsCovered == rowsTotal for {mapShape = }, "
+		f"got rowsCovered={rowsCovered}, rowsTotal={rowsTotal}."
+	)
+	assert countOverlappingDictionaries == 0, (
+		f"{functionName} expected no overlapping dictionaries for {mapShape = }, "
+		f"got countOverlappingDictionaries={countOverlappingDictionaries}."
+	)
+
+

mapFolding/tests/test_e_semiotics.py

@@ -0,0 +1,128 @@
+"""Tests for mapFolding/_semiotics.py and mapFolding/_e/_semiotics.py."""
+
+from mapFolding import decreasing, inclusive
+from mapFolding._e import (
+	leafOrigin, pileOrigin, 一, 七, 三, 九, 二, 五, 八, 六, 四, 零, 首一, 首一三, 首一二, 首一二三, 首三, 首二, 首二三, 首零, 首零一, 首零一三, 首零一二, 首零一二三, 首零三,
+	首零二, 首零二三)
+from mapFolding.tests.dataSamples.semioticsData import (
+	expectedDecreasing, expectedInclusive, expectedLeafOrigin, expectedPileOrigin, expected一, expected七, expected三,
+	expected九, expected二, expected五, expected八, expected六, expected四, expected零, expected首一, expected首一三, expected首一二,
+	expected首一二三, expected首三, expected首二, expected首二三, expected首零, expected首零一, expected首零一三, expected首零一二, expected首零一二三,
+	expected首零三, expected首零二, expected首零二三)
+import pytest
+
+class TestSemioticsConstants:
+	"""Tests for constant values in mapFolding/_semiotics.py."""
+
+	@pytest.mark.parametrize("actual, expected", [
+		(decreasing, expectedDecreasing),
+		(inclusive, expectedInclusive),
+	])
+	def test_semanticReplacements(self, actual: int, expected: int) -> None:
+		assert actual == expected, f"Expected {expected}, got {actual}"
+
+class TestDimensionIndexConstants:
+	"""Tests for dimension index constants (powers of 2) in mapFolding/_e/_semiotics.py."""
+
+	@pytest.mark.parametrize("actual, expected, identifier", [
+		(零, expected零, "零"),
+		(一, expected一, "一"),
+		(二, expected二, "二"),
+		(三, expected三, "三"),
+		(四, expected四, "四"),
+		(五, expected五, "五"),
+		(六, expected六, "六"),
+		(七, expected七, "七"),
+		(八, expected八, "八"),
+		(九, expected九, "九"),
+	])
+	def test_dimensionIndexPowersOfTwo(self, actual: int, expected: int, identifier: str) -> None:
+		assert actual == expected, f"Expected {identifier} = {expected}, got {actual}"
+
+class TestOriginConstants:
+	"""Tests for origin constants in mapFolding/_e/_semiotics.py."""
+
+	@pytest.mark.parametrize("actual, expected, identifier", [
+		(leafOrigin, expectedLeafOrigin, "leafOrigin"),
+		(pileOrigin, expectedPileOrigin, "pileOrigin"),
+	])
+	def test_originConstants(self, actual: int, expected: int, identifier: str) -> None:
+		assert actual == expected, f"Expected {identifier} = {expected}, got {actual}"
+
+class TestDimensionCoordinateFunctions:
+	"""Tests for cached functions that encode dimension coordinates."""
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首零)
+	def test_shouLing(self, dimensionsTotal: int, expected: int) -> None:
+		actual: int = 首零(dimensionsTotal)
+		assert actual == expected, f"首零({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首零一)
+	def test_shouLingYi(self, dimensionsTotal: int, expected: int) -> None:
+		actual: int = 首零一(dimensionsTotal)
+		assert actual == expected, f"首零一({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首零一二)
+	def test_shouLingYiEr(self, dimensionsTotal: int, expected: int) -> None:
+		actual: int = 首零一二(dimensionsTotal)
+		assert actual == expected, f"首零一二({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首零二)
+	def test_shouLingEr(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首零二(dimensionsTotal)
+		assert actual == expected, f"首零二({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首一)
+	def test_shouYi(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首一(dimensionsTotal)
+		assert actual == expected, f"首一({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首一二)
+	def test_shouYiEr(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首一二(dimensionsTotal)
+		assert actual == expected, f"首一二({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首二)
+	def test_shouEr(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首二(dimensionsTotal)
+		assert actual == expected, f"首二({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首三)
+	def test_shouSan(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首三(dimensionsTotal)
+		assert actual == expected, f"首三({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首零一二三)
+	def test_shouLingYiErSan(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首零一二三(dimensionsTotal)
+		assert actual == expected, f"首零一二三({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首零一三)
+	def test_shouLingYiSan(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首零一三(dimensionsTotal)
+		assert actual == expected, f"首零一三({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首零二三)
+	def test_shouLingErSan(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首零二三(dimensionsTotal)
+		assert actual == expected, f"首零二三({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首零三)
+	def test_shouLingSan(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首零三(dimensionsTotal)
+		assert actual == expected, f"首零三({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首一二三)
+	def test_shouYiErSan(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首一二三(dimensionsTotal)
+		assert actual == expected, f"首一二三({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首一三)
+	def test_shouYiSan(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首一三(dimensionsTotal)
+		assert actual == expected, f"首一三({dimensionsTotal}): expected {expected}, got {actual}"
+
+	@pytest.mark.parametrize("dimensionsTotal, expected", expected首二三)
+	def test_shouErSan(self, dimensionsTotal: int, expected: int) -> None:
+		actual = 首二三(dimensionsTotal)
+		assert actual == expected, f"首二三({dimensionsTotal}): expected {expected}, got {actual}"

mapFolding/tests/test_filesystem.py

@@ -21,20 +21,21 @@ stores computational results or adding new file formats.
 
 from contextlib import redirect_stdout
 from mapFolding import (
-	getFilenameFoldsTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, saveFoldsTotal, validateListDimensions)
+	dictionaryOEISMapFolding, getFilenameFoldsTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, saveFoldsTotal,
+	validateListDimensions)
 from pathlib import Path
 import io
 import pytest
 import unittest.mock
 
-def test_saveFoldsTotal_fallback(path_tmpTesting: Path) -> None:
-	foldsTotal = 123
-	pathFilename = path_tmpTesting / "foldsTotal.txt"
+@pytest.mark.parametrize("foldsTotal", [pytest.param(123, id="foldsTotal-123")])
+def test_saveFoldsTotal_fallback(path_tmpTesting: Path, foldsTotal: int) -> None:
+	pathFilename: Path = path_tmpTesting / "foldsTotal.txt"
 	with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")), unittest.mock.patch("os.getcwd", return_value=str(path_tmpTesting)):
-		capturedOutput = io.StringIO()
+		capturedOutput: io.StringIO = io.StringIO()
 		with redirect_stdout(capturedOutput):
 			saveFoldsTotal(pathFilename, foldsTotal)
-	fallbackFiles = list(path_tmpTesting.glob("foldsTotalYO_*.txt"))
+	fallbackFiles: list[Path] = list(path_tmpTesting.glob("foldsTotalYO_*.txt"))
 	assert len(fallbackFiles) == 1, "Fallback file was not created upon write failure."
 
 @pytest.mark.parametrize("listDimensions, expectedFilename", [
@@ -43,27 +44,48 @@ def test_saveFoldsTotal_fallback(path_tmpTesting: Path) -> None:
 ])
 def test_getFilenameFoldsTotal(listDimensions: list[int], expectedFilename: str) -> None:
 	"""Test that getFilenameFoldsTotal generates correct filenames with dimensions sorted."""
-	mapShape = validateListDimensions(listDimensions)
-	filenameActual = getFilenameFoldsTotal(mapShape)
+	mapShape: tuple[int, ...] = validateListDimensions(listDimensions)
+	filenameActual: str = getFilenameFoldsTotal(mapShape)
 	assert filenameActual == expectedFilename, f"Expected filename {expectedFilename} but got {filenameActual}"
 
-def test_getPathFilenameFoldsTotal_defaultPath(mapShapeTestFunctionality: tuple[int, ...]) -> None:
+@pytest.mark.parametrize(
+	"mapShape",
+	[
+		pytest.param(dictionaryOEISMapFolding["A000136"]["getMapShape"](3), id="A000136::n3"),
+		pytest.param(dictionaryOEISMapFolding["A001415"]["getMapShape"](3), id="A001415::n3"),
+	],
+)
+def test_getPathFilenameFoldsTotal_defaultPath(mapShape: tuple[int, ...]) -> None:
 	"""Test getPathFilenameFoldsTotal with default path."""
-	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality)
+	pathFilenameFoldsTotal: Path = getPathFilenameFoldsTotal(mapShape)
 	assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
-	assert pathFilenameFoldsTotal.name == getFilenameFoldsTotal(mapShapeTestFunctionality), "Filename should match getFilenameFoldsTotal output"
+	assert pathFilenameFoldsTotal.name == getFilenameFoldsTotal(mapShape), "Filename should match getFilenameFoldsTotal output"
 	assert pathFilenameFoldsTotal.parent == getPathRootJobDEFAULT(), "Parent directory should match default job root"
 
-def test_getPathFilenameFoldsTotal_relativeFilename(mapShapeTestFunctionality: tuple[int, ...]) -> None:
+@pytest.mark.parametrize(
+	"mapShape",
+	[
+		pytest.param(dictionaryOEISMapFolding["A000136"]["getMapShape"](3), id="A000136::n3"),
+		pytest.param(dictionaryOEISMapFolding["A001415"]["getMapShape"](3), id="A001415::n3"),
+	],
+)
+def test_getPathFilenameFoldsTotal_relativeFilename(mapShape: tuple[int, ...]) -> None:
 	"""Test getPathFilenameFoldsTotal with relative filename."""
-	relativeFilename = Path("custom/path/test.foldsTotal")
-	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, relativeFilename)
+	relativeFilename: Path = Path("custom/path/test.foldsTotal")
+	pathFilenameFoldsTotal: Path = getPathFilenameFoldsTotal(mapShape, relativeFilename)
 	assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
 	assert pathFilenameFoldsTotal == getPathRootJobDEFAULT() / relativeFilename, "Relative path should be appended to default job root"
 
-def test_getPathFilenameFoldsTotal_createsDirs(path_tmpTesting: Path, mapShapeTestFunctionality: tuple[int, ...]) -> None:
+@pytest.mark.parametrize(
+	"mapShape",
+	[
+		pytest.param(dictionaryOEISMapFolding["A000136"]["getMapShape"](3), id="A000136::n3"),
+		pytest.param(dictionaryOEISMapFolding["A001415"]["getMapShape"](3), id="A001415::n3"),
+	],
+)
+def test_getPathFilenameFoldsTotal_createsDirs(path_tmpTesting: Path, mapShape: tuple[int, ...]) -> None:
 	"""Test that getPathFilenameFoldsTotal creates necessary directories."""
-	nestedPath = path_tmpTesting / "deep/nested/structure"
-	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, nestedPath)
+	nestedPath: Path = path_tmpTesting / "deep/nested/structure"
+	pathFilenameFoldsTotal: Path = getPathFilenameFoldsTotal(mapShape, nestedPath)
 	assert pathFilenameFoldsTotal.parent.exists(), "Parent directories should be created"
 	assert pathFilenameFoldsTotal.parent.is_dir(), "Created path should be a directory"

mapFolding/tests/{test_other.py → test_parameterValidation.py}

@@ -26,9 +26,9 @@ dependencies while maintaining clear separation of concerns.
 """
 
 from collections.abc import Callable
-from hunterMakesPy import intInnit
+from hunterMakesPy.parseParameters import intInnit
 from hunterMakesPy.pytestForYourUse import PytestFor_intInnit, PytestFor_oopsieKwargsie
-from mapFolding import getLeavesTotal, setProcessorLimit, validateListDimensions
+from mapFolding import defineProcessorLimit, getLeavesTotal, validateListDimensions
 from mapFolding.tests.conftest import standardizedEqualToCallableReturn
 from typing import Any, Literal
 import multiprocessing
@@ -100,4 +100,4 @@ def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> N
 ])
 def test_setCPUlimitNumba(CPUlimit: Literal[4, -2, 0, 1] | None | float | bool, expectedLimit: Any | int) -> None:
 	numba.set_num_threads(multiprocessing.cpu_count())
-	standardizedEqualToCallableReturn(expectedLimit, setProcessorLimit, CPUlimit, 'numba')
+	standardizedEqualToCallableReturn(expectedLimit, defineProcessorLimit, CPUlimit, 'numba')

mapFolding/tests/{test_tasks.py → test_taskDivisions.py}

@@ -21,37 +21,51 @@ For users working with large-scale computations: these tests demonstrate how to
 configure and validate parallel processing setups. The concurrency limit tests
 show how to balance performance with system resource constraints.
 
-The multiprocessing configuration (spawn method) is essential for cross-platform
-compatibility and proper resource isolation between test processes.
 """
 
 from collections.abc import Callable
 from hunterMakesPy.pytestForYourUse import PytestFor_defineConcurrencyLimit
 from mapFolding import (
-	countFolds, getFoldsTotalKnown, getLeavesTotal, getTaskDivisions, setProcessorLimit, validateListDimensions)
+	defineProcessorLimit, dictionaryOEISMapFolding, getFoldsTotalKnown, getLeavesTotal, getTaskDivisions,
+	validateListDimensions)
+from mapFolding.basecamp import countFolds
 from mapFolding.tests.conftest import standardizedEqualToCallableReturn
 from typing import Literal
-import multiprocessing
 import pytest
 
-# When to use multiprocessing.set_start_method
-# https://github.com/hunterhogan/mapFolding/issues/6
-if __name__ == '__main__':
-	multiprocessing.set_start_method('spawn')
+@pytest.mark.parametrize(
+	"mapShape",
+	[
+		pytest.param(dictionaryOEISMapFolding["A000136"]["getMapShape"](3), id="A000136::n3"),
+		pytest.param(dictionaryOEISMapFolding["A001415"]["getMapShape"](3), id="A001415::n3"),
+	],
+)
+def test_countFoldsComputationDivisionsInvalid(mapShape: tuple[int, ...]) -> None:
+	standardizedEqualToCallableReturn(ValueError, countFolds, mapShape, None, {"wrong": "value"})
 
-def test_countFoldsComputationDivisionsInvalid(mapShapeTestFunctionality: tuple[int, ...]) -> None:
-	standardizedEqualToCallableReturn(ValueError, countFolds, mapShapeTestFunctionality, None, {"wrong": "value"})
-
-def test_countFoldsComputationDivisionsMaximum(mapShapeTestParallelization: list[int]) -> None:
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(mapShapeTestParallelization)), countFolds, mapShapeTestParallelization, None, 'maximum', None)
+@pytest.mark.parametrize(
+	"mapShapeList",
+	[
+		pytest.param(list(dictionaryOEISMapFolding["A001417"]["getMapShape"](5)), id="A001417::n5"),
+	],
+)
+def test_countFoldsComputationDivisionsMaximum(mapShapeList: list[int]) -> None:
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(mapShapeList)), countFolds, mapShapeList, None, 'maximum', None)
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
 def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
 	callablePytest()
 
+@pytest.mark.parametrize(
+	"mapShape",
+	[
+		pytest.param(dictionaryOEISMapFolding["A000136"]["getMapShape"](3), id="A000136::n3"),
+		pytest.param(dictionaryOEISMapFolding["A001415"]["getMapShape"](3), id="A001415::n3"),
+	],
+)
 @pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
-def test_countFolds_cpuLimitOopsie(mapShapeTestFunctionality: tuple[int, ...], CPUlimitParameter: dict[str, bool] | list[str]) -> None:
-	standardizedEqualToCallableReturn(ValueError, countFolds, mapShapeTestFunctionality, None, 'cpu', CPUlimitParameter)
+def test_countFolds_cpuLimitOopsie(mapShape: tuple[int, ...], CPUlimitParameter: dict[str, bool] | list[str]) -> None:
+	standardizedEqualToCallableReturn(ValueError, countFolds, mapShape, None, 'cpu', CPUlimitParameter)
 
 @pytest.mark.parametrize("computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions", [
 	(None, 4, [9, 11], 0),
@@ -60,12 +74,14 @@ def test_countFolds_cpuLimitOopsie(mapShapeTestFunctionality: tuple[int, ...], C
 	(["invalid"], 4, [19, 23], ValueError),
 	(20, 4, [3,5], ValueError)
 ])
-def test_getTaskDivisions(computationDivisions: Literal['maximum', 'cpu', 20] | None | list[str]
-						, concurrencyLimit: Literal[4]
-						, listDimensions: list[int]
-						, expectedTaskDivisions: Literal[0, 77, 4] | type[ValueError]) -> None:
-	mapShape = validateListDimensions(listDimensions)
-	leavesTotal = getLeavesTotal(mapShape)
+def test_getTaskDivisions(
+	computationDivisions: Literal['maximum', 'cpu', 20] | None | list[str],
+	concurrencyLimit: Literal[4],
+	listDimensions: list[int],
+	expectedTaskDivisions: int | type[ValueError]
+) -> None:
+	mapShape: tuple[int, ...] = validateListDimensions(listDimensions)
+	leavesTotal: int = getLeavesTotal(mapShape)
 	standardizedEqualToCallableReturn(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, leavesTotal)
 
 @pytest.mark.parametrize("expected,parameter", [
@@ -74,6 +90,9 @@ def test_getTaskDivisions(computationDivisions: Literal['maximum', 'cpu', 20] |
 	(ValueError, {2}),  # set
 	(ValueError, {"cores": 2}),  # dict
 ])
-def test_setCPUlimitMalformedParameter(expected: type[ValueError] | Literal[2], parameter: list[int] | tuple[int] | set[int] | dict[str, int] | Literal['2']) -> None:
+def test_setCPUlimitMalformedParameter(
+	expected: type[ValueError] | Literal[2],
+	parameter: list[int] | tuple[int, ...] | set[int] | dict[str, int] | Literal['2']
+) -> None:
 	"""Test that invalid CPUlimit types are properly handled."""
-	standardizedEqualToCallableReturn(expected, setProcessorLimit, parameter)
+	standardizedEqualToCallableReturn(expected, defineProcessorLimit, parameter)

mapFolding/zCuzDocStoopid/makeDocstrings.py

@@ -1,12 +1,13 @@
 """Make docstrings."""
 from astToolkit import Grab, IfThis, Make, NodeChanger, parsePathFilename2astModule, Then
 from astToolkit.transformationTools import makeDictionaryFunctionDef
-from hunterMakesPy import raiseIfNone, writeStringToHere
+from hunterMakesPy import raiseIfNone
+from hunterMakesPy.filesystemToolkit import writeStringToHere
 from mapFolding import dictionaryOEIS, dictionaryOEISMapFolding, packageSettings
 from pathlib import Path
 import ast
 
-# ----------------- General Settings ----------------------------------------------------------------------------------
+#------------------ General Settings ----------------------------------------------------------------------------------
 sourcePrefix: str = 'zCuzDocStoopid'
 
 moduleWarning = "NOTE: This is a generated file; edit the source file."