From 12dd2989795ee96133fced3eb43f8838646357ba Mon Sep 17 00:00:00 2001 From: Lukas Rothenberger Date: Tue, 2 Jul 2024 10:56:29 +0200 Subject: [PATCH] end-to-end tests: updated test structure to reuse loaded result --- .../do_all/backwards_array_access/test.py | 16 ++++++------- .../do_all/calls/LULESH_proxy/test.py | 18 +++++++------- .../calls/above_nesting_level_3/test.py | 16 ++++++------- test/end_to_end/do_all/calls/allowing/test.py | 16 ++++++------- .../do_all/calls/allowing_2/test.py | 16 ++++++------- test/end_to_end/do_all/calls/complex/test.py | 20 ++++++++-------- .../do_all/calls/preventing/simple/test.py | 16 ++++++------- .../calls/second_order/allowing/test.py | 16 ++++++------- .../calls/second_order/allowing_2/test.py | 16 ++++++------- .../calls/second_order/preventing/test.py | 16 ++++++------- .../calls/second_order/preventing_2/test.py | 16 ++++++------- test/end_to_end/do_all/daxpy/test.py | 24 +++++++++---------- .../nested/OMPSCR/c_Mandelbrot/test.py | 19 ++++++++------- .../global_arrays/test.py | 20 ++++++++-------- .../global_struct/test.py | 20 ++++++++-------- .../global_vectors/test.py | 20 ++++++++-------- .../global_vectors_and_struct/test.py | 20 ++++++++-------- .../simple/nested/depth_2/negative/test.py | 16 ++++++------- .../depth_2/positive/both_loops_doall/test.py | 16 ++++++------- .../depth_2/positive/inner_loop_doall/test.py | 18 +++++++------- .../outer_loop_doall/src/FileMapping.txt | 1 - .../depth_2/positive/outer_loop_doall/test.py | 18 +++++++------- .../not_nested/negative/minimal/test.py | 16 ++++++------- .../not_nested/negative/stack_access/test.py | 15 ++++++------ .../do_all/simple/not_nested/positive/test.py | 16 ++++++------- .../stack_access/nested/positive/test.py | 16 ++++++------- .../stack_access/various/case_0/test.py | 16 ++++++------- .../stack_access/various/case_1/test.py | 16 ++++++------- .../stack_access/various/case_2/test.py | 16 ++++++------- .../stack_access/various/case_3/test.py | 16 ++++++------- .../stack_access/various/case_4/test.py | 16 ++++++------- .../stack_access/various/case_5/test.py | 16 ++++++------- .../access_outside_struct/test.py | 20 ++++++++-------- .../std_data_types/test.py | 20 ++++++++-------- .../template_data_types/test.py | 20 ++++++++-------- .../negative/inner_loop_doall_only/test.py | 15 ++++++------ .../negative/outer_loop_doall_only/test.py | 15 ++++++------ .../loop_collapse/negative/simple_1/test.py | 13 +++++----- .../loop_collapse/positive/simple_1/test.py | 15 ++++++------ .../nested/OMPSCR/c_Mandelbrot/test.py | 20 ++++++++-------- 40 files changed, 335 insertions(+), 336 deletions(-) delete mode 100644 test/end_to_end/do_all/simple/nested/depth_2/positive/outer_loop_doall/src/FileMapping.txt diff --git a/test/end_to_end/do_all/backwards_array_access/test.py b/test/end_to_end/do_all/backwards_array_access/test.py index 8f6b7af56..2ad955cba 100644 --- a/test/end_to_end/do_all/backwards_array_access/test.py +++ b/test/end_to_end/do_all/backwards_array_access/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 1) else: diff --git a/test/end_to_end/do_all/calls/LULESH_proxy/test.py b/test/end_to_end/do_all/calls/LULESH_proxy/test.py index 56df12f46..3e2d5b8c0 100644 --- a/test/end_to_end/do_all/calls/LULESH_proxy/test.py +++ b/test/end_to_end/do_all/calls/LULESH_proxy/test.py @@ -51,24 +51,24 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that main loop do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - found_main_loop = False - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": - do_all_patterns = test_output.patterns.__dict__[pattern_type] + do_all_patterns = self.test_output.patterns.__dict__[pattern_type] for pattern in do_all_patterns: if cast(DoAllInfo, pattern).start_line == "1:271": diff --git a/test/end_to_end/do_all/calls/above_nesting_level_3/test.py b/test/end_to_end/do_all/calls/above_nesting_level_3/test.py index 3ffe2abcd..ff0189db8 100644 --- a/test/end_to_end/do_all/calls/above_nesting_level_3/test.py +++ b/test/end_to_end/do_all/calls/above_nesting_level_3/test.py @@ -49,6 +49,12 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) @@ -56,14 +62,8 @@ def tearDownClass(self): def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 5) else: diff --git a/test/end_to_end/do_all/calls/allowing/test.py b/test/end_to_end/do_all/calls/allowing/test.py index 0f0085181..cb7eba90a 100644 --- a/test/end_to_end/do_all/calls/allowing/test.py +++ b/test/end_to_end/do_all/calls/allowing/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 1) else: diff --git a/test/end_to_end/do_all/calls/allowing_2/test.py b/test/end_to_end/do_all/calls/allowing_2/test.py index 1ba5877e6..76b1249e9 100644 --- a/test/end_to_end/do_all/calls/allowing_2/test.py +++ b/test/end_to_end/do_all/calls/allowing_2/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 2) else: diff --git a/test/end_to_end/do_all/calls/complex/test.py b/test/end_to_end/do_all/calls/complex/test.py index 7dbbcf459..7f821ebba 100644 --- a/test/end_to_end/do_all/calls/complex/test.py +++ b/test/end_to_end/do_all/calls/complex/test.py @@ -50,24 +50,24 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": expected = ["1:22", "1:27"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: self.assertTrue(pattern.start_line in expected, "False positive: Pattern at " + pattern.start_line + " not in expected result: " + str(expected)) - self.assertTrue(len(test_output.patterns.__dict__[pattern_type]) == 2, "False negative: Missed pattern. \nFound: " + " ".join([p.start_line for p in test_output.patterns.__dict__[pattern_type]])+"\nExpected: " + " ".join(expected)) + self.assertTrue(len(self.test_output.patterns.__dict__[pattern_type]) == 2, "False negative: Missed pattern. \nFound: " + " ".join([p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])+"\nExpected: " + " ".join(expected)) else: self.assertEqual(amount_of_identified_patterns, 0) \ No newline at end of file diff --git a/test/end_to_end/do_all/calls/preventing/simple/test.py b/test/end_to_end/do_all/calls/preventing/simple/test.py index c29655a1c..7b353af36 100644 --- a/test/end_to_end/do_all/calls/preventing/simple/test.py +++ b/test/end_to_end/do_all/calls/preventing/simple/test.py @@ -52,20 +52,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 0) else: diff --git a/test/end_to_end/do_all/calls/second_order/allowing/test.py b/test/end_to_end/do_all/calls/second_order/allowing/test.py index 99f2e36f2..5bb66bf75 100644 --- a/test/end_to_end/do_all/calls/second_order/allowing/test.py +++ b/test/end_to_end/do_all/calls/second_order/allowing/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def validate_results(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 1) else: diff --git a/test/end_to_end/do_all/calls/second_order/allowing_2/test.py b/test/end_to_end/do_all/calls/second_order/allowing_2/test.py index 0d4285672..c4aefedb9 100644 --- a/test/end_to_end/do_all/calls/second_order/allowing_2/test.py +++ b/test/end_to_end/do_all/calls/second_order/allowing_2/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 1) else: diff --git a/test/end_to_end/do_all/calls/second_order/preventing/test.py b/test/end_to_end/do_all/calls/second_order/preventing/test.py index c29655a1c..7b353af36 100644 --- a/test/end_to_end/do_all/calls/second_order/preventing/test.py +++ b/test/end_to_end/do_all/calls/second_order/preventing/test.py @@ -52,20 +52,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 0) else: diff --git a/test/end_to_end/do_all/calls/second_order/preventing_2/test.py b/test/end_to_end/do_all/calls/second_order/preventing_2/test.py index c29655a1c..7b353af36 100644 --- a/test/end_to_end/do_all/calls/second_order/preventing_2/test.py +++ b/test/end_to_end/do_all/calls/second_order/preventing_2/test.py @@ -52,20 +52,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 0) else: diff --git a/test/end_to_end/do_all/daxpy/test.py b/test/end_to_end/do_all/daxpy/test.py index 3bb57dd23..a88ff1bd0 100644 --- a/test/end_to_end/do_all/daxpy/test.py +++ b/test/end_to_end/do_all/daxpy/test.py @@ -51,35 +51,35 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """compare results to gold standard""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": expected_lines = ["10","21"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected do-all patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) elif pattern_type == "reduction": expected_lines = ["29"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected reduction patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) else: self.assertEqual(amount_of_identified_patterns, 0) diff --git a/test/end_to_end/do_all/negative/nested/OMPSCR/c_Mandelbrot/test.py b/test/end_to_end/do_all/negative/nested/OMPSCR/c_Mandelbrot/test.py index da23f70a8..cff16447a 100644 --- a/test/end_to_end/do_all/negative/nested/OMPSCR/c_Mandelbrot/test.py +++ b/test/end_to_end/do_all/negative/nested/OMPSCR/c_Mandelbrot/test.py @@ -50,23 +50,24 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": unexpected_lines = ["104"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: self.assertFalse(pattern.start_line.split(":")[1] in unexpected_lines, "Found incorrect do-all pattern. Unexpected lines " + str(unexpected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) diff --git a/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_arrays/test.py b/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_arrays/test.py index d3617bc44..db4524e52 100644 --- a/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_arrays/test.py +++ b/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_arrays/test.py @@ -49,27 +49,27 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": expected_lines = ["16"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected do-all patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) else: self.assertEqual(amount_of_identified_patterns, 0) diff --git a/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_struct/test.py b/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_struct/test.py index cd59104bf..dd763f5b1 100644 --- a/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_struct/test.py +++ b/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_struct/test.py @@ -49,27 +49,27 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": expected_lines = ["17"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected do-all patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) else: self.assertEqual(amount_of_identified_patterns, 0) diff --git a/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_vectors/test.py b/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_vectors/test.py index 30faaa30a..1ae5d833f 100644 --- a/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_vectors/test.py +++ b/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_vectors/test.py @@ -49,27 +49,27 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": expected_lines = ["17"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected do-all patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) else: self.assertEqual(amount_of_identified_patterns, 0) diff --git a/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_vectors_and_struct/test.py b/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_vectors_and_struct/test.py index 30faaa30a..1ae5d833f 100644 --- a/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_vectors_and_struct/test.py +++ b/test/end_to_end/do_all/simple/global_vars/miniFE_CSRMatrix_proxy/global_vectors_and_struct/test.py @@ -49,27 +49,27 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": expected_lines = ["17"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected do-all patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) else: self.assertEqual(amount_of_identified_patterns, 0) diff --git a/test/end_to_end/do_all/simple/nested/depth_2/negative/test.py b/test/end_to_end/do_all/simple/nested/depth_2/negative/test.py index bffe332c0..124e237a9 100644 --- a/test/end_to_end/do_all/simple/nested/depth_2/negative/test.py +++ b/test/end_to_end/do_all/simple/nested/depth_2/negative/test.py @@ -50,20 +50,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 1) else: diff --git a/test/end_to_end/do_all/simple/nested/depth_2/positive/both_loops_doall/test.py b/test/end_to_end/do_all/simple/nested/depth_2/positive/both_loops_doall/test.py index 5892b5167..2b3dddda6 100644 --- a/test/end_to_end/do_all/simple/nested/depth_2/positive/both_loops_doall/test.py +++ b/test/end_to_end/do_all/simple/nested/depth_2/positive/both_loops_doall/test.py @@ -50,20 +50,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 3) else: diff --git a/test/end_to_end/do_all/simple/nested/depth_2/positive/inner_loop_doall/test.py b/test/end_to_end/do_all/simple/nested/depth_2/positive/inner_loop_doall/test.py index d4bed6dca..338374fcb 100644 --- a/test/end_to_end/do_all/simple/nested/depth_2/positive/inner_loop_doall/test.py +++ b/test/end_to_end/do_all/simple/nested/depth_2/positive/inner_loop_doall/test.py @@ -50,22 +50,22 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: expected = ["1:10", "1:18"] self.assertTrue(pattern.start_line in expected, "Pattern at " + pattern.start_line + " not in expected result: " + str(expected)) else: diff --git a/test/end_to_end/do_all/simple/nested/depth_2/positive/outer_loop_doall/src/FileMapping.txt b/test/end_to_end/do_all/simple/nested/depth_2/positive/outer_loop_doall/src/FileMapping.txt deleted file mode 100644 index 3aa4c6b7d..000000000 --- a/test/end_to_end/do_all/simple/nested/depth_2/positive/outer_loop_doall/src/FileMapping.txt +++ /dev/null @@ -1 +0,0 @@ -1 /home/lukas/git/discopop/test/end_to_end/do_all/simple/nested/depth_2/positive/outer_loop_doall/src/code.cpp diff --git a/test/end_to_end/do_all/simple/nested/depth_2/positive/outer_loop_doall/test.py b/test/end_to_end/do_all/simple/nested/depth_2/positive/outer_loop_doall/test.py index 4a6554f8c..27b2c626d 100644 --- a/test/end_to_end/do_all/simple/nested/depth_2/positive/outer_loop_doall/test.py +++ b/test/end_to_end/do_all/simple/nested/depth_2/positive/outer_loop_doall/test.py @@ -50,22 +50,22 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: expected = ["1:10", "1:16"] self.assertTrue(pattern.start_line in expected, "Pattern at " + pattern.start_line + " not in expected result: " + str(expected)) else: diff --git a/test/end_to_end/do_all/simple/not_nested/negative/minimal/test.py b/test/end_to_end/do_all/simple/not_nested/negative/minimal/test.py index c29655a1c..7b353af36 100644 --- a/test/end_to_end/do_all/simple/not_nested/negative/minimal/test.py +++ b/test/end_to_end/do_all/simple/not_nested/negative/minimal/test.py @@ -52,20 +52,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 0) else: diff --git a/test/end_to_end/do_all/simple/not_nested/negative/stack_access/test.py b/test/end_to_end/do_all/simple/not_nested/negative/stack_access/test.py index 636bdc60e..ce008909b 100644 --- a/test/end_to_end/do_all/simple/not_nested/negative/stack_access/test.py +++ b/test/end_to_end/do_all/simple/not_nested/negative/stack_access/test.py @@ -52,20 +52,21 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 0) elif pattern_type == "reduction": diff --git a/test/end_to_end/do_all/simple/not_nested/positive/test.py b/test/end_to_end/do_all/simple/not_nested/positive/test.py index 3e35c49bf..0869c502f 100644 --- a/test/end_to_end/do_all/simple/not_nested/positive/test.py +++ b/test/end_to_end/do_all/simple/not_nested/positive/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 1) else: diff --git a/test/end_to_end/do_all/stack_access/nested/positive/test.py b/test/end_to_end/do_all/stack_access/nested/positive/test.py index 8f974dc83..515350b3d 100644 --- a/test/end_to_end/do_all/stack_access/nested/positive/test.py +++ b/test/end_to_end/do_all/stack_access/nested/positive/test.py @@ -50,20 +50,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 2) elif pattern_type == "reduction": diff --git a/test/end_to_end/do_all/stack_access/various/case_0/test.py b/test/end_to_end/do_all/stack_access/various/case_0/test.py index 0d4285672..c4aefedb9 100644 --- a/test/end_to_end/do_all/stack_access/various/case_0/test.py +++ b/test/end_to_end/do_all/stack_access/various/case_0/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 1) else: diff --git a/test/end_to_end/do_all/stack_access/various/case_1/test.py b/test/end_to_end/do_all/stack_access/various/case_1/test.py index c0ad7997f..112534d82 100644 --- a/test/end_to_end/do_all/stack_access/various/case_1/test.py +++ b/test/end_to_end/do_all/stack_access/various/case_1/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 0) else: diff --git a/test/end_to_end/do_all/stack_access/various/case_2/test.py b/test/end_to_end/do_all/stack_access/various/case_2/test.py index 0d4285672..c4aefedb9 100644 --- a/test/end_to_end/do_all/stack_access/various/case_2/test.py +++ b/test/end_to_end/do_all/stack_access/various/case_2/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 1) else: diff --git a/test/end_to_end/do_all/stack_access/various/case_3/test.py b/test/end_to_end/do_all/stack_access/various/case_3/test.py index 08c451bf0..91c1ee745 100644 --- a/test/end_to_end/do_all/stack_access/various/case_3/test.py +++ b/test/end_to_end/do_all/stack_access/various/case_3/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 2) else: diff --git a/test/end_to_end/do_all/stack_access/various/case_4/test.py b/test/end_to_end/do_all/stack_access/various/case_4/test.py index fd49a357c..144511c39 100644 --- a/test/end_to_end/do_all/stack_access/various/case_4/test.py +++ b/test/end_to_end/do_all/stack_access/various/case_4/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 0) else: diff --git a/test/end_to_end/do_all/stack_access/various/case_5/test.py b/test/end_to_end/do_all/stack_access/various/case_5/test.py index 8916de37d..a0095446c 100644 --- a/test/end_to_end/do_all/stack_access/various/case_5/test.py +++ b/test/end_to_end/do_all/stack_access/various/case_5/test.py @@ -49,20 +49,20 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": self.assertEqual(amount_of_identified_patterns, 3) else: diff --git a/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/access_outside_struct/test.py b/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/access_outside_struct/test.py index 1006e8ed1..ef9314fb9 100644 --- a/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/access_outside_struct/test.py +++ b/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/access_outside_struct/test.py @@ -49,27 +49,27 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": expected_lines = ["28"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected do-all patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) else: self.assertEqual(amount_of_identified_patterns, 0) diff --git a/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/std_data_types/test.py b/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/std_data_types/test.py index 30faaa30a..1ae5d833f 100644 --- a/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/std_data_types/test.py +++ b/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/std_data_types/test.py @@ -49,27 +49,27 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": expected_lines = ["17"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected do-all patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) else: self.assertEqual(amount_of_identified_patterns, 0) diff --git a/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/template_data_types/test.py b/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/template_data_types/test.py index 90fc64af3..2171b4e8d 100644 --- a/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/template_data_types/test.py +++ b/test/end_to_end/do_all/struct/positive/miniFE_CSRMatrix_proxy/template_data_types/test.py @@ -49,27 +49,27 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "do_all": expected_lines = ["21"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected do-all patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]])) else: self.assertEqual(amount_of_identified_patterns, 0) diff --git a/test/end_to_end/optimizer/loop_collapse/negative/inner_loop_doall_only/test.py b/test/end_to_end/optimizer/loop_collapse/negative/inner_loop_doall_only/test.py index 1a26b8706..fe5d51538 100644 --- a/test/end_to_end/optimizer/loop_collapse/negative/inner_loop_doall_only/test.py +++ b/test/end_to_end/optimizer/loop_collapse/negative/inner_loop_doall_only/test.py @@ -48,19 +48,18 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that not collapse has been identified""" - - # load test output - test_output_file = os.path.join(self.src_dir, ".discopop", "optimizer", "detection_result_dump.json") - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - # check identified DoAllInfo objects for collapse clauses > 1 - for do_all_info in test_output.patterns.do_all: + for do_all_info in self.test_output.patterns.do_all: self.assertTrue(do_all_info.collapse_level <= 1) diff --git a/test/end_to_end/optimizer/loop_collapse/negative/outer_loop_doall_only/test.py b/test/end_to_end/optimizer/loop_collapse/negative/outer_loop_doall_only/test.py index 56cd0cf10..c8da25e8d 100644 --- a/test/end_to_end/optimizer/loop_collapse/negative/outer_loop_doall_only/test.py +++ b/test/end_to_end/optimizer/loop_collapse/negative/outer_loop_doall_only/test.py @@ -49,19 +49,18 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that not collapse has been identified""" - - # load test output - test_output_file = os.path.join(self.src_dir, ".discopop", "optimizer", "detection_result_dump.json") - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - # check identified DoAllInfo objects for collapse clauses > 1 - for do_all_info in test_output.patterns.do_all: + for do_all_info in self.test_output.patterns.do_all: self.assertTrue(do_all_info.collapse_level <= 1) diff --git a/test/end_to_end/optimizer/loop_collapse/negative/simple_1/test.py b/test/end_to_end/optimizer/loop_collapse/negative/simple_1/test.py index 82a01668f..e7e5396d8 100644 --- a/test/end_to_end/optimizer/loop_collapse/negative/simple_1/test.py +++ b/test/end_to_end/optimizer/loop_collapse/negative/simple_1/test.py @@ -49,18 +49,19 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that not collapse has been identified""" - # load test output - test_output_file = os.path.join(self.src_dir, ".discopop", "optimizer", "detection_result_dump.json") - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) # check identified DoAllInfo objects for collapse clauses > 1 - for do_all_info in test_output.patterns.do_all: + for do_all_info in self.test_output.patterns.do_all: self.assertTrue(do_all_info.collapse_level <= 1) diff --git a/test/end_to_end/optimizer/loop_collapse/positive/simple_1/test.py b/test/end_to_end/optimizer/loop_collapse/positive/simple_1/test.py index 585e35442..8d8d0268a 100644 --- a/test/end_to_end/optimizer/loop_collapse/positive/simple_1/test.py +++ b/test/end_to_end/optimizer/loop_collapse/positive/simple_1/test.py @@ -52,22 +52,21 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + # load test output + test_output_file = os.path.join(self.src_dir, ".discopop", "optimizer", "detection_result_dump.json") + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that a 2-level collapse has been identified""" - - # load test output - test_output_file = os.path.join(self.src_dir, ".discopop", "optimizer", "detection_result_dump.json") - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - # check identified DoAllInfo objects for collapse clauses > 1 two_level_collapse_found = False - for do_all_info in test_output.patterns.do_all: + for do_all_info in self.test_output.patterns.do_all: if do_all_info.collapse_level == 2: two_level_collapse_found = True diff --git a/test/end_to_end/reduction_pattern/positive/nested/OMPSCR/c_Mandelbrot/test.py b/test/end_to_end/reduction_pattern/positive/nested/OMPSCR/c_Mandelbrot/test.py index c33070ae6..99d959ad5 100644 --- a/test/end_to_end/reduction_pattern/positive/nested/OMPSCR/c_Mandelbrot/test.py +++ b/test/end_to_end/reduction_pattern/positive/nested/OMPSCR/c_Mandelbrot/test.py @@ -50,25 +50,25 @@ def setUpClass(self): self.src_dir = src_dir self.env_vars = env_vars + test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") + # load detection results + with open(test_output_file, "r") as f: + tmp_str = f.read() + self.test_output: DetectionResult = jsonpickle.decode(tmp_str) + @classmethod def tearDownClass(self): run_cmd("make veryclean", self.src_dir, self.env_vars) def test(self): """Check that exactly one do-all is suggested""" - test_output_file = os.path.join(self.src_dir, ".discopop", "explorer", "detection_result_dump.json") - # load detection results - with open(test_output_file, "r") as f: - tmp_str = f.read() - test_output: DetectionResult = jsonpickle.decode(tmp_str) - - for pattern_type in test_output.patterns.__dict__: - amount_of_identified_patterns = len(test_output.patterns.__dict__[pattern_type]) + for pattern_type in self.test_output.patterns.__dict__: + amount_of_identified_patterns = len(self.test_output.patterns.__dict__[pattern_type]) if pattern_type == "reduction": expected_lines = ["101"] - for pattern in test_output.patterns.__dict__[pattern_type]: + for pattern in self.test_output.patterns.__dict__[pattern_type]: if pattern.start_line.split(":")[1] in expected_lines: expected_lines.remove(pattern.start_line.split(":")[1]) self.assertTrue(len(expected_lines) == 0, "Missing expected reduction patterns at line " + str(expected_lines) + ". Found: " + str( - [p.start_line for p in test_output.patterns.__dict__[pattern_type]])) + [p.start_line for p in self.test_output.patterns.__dict__[pattern_type]]))