Move some functions into util

Author: felsenhower

conftest.py

@@ -19,9 +19,9 @@
 import json
 import re
 import shlex
+import shutil
 from pathlib import Path
 from random import shuffle
-import shutil
 
 import pytest
 

test_partdiff.py

@@ -3,105 +3,11 @@
 The test is parametrized by `pytest_generate_tests` in `conftest.py` via its `test_id` argument.
 """
 
-import os
-import subprocess
-from pathlib import Path
-
 import pytest
 
 import util
 from util import ReferenceSource, partdiff_params_tuple
 
-REFERENCE_IMPLEMENTATION_DIR = Path.cwd() / "reference_implementation"
-REFERENCE_IMPLEMENTATION_EXEC = REFERENCE_IMPLEMENTATION_DIR / "partdiff"
-
-
-def ensure_reference_implementation_exists() -> None:
-    """Ensure that the reference implementation exists.
-
-    If it doesn't exist, `make` is used to automatically compile it.
-    """
-
-    def is_executable():
-        executable = REFERENCE_IMPLEMENTATION_EXEC
-        return executable.exists() and os.access(executable, os.X_OK)
-
-    if is_executable():
-        return
-    subprocess.check_output(["make", "-C", REFERENCE_IMPLEMENTATION_DIR])
-    assert is_executable()
-
-
-def get_reference_output(
-    partdiff_params: partdiff_params_tuple,
-    reference_output_data: dict[partdiff_params_tuple, str],
-    reference_source: ReferenceSource,
-) -> str:
-    """Acquire the reference output.
-
-    Args:
-        partdiff_params (partdiff_params_tuple): The parameter combination to get the output for.
-        reference_output_data (dict[partdiff_params_tuple, str]): The cached reference output.
-        reference_source (ReferenceSource): The source of the reference output (cache, impl, or auto).
-
-    Raises:
-        RuntimeError: When reference_source=cache and the output for a parameter combination isn't cached.
-
-    Returns:
-        str: The reference output for the params.
-    """
-    # Force the number of threads to 1:
-    partdiff_params = ("1",) + partdiff_params[1:6]
-
-    def get_from_cache():
-        return reference_output_data[partdiff_params]
-
-    def get_from_impl():
-        ensure_reference_implementation_exists()
-        command_line = [REFERENCE_IMPLEMENTATION_EXEC] + list(partdiff_params)
-        return subprocess.check_output(command_line).decode("utf-8")
-
-    assert reference_source in ReferenceSource
-
-    match reference_source:
-        case ReferenceSource.auto:
-            if partdiff_params in reference_output_data:
-                return get_from_cache()
-            return get_from_impl()
-        case ReferenceSource.cache:
-            if partdiff_params not in reference_output_data:
-                raise RuntimeError(
-                    'Parameter combination "{}" was not found in cache'.format(
-                        " ".join(partdiff_params)
-                    )
-                )
-            return get_from_cache()
-        case ReferenceSource.impl:
-            return get_from_impl()
-
-
-def get_actual_output(
-    partdiff_params: partdiff_params_tuple,
-    partdiff_executable: list[str],
-    use_valgrind: bool,
-    cwd: Path | None,
-) -> str:
-    """Get the actual output for a parameter combination.
-
-    Args:
-        partdiff_params (partdiff_params_tuple): The parameter combination.
-        partdiff_executable (list[str]): The executable to run.
-        use_valgrind (bool): Wether valgrind shall be used.
-        cwd (Path | None): The working directory of the executable.
-
-    Returns:
-        str: The output of the executable.
-    """
-    command_line = partdiff_executable + list(partdiff_params)
-    if use_valgrind:
-        command_line = ["valgrind", "--leak-check=full"] + command_line
-    return subprocess.check_output(command_line, cwd=cwd).decode("utf-8")
-
 
 def test_partdiff_parametrized(
     pytestconfig: pytest.Config,
@@ -124,10 +30,10 @@ def test_partdiff_parametrized(
     reference_source = pytestconfig.getoption("reference_source")
     cwd = pytestconfig.getoption("cwd")
 
-    actual_output = get_actual_output(
+    actual_output = util.get_actual_output(
         partdiff_params, partdiff_executable, use_valgrind, cwd
     )
-    reference_output = get_reference_output(
+    reference_output = util.get_reference_output(
         partdiff_params, reference_output_data, reference_source
     )
 

util.py

@@ -1,11 +1,16 @@
 """Utility functions that are used by both `conftest.py` and `test_partdiff.py`."""
 
+import os
 import re
+import subprocess
 from collections.abc import Iterator
 from enum import StrEnum
 from functools import cache
 from pathlib import Path
 
+REFERENCE_IMPLEMENTATION_DIR = Path.cwd() / "reference_implementation"
+REFERENCE_IMPLEMENTATION_EXEC = REFERENCE_IMPLEMENTATION_DIR / "partdiff"
+
 ReferenceSource = StrEnum("ReferenceSource", ["auto", "cache", "impl"])
 
 RE_MATRIX_FLOAT = re.compile(r"[01]\.[0-9]{4}")
@@ -204,3 +209,90 @@ def get_reference_output_data_map() -> dict[partdiff_params_tuple, str]:
         dict[partdiff_params_tuple, str]: A dict mapping parameter combinations to the corresponding output.
     """
     return dict(iter_reference_output_data())
