mapFolding 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

tests/conftest.py

@@ -3,31 +3,34 @@ Other test modules must not import directly from the package being tested."""
 
 # TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
 
-from typing import Any, Callable, Dict, Generator, List, Optional, Sequence, Tuple, Type, Union
+from typing import Any, Callable, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type, Union
 import pathlib
 import pytest
 import random
+import shutil
 import unittest.mock
-
-from mapFolding import clearOEIScache
-from mapFolding import countFolds, pathJobDEFAULT
-from mapFolding import getLeavesTotal, parseDimensions, validateListDimensions
-from mapFolding.importPackages import makeTestSuiteConcurrencyLimit, defineConcurrencyLimit
-from mapFolding.importPackages import makeTestSuiteIntInnit, intInnit
-from mapFolding.importPackages import makeTestSuiteOopsieKwargsie, oopsieKwargsie
+import uuid
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteConcurrencyLimit
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteIntInnit
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteOopsieKwargsie
+from mapFolding import countFolds, pathJobDEFAULT, indexMy, indexThe, indexTrack
+from mapFolding import defineConcurrencyLimit, intInnit, oopsieKwargsie, outfitCountFolds
+from mapFolding import oeisIDfor_n, getOEISids, clearOEIScache, getFilenameFoldsTotal
+from mapFolding.beDRY import getLeavesTotal, parseDimensions, validateListDimensions
+from mapFolding.beDRY import getTaskDivisions, makeConnectionGraph, setCPUlimit
+from mapFolding.beDRY import makeDataContainer
 from mapFolding.oeis import OEIS_for_n
-from mapFolding.oeis import _formatFilenameCache
+from mapFolding.oeis import _getFilenameOEISbFile
 from mapFolding.oeis import _getOEISidValues
 from mapFolding.oeis import _parseBFileOEIS
 from mapFolding.oeis import _validateOEISid
-from mapFolding.oeis import getOEISids
-from mapFolding.oeis import oeisIDfor_n
 from mapFolding.oeis import oeisIDsImplemented
 from mapFolding.oeis import settingsOEIS
+from mapFolding import *
 
 __all__ = [
     'OEIS_for_n',
-    '_formatFilenameCache',
+    '_getFilenameOEISbFile',
     '_getOEISidValues',
     '_parseBFileOEIS',
     '_validateOEISid',
@@ -35,16 +38,23 @@ __all__ = [
     'countFolds',
     'defineConcurrencyLimit',
     'expectSystemExit',
+    'getFilenameFoldsTotal',
     'getLeavesTotal',
     'getOEISids',
+    'getTaskDivisions',
+    'indexThe',
     'intInnit',
+    'makeConnectionGraph',
+    'makeDataContainer',
     'makeTestSuiteConcurrencyLimit',
     'makeTestSuiteIntInnit',
     'makeTestSuiteOopsieKwargsie',
     'oeisIDfor_n',
     'oeisIDsImplemented',
     'oopsieKwargsie',
+    'outfitCountFolds',
     'parseDimensions',
+    'setCPUlimit',
     'settingsOEIS',
     'standardCacheTest',
     'standardComparison',
@@ -91,6 +101,75 @@ def makeDictionaryFoldsTotalKnown() -> Dict[Tuple[int,...], int]:
 
     return dictionaryMapDimensionsToFoldsTotalKnown
 
+"""
+Section: temporary paths and pathFilenames"""
+
+# SSOT for test data paths
+pathDataSamples = pathlib.Path("tests/dataSamples")
+pathTempRoot = pathDataSamples / "tmp"
+
+# The registrar maintains the register of temp files
+registerOfTempFiles: Set[pathlib.Path] = set()
+
+def addTempFileToRegister(path: pathlib.Path) -> None:
+    """The registrar adds a temp file to the register."""
+    registerOfTempFiles.add(path)
+
+def cleanupTempFileRegister() -> None:
+    """The registrar cleans up temp files in the register."""
+    for pathTemp in sorted(registerOfTempFiles, reverse=True):
+        try:
+            if pathTemp.is_file():
+                pathTemp.unlink(missing_ok=True)
+            elif pathTemp.is_dir():
+                shutil.rmtree(pathTemp, ignore_errors=True)
+        except Exception as ERRORmessage:
+            print(f"Warning: Failed to clean up {pathTemp}: {ERRORmessage}")
+    registerOfTempFiles.clear()
+
+@pytest.fixture(scope="session", autouse=True)
+def setupTeardownTestData() -> Generator[None, None, None]:
+    """Auto-fixture to setup test data directories and cleanup after."""
+    pathDataSamples.mkdir(exist_ok=True)
+    pathTempRoot.mkdir(exist_ok=True)
+    yield
+    cleanupTempFileRegister()
+
+@pytest.fixture
+def pathTempTesting(request: pytest.FixtureRequest) -> pathlib.Path:
+    """Create a unique temp directory for each test function."""
+    # Sanitize test name for filesystem compatibility
+    sanitizedName = request.node.name.replace('[', '_').replace(']', '_').replace('/', '_')
+    uniqueDirectory = f"{sanitizedName}_{uuid.uuid4()}"
+    pathTemp = pathTempRoot / uniqueDirectory
+    pathTemp.mkdir(parents=True, exist_ok=True)
+
+    addTempFileToRegister(pathTemp)
+    return pathTemp
+
+@pytest.fixture
+def pathCacheTesting(pathTempTesting: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
+    """Temporarily replace the OEIS cache directory with a test directory."""
+    from mapFolding import oeis as there_must_be_a_better_way
+    pathCacheOriginal = there_must_be_a_better_way._pathCache
+    there_must_be_a_better_way._pathCache = pathTempTesting
+    yield pathTempTesting
+    there_must_be_a_better_way._pathCache = pathCacheOriginal
+
+@pytest.fixture
+def pathFilenameBenchmarksTesting(pathTempTesting: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
+    """Temporarily replace the benchmarks directory with a test directory."""
+    from mapFolding.benchmarks import benchmarking
+    pathFilenameOriginal = benchmarking.pathFilenameRecordedBenchmarks
+    pathFilenameTest = pathTempTesting / "benchmarks.npy"
+    benchmarking.pathFilenameRecordedBenchmarks = pathFilenameTest
+    yield pathFilenameTest
+    benchmarking.pathFilenameRecordedBenchmarks = pathFilenameOriginal
+
+@pytest.fixture
+def pathFilenameFoldsTotalTesting(pathTempTesting: pathlib.Path) -> pathlib.Path:
+    return pathTempTesting.joinpath("foldsTotalTest.txt")
+
 """
 Section: Fixtures"""
 
@@ -151,27 +230,30 @@ def oeisID_1random() -> str:
     return random.choice(oeisIDsImplemented)
 
 @pytest.fixture
-def pathCacheTesting(tmp_path: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
-    """Temporarily replace the OEIS cache directory with a test directory."""
-    from mapFolding import oeis as there_must_be_a_better_way
-    pathCacheOriginal = there_must_be_a_better_way._pathCache
-    there_must_be_a_better_way._pathCache = tmp_path
-    yield tmp_path
-    there_must_be_a_better_way._pathCache = pathCacheOriginal
+def mockFoldingFunction():
+    """Creates a mock function that simulates _countFolds behavior."""
+    def make_mock(foldsValue: int, listDimensions: List[int]):
+        arraySize = getLeavesTotal(listDimensions)
+        # The array needs to sum to our target value
+        mock_array = makeDataContainer(arraySize)
+        mock_array[arraySize - 1] = foldsValue  # Put entire value in last position
 
-@pytest.fixture
-def pathBenchmarksTesting(tmp_path: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
-    """Temporarily replace the benchmarks directory with a test directory."""
-    from mapFolding.benchmarks import benchmarking
-    pathOriginal = benchmarking.pathFilenameRecordedBenchmarks
-    pathTest = tmp_path / "benchmarks.npy"
-    benchmarking.pathFilenameRecordedBenchmarks = pathTest
-    yield pathTest
-    benchmarking.pathFilenameRecordedBenchmarks = pathOriginal
+        def mock_countfolds(**keywordArguments):
+            keywordArguments['foldsSubTotals'][:] = mock_array
+            return None
+
+        return mock_countfolds
+    return make_mock
 
 """
 Section: Standardized test structures"""
 
+def formatTestMessage(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 standardComparison(expected: Any, functionTarget: Callable, *arguments: Any) -> None:
     """Template for tests expecting an error."""
     if type(expected) == Type[Exception]:
@@ -217,12 +299,6 @@ def expectSystemExit(expected: Union[str, int, Sequence[int]], functionTarget: C
         assert exitCode == expected, \
             f"Expected exit code {expected} but got {exitCode}"
 
-def formatTestMessage(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 standardCacheTest(
     expected: Any,
     setupCacheFile: Optional[Callable[[pathlib.Path, str], None]],
@@ -237,7 +313,7 @@ def standardCacheTest(
         oeisID: OEIS ID to test
         pathCache: Temporary cache directory path
     """
