Refactor the architecture to add support for running the test cases in subprocesses

docs/requirements.txt

@@ -8,6 +8,7 @@ certifi==2024.8.30 ; python_version >= "3.10" and python_version < "3.11"
 charset-normalizer==3.4.0 ; python_version >= "3.10" and python_version < "3.11"
 click==8.1.7 ; python_version >= "3.10" and python_version < "3.11"
 colorama==0.4.6 ; python_version >= "3.10" and python_version < "3.11" and (sys_platform == "win32" or platform_system == "Windows")
+dill==0.3.9 ; python_version >= "3.10" and python_version < "3.11"
 docstring-parser==0.16 ; python_version >= "3.10" and python_version < "3.11"
 docutils==0.21.2 ; python_version >= "3.10" and python_version < "3.11"
 exceptiongroup==1.2.2 ; python_version >= "3.10" and python_version < "3.11"
@@ -20,6 +21,7 @@ libcst==1.5.1 ; python_version >= "3.10" and python_version < "3.11"
 markdown-it-py==3.0.0 ; python_version >= "3.10" and python_version < "3.11"
 markupsafe==3.0.2 ; python_version >= "3.10" and python_version < "3.11"
 mdurl==0.1.2 ; python_version >= "3.10" and python_version < "3.11"
+multiprocess==0.70.17 ; python_version >= "3.10" and python_version < "3.11"
 mypy-extensions==1.0.0 ; python_version >= "3.10" and python_version < "3.11"
 networkx==3.4.2 ; python_version >= "3.10" and python_version < "3.11"
 packaging==24.2 ; python_version >= "3.10" and python_version < "3.11"

pyproject.toml

@@ -47,9 +47,11 @@ python = ">=3.10, <3.11"
 astroid = "^3.3.5"
 black = "^24.10.0"
 bytecode = "^0.16.0"
+dill = "^0.3.8"
 jellyfish = "^1.1.2"
 Jinja2 = "^3.1.4"
 networkx = "^3.4"
+multiprocess = "^0.70.16"
 rich = "^13.9.4"
 Pygments = "^2.18.0"
 pytest = "^8.3.4"
@@ -255,4 +257,4 @@ convention = "google"
     "PT006",  # Wrong name(s) type in `@pytest.mark.parameterize`, expected `tuple`
     "S101",   # Use of `assert` detected
     "SLF001", # Private member accessed
-]
+]

src/pynguin/__init__.py

@@ -6,6 +6,13 @@
 #
 """Pynguin is an automated unit test generation framework for Python."""
 
+import copyreg
+
+from collections.abc import Callable
+
+from bytecode.instr import _UNSET  # noqa: PLC2701
+from bytecode.instr import InstrLocation
+
 import pynguin.configuration as config
 import pynguin.generator as gen
 
@@ -27,3 +34,27 @@
     "run_pynguin",
     "set_configuration",
 ]
+
+
+def _pickle_instr_location(
+    instr_location: InstrLocation,
+) -> tuple[
+    Callable[[int | None, int | None, int | None, int | None], InstrLocation],
+    tuple[int | None, int | None, int | None, int | None],
+]:
+    return InstrLocation, (
+        instr_location.lineno,
+        instr_location.end_lineno,
+        instr_location.col_offset,
+        instr_location.end_col_offset,
+    )
+
+
+copyreg.pickle(InstrLocation, _pickle_instr_location)
+
+
+def _pickle_unset(unset: _UNSET) -> tuple[Callable[[], _UNSET], tuple]:  # noqa: ARG001
+    return _UNSET, ()
+
+
+copyreg.pickle(_UNSET, _pickle_unset)

src/pynguin/analyses/controlflow.py

@@ -600,6 +600,52 @@ def diameter(self) -> int:
                 self._diameter = len(self._graph.edges)
         return self._diameter
 
+    def __getstate__(self):
+        return {
+            "nodes": tuple(
+                (
+                    node.index,
+                    node.offset,
+                    node.basic_block,
+                    node.is_artificial,
+                    node.predicate_id,
+                    data,
+                )
+                for node, data in self._graph.nodes(data=True)
+            ),
+            "edges": tuple(
+                (
+                    source.index,
+                    target.index,
+                    data,
+                )
+                for source, target, data in self._graph.edges(data=True)
+            ),
+            "bytecode_cfg": self._bytecode_cfg,
+            "diameter": self._diameter,
+        }
+
+    def __setstate__(self, state: dict):
+        self._graph = nx.DiGraph()
+        nodes: dict[int, ProgramGraphNode] = {}
+        for index, offset, basic_block, is_artificial, predicate_id, data in state["nodes"]:
+            node = ProgramGraphNode(
+                index,
+                offset=offset,
+                basic_block=basic_block,
+                is_artificial=is_artificial,
+            )
+            if predicate_id is not None:
+                node.predicate_id = predicate_id
+            self._graph.add_node(node, **data)
+            nodes[index] = node
+        for source_index, target_index, data in state["edges"]:
+            source = nodes[source_index]
+            target = nodes[target_index]
+            self._graph.add_edge(source, target, **data)
+        self._bytecode_cfg = state["bytecode_cfg"]
+        self._diameter = state["diameter"]
+
 
 class DominatorTree(ProgramGraph[ProgramGraphNode]):
     """Implements a dominator tree."""
@@ -833,6 +879,48 @@ def _is_control_dependent_on_root(
                 return True
         return False
 
+    def __getstate__(self):
+        return {
+            "nodes": tuple(
+                (
+                    node.index,
+                    node.offset,
+                    node.basic_block,
+                    node.is_artificial,
+                    node.predicate_id,
+                    data,
+                )
+                for node, data in self._graph.nodes(data=True)
+            ),
+            "edges": tuple(
+                (
+                    source.index,
+                    target.index,
+                    data,
+                )
+                for source, target, data in self._graph.edges(data=True)
+            ),
+        }
+
+    def __setstate__(self, state: dict):
+        self._graph = nx.DiGraph()
+        nodes: dict[int, ProgramGraphNode] = {}
+        for index, offset, basic_block, is_artificial, predicate_id, data in state["nodes"]:
+            node = ProgramGraphNode(
+                index,
+                offset=offset,
+                basic_block=basic_block,
+                is_artificial=is_artificial,
+            )
+            if predicate_id is not None:
+                node.predicate_id = predicate_id
+            self._graph.add_node(node, **data)
+            nodes[index] = node
+        for source_index, target_index, data in state["edges"]:
+            source = nodes[source_index]
+            target = nodes[target_index]
+            self._graph.add_edge(source, target, **data)
+
     @staticmethod
     def _create_augmented_graph(graph: CFG) -> CFG:
         entry_node = graph.entry_node

src/pynguin/analyses/module.py

@@ -80,7 +80,7 @@
     import pynguin.ga.algorithms.archive as arch
     import pynguin.ga.computations as ff
 
-    from pynguin.testcase.execution import SubjectProperties
+    from pynguin.instrumentation.tracer import SubjectProperties
 
 AstroidFunctionDef: typing.TypeAlias = astroid.AsyncFunctionDef | astroid.FunctionDef
 

src/pynguin/assertion/assertion_trace.py

@@ -80,6 +80,12 @@ def clone(self) -> AssertionTrace:
                 copy.trace[stmt_key].add(entry)
         return copy
 
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, AssertionTrace) and self.trace == other.trace
+
+    def __hash__(self) -> int:
+        return hash(self.trace)
+
 
 @dataclasses.dataclass
 class AssertionVerificationTrace: