hunterMakesPy 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

hunterMakesPy/tests/test_parseParameters.py

@@ -0,0 +1,339 @@
+# pyright: standard
+from collections.abc import Callable, Iterable, Iterator
+from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
+from typing import Any, NoReturn, ParamSpec, TypeVar
+from unittest.mock import Mock, patch
+import pytest
+
+parameters = ParamSpec('parameters')
+returnType = TypeVar('returnType')
+
+def PytestFor_defineConcurrencyLimit(callableToTest: Callable[..., int] = defineConcurrencyLimit, cpuCount: int = 8) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
+	"""Return a list of test functions to validate concurrency limit behavior.
+
+	This function provides a comprehensive test suite for validating concurrency limit parsing
+	and computation, checking both valid and invalid input scenarios.
+
+	Parameters
+	----------
+	callableToTest : Callable[[bool | float | int | None, int], int] = defineConcurrencyLimit
+		The function to test, which should accept various input types and return an integer
+		representing the concurrency limit.
+	cpuCount : int = 8
+		The number of CPUs to simulate in the test environment.
+
+	Returns
+	-------
+	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
+		A list of tuples, each containing a string describing the test case and a callable
+		test function that implements the test case.
+
+	Examples
+	--------
+	Run each test on `hunterMakesPy.defineConcurrencyLimit`:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_defineConcurrencyLimit
+
+	listOfTests = PytestFor_defineConcurrencyLimit()
+	for nameOfTest, callablePytest in listOfTests:
+		callablePytest()
+	```
+
+	Or, run each test on your function that has a compatible signature:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_defineConcurrencyLimit
+	from packageLocal import functionLocal
+
+	@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit(callableToTest=functionLocal))
+	def test_functionLocal(nameOfTest, callablePytest):
+		callablePytest()
+	```
+
+	"""
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testDefaults(_mockCpu: Mock) -> None:
+		listOfParameters: list[bool | int | None] = [None, False, 0]
+		for limitParameter in listOfParameters:
+			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) == cpuCount
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testDirectIntegers(_mockCpu: Mock) -> None:
+		for limitParameter in [1, 4, 16]:
+			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) == limitParameter
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testFractionalFloats(_mockCpu: Mock) -> None:
+		testCases: dict[float, int] = {
+			0.5: cpuCount // 2,
+			0.25: cpuCount // 4,
+			0.75: int(cpuCount * 0.75)
+		}
+		for limit, expected in testCases.items():
+			assert callableToTest(limit=limit, cpuTotal=cpuCount) == expected
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testMinimumOne(_mockCpu: Mock) -> None:
+		listOfParameters: list[float | int] = [-10, -0.99, 0.1]
+		for limitParameter in listOfParameters:
+			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) >= 1
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testBooleanTrue(_mockCpu: Mock) -> None:
+		assert callableToTest(limit=True, cpuTotal=cpuCount) == 1
+		assert callableToTest(limit='True', cpuTotal=cpuCount) == 1  # pyright: ignore[reportArgumentType]
+		assert callableToTest(limit='TRUE', cpuTotal=cpuCount) == 1 # pyright: ignore[reportArgumentType]
+		assert callableToTest(limit=' true ', cpuTotal=cpuCount) == 1 # pyright: ignore[reportArgumentType]
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testInvalidStrings(_mockCpu: Mock) -> None:
+		for stringInput in ["invalid", "True but not quite", "None of the above"]:
+			with pytest.raises(ValueError, match="must be a number, `True`, `False`, or `None`"):
+				callableToTest(limit=stringInput, cpuTotal=cpuCount) # pyright: ignore[reportArgumentType]
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testStringNumbers(_mockCpu: Mock) -> None:
+		testCases: list[tuple[str, int]] = [
+			("1.51", 2),
+			("-2.51", 5),
+			("4", 4),
+			("0.5", 4),
+			("-0.25", 6),
+		]
+		for stringNumber, expectedLimit in testCases:
+			assert callableToTest(limit=stringNumber, cpuTotal=cpuCount) == expectedLimit # pyright: ignore[reportArgumentType]
+
+	return [
+		('testDefaults', testDefaults),
+		('testDirectIntegers', testDirectIntegers),
+		('testFractionalFloats', testFractionalFloats),
+		('testMinimumOne', testMinimumOne),
+		('testBooleanTrue', testBooleanTrue),
+		('testInvalidStrings', testInvalidStrings),
+		('testStringNumbers', testStringNumbers)
+	]
+
+def PytestFor_intInnit(callableToTest: Callable[[Iterable[int], str | None, type[Any] | None], list[int]] = intInnit) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
+	"""Return a list of test functions to validate integer initialization behavior.
+
+	This function provides a comprehensive test suite for validating integer parsing
+	and initialization, checking both valid and invalid input scenarios.
+
+	Parameters
+	----------
+	callableToTest : Callable[[Iterable[int], str | None, type[Any] | None], list[int]] = intInnit
+		The function to test. Should accept a sequence of integer-compatible values,
+		an optional parameter name string, and an optional parameter type.
+		Returns a list of validated integers.
+
+	Returns
+	-------
+	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
+		A list of tuples containing a string describing the test case and a callable
+		test function implementing the test case.
+
+	Examples
+	--------
+	Run tests on `hunterMakesPy.intInnit`:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_intInnit
+
+	listOfTests = PytestFor_intInnit()
+	for nameOfTest, callablePytest in listOfTests:
+		callablePytest()
+	```
+
+	Run tests on your compatible function:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_intInnit
+	from packageLocal import functionLocal
+
+	@pytest.mark.parametrize("nameOfTest,callablePytest",
+		PytestFor_intInnit(callableToTest=functionLocal))
+	def test_functionLocal(nameOfTest, callablePytest):
+		callablePytest()
+	```
+
+	"""
+	def testHandlesValidIntegers() -> None:
+		assert callableToTest([2, 3, 5, 8], 'test', None) == [2, 3, 5, 8]
+		assert callableToTest([13.0, 21.0, 34.0], 'test', None) == [13, 21, 34] # pyright: ignore[reportArgumentType]
+		assert callableToTest(['55', '89', '144'], 'test', None) == [55, 89, 144] # pyright: ignore[reportArgumentType]
+		assert callableToTest([' 233 ', '377', '-610'], 'test', None) == [233, 377, -610] # pyright: ignore[reportArgumentType]
+
+	def testRejectsNonWholeNumbers() -> None:
+		listInvalidNumbers: list[float] = [13.7, 21.5, 34.8, -55.9]
+		for invalidNumber in listInvalidNumbers:
+			with pytest.raises(ValueError):
+				callableToTest([invalidNumber], 'test', None) # pyright: ignore[reportArgumentType]
+
+	def testRejectsBooleans() -> None:
+		with pytest.raises(TypeError):
+			callableToTest([True, False], 'test', None)
+
+	def testRejectsInvalidStrings() -> None:
+		for invalidString in ['NW', '', ' ', 'SE.SW']:
+			with pytest.raises(ValueError):
+				callableToTest([invalidString], 'test', None) # pyright: ignore[reportArgumentType]
+
+	def testRejectsEmptyList() -> None:
+		with pytest.raises(ValueError):
+			callableToTest([], 'test', None)
+
+	def testHandlesMixedValidTypes() -> None:
+		assert callableToTest([13, '21', 34.0], 'test', None) == [13, 21, 34] # pyright: ignore[reportArgumentType]
+
+	def testHandlesBytes() -> None:
+		validCases: list[tuple[list[bytes], str, list[int]]] = [
+			([b'123'], '123', [123]),
+		]
+		for inputData, testName, expected in validCases:
+			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
+
+		extendedCases: list[tuple[list[bytes], str, list[int]]] = [
+			([b'123456789'], '123456789', [123456789]),
+		]
+		for inputData, testName, expected in extendedCases:
+			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
+
+		invalidCases: list[list[bytes]] = [[b'\x00']]
+		for inputData in invalidCases:
+			with pytest.raises(ValueError):
+				callableToTest(inputData, 'test', None) # pyright: ignore[reportArgumentType]
+
+	def testHandlesMemoryview() -> None:
+		validCases: list[tuple[list[memoryview], str, list[int]]] = [
+			([memoryview(b'123')], '123', [123]),
+		]
+		for inputData, testName, expected in validCases:
+			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
+
+		largeMemoryviewCase: list[memoryview] = [memoryview(b'9999999999')]
+		assert callableToTest(largeMemoryviewCase, 'test', None) == [9999999999] # pyright: ignore[reportArgumentType]
+
+		invalidMemoryviewCases: list[list[memoryview]] = [[memoryview(b'\x00')]]
+		for inputData in invalidMemoryviewCases:
+			with pytest.raises(ValueError):
+				callableToTest(inputData, 'test', None) # pyright: ignore[reportArgumentType]
+
+	def testRejectsMutableSequence() -> None:
+		class MutableList(list[int]):
+			def __iter__(self) -> Iterator[int]:
+				self.append(89)
+				return super().__iter__()
+		with pytest.raises(RuntimeError, match=".*modified during iteration.*"):
+			callableToTest(MutableList([13, 21, 34]), 'test', None)
+
+	def testHandlesComplexIntegers() -> None:
+		testCases: list[tuple[list[complex], list[int]]] = [
+			([13+0j], [13]),
+			([21+0j, 34+0j], [21, 34])
+		]
+		for inputData, expected in testCases:
+			assert callableToTest(inputData, 'test', None) == expected # pyright: ignore[reportArgumentType]
+
+	def testRejectsInvalidComplex() -> None:
+		for invalidComplex in [13+1j, 21+0.5j, 34.5+0j]:
+			with pytest.raises(ValueError):
+				callableToTest([invalidComplex], 'test', None) # pyright: ignore[reportArgumentType]
+
+	return [
+		('testHandlesValidIntegers', testHandlesValidIntegers),
+		('testRejectsNonWholeNumbers', testRejectsNonWholeNumbers),
+		('testRejectsBooleans', testRejectsBooleans),
+		('testRejectsInvalidStrings', testRejectsInvalidStrings),
+		('testRejectsEmptyList', testRejectsEmptyList),
+		('testHandlesMixedValidTypes', testHandlesMixedValidTypes),
+		('testHandlesBytes', testHandlesBytes),
+		('testHandlesMemoryview', testHandlesMemoryview),
+		('testRejectsMutableSequence', testRejectsMutableSequence),
+		('testHandlesComplexIntegers', testHandlesComplexIntegers),
+		('testRejectsInvalidComplex', testRejectsInvalidComplex)
+	]
+
+def PytestFor_oopsieKwargsie(callableToTest: Callable[[str], bool | None | str] = oopsieKwargsie) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
+	"""Return a list of test functions to validate string-to-boolean/None conversion behavior.
+
+	This function provides a comprehensive test suite for validating string parsing and conversion
+	to boolean or None values, with fallback to the original string when appropriate.
+
+	Parameters
+	----------
+	callableToTest : Callable[[str], bool | None | str] = oopsieKwargsie
+		The function to test, which should accept a string and return either a boolean, None,
+		or the original input.
+
+	Returns
+	-------
+	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
+		A list of tuples, each containing a string describing the test case and a callable
+		test function that implements the test case.
+
+	Examples
+	--------
+	Run each test on `hunterMakesPy.oopsieKwargsie`:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_oopsieKwargsie
+
+	listOfTests = PytestFor_oopsieKwargsie()
+	for nameOfTest, callablePytest in listOfTests:
+		callablePytest()
+	```
+
+	Or, run each test on your function that has a compatible signature:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_oopsieKwargsie
+	from packageLocal import functionLocal
+
+	@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_oopsieKwargsie(callableToTest=functionLocal))
+	def test_functionLocal(nameOfTest, callablePytest):
+		callablePytest()
+	```
+
+	"""
+	def testHandlesTrueVariants() -> None:
+		for variantTrue in ['True', 'TRUE', ' true ', 'TrUe']:
+			assert callableToTest(variantTrue) is True
+
+	def testHandlesFalseVariants() -> None:
+		for variantFalse in ['False', 'FALSE', ' false ', 'FaLsE']:
+			assert callableToTest(variantFalse) is False
+
+	def testHandlesNoneVariants() -> None:
+		for variantNone in ['None', 'NONE', ' none ', 'NoNe']:
+			assert callableToTest(variantNone) is None
+
+	def testReturnsOriginalString() -> None:
+		for stringInput in ['hello', '123', 'True story', 'False alarm']:
+			assert callableToTest(stringInput) == stringInput
+
+	def testHandlesNonStringObjects() -> None:
+		class NeverGonnaStringIt:
+			def __str__(self) -> NoReturn:
+				message = "Cannot be stringified"
+				raise TypeError(message)
+
+		assert callableToTest(123) == "123" # pyright: ignore[reportArgumentType]
+
+		neverGonnaStringIt = NeverGonnaStringIt()
+		result = callableToTest(neverGonnaStringIt) # pyright: ignore[reportArgumentType]
+		assert result is neverGonnaStringIt
+
+	return [
+		('testHandlesTrueVariants', testHandlesTrueVariants),
+		('testHandlesFalseVariants', testHandlesFalseVariants),
+		('testHandlesNoneVariants', testHandlesNoneVariants),
+		('testReturnsOriginalString', testReturnsOriginalString),
+		('testHandlesNonStringObjects', testHandlesNonStringObjects)
+	]
+
+@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_defineConcurrencyLimit())
+def testConcurrencyLimit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	aPytest(*arguments, **keywordArguments)
+
+@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_intInnit())
+def testIntInnit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	aPytest(*arguments, **keywordArguments)
+
+@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_oopsieKwargsie())
+def testOopsieKwargsie(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	aPytest(*arguments, **keywordArguments)

{huntermakespy-0.1.2.dist-info → huntermakespy-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.1.2
+Version: 0.2.0
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
@@ -32,7 +33,7 @@ License-File: LICENSE
 Requires-Dist: charset_normalizer
 Requires-Dist: more_itertools
 Requires-Dist: numpy
-Requires-Dist: python_minifier
+Requires-Dist: python_minifier; python_version < "3.14"
 Provides-Extra: development
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"

huntermakespy-0.2.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+hunterMakesPy/__init__.py,sha256=bVF1F2Mdo5AOiioEfxKvNrnsa3vCFI16eMK7Oy5O5TU,1450
+hunterMakesPy/_theSSOT.py,sha256=lkLOG3oTIWNKD_ULX55chlUGNqCHgqVIrBvolvK1vbQ,153
+hunterMakesPy/coping.py,sha256=covqNFAwkF9gjafrlAvMdtCO8haFsESQBhO-7s68qSg,5581
+hunterMakesPy/dataStructures.py,sha256=CFyGjmAOoN2MoEPwWwWdwKNXmOXX8kCS3ttMOa2Rsx0,11379
+hunterMakesPy/filesystemToolkit.py,sha256=vDYS0Rc1aP7ETLXHKoO3TfOpuwJQFQW2ybwtJNiIIo4,4305
+hunterMakesPy/parseParameters.py,sha256=DXpyATx7trGBg_8jlO5dXGfLcG8vg_lU3R1sq1rRFOQ,11644
+hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hunterMakesPy/pytestForYourUse.py,sha256=GiN1C1gTTM0ZunRPEMnrKlLQLMdH0wF_ZGr_RPgRjjA,500
+hunterMakesPy/theTypes.py,sha256=C2d0uLn1VIx6_2CK41it3IP7iplSQqe51tzWc-RT320,306
+hunterMakesPy/tests/__init__.py,sha256=C_FzfKDi_VrGVxlenWHyOYtKShAKlt3KW14jeRx1mQI,224
+hunterMakesPy/tests/conftest.py,sha256=K-XAGvYp6CZVCox5G5DvFA9Qk7X-oBl1BccmOXVn0BI,1645
+hunterMakesPy/tests/test_coping.py,sha256=mH89TUAL6fJanBLlhdVlCNNQqm5OpdcQMP_p5W2JJwo,9860
+hunterMakesPy/tests/test_dataStructures.py,sha256=O4aqzSKg7KfWWVhIewOH0Y8Zj28PbFCb4XX3xhwuFQA,16605
+hunterMakesPy/tests/test_filesystemToolkit.py,sha256=HmRKHXAvGz12YAI-FT9tz42CDNK6p5NcZEVPLzdfetE,2460
+hunterMakesPy/tests/test_parseParameters.py,sha256=80npsoWcCackjxvoW2dMXMpHeale7fuRXyXp78MibLs,14037
+huntermakespy-0.2.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+huntermakespy-0.2.0.dist-info/METADATA,sha256=FnWnf_rjZ_-uC3s1j4rUeLmOYc4B1s6j8TOJJcn3QlY,6631
+huntermakespy-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+huntermakespy-0.2.0.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
+huntermakespy-0.2.0.dist-info/RECORD,,

{huntermakespy-0.1.2.dist-info → huntermakespy-0.2.0.dist-info}/top_level.txt

@@ -1,2 +1 @@
 hunterMakesPy
-tests

huntermakespy-0.1.2.dist-info/RECORD

@@ -1,20 +0,0 @@
-hunterMakesPy/__init__.py,sha256=4gIm--UJmlQEhbLCqpiVFM_JVbyfVpvFFAJyMNFHekk,1329
-hunterMakesPy/_theSSOT.py,sha256=lkLOG3oTIWNKD_ULX55chlUGNqCHgqVIrBvolvK1vbQ,153
-hunterMakesPy/coping.py,sha256=covqNFAwkF9gjafrlAvMdtCO8haFsESQBhO-7s68qSg,5581
-hunterMakesPy/dataStructures.py,sha256=znMEnboo2iNXZtQKdmruRrJDEoeTfqoH4-coUDM75g4,11218
-hunterMakesPy/filesystemToolkit.py,sha256=vDYS0Rc1aP7ETLXHKoO3TfOpuwJQFQW2ybwtJNiIIo4,4305
-hunterMakesPy/parseParameters.py,sha256=plrJ4xR1FQnQR9j-oeMAwB2H9r_8QD8OALnw0OH8Kt0,11947
-hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hunterMakesPy/pytestForYourUse.py,sha256=21BI8TXyinf8rMmS6dTsuRMBOOFTcyoG_gD__Gz_e7Q,13288
-hunterMakesPy/theTypes.py,sha256=C2d0uLn1VIx6_2CK41it3IP7iplSQqe51tzWc-RT320,306
-huntermakespy-0.1.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=MkNc4Ar6yYrnAok4t1NWsgyOYFDiGo1qwXHyp8ChJf4,1672
-tests/test_coping.py,sha256=MQl0fhdWX2YSFzzjWMThSm_ZSnglE3anSJO2b33typU,9846
-tests/test_dataStructures.py,sha256=VhM3VzG1l8l3Iz1q9sQjpNBQTWSrl4zWbnefsGTccos,16406
-tests/test_filesystemToolkit.py,sha256=jk6Ke0fW6dlHIVyvA1lh7o7_I7DVZr6uMO3s_i43isQ,2445
-tests/test_parseParameters.py,sha256=bHD-O-OyWWwPOx3zvS53pSNPDm3LbFS05N5JcfNCLG4,1137
-huntermakespy-0.1.2.dist-info/METADATA,sha256=b1Xr8jhpu8t-H3BTVQUcCww_gG8q5fcb1REz-8AQbY8,6555
-huntermakespy-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-huntermakespy-0.1.2.dist-info/top_level.txt,sha256=dUy7z3LNO6aqNjPD81tZjE5N9HO70a14Y9lAWjWC2gA,20
-huntermakespy-0.1.2.dist-info/RECORD,,

tests/test_parseParameters.py

@@ -1,21 +0,0 @@
-# pyright: standard
-from collections.abc import Callable
-from hunterMakesPy.pytestForYourUse import (
-	PytestFor_defineConcurrencyLimit, PytestFor_intInnit, PytestFor_oopsieKwargsie)
-from typing import ParamSpec, TypeVar
-import pytest
-
-parameters = ParamSpec('parameters')
-returnType = TypeVar('returnType')
-
-@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_defineConcurrencyLimit())
-def testConcurrencyLimit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
-	aPytest(*arguments, **keywordArguments)
-
-@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_intInnit())
-def testIntInnit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
-	aPytest(*arguments, **keywordArguments)
-
-@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_oopsieKwargsie())
-def testOopsieKwargsie(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
-	aPytest(*arguments, **keywordArguments)