sflkit 0.5.4__tar.gz → 0.5.6__tar.gz

{sflkit-0.5.4/src/sflkit.egg-info → sflkit-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.4
+Version: 0.5.6
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
 Project-URL: Homepage, https://github.com/smythi93/sflkit/

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/__init__.py

@@ -5,8 +5,7 @@ from sflkit.analysis.analyzer import Analyzer
 from sflkit.config import Config, parse_config
 from sflkit.instrumentation.dir_instrumentation import DirInstrumentation
 
-
-__version__ = "0.5.4"
+__version__ = "0.5.6"
 
 
 def instrument_config(conf: Config):

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/analysis/spectra.py

@@ -722,7 +722,13 @@ class DefUse(Spectrum):
 
     @staticmethod
     def events():
-        return [EventType.DEF, EventType.USE]
+        return [
+            EventType.DEF,
+            EventType.USE,
+            EventType.FUNCTION_ENTER,
+            EventType.FUNCTION_EXIT,
+            EventType.FUNCTION_ERROR,
+        ]
 
     def get_suggestion(
         self, metric: Callable = None, base_dir: str = "", use_weight: bool = False

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/instrumentation/file_instrumentation.py

@@ -1,3 +1,4 @@
+import os
 from pathlib import Path
 from typing import List, Optional
 
@@ -11,7 +12,11 @@ class FileInstrumentation(Instrumentation):
         super().__init__(visitor, mapping_path)
 
     def instrument(
-        self, src: str, dst: str, suffixes: List[str] = None, file: str = ""
+        self,
+        src: os.PathLike,
+        dst: os.PathLike,
+        suffixes: List[str] = None,
+        file: str = "",
     ):
         self.visitor.instrument(src, dst, file)
         self.events = EventMapping(

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/language/meta.py

@@ -88,6 +88,7 @@ class MetaVisitor(ABC):
         event_id_generator: IDGenerator,
         function_id_generator: IDGenerator,
         tmp_generator: TmpGenerator,
+        order: int = 0,
         **kwargs,
     ):
         self.event_id_generator = event_id_generator
@@ -98,6 +99,27 @@ class MetaVisitor(ABC):
         self.condition_extract = language.condition_extract
         self.event_count = 0
         self.file = None
+        self.order = order
+
+    def __lt__(self, other):
+        if not isinstance(other, MetaVisitor):
+            raise TypeError(f"Cannot compare MetaVisitor with {type(other)}")
+        return self.order < other.order
+
+    def __gt__(self, other):
+        if not isinstance(other, MetaVisitor):
+            raise TypeError(f"Cannot compare MetaVisitor with {type(other)}")
+        return self.order > other.order
+
+    def __le__(self, other):
+        if not isinstance(other, MetaVisitor):
+            raise TypeError(f"Cannot compare MetaVisitor with {type(other)}")
+        return self.order <= other.order
+
+    def __ge__(self, other):
+        if not isinstance(other, MetaVisitor):
+            raise TypeError(f"Cannot compare MetaVisitor with {type(other)}")
+        return self.order >= other.order
 
     def get_event_call(self, event: Event):
         pass
@@ -148,26 +170,30 @@ class CombinationVisitor(MetaVisitor):
             tmp_generator,
         )
         if test:
-            self.visitors = [
-                visitor(
-                    language,
-                    event_id_generator,
-                    function_id_generator,
-                    tmp_generator,
-                    ignore_inner=ignore_inner,
-                )
-                for visitor in visitors
-            ]
+            self.visitors = sorted(
+                [
+                    visitor(
+                        language,
+                        event_id_generator,
+                        function_id_generator,
+                        tmp_generator,
+                        ignore_inner=ignore_inner,
+                    )
+                    for visitor in visitors
+                ],
+            )
         else:
-            self.visitors = [
-                visitor(
-                    language,
-                    event_id_generator,
-                    function_id_generator,
-                    tmp_generator,
-                )
-                for visitor in visitors
-            ]
+            self.visitors = sorted(
+                [
+                    visitor(
+                        language,
+                        event_id_generator,
+                        function_id_generator,
+                        tmp_generator,
+                    )
+                    for visitor in visitors
+                ],
+            )
 
     def visit_start(self, *args) -> Injection:
         injections = Injection()

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/language/python/factory.py

@@ -56,10 +56,15 @@ class PythonEventFactory(MetaVisitor, NodeVisitor):
         event_id_generator: IDGenerator,
         function_id_generator: IDGenerator,
         tmp_generator: TmpGenerator,
+        order: int = 0,
         **kwargs,
     ):
         super().__init__(
-            language, event_id_generator, function_id_generator, tmp_generator
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=order,
         )
 
     def visit_start(self, *args) -> Injection:
