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

mapFolding/tests/conftest.py

@@ -25,10 +25,12 @@ research domain.
 
 from collections.abc import Callable, Generator, Sequence
 from mapFolding import _theSSOT, getLeavesTotal, makeDataContainer, packageSettings, validateListDimensions
-from mapFolding.oeis import dictionaryOEIS, dictionaryOEISMapFolding, oeisIDsImplemented
+from mapFolding.oeis import oeisIDsImplemented
+from numpy.typing import NDArray
 from pathlib import Path
 from typing import Any
 import numpy
+import pickle
 import pytest
 import random
 import shutil
@@ -36,103 +38,130 @@ import unittest.mock
 import uuid
 import warnings
 
-# ruff: noqa: S311
+#======== uniform messages and standardized test formats ==========
 
-# SSOT for test data paths and filenames
-pathDataSamples: Path = Path(packageSettings.pathPackage, "tests/dataSamples").absolute()
-path_tmpRoot: Path = pathDataSamples / "tmp"
-path_tmpRoot.mkdir(parents=True, exist_ok=True)
-
-# The registrar maintains the register of temp files
-registerOfTemporaryFilesystemObjects: set[Path] = set()
+def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
+	"""Format assertion message for any test comparison.
 
-def registrarRecordsTemporaryFilesystemObject(path: Path) -> None:
-	"""The registrar adds a tmp file to the register.
+	Creates standardized, machine-parsable error messages that clearly display
+	what was expected versus what was received. This uniform formatting makes
+	test failures easier to debug and maintains consistency across the entire
+	test suite.
 
 	Parameters
 	----------
-	path : Path
-		The filesystem path to register for cleanup.
-
-	"""
-	registerOfTemporaryFilesystemObjects.add(path)
-
-def registrarDeletesTemporaryFilesystemObjects() -> None:
-	"""The registrar cleans up tmp files in the register."""
-	for path_tmp in sorted(registerOfTemporaryFilesystemObjects, reverse=True):
-		if path_tmp.is_file():
-			path_tmp.unlink(missing_ok=True)
-		elif path_tmp.is_dir():
-			shutil.rmtree(path_tmp, ignore_errors=True)
-	registerOfTemporaryFilesystemObjects.clear()
-
-@pytest.fixture(scope="session", autouse=True)
-def setupTeardownTemporaryFilesystemObjects() -> Generator[None, None, None]:
-	"""Auto-fixture to setup test data directories and cleanup after.
+	expected : Any
+		The value or exception type that was expected.
+	actual : Any
+		The value or exception type that was actually received.
+	functionName : str
+		Name of the function being tested.
+	arguments : Any
+		Arguments that were passed to the function.
 
 	Returns
 	-------
-	contextManager : Generator[None, None, None]
-		Context manager that sets up test directories and ensures cleanup.
+	formattedMessage : str
+		A formatted string showing the test context and comparison.
 
 	"""
-	pathDataSamples.mkdir(exist_ok=True)
-	path_tmpRoot.mkdir(exist_ok=True)
-	yield
-	registrarDeletesTemporaryFilesystemObjects()
+	return (f"\nTesting: `{functionName}({', '.join(str(parameter) for parameter in arguments)})`\n"
+			f"Expected: {expected}\n"
+			f"Got: {actual}")
 
-@pytest.fixture
-def path_tmpTesting(request: pytest.FixtureRequest) -> Path:
-	"""Creates a unique temporary directory for testing.
+def standardizedEqualToCallableReturn(expected: Any, functionTarget: Callable[..., Any], *arguments: Any) -> None:
+	"""Use with callables that produce a return or an error.
+
+	This is the primary testing function for validating both successful returns
+	and expected exceptions. It provides consistent error messaging and handles
+	the comparison logic that most tests in the suite rely on.
+
+	When testing a function that should raise an exception, pass the exception
+	type as the `expected` parameter. For successful returns, pass the expected
+	return value.
 
 	Parameters
 	----------
-	request : pytest.FixtureRequest
-		The pytest request object providing test context.
-
-	Returns
-	-------
-	temporaryPath : Path
-		Path to a unique temporary directory that will be cleaned up automatically.
+	expected : Any
+		Expected return value or exception type.
+	functionTarget : Callable[..., Any]
+		The function to test.
+	arguments : Any
+		Arguments to pass to the function.
 
 	"""
-	# "Z0Z_" ensures the directory name does not start with a number, which would make it an invalid Python identifier
-	path_tmp: Path = path_tmpRoot / ("Z0Z_" + str(uuid.uuid4().hex))
-	path_tmp.mkdir(parents=True, exist_ok=False)
+	if type(expected) is type[Exception]:
+		messageExpected = expected.__name__
+	else:
+		messageExpected = expected
 
