sflkit 0.2.16__tar.gz → 0.2.17__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sflkit
-Version: 0.2.16
+Version: 0.2.17
 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.17}/pyproject.toml

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

{sflkit-0.2.16 → sflkit-0.2.17}/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.17}/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.17}/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.17}/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.17}/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.17}/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.17}/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.17}/src/sflkit/config.py

@@ -86,9 +86,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 +113,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(
@@ -331,7 +333,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.17}/src/sflkit/instrumentation/dir_instrumentation.py

@@ -103,5 +103,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.17}/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.17}/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.17}/src/sflkit/mapping.py

@@ -27,12 +27,16 @@ class EventMapping:
     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.identifier())
+
+    @staticmethod
+    def load_from_file(identifier: str):
+        file = EventMapping.get_path(identifier)
         if file.exists():
             return EventMapping(load_json(file))
         else:
             raise InstrumentationError(
-                f"Cannot find information about instrumentation of {config.identifier()}"
+                f"Cannot find information about instrumentation of {identifier or file}"
             )
 
     def write(self, config):

{sflkit-0.2.16 → sflkit-0.2.17}/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.17}/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.17/src/sflkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sflkit
-Version: 0.2.16
+Version: 0.2.17
 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.17/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.17}/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.17/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.17}/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)