sflkit 0.2.16__tar.gz → 0.2.18__tar.gz

{sflkit-0.2.16/src/SFLKit.egg-info → sflkit-0.2.18}/PKG-INFO

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

{sflkit-0.2.16 → sflkit-0.2.18}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sflkit"
-version = "0.2.16"
+version = "0.2.18"
 authors = [
     { name = "Marius Smytzek", email = "marius.smytzek@cispa.de" },
 ]

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/__init__.py

@@ -8,7 +8,7 @@ from sflkit.instrumentation.dir_instrumentation import DirInstrumentation
 
 
 def instrument_config(conf: Config):
-    instrumentation = DirInstrumentation(conf.visitor)
+    instrumentation = DirInstrumentation(conf.visitor, conf.mapping.path)
     instrumentation.instrument(
         conf.target_path,
         conf.instrument_working,

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/analysis/analysis_type.py

@@ -28,6 +28,7 @@ class AnalysisType(enum.Enum):
     SPECIAL_STRING = 13
     EMPTY_BYTES = 14
     LENGTH = 15
+    FUNCTION_ERROR = 16
 
     def __str__(self):
         return self.name
@@ -56,6 +57,7 @@ class AnalysisObject(object):
     def __init__(self, event):
         self.suspiciousness: float = 0
         self.last_evaluation: EvaluationResult = EvaluationResult.UNOBSERVED
+        self.hits = dict()
 
     def get_last_evaluation(self, id_: int) -> EvaluationResult:
         return self.last_evaluation

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/analysis/analyzer.py

@@ -1,6 +1,7 @@
-from typing import List, Callable
+import os
+from typing import List, Callable, Set, Dict
 
-from sflkit.analysis.analysis_type import AnalysisType
+from sflkit.analysis.analysis_type import AnalysisType, AnalysisObject
 from sflkit.analysis.factory import AnalysisFactory
 from sflkit.analysis.suggestion import Suggestion
 from sflkit.model.event_file import EventFile
@@ -17,6 +18,7 @@ class Analyzer(object):
         self.relevant_event_files = relevant_event_files
         self.irrelevant_event_files = irrelevant_event_files
         self.model = Model(factory)
+        self.paths: Dict[int, os.PathLike] = dict()
 
     def _analyze(self, event_file):
         self.model.prepare(event_file)
@@ -29,16 +31,17 @@ class Analyzer(object):
 
     def analyze(self):
         for event_file in self.relevant_event_files + self.irrelevant_event_files:
+            self.paths[event_file.run_id] = event_file.path
             self._analyze(event_file)
         self._finalize()
 
     def dump(self, path):
         pass
 
-    def get_analysis(self):
+    def get_analysis(self) -> Set[AnalysisObject]:
         return list(self.model.get_analysis())
 
-    def get_analysis_by_type(self, type_: AnalysisType):
+    def get_analysis_by_type(self, type_: AnalysisType) -> Set[AnalysisObject]:
         return list(
             filter(lambda p: p.analysis_type() == type_, self.model.get_analysis())
         )
@@ -66,3 +69,23 @@ class Analyzer(object):
             ],
             reverse=True,
         )[:]
+
+    def get_coverage_per_run(
+        self, type_: AnalysisType = None
+    ) -> Dict[EventFile, Set[AnalysisObject]]:
+        if type_:
+            objects = self.get_analysis_by_type(type_)
+        else:
+            objects = self.get_analysis()
+        coverage = dict()
+        for obj in objects:
+            for run_id in obj.hits:
+                if run_id not in coverage:
+                    coverage[run_id] = {obj}
+                else:
+                    coverage[run_id].add(obj)
+        return coverage
+
+    def get_coverage(self, type_: AnalysisType = None) -> Set[AnalysisObject]:
+        coverage = self.get_coverage_per_run(type_)
+        return set.union(*coverage.values())

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/analysis/factory.py