-	registrarRecordsTemporaryFilesystemObject(path_tmp)
-	return path_tmp
+	try:
+		messageActual = actual = functionTarget(*arguments)
+	except Exception as actualError:
+		messageActual = type(actualError).__name__
+		actual = type(actualError)
 
-@pytest.fixture
-def pathFilename_tmpTesting(request: pytest.FixtureRequest) -> Path:
-	"""Creates a unique temporary file path for testing.
+	functionName: str = getattr(functionTarget, "__name__", functionTarget.__class__.__name__)
+	assert actual == expected, uniformTestMessage(messageExpected, messageActual, functionName, *arguments)
+
+def standardizedSystemExit(expected: str | int | Sequence[int], functionTarget: Callable[..., Any], *arguments: Any) -> None:
+	"""Template for tests expecting SystemExit.
 
 	Parameters
 	----------
-	request : pytest.FixtureRequest
-		The pytest request object, optionally containing `param` for file extension.
-
-	Returns
-	-------
-	temporaryFilePath : Path
-		Path to a unique temporary file that will be cleaned up automatically.
+	expected : str | int | Sequence[int]
+		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 : Callable[..., Any]
+		The function to test.
+	arguments : Any
+		Arguments to pass to the function.
 
 	"""
-	try:
-		extension = request.param
-	except AttributeError:
-		extension = ".txt"
+	with pytest.raises(SystemExit) as exitInfo:
+		functionTarget(*arguments)
 
-	# "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]
+	exitCode = exitInfo.value.code
 
-	pathFilename_tmp = Path(path_tmpRoot, subpath, filenameStem + extension)
-	pathFilename_tmp.parent.mkdir(parents=True, exist_ok=False)
+	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}"
 
-	registrarRecordsTemporaryFilesystemObject(pathFilename_tmp.parent)
-	return pathFilename_tmp
+#======== SSOT for test data paths and filenames ==============
+pathDataSamples: Path = Path(packageSettings.pathPackage, "tests/dataSamples").absolute()
+path_tmpRoot: Path = pathDataSamples / "tmp"
+path_tmpRoot.mkdir(parents=True, exist_ok=True)
+
+# The registrar maintains the register of tmp filesystem objects
+registerOfTemporaryFilesystemObjects: set[Path] = set()
+
+def registrarDeletesTemporaryFilesystemObjects() -> None:
+	"""The registrar cleans up tmp filesystem objects in the register."""
+	for path_tmp in sorted(registerOfTemporaryFilesystemObjects, reverse=True):
+		if path_tmp.is_file():
+			path_tmp.unlink(missing_ok=True)
+		elif path_tmp.is_dir():
+			shutil.rmtree(path_tmp, ignore_errors=True)
+	registerOfTemporaryFilesystemObjects.clear()
+
+def registrarRecordsTemporaryFilesystemObject(path: Path) -> None:
+	"""The registrar adds a tmp filesystem object to the register.
+
+	Parameters
+	----------
+	path : Path
+		The filesystem path to register for cleanup.
+
+	"""
+	registerOfTemporaryFilesystemObjects.add(path)
 
 @pytest.fixture
 def pathCacheTesting(path_tmpTesting: Path) -> Generator[Path, Any, None]:
@@ -140,8 +169,8 @@ def pathCacheTesting(path_tmpTesting: Path) -> Generator[Path, Any, None]:
 
 	Parameters
 	----------
-	pathTmpTesting : Path
-		Temporary directory path from the `pathTmpTesting` fixture.
+	path_tmpTesting : Path
+		Temporary directory path from the `path_tmpTesting` fixture.
 
 	Returns
 	-------
@@ -149,7 +178,7 @@ def pathCacheTesting(path_tmpTesting: Path) -> Generator[Path, Any, None]:
 		Context manager that provides the temporary cache path and restores original.
 
 	"""
-	pathCacheOriginal = _theSSOT.pathCache
+	pathCacheOriginal: Path = _theSSOT.pathCache
 	_theSSOT.pathCache = path_tmpTesting
 	yield path_tmpTesting
 	_theSSOT.pathCache = pathCacheOriginal
@@ -160,8 +189,8 @@ def pathFilenameFoldsTotalTesting(path_tmpTesting: Path) -> Path:
 
 	Parameters
 	----------