+
+
+def ensure_reference_implementation_exists() -> None:
+    """Ensure that the reference implementation exists.
+
+    If it doesn't exist, `make` is used to automatically compile it.
+    """
+
+    def is_executable():
+        executable = REFERENCE_IMPLEMENTATION_EXEC
+        return executable.exists() and os.access(executable, os.X_OK)
+
+    if is_executable():
+        return
+    subprocess.check_output(["make", "-C", REFERENCE_IMPLEMENTATION_DIR])
+    assert is_executable()
+
+
+def get_reference_output(
+    partdiff_params: partdiff_params_tuple,
+    reference_output_data: dict[partdiff_params_tuple, str],
+    reference_source: ReferenceSource,
+) -> str:
+    """Acquire the reference output.
+
+    Args:
+        partdiff_params (partdiff_params_tuple): The parameter combination to get the output for.
+        reference_output_data (dict[partdiff_params_tuple, str]): The cached reference output.
+        reference_source (ReferenceSource): The source of the reference output (cache, impl, or auto).
+
+    Raises:
+        RuntimeError: When reference_source=cache and the output for a parameter combination isn't cached.
+
+    Returns:
+        str: The reference output for the params.
+    """
+    # Force the number of threads to 1:
+    partdiff_params = ("1",) + partdiff_params[1:6]
+
+    def get_from_cache():
+        return reference_output_data[partdiff_params]
+
+    def get_from_impl():
+        ensure_reference_implementation_exists()
+        command_line = [REFERENCE_IMPLEMENTATION_EXEC] + list(partdiff_params)
+        return subprocess.check_output(command_line).decode("utf-8")
+
+    assert reference_source in ReferenceSource
+
+    match reference_source:
+        case ReferenceSource.auto:
+            if partdiff_params in reference_output_data:
+                return get_from_cache()
+            return get_from_impl()
+        case ReferenceSource.cache:
+            if partdiff_params not in reference_output_data:
+                raise RuntimeError(
+                    'Parameter combination "{}" was not found in cache'.format(
+                        " ".join(partdiff_params)
+                    )
+                )
+            return get_from_cache()
+        case ReferenceSource.impl:
+            return get_from_impl()
+
+
+def get_actual_output(
+    partdiff_params: partdiff_params_tuple,
+    partdiff_executable: list[str],
+    use_valgrind: bool,
+    cwd: Path | None,
+) -> str:
+    """Get the actual output for a parameter combination.
+
+    Args:
+        partdiff_params (partdiff_params_tuple): The parameter combination.
+        partdiff_executable (list[str]): The executable to run.
+        use_valgrind (bool): Wether valgrind shall be used.
+        cwd (Path | None): The working directory of the executable.
+
+    Returns:
+        str: The output of the executable.
+    """
+    command_line = partdiff_executable + list(partdiff_params)
+    if use_valgrind:
+        command_line = ["valgrind", "--leak-check=full"] + command_line
+    return subprocess.check_output(command_line, cwd=cwd).decode("utf-8")