@@ -18,6 +18,7 @@ from sflkit.analysis.predicate import (
     ContainsDigitPredicate,
     ContainsSpecialPredicate,
     EmptyBytesPredicate,
+    FunctionErrorPredicate,
 )
 from sflkit.analysis.spectra import Line, Function, Loop, DefUse, Length
 from sflkit.model.scope import Scope
@@ -429,6 +430,29 @@ class LengthFactory(AnalysisFactory):
             return self.objects[key][:]
 
 
+class FunctionErrorFactory(AnalysisFactory):
+    def __init__(self):
+        super().__init__()
+        self.function_mapping = dict()
+
+    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+        if event.event_type == EventType.FUNCTION_ENTER:
+            self.function_mapping[event.function_id] = event.line
+        if event.event_type in (EventType.FUNCTION_ERROR, EventType.FUNCTION_EXIT):
+            line = self.function_mapping[event.function_id]
+            key = (
+                FunctionErrorPredicate.analysis_type(),
+                event.file,
+                line,
+                event.function_id,
+            )
+            if key not in self.objects:
+                self.objects[key] = FunctionErrorPredicate(
+                    event.file, line, event.function
+                )
+            return [self.objects[key]]
+
+
 analysis_factory_mapping = {
     AnalysisType.LINE: LineFactory,
     AnalysisType.BRANCH: BranchFactory,
@@ -446,4 +470,5 @@ analysis_factory_mapping = {
     AnalysisType.VARIABLE: VariableFactory,
     AnalysisType.SCALAR_PAIR: ScalarPairFactory,
     AnalysisType.FUNCTION: FunctionFactory,
+    AnalysisType.FUNCTION_ERROR: FunctionErrorFactory,
 }

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/analysis/mapping.py

@@ -6,6 +6,7 @@ from sflkit.analysis.predicate import (
     VariablePredicate,
     ReturnPredicate,
     NonePredicate,
+    FunctionErrorPredicate,
 )
 from sflkit.analysis.predicate import (
     EmptyStringPredicate,
@@ -39,6 +40,7 @@ analysis_mapping[AnalysisType.ASCII_STRING] = IsAsciiPredicate
 analysis_mapping[AnalysisType.DIGIT_STRING] = ContainsDigitPredicate
 analysis_mapping[AnalysisType.SPECIAL_STRING] = ContainsSpecialPredicate
 analysis_mapping[AnalysisType.CONDITION] = Condition
+analysis_mapping[AnalysisType.FUNCTION_ERROR] = FunctionErrorPredicate
 
 """
 If you want to add new spectra or predicates, please register them here and in sdtools/analysis/analysis_type.py

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/analysis/predicate.py

@@ -1,9 +1,15 @@
 import enum
 from abc import ABC
-from typing import Tuple, Callable, Optional
+from typing import Tuple, Callable, Optional, List, Type
 
 from sflkitlib.events import EventType
-from sflkitlib.events.event import BranchEvent, FunctionExitEvent, DefEvent
+from sflkitlib.events.event import (
+    BranchEvent,
+    FunctionExitEvent,
+    DefEvent,
+    Event,
+    ConditionEvent,
+)
 
 from sflkit.analysis.analysis_type import AnalysisType, EvaluationResult
 from sflkit.analysis.spectra import Spectrum
@@ -51,12 +57,14 @@ class Predicate(Spectrum, ABC):
                 else:
                     self.false_relevant_observed()
 
-    def hit(self, id_, event, scope_: scope.Scope = None):
-        super(Predicate, self).hit(id_, event, scope_)
+    def hit(self, id_, event: Event, scope_: scope.Scope = None):
         if id_ not in self.true_hits:
             self.true_hits[id_] = 0
-        if self._evaluate_predicate(scope_):
+        if id_ not in self.hits:
+            self.hits[id_] = 0
+        if self._evaluate_predicate(event, scope_):
             self.true_hits[id_] += 1
+            self.hits[id_] += 1
             self.last_evaluation = EvaluationResult.TRUE
         else:
             self.last_evaluation = EvaluationResult.FALSE
@@ -66,7 +74,7 @@ class Predicate(Spectrum, ABC):
             metric = Predicate.IncreaseTrue
         return super().get_metric(metric)
 
-    def _evaluate_predicate(self, scope_: scope.Scope):
+    def _evaluate_predicate(self, event: Event, scope_: scope.Scope):
         return False
 
     def true_relevant_observed(self):
@@ -139,7 +147,7 @@ class Branch(Predicate):
     def events():
         return [EventType.BRANCH]
 
-    def hit(self, id_, event, scope_: scope.Scope = None):
+    def hit(self, id_, event: BranchEvent, scope_: scope.Scope = None):
         if id_ not in self.true_hits:
             self.true_hits[id_] = 0
         if event.then_id == self.then_id:
@@ -206,7 +214,7 @@ class Comparison(Predicate, ABC):
             EventType.FUNCTION_ERROR,
         ]
 
-    def _evaluate_predicate(self, scope_: scope.Scope) -> bool:
+    def _evaluate_predicate(self, event: Event, scope_: scope.Scope) -> bool:
         return self._compare(self._get_first(scope_), self._get_second(scope_))
 
     def _compare(self, first, second) -> bool:
@@ -220,7 +228,7 @@ class Comparison(Predicate, ABC):
 
 
 class ScalarPair(Comparison):
-    def __init__(self, event, op: Comp, var: str):
+    def __init__(self, event: DefEvent, op: Comp, var: str):
         super().__init__(event.file, event.line, op)
         self.var1 = event.var
         self.var2 = var
@@ -240,7 +248,7 @@ class ScalarPair(Comparison):
 
 
 class VariablePredicate(Comparison):
-    def __init__(self, event, op: Comp):
+    def __init__(self, event: DefEvent, op: Comp):
         super().__init__(event.file, event.line, op)
         self.var = event.var
 
@@ -376,7 +384,7 @@ class FunctionPredicate(Predicate, ABC):
             EventType.DEF,
         ]
 
-    def _evaluate_predicate(self, scope_: scope.Scope):
+    def _evaluate_predicate(self, event: Event, scope_: scope.Scope):
         value = scope_.value(self.var)
         return isinstance(value, str) and self.predicate(scope_.value(self.var))
 
@@ -438,7 +446,7 @@ class Condition(Predicate):
     def events():
         return [EventType.CONDITION]
 
-    def hit(self, id_, event, scope_: scope.Scope = None):
+    def hit(self, id_, event: ConditionEvent, scope_: scope.Scope = None):
         super(Predicate, self).hit(id_, event, scope_)
         if id_ not in self.true_hits:
             self.true_hits[id_] = 0
@@ -450,3 +458,34 @@ class Condition(Predicate):
 
     def __str__(self):
         return f"{self.analysis_type()}:{self.file}:{self.line}:{self.condition}"
+
+
+class FunctionErrorPredicate(Predicate):
+    def __init__(self, file, line, function):
+        super().__init__(file, line)
+        self.function = function
+
+    @staticmethod
+    def analysis_type() -> AnalysisType:
+        return AnalysisType.FUNCTION_ERROR
+
+    @staticmethod
+    def events() -> List[Type]:
+        return [
+            EventType.FUNCTION_ENTER,
+            EventType.FUNCTION_ERROR,
+            EventType.FUNCTION_EXIT,
+        ]
+
+    def _evaluate_predicate(self, event: Event, scope_: scope.Scope):
+        return event.event_type == EventType.FUNCTION_ERROR
+
+    def get_suggestion(self, metric: Callable = None, base_dir: str = ""):
+        finder = self.function_finder(self.file, self.line, self.function)
+        return Suggestion(
+            [Location(self.file, line) for line in finder.get_locations(base_dir)],
+            self.get_metric(metric),
+        )
+
+    def __str__(self):
+        return f"{self.analysis_type()}:{self.file}:{self.function}:{self.line}"

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/analysis/spectra.py

@@ -39,7 +39,6 @@ class Spectrum(AnalysisObject, ABC):
         self.failed = failed_observed + failed_not_observed
         self.failed_observed = failed_observed
         self.failed_not_observed = failed_not_observed
-        self.hits = dict()
         self.last_evaluation: EvaluationResult = EvaluationResult.FALSE
 
     def __str__(self):

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/cli.py

@@ -7,11 +7,15 @@ from typing import Any
 
 import sflkit
 from sflkit.analysis.suggestion import Suggestion, Location
+from sflkit.config import hash_identifier
 from sflkit.logger import LOGGER
+from sflkit.mapping import EventMapping
+from sflkit.model import EventFile
 
 INSTRUMENT = "instrument"
 RUN = "run"
 ANALYZE = "analyze"
+READ = "read"
 
 
 class ResultEncoder(json.JSONEncoder):
@@ -51,6 +55,14 @@ def main(*args: str, stdout=sys.stdout, stderr=sys.stderr):
         results = sflkit.analyze(args.config, args.analysis)
         with open(args.out, "w") as output:
             json.dump(results, output, cls=ResultEncoder, indent=4)
+    elif args.command == READ:
+        mapping = EventMapping.load_from_file(hash_identifier(args.target))
+        with EventFile(args.event_file, 0, mapping) as event_file:
+            for i, event in enumerate(event_file.load()):
+                print(f"{i:>5}: {event}")
+                if (i + 1) % 10 == 0:
+                    input("Press Enter to continue... ")
+                    print("\033[F\033[K", end="")
 
 
 def parse_args(args=None, namespace=None):
@@ -66,9 +78,6 @@ def parse_args(args=None, namespace=None):
         default=False,
         help="the debug flag to activate debug information",
     )
-    arg_parser.add_argument(
-        "-c", "--config", dest="config", required=True, help="path to the config file"
-    )
     commands = arg_parser.add_subparsers(
         title="command",
         description="The framework allows for the execution of various commands.",
@@ -77,12 +86,15 @@ def parse_args(args=None, namespace=None):
         required=True,
     )
 
-    commands.add_parser(
+    instrument_parser = commands.add_parser(
         INSTRUMENT,
         description="The instrumentation command instruments a subject to collect "
         "various predicates during its execution.",
         help="execute the instrumentation of subject",
     )
+    instrument_parser.add_argument(
+        "-c", "--config", dest="config", required=True, help="path to the config file"
+    )
 
     analyze_parser = commands.add_parser(
         ANALYZE,
@@ -90,6 +102,9 @@ def parse_args(args=None, namespace=None):
         "subject to detect the statistically correlating ones.",
         help="execute the analysis of the collected predicates",
     )
+    analyze_parser.add_argument(
+        "-c", "--config", dest="config", required=True, help="path to the config file"
+    )
     analyze_parser.add_argument(
         "-a",
         "--analysis",
@@ -106,18 +121,42 @@ def parse_args(args=None, namespace=None):
         help="The report of the final results, i.e. the suggestions sorted by analysis",
     )
 
-    analyze_parser = commands.add_parser(
+    run_parser = commands.add_parser(
         RUN,
         description="The run command executes the tests of the subject and creates the event files.",
         help="execute the tests and collect predicates",
     )
-    analyze_parser.add_argument(
+    run_parser.add_argument(
+        "-c", "--config", dest="config", required=True, help="path to the config file"
+    )
+    run_parser.add_argument(
         "-o",
         "--out",
         dest="out",
         default=None,
         help="The output path of the event files.",
     )
+
+    read_parser = commands.add_parser(
+        READ,
+        description="The read command reads an event file and prints the events.",
+        help="read an event file",
+    )
+    read_parser.add_argument(
+        "-e",
+        "--events",
+        dest="event_file",
+        required=True,
+        help="The input path of the event file.",
+    )
+    read_parser.add_argument(
+        "-t",
+        "--target",
+        dest="target",
+        required=True,
+        help="The path of the target to investigate.",
+    )
+
     return arg_parser.parse_args(args=args, namespace=namespace)
 
 

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/config.py

@@ -77,6 +77,7 @@ class Config:
         self.instrument_working = None
         self.runner = None
         self.mapping = None
+        self.mapping_path = None
         if path:
             if isinstance(path, configparser.ConfigParser):
                 config = path
@@ -86,9 +87,11 @@ class Config:
             try:
                 # target section
                 target = config["target"]
-                self.target_path = Path(target["path"])
-                self.language = Language[target["language"].upper()]
-                self.language.setup()
+                if "path" in target:
+                    self.target_path = Path(target["path"])
+                if "language" in target:
+                    self.language = Language[target["language"].upper()]
+                    self.language.setup()
 
                 # events section
                 events = config["events"]
@@ -111,7 +114,7 @@ class Config:
                     self.events = {
                         e for p in self.predicates for e in analysis_mapping[p].events()
                     }
-                else:
+                elif "events" in events:
                     self.factory = CombinationFactory(list())
                     # get the events
                     self.events = list(
@@ -141,10 +144,12 @@ class Config:
                     self.metrics = [Spectrum.Ochiai]
 
                 run_id_generator = IDGenerator()
+                if "mapping" in events:
+                    self.mapping_path = Path(events["mapping"])
                 try:
                     self.mapping = EventMapping.load(self)
                 except InstrumentationError:
-                    self.mapping = EventMapping()
+                    self.mapping = EventMapping(path=self.mapping_path)
                 if "passing" in events:
                     self.passing = self.get_event_files(
                         list(csv.reader([events["passing"]]))[0],
@@ -196,6 +201,7 @@ class Config:
         visitor: ASTVisitor = None,
         passing: List[EventFile] = None,
         failing: List[EventFile] = None,
+        mapping: EventMapping = None,
         instrument_include: List[str] = None,
         instrument_exclude: List[str] = None,
         instrument_working: str = None,
@@ -218,6 +224,10 @@ class Config:
         conf.instrument_exclude = instrument_exclude if instrument_exclude else list()
         conf.instrument_working = instrument_working
         conf.runner = runner
+        if mapping:
+            conf.mapping = mapping
+            if mapping.path:
+                conf.mapping_path = mapping.path
         return conf
 
     @staticmethod
@@ -261,6 +271,7 @@ class Config:
         metrics=None,
         passing=None,
         failing=None,
+        mapping_path=None,
         working=None,
         include=None,
         exclude=None,
@@ -286,6 +297,8 @@ class Config:
             conf["events"]["passing"] = passing
         if failing:
             conf["events"]["failing"] = failing
+        if mapping_path:
+            conf["events"]["mapping"] = mapping_path
         if working:
             conf["instrumentation"]["path"] = working
         if include:
@@ -318,6 +331,8 @@ class Config:
             conf["events"]["passing"] = ",".join(e.path for e in self.passing)
         if self.failing:
             conf["events"]["failing"] = ",".join(e.path for e in self.failing)
+        if self.mapping_path:
+            conf["events"]["mapping"] = str(self.mapping_path)
         if self.instrument_working:
             conf["instrumentation"]["path"] = str(self.instrument_working)
         if self.instrument_include:
@@ -331,7 +346,11 @@ class Config:
             conf.write(fp)
 
     def identifier(self):
-        return hashlib.md5(str(self.target_path).encode("utf-8")).hexdigest()
+        return hash_identifier(self.target_path)
+
+
+def hash_identifier(path: os.PathLike):
+    return hashlib.md5(str(path).encode("utf-8")).hexdigest()
 
 
 def parse_config(path: str) -> Config:

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/instrumentation/__init__.py

@@ -1,8 +1,6 @@
-import json
 from abc import abstractmethod
-from typing import List
-
-from sflkitlib.events import event
+from pathlib import Path
+from typing import List, Optional
 
 from sflkit import Config
 from sflkit.language.visitor import ASTVisitor
@@ -10,9 +8,9 @@ from sflkit.mapping import EventMapping
 
 
 class Instrumentation:
-    def __init__(self, visitor: ASTVisitor):
+    def __init__(self, visitor: ASTVisitor, mapping_path: Optional[Path] = None):
         self.visitor = visitor
-        self.events = EventMapping()
+        self.events = EventMapping(path=mapping_path)
 
     @abstractmethod
     def instrument(

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/instrumentation/dir_instrumentation.py

@@ -2,6 +2,7 @@ import os
 import queue
 import re
 import shutil
+from pathlib import Path
 from typing import List, Optional, Iterable, Tuple
 
 from sflkit.instrumentation import Instrumentation
@@ -11,9 +12,9 @@ from sflkit.logger import LOGGER
 
 
 class DirInstrumentation(Instrumentation):
-    def __init__(self, visitor: ASTVisitor):
-        super().__init__(visitor)
-        self.file_instrumentation = FileInstrumentation(visitor)
+    def __init__(self, visitor: ASTVisitor, mapping_path: Optional[Path] = None):
+        super().__init__(visitor, mapping_path)
+        self.file_instrumentation = FileInstrumentation(visitor, mapping_path)
 
     @staticmethod
     def check_included(element: str, includes: Optional[Iterable[str]]):
@@ -103,5 +104,5 @@ class DirInstrumentation(Instrumentation):
                     continue
                 else:
                     self.handle_element(element, file_queue, src, dst, suffixes, check)
-            self.events = self.file_instrumentation.events
+        self.events = self.file_instrumentation.events
         LOGGER.info(f"I found {len(self.events)} events in {src}.")

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/instrumentation/file_instrumentation.py

@@ -1,4 +1,5 @@
-from typing import List
+from pathlib import Path
+from typing import List, Optional
 
 from sflkit.instrumentation import Instrumentation
 from sflkit.language.visitor import ASTVisitor
@@ -6,13 +7,13 @@ from sflkit.mapping import EventMapping
 
 
 class FileInstrumentation(Instrumentation):
-    def __init__(self, visitor: ASTVisitor):
-        super().__init__(visitor)
+    def __init__(self, visitor: ASTVisitor, mapping_path: Optional[Path] = None):
+        super().__init__(visitor, mapping_path)
 
     def instrument(
         self, src: str, dst: str, suffixes: List[str] = None, file: str = ""
     ):
         self.visitor.instrument(src, dst, file)
         self.events = EventMapping(
-            {event.event_id: event for event in self.visitor.events}
+            {event.event_id: event for event in self.visitor.events}, self.events.path
         )

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/language/meta.py

@@ -61,7 +61,7 @@ class TmpGenerator:
         self.random = random.randbytes(4).hex()
 
     def get_var_name(self):
-        var = f"sd_tmp_{self.random}_{self._tmp_count}"
+        var = f"sk_tmp_{self.random}_{self._tmp_count}"
         self._tmp_count += 1
         return var
 

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/language/python/factory.py

@@ -521,7 +521,7 @@ class FunctionErrorEventFactory(FunctionEventFactory):
         function_error_event = FunctionErrorEvent(
             self.file,
             node.lineno,
-            self.get_function_event_id(node, self.event_id_generator),
+            self.event_id_generator.get_next_id(),
             node.name,
             self.get_function_id(node),
         )

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/mapping.py

@@ -13,33 +13,45 @@ class InstrumentationError(RuntimeError):
 
 
 class EventMapping:
-    def __init__(self, mapping: Dict[int, Event] = None):
+    def __init__(
+        self, mapping: Dict[int, Event] = None, path: Optional[os.PathLike] = None
+    ):
         self.mapping = mapping or dict()
+        self.path = path
 
     def get(self, event_id) -> Optional[Event]:
         return self.mapping.get(event_id, None)
 
     @staticmethod
-    def get_path(identifier: str):
+    def get_path(identifier: str) -> Path:
         return SFLKIT_PATH / f"{identifier}.json"
 
     @staticmethod
     def load(config: Any):
         if not hasattr(config, "identifier"):
             raise InstrumentationError(f"Argument does not have an identifier")
-        file = EventMapping.get_path(config.identifier())
+        return EventMapping.load_from_file(
+            config.mapping_path or EventMapping.get_path(config.identifier()),
+            config.target_path,
+        )
+
+    @staticmethod
+    def load_from_file(file: Path, path: os.PathLike):
         if file.exists():
-            return EventMapping(load_json(file))
+            return EventMapping(load_json(file), file)
         else:
             raise InstrumentationError(
-                f"Cannot find information about instrumentation of {config.identifier()}"
+                f"Cannot find information about instrumentation of {path or file}"
             )
 
     def write(self, config):
         if not hasattr(config, "identifier"):
             raise InstrumentationError(f"Argument does not have an identifier")
-        SFLKIT_PATH.mkdir(parents=True, exist_ok=True)
-        file = self.get_path(config.identifier())
+        if self.path:
+            file = self.path
+        else:
+            SFLKIT_PATH.mkdir(parents=True, exist_ok=True)
+            file = self.get_path(config.identifier())
         with file.open("w") as fp:
             json.dump(list(self.mapping.values()), fp, cls=EventEncoder)
 

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/model/event_file.py

@@ -1,3 +1,4 @@
+import os
 from pickle import PickleError
 
 from sflkitlib.events import event
@@ -7,7 +8,11 @@ from sflkit.mapping import EventMapping
 
 class EventFile(object):
     def __init__(
-        self, path: str, run_id: int, mapping: EventMapping, failing: bool = False
+        self,
+        path: os.PathLike,
+        run_id: int,
+        mapping: EventMapping,
+        failing: bool = False,
     ):
         self.path = path
         self.run_id = run_id
@@ -18,6 +23,7 @@ class EventFile(object):
 
     def __enter__(self):
         self._file_pointer = open(self.path, "rb")
+        return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self._file_pointer.close()

{sflkit-0.2.16 → sflkit-0.2.18}/src/sflkit/model/model.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import Set
 
 from sflkit.model.scope import Scope
 
@@ -68,7 +68,8 @@ class Model(object):
     def exit_scope(self):
         self.variables = self.variables.exit()
 
-    def get_analysis(self) -> List:
+    # noinspection PyUnresolvedReferences
+    def get_analysis(self) -> Set["AnalysisObject"]:
         return self.factory.get_all()
 
     def finalize(self, passed, failed):

{sflkit-0.2.16 → sflkit-0.2.18/src/sflkit.egg-info}/PKG-INFO

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

{sflkit-0.2.16/src/SFLKit.egg-info → sflkit-0.2.18/src/sflkit.egg-info}/SOURCES.txt

@@ -1,11 +1,6 @@
 LICENSE
 README.md
 pyproject.toml
-src/SFLKit.egg-info/PKG-INFO
-src/SFLKit.egg-info/SOURCES.txt
-src/SFLKit.egg-info/dependency_links.txt
-src/SFLKit.egg-info/entry_points.txt
-src/SFLKit.egg-info/top_level.txt
 src/sflkit/__init__.py
 src/sflkit/cli.py
 src/sflkit/color.py
@@ -51,6 +46,7 @@ tests/test_analysis_objects.py
 tests/test_cli.py
 tests/test_color.py
 tests/test_config.py
+tests/test_coverage.py
 tests/test_events.py
 tests/test_execution.py
 tests/test_instrumentation.py

{sflkit-0.2.16 → sflkit-0.2.18}/tests/test_cli.py

@@ -34,9 +34,9 @@ class TestCli(BaseTest):
             pass
 
     def test_instrument_analyze(self):
-        main("-c", self.config_path, "instrument")
+        main("instrument", "-c", self.config_path)
         self.execute_subject([], 0)
-        main("-c", self.config_path, "analyze", "-o", self.results_path)
+        main("analyze", "-c", self.config_path, "-o", self.results_path)
         with open(self.results_path, "r") as fp:
             results = json.load(fp)
         self.assertEqual(1, len(results))

{sflkit-0.2.16 → sflkit-0.2.18}/tests/test_config.py

@@ -93,6 +93,7 @@ class ConfigTests(unittest.TestCase):
             config.visitor,
             config.passing,
             config.failing,
+            config.mapping,
             config.instrument_include,
             config.instrument_exclude,
             config.instrument_working,

sflkit-0.2.18/tests/test_coverage.py

@@ -0,0 +1,19 @@
+from typing import List
+
+from sflkit.analysis.analysis_type import AnalysisType
+from sflkit.analysis.spectra import Line
+from utils import BaseTest
+
+
+class TestCoverage(BaseTest):
+    def test_coverage(self):
+        analyzer = self.run_analysis(
+            self.TEST_SUGGESTIONS,
+            "line",
+            "line",
+            relevant=[["2", "1", "3"]],
+            irrelevant=[["3", "2", "1"], ["3", "1", "2"]],
+        )
+        coverage: List[Line] = analyzer.get_coverage(AnalysisType.LINE)
+        coverage = {line.line for line in coverage}
+        self.assertEqual(coverage, {1, 5, 6, 7, 9, 10, 12, 13, 16, 19, 20})

{sflkit-0.2.16 → sflkit-0.2.18}/tests/test_instrumentation.py

@@ -106,6 +106,21 @@ class TestInstrumentation(BaseTest):
             )
         )
 
+    def test_mapping_output(self):
+        instrument_config(
+            Config.create(
+                path=os.path.join(BaseTest.TEST_RESOURCES, "test_instrumentation"),
+                language="python",
+                events="line",
+                predicates="line",
+                working=BaseTest.TEST_DIR,
+                mapping_path="mapping.json",
+            )
+        )
+        mapping = Path("mapping.json")
+        self.assertTrue(mapping.exists())
+        self.assertTrue(mapping.is_file())
+
 
 class TestLib(BaseTest):
     @classmethod

{sflkit-0.2.16 → sflkit-0.2.18}/tests/test_suggestions.py

@@ -307,3 +307,31 @@ class SuggestionsFromConditionsLoopTest(BaseTest):
         self.assertAlmostEqual(0.5, suggestions[0].suspiciousness, delta=self.DELTA)
         self.assertEqual(1, len(suggestions[0].lines))
         self.assertIn(Location("main.py", 7), suggestions[0].lines)
+
+
+class SuggestionsFromPredicatesFunctionErrorTest(BaseTest):
+    @classmethod
+    def setUpClass(cls):
+        cls.analyzer = cls.run_analysis(
+            cls.TEST_ERROR,
+            "",
+            "function_error",
+            relevant=[["-1"]],
+            irrelevant=[["1"]],
+        )
+        cls.original_dir = os.path.join(cls.TEST_RESOURCES, cls.TEST_ERROR)
+
+    def test_function_error_suggestions(self):
+        suggestions = self.analyzer.get_sorted_suggestions(
+            base_dir=self.original_dir,
+            type_=AnalysisType.FUNCTION_ERROR,
+            metric=Spectrum.Tarantula,
+        )
+        self.assertAlmostEqual(1, suggestions[0].suspiciousness, delta=self.DELTA)
+        self.assertEqual(5, len(suggestions[0].lines))
+        for i in range(4, 9):
+            self.assertIn(Location("main.py", i), suggestions[0].lines)
+        self.assertAlmostEqual(0, suggestions[1].suspiciousness, delta=self.DELTA)
+        self.assertEqual(5, len(suggestions[1].lines))
+        for i in range(11, 16):
+            self.assertIn(Location("main.py", i), suggestions[1].lines)