@@ -291,7 +296,21 @@ class DefEventFactory(PythonEventFactory):
     def visit_AsyncFunctionDef(self, node: AsyncFunctionDef) -> Injection:
         return self.visit_function(node)
 
-    def get_event(self, node: typing.Union[Assign, AnnAssign, AugAssign], var: str):
+    def get_event(
+        self,
+        node: typing.Union[
+            Assign,
+            AnnAssign,
+            AugAssign,
+            FunctionDef,
+            AsyncFunctionDef,
+            For,
+            AsyncFor,
+            With,
+            AsyncWith,
+        ],
+        var: str,
+    ):
         return DefEvent(
             self.file, node.lineno, self.event_id_generator.get_next_id(), var
         )
@@ -369,18 +388,24 @@ class FunctionEventFactory(PythonEventFactory):
         event_id_generator: IDGenerator,
         function_id_generator: IDGenerator,
         tmp_generator: TmpGenerator,
+        order: int,
         **kwargs,
     ):
         super().__init__(
-            language, event_id_generator, function_id_generator, tmp_generator, **kwargs
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=order,
+            **kwargs,
         )
         self.function_stack = list()
 
     def get_function_id(self, node: AST) -> int:
         if node not in FunctionEventFactory.functions:
-            FunctionEventFactory.functions[
-                node
-            ] = self.function_id_generator.get_next_id()
+            FunctionEventFactory.functions[node] = (
+                self.function_id_generator.get_next_id()
+            )
         return FunctionEventFactory.functions[node]
 
     @staticmethod
