mapFolding 0.2.0__py3-none-any.whl

tests/test_oeis.py

@@ -0,0 +1,195 @@
+from .conftest import *
+from contextlib import redirect_stdout
+from datetime import datetime, timedelta
+import io
+import os
+import pathlib
+import pytest
+import random
+import re as regex
+import unittest
+import unittest.mock
+import urllib.error
+import urllib.request
+
+def test_aOFn_calculate_value(oeisID: str):
+    for n in settingsOEIS[oeisID]['valuesTestValidation']:
+        standardComparison(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+
+@pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
+def test__validateOEISid_invalid_id(badID: str):
+    standardComparison(KeyError, _validateOEISid, badID)
+
+def test__validateOEISid_partially_valid(oeisID_1random: str):
+    standardComparison(KeyError, _validateOEISid, f"{oeisID_1random}extra")
+
+def test__validateOEISid_valid_id(oeisID: str):
+    standardComparison(oeisID, _validateOEISid, oeisID)
+
+def test__validateOEISid_valid_id_case_insensitive(oeisID: str):
+    standardComparison(oeisID.upper(), _validateOEISid, oeisID.lower())
+    standardComparison(oeisID.upper(), _validateOEISid, oeisID.upper())
+    standardComparison(oeisID.upper(), _validateOEISid, oeisID.swapcase())
+
+parameters_test_aOFn_invalid_n = [
+    # (2, "ok"), # test the test template
+    (-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):
+    """Check that negative or non-integer n raises ValueError."""
+    standardComparison(ValueError, oeisIDfor_n, oeisID_1random, badN)
+
+def test_aOFn_zeroDim_A001418():
+    standardComparison(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):
+    """Test OEIS cache clearing with both existing and non-existing cache."""
+    mock_exists.return_value = cacheExists
+    clearOEIScache()
+
+    if cacheExists:
+        assert mock_unlink.call_count == len(settingsOEIS)
+        mock_unlink.assert_has_calls([unittest.mock.call(missing_ok=True)] * len(settingsOEIS))
+    else:
+        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)
+
+def testCacheExpired(pathCacheTesting: pathlib.Path, oeisID_1random: str):
+    """Test expired cache scenario."""
+    def setupExpiredCache(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:
+        pathCache.write_text("Invalid content")
+
+    standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupInvalidCache, oeisID_1random, pathCacheTesting)
+
+def testInvalidFileContent(pathCacheTesting: pathlib.Path, oeisID_1random: str):
+    pathFilenameCache = pathCacheTesting / _formatFilenameCache.format(oeisID=oeisID_1random)
+
+    # Write invalid content to cache
+    pathFilenameCache.write_text("# A999999\n1 1\n2 2\n")
+    modificationTimeOriginal = pathFilenameCache.stat().st_mtime
+
+    # Function should detect invalid content, fetch fresh data, and update cache
+    OEISsequence = _getOEISidValues(oeisID_1random)
+
+    # Verify the function succeeded
+    assert OEISsequence is not None
+    # Verify cache was updated (modification time changed)
+    assert pathFilenameCache.stat().st_mtime > modificationTimeOriginal
+    # 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)
+
+    # Write content with extra comment lines
+    contentWithExtraComments = f"""# {oeisID_1random}
+# Extra comment line 1
+# Extra comment line 2
+1 2
+2 4
+3 6
+# Another comment in the middle
+4 8
+5 10"""
+    pathFilenameCache.write_text(contentWithExtraComments)
+
+    OEISsequence = _getOEISidValues(oeisID_1random)
+    # Verify sequence values are correct despite extra comments
+    standardComparison(2, lambda d: d[1], OEISsequence)  # First value
+    standardComparison(8, lambda d: d[4], OEISsequence)  # Value after mid-sequence comment
+    standardComparison(10, lambda d: d[5], OEISsequence)  # Last value
+
+# ===== Command Line Interface Tests =====
+def testHelpText():
+    """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()
+        standardComparison(expectedValue, lambda: int(outputStream.getvalue().strip().split()[0]))
+
+def testCLI_InvalidInputs():
+    """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):
+            expectSystemExit("error", OEIS_for_n)
+
+def testCLI_HelpFlag():
+    """Verify --help output contains required information."""
+    with unittest.mock.patch('sys.argv', ['OEIS_for_n', '--help']):
+        outputStream = io.StringIO()
+        with redirect_stdout(outputStream):
+            expectSystemExit("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,71 @@
+from .conftest import *
+import pytest
+import sys
+# TODO test `outfitFoldings`, especially that `listDimensions` is sorted.
+
+@pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
+    (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
+    (['a'], ValueError, ValueError, ValueError, ValueError),  # string
+    ([-4, 2], [-4, 2], ValueError, ValueError, ValueError),  # negative
+    ([-3], [-3], ValueError, ValueError, ValueError),  # negative
+    ([0, 0], [0, 0], [0, 0], NotImplementedError, 0),  # no positive dimensions
+    ([0, 5, 6], [0, 5, 6], [0, 5, 6], [5, 6], 30),  # zeros ignored
+    ([0], [0], [0], NotImplementedError, 0),  # edge case
+    ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], 120),  # sequential
+    ([1, sys.maxsize], [1, sys.maxsize], [1, sys.maxsize], [1, sys.maxsize], sys.maxsize),  # maxint
+    ([7.5], ValueError, ValueError, ValueError, ValueError),  # float
+    ([1] * 1000, [1] * 1000, [1] * 1000, [1] * 1000, 1),  # long list
+    ([11], [11], [11], NotImplementedError, 11),  # single dimension
+    ([13, 0, 17], [13, 0, 17], [13, 0, 17], [13, 17], 221),  # zeros handled
+    ([2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], 16),  # repeated dimensions
+    ([2, 3, 4], [2, 3, 4], [2, 3, 4], [2, 3, 4], 24),
+    ([2, 3], [2, 3], [2, 3], [2, 3], 6),
+    ([2] * 11, [2] * 11, [2] * 11, [2] * 11, 2048),  # power of 2
+    ([3, 2], [3, 2], [3, 2], [3, 2], 6),  # return value is the input when valid
+    ([3] * 5, [3] * 5, [3] * 5, [3, 3, 3, 3, 3], 243),  # power of 3
+    ([None], TypeError, TypeError, TypeError, TypeError),  # None
+    ([True], TypeError, TypeError, TypeError, TypeError),  # bool
+    ([[17, 39]], TypeError, TypeError, TypeError, TypeError),  # nested
+    ([], ValueError, ValueError, ValueError, ValueError),  # empty
+    ([complex(1,1)], ValueError, ValueError, ValueError, ValueError),  # complex number
+    ([float('inf')], ValueError, ValueError, ValueError, ValueError),  # infinity
+    ([float('nan')], ValueError, ValueError, ValueError, ValueError),  # NaN
+    ([sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [sys.maxsize - 1, 1], sys.maxsize - 1),  # near maxint
+    ([sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], OverflowError),  # overflow protection
+    ([sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], OverflowError),  # overflow protection
+    (range(3, 7), [3, 4, 5, 6], [3, 4, 5, 6], [3, 4, 5, 6], 360),  # range sequence type
+    (tuple([3, 5, 7]), [3, 5, 7], [3, 5, 7], [3, 5, 7], 105),  # 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_parseListDimensions: type[ValueError] | list[int] | type[TypeError], expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | list[int] | type[TypeError], expected_getLeavesTotal: type[ValueError] | int | type[TypeError] | type[OverflowError]) -> None:
+    """Test both validateListDimensions and getLeavesTotal with the same inputs."""
+    standardComparison(expected_intInnit, intInnit, listDimensions)
+    standardComparison(expected_parseListDimensions, parseDimensions, listDimensions)
+    standardComparison(expected_validateListDimensions, validateListDimensions, listDimensions)
+    standardComparison(expected_getLeavesTotal, getLeavesTotal, listDimensions)
+
+def test_getLeavesTotal_edge_cases() -> None:
+    """Test edge cases for getLeavesTotal."""
+    # Order independence
+    standardComparison(getLeavesTotal([2, 3, 4]), getLeavesTotal, [4, 2, 3])
+
+    # Immutability
+    listOriginal = [2, 3]
+    standardComparison(6, getLeavesTotal, listOriginal)
+    standardComparison([2, 3], lambda x: x, listOriginal)  # Check that the list wasn't modified
+
+# ===== Parse Integers Tests =====
+def test_intInnit() -> None:
+    """Test integer parsing using the test suite generator."""
+    for testName, testFunction in makeTestSuiteIntInnit(intInnit).items():
+        testFunction()
+
+def test_oopsieKwargsie() -> None:
+    """Test handling of unexpected keyword arguments."""
+    for testName, testFunction in makeTestSuiteOopsieKwargsie(oopsieKwargsie).items():
+        testFunction()
+
+def test_countFolds_invalid_computationDivisions() -> None:
+    standardComparison(ValueError, countFolds, [2, 2], {"wrong": "value"})
+
+def test_parseListDimensions_noDimensions() -> None:
+    standardComparison(ValueError, parseDimensions, [])

tests/test_tasks.py

@@ -0,0 +1,18 @@
+from .conftest import *
+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.
+
+def test_foldings_computationDivisions(listDimensionsTest_countFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
+    standardComparison(foldsTotalKnown[tuple(listDimensionsTest_countFolds)], countFolds, listDimensionsTest_countFolds, True)
+
+def test_defineConcurrencyLimit() -> None:
+    testSuite = makeTestSuiteConcurrencyLimit(defineConcurrencyLimit)
+    for testName, testFunction in testSuite.items():
+        testFunction()
+
+@pytest.mark.parametrize("cpuLimitValue", [{"invalid": True}, ["weird"]])
+def test_countFolds_cpuLimitOopsie(cpuLimitValue: Dict[str, bool] | List[str]) -> None:
+    # This forces CPUlimit = oopsieKwargsie(cpuLimitValue).
+    standardComparison(ValueError, countFolds, [2, 2], True, cpuLimitValue)