-	pathTmpTesting : Path
-		Temporary directory path from the `pathTmpTesting` fixture.
+	path_tmpTesting : Path
+		Temporary directory path from the `path_tmpTesting` fixture.
 
 	Returns
 	-------
@@ -171,165 +200,74 @@ def pathFilenameFoldsTotalTesting(path_tmpTesting: Path) -> Path:
 	"""
 	return path_tmpTesting.joinpath("foldsTotalTest.txt")
 
-"""
-Section: Fixtures"""
-
-@pytest.fixture(autouse=True)
-def setupWarningsAsErrors() -> Generator[None, Any, None]:
-	"""Convert all warnings to errors for all tests.
-
-	Returns
-	-------
-	contextManager : Generator[None, Any, None]
-		Context manager that configures warnings as errors and restores settings.
-
-	"""
-	warnings.filterwarnings("error")
-	yield
-	warnings.resetwarnings()
-
 @pytest.fixture
-def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
-	"""For each `oeisID_1random` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation`
-	if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts.
-
-	This fixture provides a single test case to avoid issues with tests that write to the same
-	output files. It's particularly useful when testing code generation or file output functions
-	where multiple concurrent tests could interfere with each other.
-
-	The returned map shape is guaranteed to be computationally feasible for testing purposes,
-	avoiding cases that would take excessive time to complete during test runs.
-
-	Parameters
-	----------
-	oeisID_1random : str
-		Random OEIS sequence identifier from the `oeisID_1random` fixture.
-
-	Returns
-	-------
-	mapDimensions : tuple[int, ...]
-		Valid map dimensions suitable for testing fold counting operations.
-
-	"""
-	while True:
-		n = random.choice(dictionaryOEISMapFolding[oeisID_1random]['valuesTestValidation'])
-		if n < 2:
-			continue
-		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID_1random]['getMapShape'](n))
-
-		try:
-			return validateListDimensions(listDimensionsCandidate)
-		except (ValueError, NotImplementedError):
-			pass
-
-@pytest.fixture
-def mapShapeTestCountFolds(oeisIDmapFolding: str) -> tuple[int, ...]:
-	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation` if
-	`validateListDimensions` approves. Each `listDimensions` is suitable for testing counts.
+def pathFilename_tmpTesting(request: pytest.FixtureRequest) -> Path:
+	"""Creates a unique temporary file path for testing.
 
 	Parameters
 	----------
-	oeisID : str
-		OEIS sequence identifier from the `oeisID` fixture.
+	request : pytest.FixtureRequest
+		The pytest request object, optionally containing `param` for file extension.
 
 	Returns
 	-------
-	mapDimensions : tuple[int, ...]
-		Valid map dimensions suitable for testing fold counting operations.
+	temporaryFilePath : Path
+		Path to a unique temporary file that will be cleaned up automatically.
 
 	"""
-	while True:
-		n = random.choice(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestValidation'])
-		if n < 2:
-			continue
-		listDimensionsCandidate: list[int] = list(dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n))
-
-		try:
-			return validateListDimensions(listDimensionsCandidate)
-		except (ValueError, NotImplementedError):
-			pass
-
-@pytest.fixture
-def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
-	"""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.
-
-	Parameters
-	----------
-	oeisID_1random : str
-		Random OEIS sequence identifier from the `oeisID_1random` fixture.
+	try:
+		extension = request.param
+	except AttributeError:
+		extension = ".txt"
 
-	Returns
-	-------
-	mapDimensions : tuple[int, ...]
-		Valid map dimensions that can be processed quickly for functional testing.
+	# "Z0Z_" ensures the name does not start with a number, which would make it an invalid Python identifier
+	uuid_hex: str = uuid.uuid4().hex
+	relativePath: str = "Z0Z_" + uuid_hex[0:-8]
+	filenameStem: str = "Z0Z_" + uuid_hex[-8:None]
 
-	"""
-	while True:
-		n = random.choice(dictionaryOEISMapFolding[oeisID_1random]['valuesTestValidation'])
-		if n < 2:
-			continue
-		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID_1random]['getMapShape'](n))
+	pathFilename_tmp = Path(path_tmpRoot, relativePath, filenameStem + extension)
+	pathFilename_tmp.parent.mkdir(parents=True, exist_ok=False)
 
-		try:
-			return validateListDimensions(listDimensionsCandidate)
-		except (ValueError, NotImplementedError):
-			pass
+	registrarRecordsTemporaryFilesystemObject(pathFilename_tmp.parent)
+	return pathFilename_tmp
 
 @pytest.fixture