-    pathFilenameCache = pathCache / _formatFilenameCache.format(oeisID=oeisID)
+    pathFilenameCache = pathCache / _getFilenameOEISbFile(oeisID)
 
     # Setup cache file if provided
     if setupCacheFile:

tests/pythons_idiotic_namespace.py

@@ -0,0 +1 @@
+from mapFolding.theSSOT import *

tests/test_oeis.py

@@ -1,6 +1,7 @@
-from .conftest import *
+from tests.conftest import *
 from contextlib import redirect_stdout
 from datetime import datetime, timedelta
+from typing import Optional, Tuple, Union
 import io
 import os
 import pathlib
@@ -62,29 +63,27 @@ def test_clearOEIScache(mock_unlink: unittest.mock.MagicMock, mock_exists: unitt
         mock_exists.assert_called_once()
         mock_unlink.assert_not_called()
 
-def testCacheMiss(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    """Test cache miss scenario - cache file doesn't exist."""
-    # No setup function needed - we want to test missing cache
-    standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], None, oeisID_1random, pathCacheTesting)
+@pytest.mark.parametrize("scenarioCache", ["miss", "expired", "invalid"])
+def testCacheScenarios(pathCacheTesting: pathlib.Path, oeisID_1random: str, scenarioCache: str) -> None:
+    """Test cache scenarios: missing file, expired file, and invalid file."""
 