@@ -403,6 +428,23 @@ class FunctionEventFactory(PythonEventFactory):
 
 
 class FunctionEnterEventFactory(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=-2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_function_enter_event"
 
@@ -441,6 +483,23 @@ class FunctionEnterEventFactory(FunctionEventFactory):
 
 
 class FunctionExitEventFactor(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_function_exit_event"
 
@@ -521,6 +580,23 @@ class FunctionExitEventFactor(FunctionEventFactory):
 
 
 class FunctionErrorEventFactory(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_function_error_event"
 
@@ -550,6 +626,24 @@ class LoopEventFactory(PythonEventFactory):
     loops: typing.Dict[AST, int] = dict()
     loop_id: int = 0
 
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        order: int,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=order,
+            **kwargs,
+        )
+
     @staticmethod
     def get_loop_id(node: AST) -> int:
         if node not in LoopEventFactory.loops:
@@ -571,6 +665,23 @@ class LoopEventFactory(PythonEventFactory):
 
 
 class LoopBeginEventFactory(LoopEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=-1,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_loop_begin_event"
 
@@ -587,6 +698,23 @@ class LoopBeginEventFactory(LoopEventFactory):
 
 
 class LoopHitEventFactory(LoopEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=-1,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_loop_hit_event"
 
@@ -603,6 +731,23 @@ class LoopHitEventFactory(LoopEventFactory):
 
 
 class LoopEndEventFactory(LoopEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=1,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_loop_end_event"
 
@@ -717,6 +862,7 @@ class UseEventFactory(PythonEventFactory):
         return self._get_try_wrapper(event)
 
     def get_event(self, node: AST, use: str) -> UseEvent:
+        # noinspection PyUnresolvedReferences
         return UseEvent(
             self.file, node.lineno, self.event_id_generator.get_next_id(), use
         )
@@ -894,6 +1040,23 @@ class LenEventFactory(DefEventFactory):
 
 
 class TestStartEventFactory(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_test_start_event"
 
@@ -924,6 +1087,23 @@ class TestStartEventFactory(FunctionEventFactory):
 
 
 class TestEndEventFactory(FunctionEventFactory):
+    def __init__(
+        self,
+        language,
+        event_id_generator: IDGenerator,
+        function_id_generator: IDGenerator,
+        tmp_generator: TmpGenerator,
+        **kwargs,
+    ):
+        super().__init__(
+            language,
+            event_id_generator,
+            function_id_generator,
+            tmp_generator,
+            order=2,
+            **kwargs,
+        )
+
     def get_function(self):
         return "add_test_end_event"
 
@@ -991,6 +1171,7 @@ class TestLineEventFactory(LineEventFactory):
         return "add_test_line_event"
 
     def visit_line(self, node: AST) -> Injection:
+        # noinspection PyUnresolvedReferences
         line_event = TestLineEvent(
             self.file, node.lineno, self.event_id_generator.get_next_id()
         )
@@ -1113,6 +1294,7 @@ class TestUseEventFactory(UseEventFactory):
         return "add_test_use_event"
 
     def get_event(self, node: AST, use: str) -> TestUseEvent:
+        # noinspection PyUnresolvedReferences
         return TestUseEvent(
             self.file, node.lineno, self.event_id_generator.get_next_id(), use
         )

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/language/visitor.py

@@ -1,3 +1,4 @@
+import os
 from abc import abstractmethod, ABC
 
 from sflkit.language.meta import MetaVisitor
@@ -22,7 +23,7 @@ class ASTVisitor(ABC):
     def start_visit(self, ast):
         raise NotImplementedError()
 
-    def instrument(self, src: str, dst: str, file: str = ""):
+    def instrument(self, src: os.PathLike, dst: os.PathLike, file: str = ""):
         self.file = file
         with open(src, "r") as fp:
             source = fp.read()

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/model/parallel.py

@@ -1,15 +1,11 @@
-from typing import Optional, Set
-
 from sflkitlib.events.event import (
     FunctionEnterEvent,
     FunctionExitEvent,
     FunctionErrorEvent,
     DefEvent,
     UseEvent,
-    Event,
 )
 
-from sflkit.analysis.analysis_type import AnalysisObject
 from sflkit.events.event_file import EventFile
 from sflkit.model.model import Model
 from sflkit.model.scope import Scope
@@ -89,11 +85,15 @@ class ParallelModel(Model):
             )
 
     def enter_parallel_scope(self, thread_id: int, event_file: EventFile):
-        self.variables_map[event_file][thread_id] = self.variables_map.get(
-            thread_id, self.variables
-        ).enter()
+        self.variables_map[event_file][thread_id] = (
+            self.variables_map[event_file]
+            .get(thread_id, self.variables[event_file])
+            .enter()
+        )
 
     def exit_parallel_scope(self, thread_id: int, event_file: EventFile):
-        self.variables_map[event_file][thread_id] = self.variables_map.get(
-            thread_id, self.variables
-        ).exit()
+        self.variables_map[event_file][thread_id] = (
+            self.variables_map[event_file]
+            .get(thread_id, self.variables[event_file])
+            .exit()
+        )

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/runners/run.py

@@ -666,7 +666,7 @@ class ParallelInputRunner(InputRunner):
 
         with ProcessPoolExecutor(max_workers=self.workers) as executor:
             # Consume the iterator to ensure all tasks complete
-            executor.map(self.process_test, tests)
+            list(executor.map(self.process_test, tests))
 
         # Ensure all files are flushed to disk (helps with race conditions in CI)
         os.sync()

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/weights/__init__.py

@@ -1,4 +1,4 @@
-from sflkit.weights.analyzer import TimeAnalyzer
+from sflkit.weights.analyzer import ProximityAnalyzer
 from sflkit.weights.models import (
     TestTimeModel,
     TestFunctionModel,
@@ -10,7 +10,7 @@ from sflkit.weights.models import (
 )
 
 __all__ = [
-    "TimeAnalyzer",
+    "ProximityAnalyzer",
     "TestTimeModel",
     "TestFunctionModel",
     "TestLineModel",

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit/weights/analyzer.py

@@ -12,7 +12,7 @@ from sflkit.events.event_file import EventFile
 from sflkit.model.model import MetaModel
 
 
-class TimeAnalyzer(Analyzer):
+class ProximityAnalyzer(Analyzer):
     def __init__(
         self,
         model_class: Type[TestTimeModel],
@@ -51,10 +51,12 @@ class TimeAnalyzer(Analyzer):
 
     @staticmethod
     def load_with_dependencies(path: os.PathLike, model_class: Type[TestTimeModel]):
-        return TimeAnalyzer(model_class, meta_model=MetaModel(load_analysis_json(path)))
+        return ProximityAnalyzer(
+            model_class, meta_model=MetaModel(load_analysis_json(path))
+        )
 
     @staticmethod
     def loads_with_dependencies(data: str, model_class: Type[TestTimeModel]):
-        return TimeAnalyzer(
+        return ProximityAnalyzer(
             model_class, meta_model=MetaModel(set(map(deserialize, json.loads(data))))
         )

{sflkit-0.5.4 → sflkit-0.5.6/src/sflkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.4
+Version: 0.5.6
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
 Project-URL: Homepage, https://github.com/smythi93/sflkit/

{sflkit-0.5.4 → sflkit-0.5.6}/src/sflkit.egg-info/SOURCES.txt

@@ -67,6 +67,7 @@ tests/test_dependency_weights.py
 tests/test_evaluation.py
 tests/test_events.py
 tests/test_execution.py
+tests/test_expression.py
 tests/test_features.py
 tests/test_instrumentation.py
 tests/test_language.py

{sflkit-0.5.4 → sflkit-0.5.6}/tests/test_analysis_objects.py

@@ -86,9 +86,12 @@ class TestAnalysisObjects(BaseTest):
         self.assertEqual(2, obj.use_line)
         self.assertEqual("x", obj.var)
         self.assertEqual(AnalysisType.DEF_USE, obj.analysis_type())
-        self.assertEqual(2, len(obj.events()))
+        self.assertEqual(5, len(obj.events()))
         self.assertIn(EventType.DEF, obj.events())
         self.assertIn(EventType.USE, obj.events())
+        self.assertIn(EventType.FUNCTION_ENTER, obj.events())
+        self.assertIn(EventType.FUNCTION_EXIT, obj.events())
+        self.assertIn(EventType.FUNCTION_ERROR, obj.events())
 
     def test_condition(self):
         obj = Condition(self.ACCESS, 1, "x < y")

{sflkit-0.5.4 → sflkit-0.5.6}/tests/test_config.py

@@ -63,9 +63,12 @@ class ConfigTests(unittest.TestCase):
         )
         self.assertEqual(Path("test", "path"), config.target_path)
         self.assertEqual(Language.PYTHON, config.language)
-        self.assertEqual(2, len(config.events))
+        self.assertEqual(5, len(config.events))
         self.assertIn(EventType.DEF, config.events)
         self.assertIn(EventType.USE, config.events)
+        self.assertIn(EventType.FUNCTION_ENTER, config.events)
+        self.assertIn(EventType.FUNCTION_EXIT, config.events)
+        self.assertIn(EventType.FUNCTION_ERROR, config.events)
         self.assertEqual(1, len(config.predicates))
         self.assertIn(AnalysisType.DEF_USE, config.predicates)
         self.assertEqual(1, len(config.factory.factories))

{sflkit-0.5.4 → sflkit-0.5.6}/tests/test_dependency_weights.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from sflkit import Config, instrument_config
 from sflkit.analysis.analysis_type import AnalysisType
 from sflkit.analysis.suggestion import Location
-from sflkit.weights.analyzer import TimeAnalyzer
+from sflkit.weights.analyzer import ProximityAnalyzer
 from sflkit.weights.models import (
     TestLineModel,
     TestDefUseModel,
@@ -39,7 +39,7 @@ class TestTimeWeights(BaseTest):
         output = Path(BaseTest.TEST_DIR, "events").absolute()
         runner.run(Path(BaseTest.TEST_DIR), output, files=["test.py"])
         mapping = EventMapping.load(config)
-        analyzer = TimeAnalyzer(
+        analyzer = ProximityAnalyzer(
             TestFunctionModel,
             [
                 EventFile(
@@ -82,7 +82,7 @@ class TestTimeWeights(BaseTest):
         output = Path(BaseTest.TEST_DIR, "events").absolute()
         runner.run(Path(BaseTest.TEST_DIR), output, files=["test.py"])
         mapping = EventMapping.load(config)
-        analyzer = TimeAnalyzer(
+        analyzer = ProximityAnalyzer(
             TestLineModel,
             [
                 EventFile(
@@ -130,7 +130,7 @@ class TestTimeWeights(BaseTest):
         output = Path(BaseTest.TEST_DIR, "events").absolute()
         runner.run(Path(BaseTest.TEST_DIR), output, files=["test.py"])
         mapping = EventMapping.load(config)
-        analyzer = TimeAnalyzer(
+        analyzer = ProximityAnalyzer(
             TestDefUseModel,
             [
                 EventFile(
@@ -178,7 +178,7 @@ class TestTimeWeights(BaseTest):
         output = Path(BaseTest.TEST_DIR, "events").absolute()
         runner.run(Path(BaseTest.TEST_DIR), output, files=["test.py"])
         mapping = EventMapping.load(config)
-        analyzer = TimeAnalyzer(
+        analyzer = ProximityAnalyzer(
             TestDefUsesModel,
             [
                 EventFile(
@@ -225,7 +225,7 @@ class TestTimeWeights(BaseTest):
         output = Path(BaseTest.TEST_DIR, "events").absolute()
         runner.run(Path(BaseTest.TEST_DIR), output, files=["test.py"])
         mapping = EventMapping.load(config)
-        analyzer = TimeAnalyzer(
+        analyzer = ProximityAnalyzer(
             TestAssertDefUseModel,
             [
                 EventFile(
@@ -272,7 +272,7 @@ class TestTimeWeights(BaseTest):
         output = Path(BaseTest.TEST_DIR, "events").absolute()
         runner.run(Path(BaseTest.TEST_DIR), output, files=["test.py"])
         mapping = EventMapping.load(config)
-        analyzer = TimeAnalyzer(
+        analyzer = ProximityAnalyzer(
             TestAssertDefUsesModel,
             [
                 EventFile(
@@ -337,7 +337,7 @@ class TestTimeWeights(BaseTest):
             ],
             expectations,
         ):
-            analyzer = TimeAnalyzer(
+            analyzer = ProximityAnalyzer(
                 model_class,
                 [
                     EventFile(

sflkit-0.5.6/tests/test_expression.py

@@ -0,0 +1,181 @@
+import os
+
+from sflkit import Analyzer
+from sflkit.analysis.analysis_type import AnalysisType
+from sflkit.analysis.spectra import DefUse
+from utils import BaseTest
+
+
+class ExpressionTest(BaseTest):
+    EXPRESSIONS = "expressions"
+
+    def test_expression(self):
+        config, relevant_event_files, irrelevant_event_files = (
+            self.run_analysis_event_files(
+                self.EXPRESSIONS,
+                events="",
+                predicates="def_use",
+                relevant=[["2 - 3"], ["2 * (1 - 1)"]],
+                irrelevant=[
+                    ["2 + 3"],
+                    ["5 / 6"],
+                    ["1 + (2 * 3)"],
+                    ["(1 + 2) * 3"],
+                    ["1 + 1"],
+                    ["1 - 0"],
+                    ["~ 4"],
+                ],
+                access="evaluate.py",
+            )
+        )
+        analyzer = Analyzer(
+            relevant_event_files, irrelevant_event_files, config.factory, workers=1
+        )
+        analyzer.analyze()
+        expected_def_use = {
+            # evaluate.py
+            ("arg", "evaluate.py", 7): {
+                ("evaluate.py", 8),
+            },
+            ("term", "evaluate.py", 8): {
+                ("evaluate.py", 9),
+            },
+            ("result", "evaluate.py", 9): {
+                ("evaluate.py", 10),
+            },
+            # expr/parse.py
+            # parse()
+            ("s", os.path.join("expr", "parse.py"), 15): {
+                (os.path.join("expr", "parse.py"), 16),
+            },
+            ("s", os.path.join("expr", "parse.py"), 16): {
+                (os.path.join("expr", "parse.py"), 17),
+            },
+            ("s", os.path.join("expr", "parse.py"), 17): {
+                (os.path.join("expr", "parse.py"), 18),
+                (os.path.join("expr", "parse.py"), 19),
+                (os.path.join("expr", "parse.py"), 20),
+            },
+            ("s", os.path.join("expr", "parse.py"), 19): {
+                (os.path.join("expr", "parse.py"), 18),
+            },
+            ("s", os.path.join("expr", "parse.py"), 19): {
+                (os.path.join("expr", "parse.py"), 20),
+            },
+            ("s", os.path.join("expr", "parse.py"), 20): {
+                (os.path.join("expr", "parse.py"), 21),
+            },
+            ("tokens", os.path.join("expr", "parse.py"), 21): {
+                (os.path.join("expr", "parse.py"), 22),
+                (os.path.join("expr", "parse.py"), 23),
+                (os.path.join("expr", "parse.py"), 24),
+            },
+            ("term", os.path.join("expr", "parse.py"), 23): {
+                (os.path.join("expr", "parse.py"), 25),
+            },
+            # parse_terminal()
+            ("tokens", os.path.join("expr", "parse.py"), 28): {
+                (os.path.join("expr", "parse.py"), 29),
+                (os.path.join("expr", "parse.py"), 33),
+                (os.path.join("expr", "parse.py"), 34),
+            },
+            ("token", os.path.join("expr", "parse.py"), 29): {
+                (os.path.join("expr", "parse.py"), 30),
+                (os.path.join("expr", "parse.py"), 31),
+                (os.path.join("expr", "parse.py"), 32),
+            },
+            ("term", os.path.join("expr", "parse.py"), 33): {
+                (os.path.join("expr", "parse.py"), 36),
+            },
+            ("token", os.path.join("expr", "parse.py"), 34): {
+                (os.path.join("expr", "parse.py"), 35),
+            },
+            # parse_neg()
+            ("tokens", os.path.join("expr", "parse.py"), 41): {
+                (os.path.join("expr", "parse.py"), 42),
+                (os.path.join("expr", "parse.py"), 43),
+                (os.path.join("expr", "parse.py"), 44),
+            },
+            ("term", os.path.join("expr", "parse.py"), 42): {
+                (os.path.join("expr", "parse.py"), 45),
+                (os.path.join("expr", "parse.py"), 47),
+            },
+            # parse_mul_div()
+            ("tokens", os.path.join("expr", "parse.py"), 50): {
+                (os.path.join("expr", "parse.py"), 51),
+                (os.path.join("expr", "parse.py"), 52),
+                (os.path.join("expr", "parse.py"), 53),
+                (os.path.join("expr", "parse.py"), 55),
+                (os.path.join("expr", "parse.py"), 57),
+            },
+            ("term", os.path.join("expr", "parse.py"), 51): {
+                (os.path.join("expr", "parse.py"), 55),
+                (os.path.join("expr", "parse.py"), 57),
+                (os.path.join("expr", "parse.py"), 59),
+            },
+            ("token", os.path.join("expr", "parse.py"), 53): {
+                (os.path.join("expr", "parse.py"), 54),
+            },
+            # parse_add_sub()
+            ("tokens", os.path.join("expr", "parse.py"), 62): {
+                (os.path.join("expr", "parse.py"), 63),
+                (os.path.join("expr", "parse.py"), 64),
+                (os.path.join("expr", "parse.py"), 65),
+                (os.path.join("expr", "parse.py"), 67),
+                (os.path.join("expr", "parse.py"), 69),
+            },
+            ("term", os.path.join("expr", "parse.py"), 63): {
+                (os.path.join("expr", "parse.py"), 67),
+                (os.path.join("expr", "parse.py"), 69),
+                (os.path.join("expr", "parse.py"), 71),
+            },
+            ("token", os.path.join("expr", "parse.py"), 65): {
+                (os.path.join("expr", "parse.py"), 66),
+            },
+            # expr/arithmetic.py
+            # Binary.__init__()
+            ("left", os.path.join("expr", "arithmetic.py"), 7): {
+                (os.path.join("expr", "arithmetic.py"), 8),
+            },
+            ("right", os.path.join("expr", "arithmetic.py"), 7): {
+                (os.path.join("expr", "arithmetic.py"), 9),
+            },
+            ("self.left", os.path.join("expr", "arithmetic.py"), 8): {
+                (os.path.join("expr", "arithmetic.py"), 14),
+                (os.path.join("expr", "arithmetic.py"), 19),
+                (os.path.join("expr", "arithmetic.py"), 24),
+                (os.path.join("expr", "arithmetic.py"), 29),
+            },
+            ("self.right", os.path.join("expr", "arithmetic.py"), 9): {
+                (os.path.join("expr", "arithmetic.py"), 14),
+                (os.path.join("expr", "arithmetic.py"), 19),
+                (os.path.join("expr", "arithmetic.py"), 24),
+                (os.path.join("expr", "arithmetic.py"), 29),
+            },
+            # Neg.__init__()
+            ("term", os.path.join("expr", "arithmetic.py"), 33): {
+                (os.path.join("expr", "arithmetic.py"), 34),
+            },
+            ("self.term", os.path.join("expr", "arithmetic.py"), 34): {
+                (os.path.join("expr", "arithmetic.py"), 37),
+            },
+            # Constant.__init__()
+            ("value", os.path.join("expr", "arithmetic.py"), 41): {
+                (os.path.join("expr", "arithmetic.py"), 42),
+            },
+            ("self.value", os.path.join("expr", "arithmetic.py"), 42): {
+                (os.path.join("expr", "arithmetic.py"), 45),
+            },
+        }
+
+        actual = {}
+
+        for analysis in analyzer.get_analysis_by_type(AnalysisType.DEF_USE):
+            if not isinstance(analysis, DefUse):
+                continue
+            key = (analysis.var, analysis.file, analysis.line)
+            if key not in actual:
+                actual[key] = set()
+            actual[key].add((analysis.use_file, analysis.use_line))
+
+        self.assertEqual(expected_def_use, actual)

{sflkit-0.5.4 → sflkit-0.5.6}/tests/test_runner_parallel.py

@@ -80,13 +80,15 @@ class ParallelRunnerTests(BaseTest):
             working=BaseTest.TEST_DIR,
             exclude="tests",
             mapping_path=BaseTest.TEST_MAPPING,
+            thread_support=True,
         )
         instrument_config(config)
         runner = ParallelInputRunner(
-            "main.py",
+            Path("main.py"),
             failing=[["2", "1", "3"]],
             passing=[["3", "2", "1"], ["3", "1", "2"]],
             workers=4,
+            thread_support=True,
         )
         output = Path(BaseTest.TEST_DIR, "events").absolute()
         runner.run(Path(BaseTest.TEST_DIR), output)