-def mapShapeTestParallelization(oeisIDmapFolding: str) -> tuple[int, ...]:
-	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`.
+def path_tmpTesting(request: pytest.FixtureRequest) -> Path:
+	"""Creates a unique temporary directory for testing.
 
 	Parameters
 	----------
-	oeisID : str
-		OEIS sequence identifier from the `oeisID` fixture.
+	request : pytest.FixtureRequest
+		The pytest request object providing test context.
 
 	Returns
 	-------
-	mapDimensions : tuple[int, ...]
-		Map dimensions suitable for testing parallelization features.
+	temporaryPath : Path
+		Path to a unique temporary directory that will be cleaned up automatically.
 
 	"""
-	n = random.choice(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestParallelization'])
-	return dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n)
-
-@pytest.fixture
-def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
-	"""Mock time.perf_counter_ns for consistent benchmark timing.
-
-	Returns
-	-------
-	mockTimer : Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]
-		Mock timer that returns predictable timing values for testing benchmarks.
+	# "Z0Z_" ensures the directory name does not start with a number, which would make it an invalid Python identifier
+	uuid_hex: str = uuid.uuid4().hex
+	path_tmp: Path = path_tmpRoot / ("Z0Z_" + uuid_hex)
+	path_tmp.mkdir(parents=True, exist_ok=False)
 
-	"""
-	with unittest.mock.patch('time.perf_counter_ns') as mockTimer:
-		mockTimer.side_effect = [0, 1e9]  # Start and end times for 1 second
-		yield mockTimer
+	registrarRecordsTemporaryFilesystemObject(path_tmp)
+	return path_tmp
 
-@pytest.fixture
-def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
-	"""Creates a mock function that simulates _countFolds behavior.
+@pytest.fixture(scope="session", autouse=True)
+def setupTeardownTemporaryFilesystemObjects() -> Generator[None, None, None]:
+	"""Auto-fixture to setup test data directories and cleanup after.
 
 	Returns
 	-------
-	mockFactory : Callable[..., Callable[..., None]]
-		Factory function that creates mock folding functions with specified behavior.
+	contextManager : Generator[None, None, None]
+		Context manager that sets up test directories and ensures cleanup.
 
 	"""
-	def make_mock(foldsValue: int, listDimensions: list[int]) -> Callable[..., None]:
-		mock_array = makeDataContainer(2, numpy.int32)
-		mock_array[0] = foldsValue
-		mapShape = validateListDimensions(listDimensions)
-		mock_array[-1] = getLeavesTotal(mapShape)
-
-		def mock_countFolds(**keywordArguments: Any) -> None:
-			keywordArguments['foldGroups'][:] = mock_array
-
-		return mock_countFolds
-	return make_mock
+	pathDataSamples.mkdir(exist_ok=True)
+	path_tmpRoot.mkdir(exist_ok=True)
+	yield
+	registrarDeletesTemporaryFilesystemObjects()
 
 @pytest.fixture(params=oeisIDsImplemented)
 def oeisIDmapFolding(request: pytest.FixtureRequest) -> Any:
@@ -350,142 +288,83 @@ def oeisIDmapFolding(request: pytest.FixtureRequest) -> Any:
 	"""
 	return request.param
 
-@pytest.fixture(params=('A000682', 'A005316'))
-def oeisIDmeanders(request: pytest.FixtureRequest) -> Any:
-	"""Parametrized fixture providing all Meanders OEIS sequence identifiers.
-
-	Parameters
-	----------
-	request : pytest.FixtureRequest
-		The pytest request object containing the current parameter value.
+@pytest.fixture
+def oeisID_1random() -> str:
+	"""Return one random valid OEIS ID.
 
 	Returns
 	-------
-	sequenceIdentifier : Any
-		OEIS sequence identifier for testing across all Meanders sequences.
+	randomSequenceIdentifier : str
+		Randomly selected OEIS sequence identifier from implemented sequences.
 
 	"""
-	return request.param
+	return random.choice(oeisIDsImplemented)  # noqa: S311
 
-@pytest.fixture(params=tuple(dictionaryOEIS.keys()))
-def oeisIDother(request: pytest.FixtureRequest) -> Any:
-	"""Parametrized fixture providing all other OEIS sequence identifiers.
+#======== Miscellaneous =====================================
 
-	Parameters
-	----------
-	request : pytest.FixtureRequest
-		The pytest request object containing the current parameter value.
+@pytest.fixture(autouse=True)
+def setupWarningsAsErrors() -> Generator[None, Any, None]:
+	"""Convert all warnings to errors for all tests.
 
 	Returns
 	-------
-	sequenceIdentifier : Any
-		OEIS sequence identifier for testing across all other sequences.
+	contextManager : Generator[None, Any, None]
+		Context manager that configures warnings as errors and restores settings.
 
 	"""
-	return request.param
+	warnings.filterwarnings("error")
+	yield
+	warnings.resetwarnings()
 
 @pytest.fixture
-def oeisID_1random() -> str:
-	"""Return one random valid OEIS ID.
+def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
+	"""Mock time.perf_counter_ns for consistent benchmark timing.
 
 	Returns
 	-------
-	randomSequenceIdentifier : str
-		Randomly selected OEIS sequence identifier from implemented sequences.
+	mockTimer : Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]
+		Mock timer that returns predictable timing values for testing benchmarks.
 
 	"""
-	return random.choice(oeisIDsImplemented)
-
-def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
-	"""Format assertion message for any test comparison.
-
-	Creates standardized, machine-parsable error messages that clearly display
-	what was expected versus what was received. This uniform formatting makes
-	test failures easier to debug and maintains consistency across the entire
-	test suite.
+	with unittest.mock.patch('time.perf_counter_ns') as mockTimer:
+		mockTimer.side_effect = [0, 1e9]  # Start and end times for 1 second
+		yield mockTimer
 
-	Parameters
-	----------
-	expected : Any
-		The value or exception type that was expected.
-	actual : Any
-		The value or exception type that was actually received.
-	functionName : str
-		Name of the function being tested.
-	arguments : Any
-		Arguments that were passed to the function.
+@pytest.fixture
+def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
+	"""Creates a mock function that simulates _countFolds behavior.
 
 	Returns
 	-------
-	formattedMessage : str
-		A formatted string showing the test context and 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.
-
-	This is the primary testing function for validating both successful returns
-	and expected exceptions. It provides consistent error messaging and handles
-	the comparison logic that most tests in the suite rely on.
-
-	When testing a function that should raise an exception, pass the exception
-	type as the `expected` parameter. For successful returns, pass the expected
-	return value.
-
-	Parameters
-	----------
-	expected : Any
-		Expected return value or exception type.
-	functionTarget : Callable[..., Any]
-		The function to test.
-	arguments : Any
-		Arguments to pass to the function.
+	mockFactory : Callable[..., Callable[..., None]]
+		Factory function that creates mock folding functions with specified behavior.
 
 	"""
-	if type(expected) is type[Exception]:
-		messageExpected = expected.__name__
-	else:
-		messageExpected = expected
+	def makeMock(foldsValue: int, listDimensions: list[int]) -> Callable[..., None]:
+		arrayMock = makeDataContainer(2, numpy.int32)
+		arrayMock[0] = foldsValue
+		mapShape: tuple[int, ...] = validateListDimensions(listDimensions)
+		arrayMock[-1] = getLeavesTotal(mapShape)
 
-	try:
-		messageActual = actual = functionTarget(*arguments)
-	except Exception as actualError:
-		messageActual = type(actualError).__name__
-		actual = type(actualError)
+		def mockCountFolds(**keywordArguments: Any) -> None:
+			keywordArguments['foldGroups'][:] = arrayMock
 
-	assert actual == expected, uniformTestMessage(messageExpected, messageActual, functionTarget.__name__, *arguments)
+		return mockCountFolds
+	return makeMock
 
-def standardizedSystemExit(expected: str | int | Sequence[int], functionTarget: Callable[..., Any], *arguments: Any) -> None:
-	"""Template for tests expecting SystemExit.
-
-	Parameters
-	----------
-	expected : str | int | Sequence[int]
-		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 : Callable[..., Any]
-		The function to test.
-	arguments : Any
-		Arguments to pass to the function.
+@pytest.fixture
+def loadArrayFoldings() -> Callable[[int], NDArray[numpy.uint8]]:
+	"""Factory fixture for loading pickled array foldings data.
 
+	Returns
+	-------
+	loaderFunction : Callable[[int], NDArray[numpy.uint8]]
+		Function that loads arrayFoldings for a given dimensionsTotal.
 	"""
-	with pytest.raises(SystemExit) as exitInfo:
-		functionTarget(*arguments)
+	def loader(dimensionsTotal: int) -> NDArray[numpy.uint8]:
+		pathFilename = pathDataSamples / f"arrayFoldingsP2d{dimensionsTotal}.pkl"
+		arrayFoldings: NDArray[numpy.uint8] = pickle.loads(pathFilename.read_bytes())  # noqa: S301
+		return arrayFoldings
 
-	exitCode = exitInfo.value.code
+	return loader
 
-	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}"