-def testCacheExpired(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    """Test expired cache scenario."""
-    def setupExpiredCache(pathCache: pathlib.Path, oeisID: str) -> None:
+    def setupCacheExpired(pathCache: pathlib.Path, oeisID: str) -> None:
         pathCache.write_text("# Old cache content")
         oldModificationTime = datetime.now() - timedelta(days=30)
         os.utime(pathCache, times=(oldModificationTime.timestamp(), oldModificationTime.timestamp()))
 
-    standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupExpiredCache, oeisID_1random, pathCacheTesting)
-
-def testInvalidCache(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    """Test invalid cache content scenario."""
-    def setupInvalidCache(pathCache: pathlib.Path, oeisID: str) -> None:
+    def setupCacheInvalid(pathCache: pathlib.Path, oeisID: str) -> None:
         pathCache.write_text("Invalid content")
 
-    standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupInvalidCache, oeisID_1random, pathCacheTesting)
+    if scenarioCache == "miss":
+        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], None, oeisID_1random, pathCacheTesting)
+    elif scenarioCache == "expired":
+        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheExpired, oeisID_1random, pathCacheTesting)
+    else:
+        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheInvalid, oeisID_1random, pathCacheTesting)
 
 def testInvalidFileContent(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    pathFilenameCache = pathCacheTesting / _formatFilenameCache.format(oeisID=oeisID_1random)
+    pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
 
     # Write invalid content to cache
     pathFilenameCache.write_text("# A999999\n1 1\n2 2\n")
@@ -100,25 +99,17 @@ def testInvalidFileContent(pathCacheTesting: pathlib.Path, oeisID_1random: str):
     # Verify cache now contains correct sequence ID
     assert f"# {oeisID_1random}" in pathFilenameCache.read_text()
 
-def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.Path):
-    def mockUrlopen(*args, **kwargs):
-        raise urllib.error.URLError("Network error")
-
-    monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
-    with pytest.raises(urllib.error.URLError):
-        _getOEISidValues(next(iter(settingsOEIS)))
-
 def testParseContentErrors():
     """Test invalid content parsing."""
     standardComparison(ValueError, _parseBFileOEIS, "Invalid content\n1 2\n", 'A001415')
 
 def testExtraComments(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    pathFilenameCache = pathCacheTesting / _formatFilenameCache.format(oeisID=oeisID_1random)
+    pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
 
     # Write content with extra comment lines
     contentWithExtraComments = f"""# {oeisID_1random}
-# Extra comment line 1
-# Extra comment line 2
+# Normal place for comment line 1
+# Abnormal comment line
 1 2
 2 4
 3 6
@@ -133,6 +124,14 @@ def testExtraComments(pathCacheTesting: pathlib.Path, oeisID_1random: str):
     standardComparison(8, lambda d: d[4], OEISsequence)  # Value after mid-sequence comment
     standardComparison(10, lambda d: d[5], OEISsequence)  # Last value
 
+def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.Path):
+    """Test network error handling."""
+    def mockUrlopen(*args, **kwargs):
+        raise urllib.error.URLError("Network error")
+
+    monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
+    standardComparison(urllib.error.URLError, _getOEISidValues, next(iter(settingsOEIS)))
+
 # ===== Command Line Interface Tests =====
 def testHelpText():
     """Test that help text is complete and examples are valid."""

tests/test_other.py

@@ -1,7 +1,12 @@
-from .conftest import *
+from pathlib import Path
+from typing import List, Optional, Dict, Any, Union
+from tests.conftest import *
+from tests.pythons_idiotic_namespace import *
 import pytest
 import sys
-# TODO test `outfitFoldings`, especially that `listDimensions` is sorted.
+import unittest.mock
+import numpy
+import numba
 
 @pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
     (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
@@ -53,7 +58,35 @@ def test_getLeavesTotal_edge_cases() -> None:
     standardComparison(6, getLeavesTotal, listOriginal)
     standardComparison([2, 3], lambda x: x, listOriginal)  # Check that the list wasn't modified
 
-# ===== Parse Integers Tests =====
+@pytest.mark.parametrize("foldsValue,writeFoldsTarget", [
+    (756839, "foldsTotalTest.txt"),  # Direct file
+    (2640919, "foldsTotalTest.txt"), # Direct file
+    (7715177, None),                  # Directory, will use default filename
+])
+def test_countFolds_writeFoldsTotal(
+    listDimensionsTestFunctionality: List[int],
+    pathTempTesting: Path,
+    mockFoldingFunction,
+    foldsValue: int,
+    writeFoldsTarget: Optional[str]
+) -> None:
+    """Test writing folds total to either a file or directory."""
+    # For directory case, use the directory path directly
+    if writeFoldsTarget is None:
+        pathWriteTarget = pathTempTesting
+        filenameFoldsTotalExpected = getFilenameFoldsTotal(listDimensionsTestFunctionality)
+    else:
+        pathWriteTarget = pathTempTesting / writeFoldsTarget
+        filenameFoldsTotalExpected = writeFoldsTarget
+
+    mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
+
+    with unittest.mock.patch("mapFolding.babbage._countFolds", side_effect=mock_countFolds):
+        returned = countFolds(listDimensionsTestFunctionality, writeFoldsTotal=pathWriteTarget)
+
+    standardComparison(foldsValue, lambda: returned)  # Check return value
+    standardComparison(str(foldsValue), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
+
 def test_intInnit() -> None:
     """Test integer parsing using the test suite generator."""
     for testName, testFunction in makeTestSuiteIntInnit(intInnit).items():
@@ -64,5 +97,102 @@ def test_oopsieKwargsie() -> None:
     for testName, testFunction in makeTestSuiteOopsieKwargsie(oopsieKwargsie).items():
         testFunction()
 
-def test_parseListDimensions_noDimensions() -> None:
-    standardComparison(ValueError, parseDimensions, [])
+# TODO mock CPU counts?
+# @pytest.mark.parametrize("CPUlimit, expectedLimit", [
+#     (None, numba.config.NUMBA_DEFAULT_NUM_THREADS),
+#     (False, numba.config.NUMBA_DEFAULT_NUM_THREADS),
+#     (True, 1),
+#     (4, 4),
+#     (0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)),
+#     (-0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)),
+#     (-2, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS - 2)),
+# ])
+# def test_setCPUlimit(CPUlimit, expectedLimit) -> None:
+#     standardComparison(expectedLimit, setCPUlimit, CPUlimit)
+
+def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[int]) -> None:
+    connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality)
+    assert numpy.all(connectionGraph >= 0), "All values in the connection graph should be non-negative."
+
+@pytest.mark.parametrize("datatype", [numpy.int16, numpy.uint64])
+def test_makeConnectionGraph_datatype(listDimensionsTestFunctionality: List[int], datatype) -> None:
+    connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality, datatype=datatype)
+    assert connectionGraph.dtype == datatype, f"Expected datatype {datatype}, but got {connectionGraph.dtype}."
+
+# @pytest.mark.parametrize("computationDivisions,CPUlimit,datatypeOverrides", [
+#     (None, None, {}),  # Basic case
+#     ("maximum", True, {"datatypeDefault": numpy.int32}),  # Max divisions, min CPU, custom dtype
+#     ("cpu", 4, {"datatypeLarge": numpy.int64}),  # CPU-based divisions, fixed CPU limit
+#     (3, 0.5, {}),  # Fixed divisions, fractional CPU
+# ])
+# def test_outfitCountFolds(
+#     listDimensionsTestFunctionality: List[int],
+#     computationDivisions: Optional[Union[int, str]],
+#     CPUlimit: Optional[Union[bool, float, int]],
+#     datatypeOverrides: Dict[str, Any]
+# ) -> None:
+#     """Test outfitCountFolds as a nexus of configuration and initialization.
+
+#     Strategy:
+#     1. Validate structure against computationState TypedDict
+#     2. Compare with direct function calls
+#     3. Verify enum-based indexing
+#     4. Check datatypes and shapes
+#     """
+#     # Get initialized state
+#     stateInitialized = outfitCountFolds(
+#         listDimensionsTestFunctionality,
+#         computationDivisions=computationDivisions,
+#         CPUlimit=CPUlimit,
+#         **datatypeOverrides
+#     )
+
+#     # 1. TypedDict structure validation
+#     for keyRequired in computationState.__annotations__:
+#         assert keyRequired in stateInitialized, f"Missing required key: {keyRequired}"
+#         assert stateInitialized[keyRequired] is not None, f"Key has None value: {keyRequired}"
+
+#         # Type checking
+#         expectedType = computationState.__annotations__[keyRequired]
+#         assert isinstance(stateInitialized[keyRequired], expectedType), \
+#             f"Type mismatch for {keyRequired}: expected {expectedType}, got {type(stateInitialized[keyRequired])}"
+
+#     # 2. Compare with direct function calls
+#     directMapShape = tuple(sorted(validateListDimensions(listDimensionsTestFunctionality)))
+#     assert stateInitialized['mapShape'] == directMapShape
+
+#     directConnectionGraph = makeConnectionGraph(
+#         directMapShape,
+#         datatype=datatypeOverrides.get('datatypeDefault', dtypeDefault)
+#     )
+#     assert numpy.array_equal(stateInitialized['connectionGraph'], directConnectionGraph)
+
+#     # 3. Enum-based indexing validation
+#     for arrayName, indexEnum in [
+#         ('my', indexMy),
+#         ('the', indexThe),
+#         ('track', indexTrack)
+#     ]:
+#         array = stateInitialized[arrayName]
+#         assert array.shape[0] >= len(indexEnum), \
+#             f"Array {arrayName} too small for enum {indexEnum.__name__}"
+
+#         # Test each enum index
+#         for enumMember in indexEnum:
+#             assert array[enumMember.value] >= 0, \
+#                 f"Negative value at {arrayName}[{enumMember.name}]"
+
+#     # 4. Special value checks
+#     assert stateInitialized['my'][indexMy.leaf1ndex.value] == 1, \
+#         "Initial leaf index should be 1"
+
+#     # 5. Shape consistency
+#     leavesTotal = getLeavesTotal(listDimensionsTestFunctionality)
+#     assert stateInitialized['foldsSubTotals'].shape == (leavesTotal,), \
+#         "foldsSubTotals shape mismatch"
+#     assert stateInitialized['gapsWhere'].shape == (leavesTotal * leavesTotal + 1,), \
+#         "gapsWhere shape mismatch"
+#     assert stateInitialized['track'].shape == (len(indexTrack), leavesTotal + 1), \
+#         "track shape mismatch"
+
+# TODO test `outfitCountFolds`; no negative values in arrays; compare datatypes to the typeddict; compare the connection graph to making a graph

tests/test_tasks.py

@@ -3,6 +3,7 @@ import pytest
 from typing import List, Dict, Tuple
 
 # 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_countFolds_computationDivisions(listDimensionsTest_countFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
     standardComparison(foldsTotalKnown[tuple(listDimensionsTest_countFolds)], countFolds, listDimensionsTest_countFolds, None, 'maximum')
@@ -14,8 +15,17 @@ def test_defineConcurrencyLimit() -> None:
 
 @pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
 def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
-    # This forces CPUlimit = oopsieKwargsie(cpuLimitValue).
     standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
 
 def test_countFolds_invalid_computationDivisions(listDimensionsTestFunctionality: List[int]) -> None:
     standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
+
+@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, concurrencyLimit, listDimensions, expectedTaskDivisions) -> None:
+    standardComparison(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, None, listDimensions)

