mapFolding 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

tests/conftest.py

@@ -0,0 +1,278 @@
+from collections.abc import Callable, Generator, Sequence
+from mapFolding.theSSOT import getAlgorithmDispatcher, getSourceAlgorithm, getPackageDispatcher, theModuleOfSyntheticModules, FREAKOUT
+from mapFolding.beDRY import getLeavesTotal, validateListDimensions, makeDataContainer
+from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
+from pathlib import Path
+from typing import Any, ContextManager
+import importlib.util
+import pytest
+import random
+import shutil
+import unittest.mock
+import uuid
+# TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
+
+# SSOT for test data paths and filenames
+pathDataSamples = Path("tests/dataSamples")
+# NOTE `tmp` is not a diminutive form of temporary: it signals a technical term. And "temp" is strongly disfavored.
+pathTmpRoot: Path = pathDataSamples / "tmp"
+
+# The registrar maintains the register of temp files
+registerOfTemporaryFilesystemObjects: set[Path] = set()
+
+def registrarRecordsTmpObject(path: Path) -> None:
+	"""The registrar adds a tmp file to the register."""
+	registerOfTemporaryFilesystemObjects.add(path)
+
+def registrarDeletesTmpObjects() -> None:
+	"""The registrar cleans up tmp files in the register."""
+	for pathTmp in sorted(registerOfTemporaryFilesystemObjects, reverse=True):
+		try:
+			if pathTmp.is_file():
+				pathTmp.unlink(missing_ok=True)
+			elif pathTmp.is_dir():
+				shutil.rmtree(pathTmp, ignore_errors=True)
+		except Exception as ERRORmessage:
+			print(f"Warning: Failed to clean up {pathTmp}: {ERRORmessage}")
+	registerOfTemporaryFilesystemObjects.clear()
+
+@pytest.fixture(scope="session", autouse=True)
+def setupTeardownTmpObjects() -> Generator[None, None, None]:
+	"""Auto-fixture to setup test data directories and cleanup after."""
+	pathDataSamples.mkdir(exist_ok=True)
+	pathTmpRoot.mkdir(exist_ok=True)
+	yield
+	registrarDeletesTmpObjects()
+
+@pytest.fixture
+def pathTmpTesting(request: pytest.FixtureRequest) -> Path:
+	# "Z0Z_" ensures the directory name does not start with a number, which would make it an invalid Python identifier
+	pathTmp = pathTmpRoot / ("Z0Z_" + str(uuid.uuid4().hex))
+	pathTmp.mkdir(parents=True, exist_ok=False)
+
+	registrarRecordsTmpObject(pathTmp)
+	return pathTmp
+
+@pytest.fixture
+def pathFilenameTmpTesting(request: pytest.FixtureRequest) -> Path:
+	try:
+		extension = request.param
+	except AttributeError:
+		extension = ".txt"
+
+	# "Z0Z_" ensures the name does not start with a number, which would make it an invalid Python identifier
+	uuidHex = uuid.uuid4().hex
+	subpath = "Z0Z_" + uuidHex[0:-8]
+	filenameStem = "Z0Z_" + uuidHex[-8:None]
+
+	pathFilenameTmp = Path(pathTmpRoot, subpath, filenameStem + extension)
+	pathFilenameTmp.parent.mkdir(parents=True, exist_ok=False)
+
+	registrarRecordsTmpObject(pathFilenameTmp)
+	return pathFilenameTmp
+
+@pytest.fixture
+def pathCacheTesting(pathTmpTesting: Path) -> Generator[Path, Any, None]:
+	"""Temporarily replace the OEIS cache directory with a test directory."""
+	import mapFolding.oeis as oeis
+	pathCacheOriginal = oeis.pathCache
+	oeis.pathCache = pathTmpTesting
+	yield pathTmpTesting
+	oeis.pathCache = pathCacheOriginal
+
+@pytest.fixture
+def pathFilenameFoldsTotalTesting(pathTmpTesting: Path) -> Path:
+	return pathTmpTesting.joinpath("foldsTotalTest.txt")
+
+"""
+Section: Fixtures"""
+
+@pytest.fixture(autouse=True)
+def setupWarningsAsErrors() -> Generator[None, Any, None]:
+	"""Convert all warnings to errors for all tests."""
+	import warnings
+	warnings.filterwarnings("error")
+	yield
+	warnings.resetwarnings()
+
+@pytest.fixture
+def listDimensionsTestCountFolds(oeisID: str):
+	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation`
+	if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts."""
+	while True:
+		n = random.choice(settingsOEIS[oeisID]['valuesTestValidation'])
+		if n < 2:
+			continue
+		listDimensionsCandidate = list(settingsOEIS[oeisID]['getMapShape'](n))
+
+		try:
+			return validateListDimensions(listDimensionsCandidate)
+		except (ValueError, NotImplementedError):
+			pass
+
+@pytest.fixture
+def mapShapeTestFunctionality(oeisID_1random: str):
+	"""To test functionality, get one `listDimensions` from `valuesTestValidation` if
+	`validateListDimensions` approves. The algorithm can count the folds of the returned
+	`listDimensions` in a short enough time suitable for testing."""
+	while True:
+		n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
+		if n < 2:
+			continue
+		listDimensionsCandidate = list(settingsOEIS[oeisID_1random]['getMapShape'](n))
+
+		try:
+			return validateListDimensions(listDimensionsCandidate)
+		except (ValueError, NotImplementedError):
+			pass
+
+@pytest.fixture
+def listDimensionsTestParallelization(oeisID: str) -> list[int]:
+	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`"""
+	n = random.choice(settingsOEIS[oeisID]['valuesTestParallelization'])
+	return list(settingsOEIS[oeisID]['getMapShape'](n))
+
+@pytest.fixture
+def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
+	"""Mock time.perf_counter_ns for consistent benchmark timing."""
+	with unittest.mock.patch('time.perf_counter_ns') as mockTimer:
+		mockTimer.side_effect = [0, 1e9]  # Start and end times for 1 second
+		yield mockTimer
+
+@pytest.fixture
+def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
+	"""Creates a mock function that simulates _countFolds behavior."""
+	def make_mock(foldsValue: int, listDimensions: list[int]) -> Callable[..., None]:
+		mock_array = makeDataContainer(2)
+		mock_array[0] = foldsValue
+		mapShape = validateListDimensions(listDimensions)
+		mock_array[-1] = getLeavesTotal(mapShape)
+
+		def mock_countFolds(**keywordArguments: Any) -> None:
+			keywordArguments['foldGroups'][:] = mock_array
+			return None
+
+		return mock_countFolds
+	return make_mock
+
+@pytest.fixture
+def mockDispatcher() -> Callable[[Any], ContextManager[Any]]:
+	"""Context manager for mocking dispatcher callable."""
+	def wrapper(mockFunction: Any) -> ContextManager[Any]:
+		dispatcherCallable = getPackageDispatcher()
+		return unittest.mock.patch(
+			f"{dispatcherCallable.__module__}.{dispatcherCallable.__name__}",
+			side_effect=mockFunction
+		)
+	return wrapper
+
+@pytest.fixture(params=oeisIDsImplemented)
+def oeisID(request: pytest.FixtureRequest) -> Any:
+	return request.param
+
+@pytest.fixture
+def oeisID_1random() -> str:
+	"""Return one random valid OEIS ID."""
+	return random.choice(oeisIDsImplemented)
+
+@pytest.fixture
+def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
+	"""A fixture providing a context manager for temporarily replacing the dispatcher.
+
+	Returns
+		A context manager for patching the dispatcher
+	"""
+	import mapFolding.basecamp as basecamp
+	dispatcherOriginal = basecamp.getPackageDispatcher
+
+	def patchDispatcher(callableTarget: Callable[..., Any]) -> None:
+		def callableParameterized(*arguments: Any, **keywordArguments: Any) -> Callable[..., Any]:
+			return callableTarget
+		basecamp.getPackageDispatcher = callableParameterized
+
+	yield patchDispatcher
+	basecamp.getPackageDispatcher = dispatcherOriginal
+
+@pytest.fixture
+def useAlgorithmSourceDispatcher(useThisDispatcher: Callable[..., Any]) -> Generator[None, None, None]:
+	"""Temporarily patches getDispatcherCallable to return the algorithm dispatcher."""
+	useThisDispatcher(getAlgorithmDispatcher())
+	yield
+
+@pytest.fixture
+def syntheticDispatcherFixture(useThisDispatcher: Callable[..., Any]) -> Callable[..., Any]:
+	listCallablesInline = listNumbaCallableDispatchees
+	callableDispatcher = True
+	algorithmSource = getSourceAlgorithm()
+	relativePathWrite = theModuleOfSyntheticModules
+	filenameModuleWrite = 'pytestCount.py'
+	formatFilenameWrite = "pytest_{callableTarget}.py"
+	listSynthesizedModules: list[YouOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, filenameModuleWrite, formatFilenameWrite)
+	dispatcherSynthetic: YouOughtaKnow | None = None
+	for stuff in listSynthesizedModules:
+		registrarRecordsTmpObject(stuff.pathFilenameForMe)
+		if stuff.callableSynthesized not in listCallablesInline:
+			dispatcherSynthetic = stuff
+
+	if dispatcherSynthetic is None:
+		raise FREAKOUT
+
+	dispatcherSpec = importlib.util.spec_from_file_location(dispatcherSynthetic.callableSynthesized, dispatcherSynthetic.pathFilenameForMe)
+	if dispatcherSpec is None:
+		raise ImportError(f"{dispatcherSynthetic.pathFilenameForMe=}")
+	if dispatcherSpec.loader is None:
+		raise ImportError(f"Failed to get loader for module {dispatcherSynthetic.pathFilenameForMe}")
+
+	dispatcherModule = importlib.util.module_from_spec(dispatcherSpec)
+	dispatcherSpec.loader.exec_module(dispatcherModule)
+	callableDispatcherSynthetic = getattr(dispatcherModule, dispatcherSynthetic.callableSynthesized)
+
+	useThisDispatcher(callableDispatcherSynthetic)
+	return callableDispatcherSynthetic
+
+def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
+	"""Format assertion message for any test comparison."""
+	return (f"\nTesting: `{functionName}({', '.join(str(parameter) for parameter in arguments)})`\n"
+			f"Expected: {expected}\n"
+			f"Got: {actual}")
+
+def standardizedEqualToCallableReturn(expected: Any, functionTarget: Callable[..., Any], *arguments: Any) -> None:
+	"""Use with callables that produce a return or an error."""
+	if type(expected) is type[Exception]:
+		messageExpected = expected.__name__
+	else:
+		messageExpected = expected
+
+	try:
+		messageActual = actual = functionTarget(*arguments)
+	except Exception as actualError:
+		messageActual = type(actualError).__name__
+		actual = type(actualError)
+
+	assert actual == expected, uniformTestMessage(messageExpected, messageActual, functionTarget.__name__, *arguments)
+
+def standardizedSystemExit(expected: str | int | Sequence[int], functionTarget: Callable[..., Any], *arguments: Any) -> None:
+	"""Template for tests expecting SystemExit.
+
+	Parameters
+		expected: Exit code expectation:
+			- "error": any non-zero exit code
+			- "nonError": specifically zero exit code
+			- int: exact exit code match
+			- Sequence[int]: exit code must be one of these values
+		functionTarget: The function to test
+		arguments: Arguments to pass to the function
+	"""
+	with pytest.raises(SystemExit) as exitInfo:
+		functionTarget(*arguments)
+
+	exitCode = exitInfo.value.code
+
+	if expected == "error":
+		assert exitCode != 0, f"Expected error exit (non-zero) but got code {exitCode}"
+	elif expected == "nonError":
+		assert exitCode == 0, f"Expected non-error exit (0) but got code {exitCode}"
+	elif isinstance(expected, (list, tuple)):
+		assert exitCode in expected, f"Expected exit code to be one of {expected} but got {exitCode}"
+	else:
+		assert exitCode == expected, f"Expected exit code {expected} but got {exitCode}"

tests/test_computations.py

@@ -0,0 +1,49 @@
+from mapFolding.basecamp import countFolds
+from mapFolding.filesystem import getPathFilenameFoldsTotal
+from mapFolding.noHomeYet import getFoldsTotalKnown
+from mapFolding.oeis import settingsOEIS, oeisIDfor_n
+# from mapFolding.someAssemblyRequired import writeJobNumba
+from tests.conftest import standardizedEqualToCallableReturn, registrarRecordsTmpObject
+import importlib.util
+import pytest
+from pathlib import Path
+from types import ModuleType
+
+def test_algorithmSourceParallel(listDimensionsTestParallelization, useAlgorithmSourceDispatcher: None) -> None:
+    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
+
+def test_algorithmSourceSequential(listDimensionsTestCountFolds, useAlgorithmSourceDispatcher: None) -> None:
+    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
+
+def test_aOFn_calculate_value(oeisID: str) -> None:
+    for n in settingsOEIS[oeisID]['valuesTestValidation']:
+        standardizedEqualToCallableReturn(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+
+# @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
+# def test_writeJobNumba(listDimensionsTestCountFolds: list[int], pathFilenameTmpTesting: Path) -> None:
+#     from mapFolding.syntheticModules import numbaCount
+#     algorithmSourceHARDCODED: ModuleType = numbaCount
+#     algorithmSource = algorithmSourceHARDCODED
+#     callableTargetHARDCODED = 'countSequential'
+#     callableTarget = callableTargetHARDCODED
+#     pathFilenameModule = writeJobNumba(listDimensionsTestCountFolds, algorithmSource, callableTarget, pathFilenameWriteJob=pathFilenameTmpTesting.absolute())
+
+#     Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
+#     if Don_Lapre_Road_to_Self_Improvement is None:
+#         raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
+#     if Don_Lapre_Road_to_Self_Improvement.loader is None:
+#         raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
+#     module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
+
+#     module.__name__ = "__main__"
+#     Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
+
+#     pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
+#     registrarRecordsTmpObject(pathFilenameFoldsTotal)
+#     standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
+
+# def test_syntheticParallel(syntheticDispatcherFixture: None, listDimensionsTestParallelization: list[int], foldsTotalKnown: dict[tuple[int, ...], int]):
+#     standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+
+# def test_syntheticSequential(syntheticDispatcherFixture: None, listDimensionsTestCountFolds: list[int], foldsTotalKnown: dict[tuple[int, ...], int]):
+#     standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)

tests/test_filesystem.py

@@ -0,0 +1,52 @@
+from contextlib import redirect_stdout
+from mapFolding.filesystem import getFilenameFoldsTotal, getPathFilenameFoldsTotal, saveFoldsTotal
+from mapFolding.beDRY import validateListDimensions
+from mapFolding.theSSOT import getPathJobRootDEFAULT
+from pathlib import Path
+from typing import Any
+import io
+import numpy
+import pytest
+import unittest.mock
+
+def test_saveFoldsTotal_fallback(pathTmpTesting: Path) -> None:
+    foldsTotal = 123
+    pathFilename = pathTmpTesting / "foldsTotal.txt"
+    with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):
+        with unittest.mock.patch("os.getcwd", return_value=str(pathTmpTesting)):
+            capturedOutput = io.StringIO()
+            with redirect_stdout(capturedOutput):
+                saveFoldsTotal(pathFilename, foldsTotal)
+    fallbackFiles = list(pathTmpTesting.glob("foldsTotalYO_*.txt"))
+    assert len(fallbackFiles) == 1, "Fallback file was not created upon write failure."
+
+@pytest.mark.parametrize("listDimensions, expectedFilename", [
+    ([11, 13], "p11x13.foldsTotal"),
+    ([17, 13, 11], "p11x13x17.foldsTotal"),
+])
+def test_getFilenameFoldsTotal(listDimensions: list[int], expectedFilename: str) -> None:
+    """Test that getFilenameFoldsTotal generates correct filenames with dimensions sorted."""
+    mapShape = validateListDimensions(listDimensions)
+    filenameActual = getFilenameFoldsTotal(mapShape)
+    assert filenameActual == expectedFilename, f"Expected filename {expectedFilename} but got {filenameActual}"
+
+def test_getPathFilenameFoldsTotal_defaultPath(mapShapeTestFunctionality: tuple[int, ...]) -> None:
+    """Test getPathFilenameFoldsTotal with default path."""
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality)
+    assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
+    assert pathFilenameFoldsTotal.name == getFilenameFoldsTotal(mapShapeTestFunctionality), "Filename should match getFilenameFoldsTotal output"
+    assert pathFilenameFoldsTotal.parent == getPathJobRootDEFAULT(), "Parent directory should match default job root"
+
+def test_getPathFilenameFoldsTotal_relativeFilename(mapShapeTestFunctionality: tuple[int, ...]) -> None:
+    """Test getPathFilenameFoldsTotal with relative filename."""
+    relativeFilename = Path("custom/path/test.foldsTotal")
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, relativeFilename)
+    assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
+    assert pathFilenameFoldsTotal == getPathJobRootDEFAULT() / relativeFilename, "Relative path should be appended to default job root"
+
+def test_getPathFilenameFoldsTotal_createsDirs(pathTmpTesting: Path, mapShapeTestFunctionality: tuple[int, ...]) -> None:
+    """Test that getPathFilenameFoldsTotal creates necessary directories."""
+    nestedPath = pathTmpTesting / "deep/nested/structure"
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, nestedPath)
+    assert pathFilenameFoldsTotal.parent.exists(), "Parent directories should be created"
+    assert pathFilenameFoldsTotal.parent.is_dir(), "Created path should be a directory"

tests/test_oeis.py

@@ -0,0 +1,128 @@
+from contextlib import redirect_stdout
+from mapFolding.oeis import oeisIDfor_n, getOEISids, clearOEIScache, getOEISidValues, OEIS_for_n, oeisIDsImplemented, settingsOEIS, validateOEISid
+from pathlib import Path
+from tests.conftest import standardizedEqualToCallableReturn, standardizedSystemExit
+from typing import Any, NoReturn
+from urllib.error import URLError
+import io
+import pytest
+import random
+import re as regex
+import unittest.mock
+import urllib.request
+
+@pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
+def test__validateOEISid_invalid_id(badID: str) -> None:
+	standardizedEqualToCallableReturn(KeyError, validateOEISid, badID)
+
+def test__validateOEISid_partially_valid(oeisID_1random: str) -> None:
+	standardizedEqualToCallableReturn(KeyError, validateOEISid, f"{oeisID_1random}extra")
+
+def test__validateOEISid_valid_id(oeisID: str) -> None:
+	standardizedEqualToCallableReturn(oeisID, validateOEISid, oeisID)
+
+def test__validateOEISid_valid_id_case_insensitive(oeisID: str) -> None:
+	standardizedEqualToCallableReturn(oeisID.upper(), validateOEISid, oeisID.lower())
+	standardizedEqualToCallableReturn(oeisID.upper(), validateOEISid, oeisID.upper())
+	standardizedEqualToCallableReturn(oeisID.upper(), validateOEISid, oeisID.swapcase())
+
+parameters_test_aOFn_invalid_n = [
+	(-random.randint(1, 100), "randomNegative"),
+	("foo", "string"),
+	(1.5, "float")
+]
+badValues, badValuesIDs = zip(*parameters_test_aOFn_invalid_n)
+@pytest.mark.parametrize("badN", badValues, ids=badValuesIDs)
+def test_aOFn_invalid_n(oeisID_1random: str, badN: Any) -> None:
+	"""Check that negative or non-integer n raises ValueError."""
+	standardizedEqualToCallableReturn(ValueError, oeisIDfor_n, oeisID_1random, badN)
+
+def test_aOFn_zeroDim_A001418() -> None:
+	standardizedEqualToCallableReturn(ArithmeticError, oeisIDfor_n, 'A001418', 0)
+
+# ===== OEIS Cache Tests =====
+@pytest.mark.parametrize("cacheExists", [True, False])
+@unittest.mock.patch('pathlib.Path.exists')
+@unittest.mock.patch('pathlib.Path.unlink')
+def test_clearOEIScache(mock_unlink: unittest.mock.MagicMock, mock_exists: unittest.mock.MagicMock, cacheExists: bool) -> None:
+	"""Test OEIS cache clearing with both existing and non-existing cache."""
+	mock_exists.return_value = cacheExists
+	clearOEIScache()
+
+	if cacheExists:
+		# Each OEIS ID has two cache files
+		expected_calls = len(settingsOEIS) * 2
+		assert mock_unlink.call_count == expected_calls
+		mock_unlink.assert_has_calls([unittest.mock.call(missing_ok=True)] * expected_calls)
+	else:
+		mock_exists.assert_called_once()
+		mock_unlink.assert_not_called()
+
+def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: Path) -> None:
+	"""Test network error handling."""
+	def mockUrlopen(*args: Any, **kwargs: Any) -> NoReturn:
+		raise URLError("Network error")
+
+	monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
+	standardizedEqualToCallableReturn(URLError, getOEISidValues, next(iter(settingsOEIS)))
+
+# ===== Command Line Interface Tests =====
+def testHelpText() -> None:
+	"""Test that help text is complete and examples are valid."""
+	outputStream = io.StringIO()
+	with redirect_stdout(outputStream):
+		getOEISids()
+
+	helpText = outputStream.getvalue()
+
+	# Verify content
+	for oeisID in oeisIDsImplemented:
+		assert oeisID in helpText
+		assert settingsOEIS[oeisID]['description'] in helpText
+
+	# Extract and verify examples
+
+	cliMatch = regex.search(r'OEIS_for_n (\w+) (\d+)', helpText)
+	pythonMatch = regex.search(r"oeisIDfor_n\('(\w+)', (\d+)\)", helpText)
+
+	assert cliMatch and pythonMatch, "Help text missing examples"
+	oeisID, n = pythonMatch.groups()
+	n = int(n)
+
+	# Verify CLI and Python examples use same values
+	assert cliMatch.groups() == (oeisID, str(n)), "CLI and Python examples inconsistent"
+
+	# Verify the example works
+	expectedValue = oeisIDfor_n(oeisID, n)
+
+	# Test CLI execution of the example
+	with unittest.mock.patch('sys.argv', ['OEIS_for_n', oeisID, str(n)]):
+		outputStream = io.StringIO()
+		with redirect_stdout(outputStream):
+			OEIS_for_n()
+		standardizedEqualToCallableReturn(expectedValue, lambda: int(outputStream.getvalue().strip().split()[0]))
+
+def testCLI_InvalidInputs() -> None:
+	"""Test CLI error handling."""
+	testCases = [
+		(['OEIS_for_n'], "missing arguments"),
+		(['OEIS_for_n', 'A999999', '1'], "invalid OEIS ID"),
+		(['OEIS_for_n', 'A001415', '-1'], "negative n"),
+		(['OEIS_for_n', 'A001415', 'abc'], "non-integer n"),
+	]
+
+	for arguments, _testID in testCases:
+		with unittest.mock.patch('sys.argv', arguments):
+			standardizedSystemExit("error", OEIS_for_n)
+
+def testCLI_HelpFlag() -> None:
+	"""Verify --help output contains required information."""
+	with unittest.mock.patch('sys.argv', ['OEIS_for_n', '--help']):
+		outputStream = io.StringIO()
+		with redirect_stdout(outputStream):
+			standardizedSystemExit("nonError", OEIS_for_n)
+
+		helpOutput = outputStream.getvalue()
+		assert "Available OEIS sequences:" in helpOutput
+		assert "Usage examples:" in helpOutput
+		assert all(oeisID in helpOutput for oeisID in oeisIDsImplemented)

tests/test_other.py

@@ -0,0 +1,84 @@
+from collections.abc import Callable
+from mapFolding.beDRY import getLeavesTotal, setCPUlimit, validateListDimensions
+from tests.conftest import standardizedEqualToCallableReturn
+from typing import Any, Literal
+from Z0Z_tools import intInnit
+from Z0Z_tools.pytestForYourUse import PytestFor_intInnit, PytestFor_oopsieKwargsie
+import numba
+import pytest
+import sys
+
+@pytest.mark.parametrize("listDimensions,expected_intInnit,expected_validateListDimensions", [
+	(None, ValueError, ValueError),  # None instead of list
+	(['a'], ValueError, ValueError),  # string
+	([-4, 2], [-4, 2], ValueError),  # negative
+	([-3], [-3], ValueError),  # negative
+	([0, 0], [0, 0], NotImplementedError),  # no positive dimensions
+	([0, 5, 6], [0, 5, 6], (5, 6)),  # zeros ignored
+	([0], [0], NotImplementedError),  # edge case
+	([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], (1, 2, 3, 4, 5)),  # sequential
+	([1, sys.maxsize], [1, sys.maxsize], (1, sys.maxsize)),  # maxint
+	([7.5], ValueError, ValueError),  # float
+	([1] * 1000, [1] * 1000, (1,) * 1000),  # long list
+	([11], [11], NotImplementedError),  # single dimension
+	([13, 0, 17], [13, 0, 17], (13, 17)),  # zeros handled
+	([2, 2, 2, 2], [2, 2, 2, 2], (2, 2, 2, 2)),  # repeated dimensions
+	([2, 3, 4], [2, 3, 4], (2, 3, 4)),
+	([2, 3], [2, 3], (2, 3)),
+	([2] * 11, [2] * 11, (2,) * 11),  # power of 2
+	([3, 2], [3, 2], (2, 3)),  # return value is sorted
+	([3] * 5, [3] * 5, (3,) * 5),  # power of 3
+	([None], TypeError, TypeError),  # None
+	([True], TypeError, TypeError),  # bool
+	([[17, 39]], TypeError, TypeError),  # nested
+	([], ValueError, ValueError),  # empty
+	([complex(1,1)], ValueError, ValueError),  # complex number
+	([float('inf')], ValueError, ValueError),  # infinity
+	([float('nan')], ValueError, ValueError),  # NaN
+	([sys.maxsize - 1, 1], [sys.maxsize - 1, 1], (1, sys.maxsize - 1)),  # near maxint
+	([sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], (2, sys.maxsize // 2, sys.maxsize // 2)),  # overflow protection
+	([sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], (sys.maxsize, sys.maxsize)),  # overflow protection
+	(range(3, 7), [3, 4, 5, 6], (3, 4, 5, 6)),  # range sequence type
+	(tuple([3, 5, 7]), [3, 5, 7], (3, 5, 7)),  # tuple sequence type
+])
+def test_listDimensionsAsParameter(listDimensions: None | list[str] | list[int] | list[float] | list[None] | list[bool] | list[list[int]] | list[complex] | range | tuple[int, ...],
+							   expected_intInnit: type[ValueError] | list[int] | type[TypeError],
+							   expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | tuple[int, ...] | type[TypeError]) -> None:
+	"""Test both validateListDimensions and getLeavesTotal with the same inputs."""
+	standardizedEqualToCallableReturn(expected_intInnit, intInnit, listDimensions)
+	standardizedEqualToCallableReturn(expected_validateListDimensions, validateListDimensions, listDimensions)
+
+def test_getLeavesTotal_edge_cases() -> None:
+	"""Test edge cases for getLeavesTotal."""
+	# Order independence
+	standardizedEqualToCallableReturn(getLeavesTotal((2, 3, 4)), getLeavesTotal, (4, 2, 3))
+
+	# Input preservation
+	mapShape = (2, 3)
+	standardizedEqualToCallableReturn(6, getLeavesTotal, mapShape)
+	# Remove the lambda entirely for a simpler approach
+	assert mapShape == (2, 3), "Input tuple was modified"
+
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_intInnit())
+def testIntInnit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
+	callablePytest()
+
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_oopsieKwargsie())
+def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
+	callablePytest()
+
+@pytest.mark.parametrize("CPUlimit, expectedLimit", [
+	(None, numba.get_num_threads()),
+	(False, numba.get_num_threads()),
+	(True, 1),
+	(4, 4),
+	(0.5, max(1, numba.get_num_threads() // 2)),
+	(-0.5, max(1, numba.get_num_threads() // 2)),
+	(-2, max(1, numba.get_num_threads() - 2)),
+	(0, numba.get_num_threads()),
+	(1, 1),
+])
+def test_setCPUlimit(CPUlimit: None | float | bool | Literal[4] | Literal[-2] | Literal[0] | Literal[1], expectedLimit: Any | int) -> None:
+	from mapFolding.theSSOT import concurrencyPackage
+	if concurrencyPackage == 'numba':
+		standardizedEqualToCallableReturn(expectedLimit, setCPUlimit, CPUlimit)

tests/test_tasks.py

@@ -0,0 +1,50 @@
+from typing import Literal
+from mapFolding.basecamp import countFolds
+from mapFolding.beDRY import getTaskDivisions, setCPUlimit, validateListDimensions, getLeavesTotal
+from mapFolding.noHomeYet import getFoldsTotalKnown
+from tests.conftest import standardizedEqualToCallableReturn
+from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit
+from collections.abc import Callable
+import pytest
+
+# TODO add a test. `C` = number of logical cores available. `n = C + 1`. Ensure that `[2,n]` is computed correctly.
+# Or, probably smarter: limit the number of cores, then run a test with C+1.
+
+def test_countFoldsComputationDivisionsInvalid(mapShapeTestFunctionality: tuple[int, ...]) -> None:
+	standardizedEqualToCallableReturn(ValueError, countFolds, mapShapeTestFunctionality, None, {"wrong": "value"})
+
+def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: list[int]) -> None:
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
+
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
+def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
+	callablePytest()
+
+@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)
+
+@pytest.mark.parametrize("computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions", [
+	(None, 4, [9, 11], 0),
+	("maximum", 4, [7, 11], 77),
+	("cpu", 4, [3, 7], 4),
+	(["invalid"], 4, [19, 23], ValueError),
+	(20, 4, [3,5], ValueError)
+])
+def test_getTaskDivisions(computationDivisions: None | list[str] | Literal['maximum'] | Literal['cpu'] | Literal[20],
+							concurrencyLimit: Literal[4],
+							listDimensions: list[int],
+							expectedTaskDivisions: type[ValueError] | Literal[0] | Literal[77] | Literal[4]) -> None:
+	mapShape = validateListDimensions(listDimensions)
+	leavesTotal = getLeavesTotal(mapShape)
+	standardizedEqualToCallableReturn(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, leavesTotal)
+
+@pytest.mark.parametrize("expected,parameter", [
+	(ValueError, [4]),  # list
+	(ValueError, (2,)), # tuple
+	(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:
+	"""Test that invalid CPUlimit types are properly handled."""
+	standardizedEqualToCallableReturn(expected, setCPUlimit, parameter)