mapFolding/importPackages.py

@@ -1,5 +0,0 @@
-"""Experiment"""
-from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from Z0Z_tools.pytest_parseParameters import makeTestSuiteConcurrencyLimit
-from Z0Z_tools.pytest_parseParameters import makeTestSuiteIntInnit
-from Z0Z_tools.pytest_parseParameters import makeTestSuiteOopsieKwargsie

mapFolding-0.2.1.dist-info/RECORD

@@ -1,28 +0,0 @@
-mapFolding/__init__.py,sha256=3kQQWyOBriVg9wO5btGE1Cq3lNqJz6CudrkOxVWcsy8,368
-mapFolding/babbage.py,sha256=3D1qcntoiJm2tqgbiCAMc7GpGA0SZTdGORNEnensyxk,1882
-mapFolding/beDRY.py,sha256=QACsmdskZplzMpYGUu7DSTSCE7x5JFApEyUqvUh0H0c,12613
-mapFolding/importPackages.py,sha256=Pno5VXaNiyJKG2Jtj4sB_h6EG50IJ7tQKyivVoKFMxo,303
-mapFolding/lovelace.py,sha256=qcyGpVEPP3n0r-RNrSUgPRP3yZJfBEfmok7jYMm1OI0,11473
-mapFolding/oeis.py,sha256=c8oCAcWgLvwC-bBZzGty8yth1vWtT8lWcKQeCiNGYgw,12078
-mapFolding/startHere.py,sha256=Z73A2bm35XygF6bpz710S8G2tVRdU_5-nO-nDgTaDhM,5068
-mapFolding/theSSOT.py,sha256=-t23-gPLPNWWBEeSi1mKkNCeeQA4y1AA_oPKC7tZwe4,1970
-mapFolding/JAX/lunnanJAX.py,sha256=xMZloN47q-MVfjdYOM1hi9qR4OnLq7qALmGLMraevQs,14819
-mapFolding/JAX/taskJAX.py,sha256=yJNeH0rL6EhJ6ppnATHF0Zf81CDMC10bnPnimVxE1hc,20037
-mapFolding/benchmarks/benchmarking.py,sha256=kv85F6V9pGhZvTOImArOuxyg5rywA_T6JLH_qFXM8BM,3018
-mapFolding/benchmarks/test_benchmarks.py,sha256=c4ANeR3jgqpKXFoxDeZkmAHxSuenMwsjmrhKJ1_XPqY,3659
-mapFolding/reference/hunterNumba.py,sha256=jV0dBjhLcnJjUHWRxLV_xvPIUP_GRLRKVeDhOtM9Wp4,7475
-mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
-mapFolding/reference/lunnan.py,sha256=SwjpOr1ROg-yZaZuiL7XjXhuvBxu_K4gQoPAWKUjJk4,5037
-mapFolding/reference/lunnanNumpy.py,sha256=bDQsBZUQcqJ9bTdnMF7HgtPcgpIodctujkm_lpq9NZ4,4653
-mapFolding/reference/lunnanWhile.py,sha256=p8_zLdMc6ujTYIu_yn-hbzOuLTQHvo0ENciIDmKayDU,4067
-mapFolding/reference/rotatedEntryPoint.py,sha256=6WVvEcGwDgRPa7dDs7ODAHUJjHDZDIDN6CXH8fFVFmA,12105
-tests/__init__.py,sha256=PGYVr7r23gATgcvZ3Sfph9D_g1MVvhgzMNWXBs_9tmY,52
-tests/conftest.py,sha256=ur6l5nDnWju7zOEMXqoNGYHY-Hf9GApOm4VT9pXtMtY,10594
-tests/test_oeis.py,sha256=h-NhWRoarl3v6qoB0RpnaUPuMGrQpWyfmsL0FXsGauU,7972
-tests/test_other.py,sha256=3Qc6fA39q5u_U0JhFUB9mdBd5_XcVC7IP9DwlNuG9p8,4716
-tests/test_tasks.py,sha256=Hn4N8OVVfDeNjL7ad5ELKKDgdOn8sDBj6IebPGpLIlE,1254
-mapFolding-0.2.1.dist-info/METADATA,sha256=r7QVig9M5_DReHsPG_wyyRNJe0UkggfUotMf8tfoF7I,5914
-mapFolding-0.2.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.2.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.2.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.2.1.dist-info/RECORD,,