From c43e400315222bf0b977c951e616d1c8ca8d51b6 Mon Sep 17 00:00:00 2001 From: SiwyKot41 Date: Sun, 11 Jun 2023 22:32:58 +0000 Subject: [PATCH 01/25] feat: adjust output to pipetester requirements --- main.py | 36 ++++++++++++++++++++++++------------ simple.txt | 29 +++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 12 deletions(-) create mode 100644 simple.txt diff --git a/main.py b/main.py index f79d244..e28e1a8 100644 --- a/main.py +++ b/main.py @@ -1,12 +1,13 @@ import sys +from threading import Timer -from ats.ast.nodes import ProcedureNode, ProgramNode, StmtLstNode, StmtNode +# from ats.ast.nodes import ProcedureNode, ProgramNode, StmtLstNode, StmtNode from ats.parser.parser import parse from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query if __name__ == "__main__": - sys.stdout.reconfigure(encoding="utf-8") + sys.stdout.reconfigure(encoding="utf-8") # nie powinno być ibm852? if "--print-test-tree" in sys.argv: tree = parse( """ @@ -32,11 +33,11 @@ """ ) - tree.print_tree( - filter=lambda node: isinstance( - node, (ProgramNode, ProcedureNode, StmtLstNode, StmtNode) - ) - ) + # tree.print_tree( + # filter=lambda node: isinstance( + # node, (ProgramNode, ProcedureNode, StmtLstNode, StmtNode) + # ) + # ) queries = parse_query( # """stmt s1; while w1; Select BOOLEAN such that Follows(s1, w1)""" @@ -49,13 +50,24 @@ print(evaluate_query(tree, queries[0])) elif len(sys.argv) > 0: + + def no_time_left(): + print("\nPreparationTimeout") + exit(1) + with open(sys.argv[-1]) as f: code = f.read() tree = parse(code) - # TODO: Extract design patterns here! - print("Ready") - query = input() + "\n" + input() + while True: + print("Ready") + t = Timer(60, no_time_left) + t.start() + query = input() + "\n" + input() + t.cancel() + # TODO: Wyjątki powinny być zgłaszane na stdout lub stderr, w jednej linni, zaczynającej się od znaku kratki #. - # TODO: use PQL and PKB - print("8") + queries = parse_query(query) + result = evaluate_query(tree, queries[0]) + output = ", ".join(str(part) for part in result) + print(output) diff --git a/simple.txt b/simple.txt new file mode 100644 index 0000000..1dcbc18 --- /dev/null +++ b/simple.txt @@ -0,0 +1,29 @@ +procedure test { + a = b; + while a { + a = c + d + g; + if e then { + b = a + e; + } + else { + c = f + c; + } + } + b = 10; + while a { + c = a + b; + f = c; + } +} +procedure test2 { + a = b + c; + while d { + if e then { + call test; + } + else { + a = f; + } + } + i = j; +} From a88e21890b72177b38332709c1e5ad7622b50b80 Mon Sep 17 00:00:00 2001 From: SiwyKot41 Date: Sun, 11 Jun 2023 22:34:56 +0000 Subject: [PATCH 02/25] refactor: uncomment an important code --- main.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/main.py b/main.py index e28e1a8..dbc6c0d 100644 --- a/main.py +++ b/main.py @@ -1,7 +1,7 @@ import sys from threading import Timer -# from ats.ast.nodes import ProcedureNode, ProgramNode, StmtLstNode, StmtNode +from ats.ast.nodes import ProcedureNode, ProgramNode, StmtLstNode, StmtNode from ats.parser.parser import parse from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -33,11 +33,11 @@ """ ) - # tree.print_tree( - # filter=lambda node: isinstance( - # node, (ProgramNode, ProcedureNode, StmtLstNode, StmtNode) - # ) - # ) + tree.print_tree( + filter=lambda node: isinstance( + node, (ProgramNode, ProcedureNode, StmtLstNode, StmtNode) + ) + ) queries = parse_query( # """stmt s1; while w1; Select BOOLEAN such that Follows(s1, w1)""" From 12f3f692a39bd79004eadba309c595842a08054d Mon Sep 17 00:00:00 2001 From: SiwyKot41 Date: Sun, 11 Jun 2023 22:38:18 +0000 Subject: [PATCH 03/25] refactor: put print ready up the loop --- main.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main.py b/main.py index dbc6c0d..a648633 100644 --- a/main.py +++ b/main.py @@ -58,9 +58,9 @@ def no_time_left(): with open(sys.argv[-1]) as f: code = f.read() tree = parse(code) + print("Ready") while True: - print("Ready") t = Timer(60, no_time_left) t.start() query = input() + "\n" + input() From 8ea8843cba348ab100cc6455a73c404961151f0a Mon Sep 17 00:00:00 2001 From: KamiloSzcz <127205348+KamiloSzcz@users.noreply.github.com> Date: Tue, 13 Jun 2023 12:20:16 +0200 Subject: [PATCH 04/25] fix: fix pipetester output --- main.py | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/main.py b/main.py index a648633..c43d09e 100644 --- a/main.py +++ b/main.py @@ -61,13 +61,22 @@ def no_time_left(): print("Ready") while True: - t = Timer(60, no_time_left) - t.start() - query = input() + "\n" + input() - t.cancel() - # TODO: Wyjątki powinny być zgłaszane na stdout lub stderr, w jednej linni, zaczynającej się od znaku kratki #. + try: + t = Timer(60, no_time_left) + t.start() + query = input() + "\n" + input() + t.cancel() + # TODO: Wyjątki powinny być zgłaszane na stdout lub stderr, w jednej linni, zaczynającej się od znaku kratki #. - queries = parse_query(query) - result = evaluate_query(tree, queries[0]) - output = ", ".join(str(part) for part in result) - print(output) + queries = parse_query(query) + result = evaluate_query(tree, queries[0]) + if len(result) == 0: + print('none') + continue + + output = ", ".join(str(part) for part in result) + print(output) + except Exception: + import traceback + print('#' + traceback.format_exc()) + From fa3818e8bdc3dac292fada1380d84bb8d3d5d5ca Mon Sep 17 00:00:00 2001 From: Michal_Parchanowicz Date: Tue, 13 Jun 2023 13:06:56 +0200 Subject: [PATCH 05/25] fix: return error on one line --- main.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/main.py b/main.py index c43d09e..3e9a153 100644 --- a/main.py +++ b/main.py @@ -71,12 +71,13 @@ def no_time_left(): queries = parse_query(query) result = evaluate_query(tree, queries[0]) if len(result) == 0: - print('none') + print("none") continue - + output = ", ".join(str(part) for part in result) print(output) except Exception: import traceback - print('#' + traceback.format_exc()) - + + exc_info = traceback.format_exc().replace("\n", "") + print("#" + exc_info) From f56004fb073eaccf97d8ed49a63933e11f4b89c4 Mon Sep 17 00:00:00 2001 From: KamiloSzcz <127205348+KamiloSzcz@users.noreply.github.com> Date: Tue, 13 Jun 2023 15:00:07 +0200 Subject: [PATCH 06/25] Update main.py --- main.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/main.py b/main.py index 3e9a153..2df27ec 100644 --- a/main.py +++ b/main.py @@ -3,6 +3,7 @@ from ats.ast.nodes import ProcedureNode, ProgramNode, StmtLstNode, StmtNode from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -59,7 +60,7 @@ def no_time_left(): code = f.read() tree = parse(code) print("Ready") - + context = extract(tree) while True: try: t = Timer(60, no_time_left) @@ -69,10 +70,12 @@ def no_time_left(): # TODO: Wyjątki powinny być zgłaszane na stdout lub stderr, w jednej linni, zaczynającej się od znaku kratki #. queries = parse_query(query) - result = evaluate_query(tree, queries[0]) - if len(result) == 0: - print("none") - continue + result = evaluate_query(tree, queries[0], context) + + if not isinstance(result, bool): + if len(result) == 0: + print("none") + continue output = ", ".join(str(part) for part in result) print(output) From dfd3ffa97341ab3b79222e38e61997a7d414348a Mon Sep 17 00:00:00 2001 From: KamiloSzcz <127205348+KamiloSzcz@users.noreply.github.com> Date: Tue, 13 Jun 2023 15:01:33 +0200 Subject: [PATCH 07/25] Update query_evaluator.py --- ats/pkb/query_evaluator.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/ats/pkb/query_evaluator.py b/ats/pkb/query_evaluator.py index 329a46a..6ab26fa 100644 --- a/ats/pkb/query_evaluator.py +++ b/ats/pkb/query_evaluator.py @@ -1,6 +1,5 @@ from ats.ast import nodes from ats.ast.nodes import ProcedureNode -from ats.pkb.design_extractor import extract from ats.pkb.utils import process_relation @@ -168,8 +167,7 @@ def relation_cb(node_a, node_b): ) -def evaluate_query(node: nodes.ProgramNode, query): - context = extract(node) +def evaluate_query(node: nodes.ProgramNode, query, context): all_results = set() for i, relation in enumerate(query["conditions"]["relations"]): results = all_results if i == 0 else set() From d0c83782f757d825b55906514c7aec82b0b4d2fa Mon Sep 17 00:00:00 2001 From: KamiloSzcz <127205348+KamiloSzcz@users.noreply.github.com> Date: Tue, 13 Jun 2023 15:08:07 +0200 Subject: [PATCH 08/25] Update main.py --- main.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/main.py b/main.py index 2df27ec..af061e3 100644 --- a/main.py +++ b/main.py @@ -47,8 +47,8 @@ Select BOOLEAN such that Calls(_, _) """ ) - - print(evaluate_query(tree, queries[0])) + context = extract(tree) + print(evaluate_query(tree, queries[0], context)) elif len(sys.argv) > 0: From 316ed06431bcfa34e3b3980924050c9d3ead00cc Mon Sep 17 00:00:00 2001 From: KamiloSzcz <127205348+KamiloSzcz@users.noreply.github.com> Date: Tue, 13 Jun 2023 15:16:48 +0200 Subject: [PATCH 09/25] Update main.py --- main.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main.py b/main.py index af061e3..9ec623f 100644 --- a/main.py +++ b/main.py @@ -77,7 +77,7 @@ def no_time_left(): print("none") continue - output = ", ".join(str(part) for part in result) + output = ", ".join(str(part) for part in result) print(output) except Exception: import traceback From 9eefbf5e3d3bf3399e3ce341cc99dbb1fb87b132 Mon Sep 17 00:00:00 2001 From: KamiloSzcz <127205348+KamiloSzcz@users.noreply.github.com> Date: Tue, 13 Jun 2023 15:38:23 +0200 Subject: [PATCH 10/25] Update main.py --- main.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/main.py b/main.py index 9ec623f..ab68b06 100644 --- a/main.py +++ b/main.py @@ -78,6 +78,14 @@ def no_time_left(): continue output = ", ".join(str(part) for part in result) + else: + if len(result) == 0: + print("false") + continue + else: + print("true") + continue + print(output) except Exception: import traceback From e52f768071667b8f8e6ba7043d3f68637657bbfc Mon Sep 17 00:00:00 2001 From: Michal_Parchanowicz Date: Tue, 13 Jun 2023 18:05:42 +0200 Subject: [PATCH 11/25] fix: fix tests to new format --- ats/pkb/query_evaluator.py | 3 +- main.py | 16 ++---- tests/pkb/test_boolean.py | 10 ++-- tests/pkb/test_calls.py | 28 ++++++----- tests/pkb/test_calls_deep.py | 20 +++++--- tests/pkb/test_follows.py | 39 ++++++++------- tests/pkb/test_follows_deep.py | 27 +++++----- tests/pkb/test_modifies.py | 47 +++++++++--------- tests/pkb/test_multiple_such_that.py | 4 +- tests/pkb/test_next.py | 74 +++++++++++----------------- tests/pkb/test_next_deep.py | 53 ++++++++------------ tests/pkb/test_parent.py | 28 ++++++----- tests/pkb/test_parent_deep.py | 22 +++++---- tests/pkb/test_uses.py | 41 ++++++++------- 14 files changed, 201 insertions(+), 211 deletions(-) diff --git a/ats/pkb/query_evaluator.py b/ats/pkb/query_evaluator.py index 6ab26fa..c26c711 100644 --- a/ats/pkb/query_evaluator.py +++ b/ats/pkb/query_evaluator.py @@ -1,4 +1,3 @@ -from ats.ast import nodes from ats.ast.nodes import ProcedureNode from ats.pkb.utils import process_relation @@ -167,7 +166,7 @@ def relation_cb(node_a, node_b): ) -def evaluate_query(node: nodes.ProgramNode, query, context): +def evaluate_query(query, context): all_results = set() for i, relation in enumerate(query["conditions"]["relations"]): results = all_results if i == 0 else set() diff --git a/main.py b/main.py index ab68b06..581c4e8 100644 --- a/main.py +++ b/main.py @@ -48,7 +48,7 @@ """ ) context = extract(tree) - print(evaluate_query(tree, queries[0], context)) + print(evaluate_query(queries[0], context)) elif len(sys.argv) > 0: @@ -59,18 +59,17 @@ def no_time_left(): with open(sys.argv[-1]) as f: code = f.read() tree = parse(code) - print("Ready") context = extract(tree) + print("Ready") while True: try: t = Timer(60, no_time_left) t.start() query = input() + "\n" + input() t.cancel() - # TODO: Wyjątki powinny być zgłaszane na stdout lub stderr, w jednej linni, zaczynającej się od znaku kratki #. queries = parse_query(query) - result = evaluate_query(tree, queries[0], context) + result = evaluate_query(queries[0], context) if not isinstance(result, bool): if len(result) == 0: @@ -79,13 +78,8 @@ def no_time_left(): output = ", ".join(str(part) for part in result) else: - if len(result) == 0: - print("false") - continue - else: - print("true") - continue - + output = result + print(output) except Exception: import traceback diff --git a/tests/pkb/test_boolean.py b/tests/pkb/test_boolean.py index 09eff83..99df2f8 100644 --- a/tests/pkb/test_boolean.py +++ b/tests/pkb/test_boolean.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -40,6 +41,7 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_boolean_with_condition(): @@ -50,7 +52,7 @@ def test_pkb_boolean_with_condition(): Select BOOLEAN with v.varName = p.procName """ ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is False @@ -61,17 +63,17 @@ def test_pkb_boolean_constant_with_condtition(): Select BOOLEAN with c1.value = c2.value and c2.value = 10 """ ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is False def test_pkb_boolean_true_stmt_stmt(): queries = parse_query("stmt s1, s2; Select BOOLEAN such that Follows(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is True def test_pkb_boolean_false_stmt_constant(): queries = parse_query("stmt s1, s2; Select BOOLEAN such that Follows(s1, 1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is False diff --git a/tests/pkb/test_calls.py b/tests/pkb/test_calls.py index 959a3a3..416e088 100644 --- a/tests/pkb/test_calls.py +++ b/tests/pkb/test_calls.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -35,41 +36,42 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_calls_procedure_any(): queries = parse_query("""procedure p; Select p such that Calls(p, _)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test1", "test2", "test3", "test4"] def test_pkb_calls_procedure_any_1(): queries = parse_query("""procedure q; Select q such that Calls(_, q)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test1", "test2", "test3", "test4", "test5"] def test_pkb_calls_procedure_procedure(): queries = parse_query("""procedure p, q; Select p such that Calls(p, q)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test1", "test2", "test3", "test4"] def test_pkb_calls_procedure_procedure_1(): queries = parse_query("""procedure p, q; Select q such that Calls(p, q)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test1", "test2", "test3", "test4", "test5"] def test_pkb_calls_procedure_name_procedure(): queries = parse_query("""procedure p; Select p such that Calls (p, "test5")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == ["test3"] def test_pkb_calls_procedure_name_procedure_1(): queries = parse_query("""procedure q; Select q such that Calls ("test1", q)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test2", "test4"] @@ -77,7 +79,7 @@ def test_pkb_calls_procedure_name_name(): queries = parse_query( """procedure p; Select p such that Calls ("test3", "test5")""" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test1", "test2", "test3", "test4", "test5", "test6"] @@ -85,19 +87,19 @@ def test_pkb_calls_procedure_name_name_1(): queries = parse_query( """procedure p; Select p such that Calls ("test4", "test5")""" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [] def test_pkb_calls_procedure_proc_name_1(): queries = parse_query("""procedure p; Select p such that Calls(p, "test2")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test1"] def test_pkb_calls_procedure_proc_invalid_1(): queries = parse_query("""procedure p; Select p such that Calls(p, "test")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [] @@ -124,7 +126,7 @@ def test_pkb_calls_procedure_proc_invalid_1(): # } # """ # ) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert result == ["test3"] @@ -135,7 +137,7 @@ def test_pkb_calls_procedure_proc_invalid_1(): # Select BOOLEAN such that Calls (p, "test5") with p.procName = "test3" # """ # ) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert result is True @@ -146,5 +148,5 @@ def test_pkb_calls_procedure_proc_invalid_1(): # Select BOOLEAN such that Calls (p, q) with p.procName = "test2" and q.procName = "test3" # """ # ) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert result is True diff --git a/tests/pkb/test_calls_deep.py b/tests/pkb/test_calls_deep.py index 99c9f21..93d4534 100644 --- a/tests/pkb/test_calls_deep.py +++ b/tests/pkb/test_calls_deep.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -30,13 +31,14 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_calls_star_name_name(): queries = parse_query( """procedure p, q; Select p such that Calls* ("test2", "test5")""" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test1", "test2", "test3", "test4", "test5", "test6"] @@ -44,25 +46,25 @@ def test_pkb_calls_star_name_name_1(): queries = parse_query( """procedure p, q; Select p such that Calls* ("test6", "test1")""" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [] def test_pkb_calls_star_procedure_name(): queries = parse_query("""procedure p, q; Select p such that Calls* (p, "test5")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test1", "test2", "test3"] def test_pkb_calls_star_name_procedure(): queries = parse_query("""procedure q; Select q such that Calls* ("test1", q)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test2", "test3", "test4", "test5", "test6"] def test_pkb_calls_star_name_procedure_1(): queries = parse_query("""procedure q; Select q such that Calls* ("test2", q)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test3", "test5", "test6"] @@ -95,17 +97,18 @@ def _get_ast_tree2(): tree2 = _get_ast_tree2() +context2 = extract(tree2) def test_pkb_calls_procedure_procedure_2(): queries = parse_query("""procedure p, q; Select p such that Calls(p, q)""") - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == ["test1", "test2", "test3", "test4", "test5"] def test_pkb_calls_procedure_procedure_3(): queries = parse_query("""procedure p, q; Select q such that Calls(p, q)""") - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == ["test2", "test3", "test5", "test6", "test7"] @@ -124,11 +127,12 @@ def _get_ast_tree3(): tree3 = _get_ast_tree3() +context3 = extract(tree3) def test_pkb_calls_star_name_name_3(): queries = parse_query( """procedure p, q; Select p such that Calls* ("test1", "test2")""" ) - result = evaluate_query(tree3, queries[0]) + result = evaluate_query(queries[0], context3) assert sorted(result) == [] diff --git a/tests/pkb/test_follows.py b/tests/pkb/test_follows.py index 7702318..11140d0 100644 --- a/tests/pkb/test_follows.py +++ b/tests/pkb/test_follows.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -22,83 +23,84 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_follows_const_const(): queries = parse_query("stmt s1; Select s1 such that Follows(1, 2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [1, 2, 3, 4, 5, 6, 7] def test_pkb_follows_const_const_1(): queries = parse_query("stmt s1; Select s1 such that Follows(2, 1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_follows_stmt_const(): queries = parse_query("stmt s1; Select s1 such that Follows(s1, 2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [1] def test_pkb_follows_stmt_const_1(): queries = parse_query("assign a1; Select a1 such that Follows(a1, 2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [1] def test_pkb_follows_stmt_const_2(): queries = parse_query("while w1; Select w1 such that Follows(w1, 2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_follows_const_stmt(): queries = parse_query("stmt s1; Select s1 such that Follows(1, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2] def test_pkb_follows_const_stmt_1(): queries = parse_query("assign a1; Select a1 such that Follows(1, a1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2] def test_pkb_follows_const_stmt_2(): queries = parse_query("while w1; Select w1 such that Follows(1, w1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_follows_stmt_stmt(): queries = parse_query("stmt s1, s2; Select s1 such that Follows(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [1, 2, 3, 4, 6] def test_pkb_follows_stmt_stmt_1(): queries = parse_query("assign a1, a2; Select a1 such that Follows(a1, a2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [1, 2, 3, 6] def test_pkb_follows_stmt_stmt_2(): queries = parse_query("assign a1, a2; Select a2 such that Follows(a1, a2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2, 3, 4, 7] def test_pkb_follows_stmt_stmt_3(): queries = parse_query("stmt s1, s2; Select s2 such that Follows(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2, 3, 4, 5, 7] def test_pkb_follows_stmt_stmt_4(): queries = parse_query("stmt s1, s2, s3; Select s3 such that Follows(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [1, 2, 3, 4, 5, 6, 7] @@ -130,31 +132,32 @@ def _get_ast_tree_if(): tree_if = _get_ast_tree_if() +context_if = extract(tree_if) def test_pkb_follows_stmt_stmt_if(): queries = parse_query( "stmt s1; assign a1; if i1; Select s1 such that Follows(a1, i1)" ) - result = evaluate_query(tree_if, queries[0]) + result = evaluate_query(queries[0], context_if) assert result == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] def test_pkb_follows_stmt_stmt_if_1(): queries = parse_query("assign a1; if i1; Select i1 such that Follows(i1, a1)") - result = evaluate_query(tree_if, queries[0]) + result = evaluate_query(queries[0], context_if) assert sorted(result) == [3, 8] def test_pkb_follows_stmt_stmt_if_2(): queries = parse_query("assign a1; if i1; Select i1 such that Follows(a1, i1)") - result = evaluate_query(tree_if, queries[0]) + result = evaluate_query(queries[0], context_if) assert sorted(result) == [8] def test_pkb_follows_stmt_invalid_id_1(): queries = parse_query("""stmt p; Select p such that Follows(p, 99999)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context_if) assert sorted(result) == [] @@ -166,5 +169,5 @@ def test_pkb_boolean_follows_with_condition(): """ ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context_if) assert result is False diff --git a/tests/pkb/test_follows_deep.py b/tests/pkb/test_follows_deep.py index bcb6d11..f45740c 100644 --- a/tests/pkb/test_follows_deep.py +++ b/tests/pkb/test_follows_deep.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -28,53 +29,54 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_follows_star_const_const(): queries = parse_query("stmt s1; Select s1 such that Follows*(1, 10)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] def test_pkb_follows_star_const_const_1(): queries = parse_query("stmt s1; Select s1 such that Follows*(5, 6)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [] def test_pkb_follows_star_stmt_const(): queries = parse_query("stmt s1; Select s1 such that Follows*(s1, 10)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 8] def test_pkb_follows_star_stmt_const_1(): queries = parse_query("assign a1; Select a1 such that Follows*(a1, 10)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1] def test_pkb_follows_star_stmt_const_2(): queries = parse_query("assign a1; Select a1 such that Follows*(a1, 5)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [3, 4] def test_pkb_follows_star_const_stmt(): queries = parse_query("stmt s1; Select s1 such that Follows*(1, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 8, 10] def test_pkb_follows_star_const_stmt_1(): queries = parse_query("assign a1; Select a1 such that Follows*(3, a1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [4, 5] def test_pkb_follows_star_const_stmt_2(): queries = parse_query("while w1; Select w1 such that Follows*(1, w1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [8, 10] @@ -108,27 +110,28 @@ def _get_ast_tree_2(): tree2 = _get_ast_tree_2() +context2 = extract(tree2) def test_pkb_follows_star_stmt_stmt(): queries = parse_query("stmt s1, s2; Select s1 such that Follows*(s1, s2)") - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [1, 2, 4, 5, 6, 7, 8, 10, 12] def test_pkb_follows_star_stmt_stmt_1(): queries = parse_query("assign a1; while w1; Select w1 such that Follows*(a1, w1)") - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [2, 12, 14] def test_pkb_follows_star_stmt_stmt_2(): queries = parse_query("assign a1, a2; Select a1 such that Follows*(a1, a2)") - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [1, 6, 7, 8, 10] def test_pkb_follows_star_stmt_stmt_3(): queries = parse_query("assign a1; while w1; Select a1 such that Follows*(a1, w1)") - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [1, 4] diff --git a/tests/pkb/test_modifies.py b/tests/pkb/test_modifies.py index 913d2c5..0e9409f 100644 --- a/tests/pkb/test_modifies.py +++ b/tests/pkb/test_modifies.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -38,89 +39,90 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_modifies_const_variable(): queries = parse_query("""while w1; Select w1 such that Modifies(1, "a")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 8, 12] def test_pkb_modifies_const_variable_0(): queries = parse_query("""variable v1, v2; Select v2 such that Modifies(1, v1)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["a", "b", "c", "d", "e", "f", "g", "i", "j"] def test_pkb_modifies_const_variable_1(): queries = parse_query("""variable v1; Select v1 such that Modifies(1, v1)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == ["a"] def test_pkb_modifies_const_variable_2(): queries = parse_query("""while w1; Select w1 such that Modifies(2, "a")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 8, 12] def test_pkb_modifies_const_variable_3(): queries = parse_query("""variable v1; Select v1 such that Modifies(2, v1)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["a", "b", "c"] def test_pkb_modifies_assign_variable(): queries = parse_query("""assign a1; Select a1 such that Modifies(a1, "a")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 3, 11, 15] def test_pkb_modifies_assign_variable_1(): queries = parse_query("""assign a1; Select a1 such that Modifies(a1, "c")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [6, 9] def test_pkb_modifies_while_variable(): queries = parse_query("""while w1; Select w1 such that Modifies(w1, "a")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 12] def test_pkb_modifies_if_variable(): queries = parse_query("""if i1; Select i1 such that Modifies(i1, "c")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [4, 13] def test_pkb_modifies_if_variable_1(): queries = parse_query("""if i1; Select i1 such that Modifies(i1, "f")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [13] def test_pkb_modifies_statements_variable(): queries = parse_query("""stmt s1; Select s1 such that Modifies(s1, "c")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 4, 6, 8, 9, 12, 13, 14] def test_pkb_modifies_procedure_variable(): queries = parse_query("""procedure p1; Select p1 such that Modifies(p1, "a")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test", "test2"] def test_pkb_modifies_procedure_variable_1(): queries = parse_query("""procedure p1; Select p1 such that Modifies(p1, "i")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == ["test2"] def test_pkb_modifies_procedure_variable_2(): queries = parse_query("""procedure p1; Select p1 such that Modifies(p1, "q")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] @@ -132,7 +134,7 @@ def test_pkb_modifies_procedure_variable_2(): # with v1.varName = v2.varName # """) # -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert result == [] @@ -143,7 +145,7 @@ def test_pkb_modifies_procedure_variable_2(): # Select a such that Modifies (a, v) with v.varName = "b" # """) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # def test_pkb_modifies_boolean_with_condition(): @@ -157,7 +159,7 @@ def test_pkb_modifies_procedure_variable_2(): # """ # ) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert result == True @@ -169,7 +171,7 @@ def test_pkb_modifies_procedure_variable_2(): # """ # ) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert result == [2, 4, 19, 25] @@ -212,27 +214,28 @@ def _get_ast_tree_call(): tree_call = _get_ast_tree_call() +context_call = extract(tree_call) def test_pkb_modifies_call_procedure_variable(): queries = parse_query("""procedure p1; Select p1 such that Modifies(p1, "c")""") - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert sorted(result) == ["test1", "test2", "test3"] def test_pkb_modifies_call_procedure_variable_1(): queries = parse_query("""procedure p1; Select p1 such that Modifies(p1, "e")""") - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert sorted(result) == ["test4", "test5", "test6"] def test_pkb_modifies_call_stmt_variable(): queries = parse_query("""stmt s1; Select s1 such that Modifies(s1, "c")""") - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert sorted(result) == [2, 3, 4, 5] def test_pkb_modifies_call_stmt_variable_1(): queries = parse_query("""stmt s1; Select s1 such that Modifies(s1, "e")""") - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert sorted(result) == [6, 7, 8] diff --git a/tests/pkb/test_multiple_such_that.py b/tests/pkb/test_multiple_such_that.py index e660946..2e41fdf 100644 --- a/tests/pkb/test_multiple_such_that.py +++ b/tests/pkb/test_multiple_such_that.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -22,6 +23,7 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_follows_complex(): @@ -33,5 +35,5 @@ def test_pkb_follows_complex(): Select s1 such that Follows(s1, a) and Parent(w, s1) """ ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [6] diff --git a/tests/pkb/test_next.py b/tests/pkb/test_next.py index 9147aa4..21d216b 100644 --- a/tests/pkb/test_next.py +++ b/tests/pkb/test_next.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -35,162 +36,143 @@ def _get_ast_tree(): ) +tree = _get_ast_tree() +context = extract(tree) + + def test_pkb_next_const_const_1(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(1, 2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] def test_pkb_next_const_const_2(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(8, 2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] def test_pkb_next_const_const_3(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(5, 6)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_next_const_const_4(): - tree = _get_ast_tree() queries = parse_query("assign a1; Select a1 such that Next(1, 2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [1, 4, 5, 7, 9, 12] def test_pkb_next_const_stmt_1(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(1, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2] def test_pkb_next_const_stmt_2(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(4, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [5] def test_pkb_next_const_stmt_3(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(5, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2] def test_pkb_next_const_stmt_4(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(8, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 9] def test_pkb_next_const_stmt_5(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(12, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [11] def test_pkb_next_const_stmt_6(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(10, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_next_const_while_1(): - tree = _get_ast_tree() queries = parse_query("while w1; Select w1 such that Next(5, w1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2] def test_pkb_next_const_while_2(): - tree = _get_ast_tree() queries = parse_query("while w1; Select w1 such that Next(6, w1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [8] def test_pkb_next_stmt_const_1(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(s1, 2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 5, 7, 8] def test_pkb_next_stmt_const_2(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(s1, 8)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [6, 9] def test_pkb_next_stmt_const_3(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(s1, 10)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2] def test_pkb_next_stmt_const_4(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next(s1, 12)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [11] def test_pkb_next_if_const_1(): - tree = _get_ast_tree() queries = parse_query("if i1; Select i1 such that Next(i1, 4)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [3] def test_pkb_next_stmt_stmt_1(): - tree = _get_ast_tree() queries = parse_query("stmt s1, s2; Select s1 such that Next(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12] def test_pkb_next_stmt_stmt_2(): - tree = _get_ast_tree() queries = parse_query("stmt s1, s2; Select s2 such that Next(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] def test_pkb_next_if_while_1(): - tree = _get_ast_tree() queries = parse_query("if i1; while w1; Select i1 such that Next(i1, w1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [6] def test_pkb_next_if_while_2(): - tree = _get_ast_tree() queries = parse_query("if i1; while w1; Select w1 such that Next(i1, w1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [8] def test_pkb_next_assign_while_1(): - tree = _get_ast_tree() queries = parse_query("assign a1; while w1; Select a1 such that Next(a1, w1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 5, 7, 9, 12] def test_pkb_next_assign_while_2(): - tree = _get_ast_tree() queries = parse_query("assign a1; while w1; Select w1 such that Next(a1, w1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 8, 11] diff --git a/tests/pkb/test_next_deep.py b/tests/pkb/test_next_deep.py index 0a358ee..653ff3b 100644 --- a/tests/pkb/test_next_deep.py +++ b/tests/pkb/test_next_deep.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -34,113 +35,101 @@ def _get_ast_tree(): ) +tree = _get_ast_tree() +context = extract(tree) + + def test_pkb_next_star_const_const_1(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(2, 8)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] def test_pkb_next_star_const_const_2(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(4, 6)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_next_star_const_const_3(): - tree = _get_ast_tree() queries = parse_query("while w1; Select w1 such that Next*(5, 10)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [6, 10] def test_pkb_next_star_const_const_4(): - tree = _get_ast_tree() queries = parse_query("if i1; Select i1 such that Next*(9, 14)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [3, 11] def test_pkb_next_star_const_stmt_1(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(1, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] def test_pkb_next_star_const_stmt_2(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(4, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [5, 10, 11, 12, 13, 14] def test_pkb_next_star_const_stmt_3(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(8, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [6, 7, 8, 9, 10, 11, 12, 13, 14] def test_pkb_next_star_const_stmt_4(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(13, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [10, 11, 12, 13, 14] def test_pkb_next_star_const_stmt_5(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(14, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_next_star_stmt_const_1(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(s1, 1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_next_star_stmt_const_2(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(s1, 14)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] def test_pkb_next_star_stmt_const_3(): - tree = _get_ast_tree() queries = parse_query("stmt s1; Select s1 such that Next*(s1, 9)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 3, 6, 7, 8] def test_pkb_next_star_stmt_stmt_1(): - tree = _get_ast_tree() queries = parse_query("stmt s1, s2; Select s1 such that Next*(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] def test_pkb_next_star_stmt_stmt_2(): - tree = _get_ast_tree() queries = parse_query("stmt s1, s2; Select s2 such that Next*(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] def test_pkb_next_star_while_assign_1(): - tree = _get_ast_tree() queries = parse_query("while w1; assign a1; Select w1 such that Next*(w1, a1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [6, 10] def test_pkb_next_star_while_assign_2(): - tree = _get_ast_tree() queries = parse_query("while w1; assign a1; Select a1 such that Next*(w1, a1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [7, 8, 9, 12, 13, 14] diff --git a/tests/pkb/test_parent.py b/tests/pkb/test_parent.py index 35eab51..02876e2 100644 --- a/tests/pkb/test_parent.py +++ b/tests/pkb/test_parent.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -23,77 +24,78 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_parent_const_const(): queries = parse_query("stmt s1; Select s1 such that Parent(2, 3)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [1, 2, 3, 4, 5, 6, 7] def test_pkb_parent_const_stmt(): queries = parse_query("stmt s1; Select s1 such that Parent(2, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [3, 6] def test_pkb_parent_const_stmt_2(): queries = parse_query("assign a1; Select a1 such that Parent(1, a1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_parent_const_stmt_3(): queries = parse_query("if if1; Select if1 such that Parent(2, if1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [3] def test_pkb_parent_stmt_const(): queries = parse_query("stmt s1; Select s1 such that Parent(s1, 3)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2] def test_pkb_parent_stmt_const_2(): queries = parse_query("assign a1; Select a1 such that Parent(a1, 2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_parent_stmt_const_3(): queries = parse_query("while w1; Select w1 such that Parent(w1, 3)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2] def test_pkb_parent_stmt_stmt(): queries = parse_query("stmt s1, s2; Select s1 such that Parent(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [2, 3] def test_pkb_parent_stmt_stmt_1(): queries = parse_query("assign a1, a2; Select a2 such that Parent(a1, a2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_parent_stmt_stmt_2(): queries = parse_query("assign a1, a2; Select a1 such that Parent(a1, a2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_parent_stmt_stmt_3(): queries = parse_query("stmt s1, s2; Select s2 such that Parent(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [3, 4, 5, 6] def test_pkb_parent_stmt_stmt_5(): queries = parse_query("stmt s1, s2, s3; Select s3 such that Parent(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [1, 2, 3, 4, 5, 6, 7] @@ -104,5 +106,5 @@ def test_pkb_parent_stmt_stmt_5(): # Select s1 such that Parent(s1, s2) with s2.stmt# = 4 # """ # ) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert sorted(result) == [3] diff --git a/tests/pkb/test_parent_deep.py b/tests/pkb/test_parent_deep.py index ed7ca94..09fb1fc 100644 --- a/tests/pkb/test_parent_deep.py +++ b/tests/pkb/test_parent_deep.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -36,63 +37,64 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_parent_star_const_const(): queries = parse_query("stmt s1; Select s1 such that Parent*(1, 6)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] def test_pkb_parent_star_stmt_const(): queries = parse_query("stmt s1; Select s1 such that Parent*(s1, 11)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 8, 10] def test_pkb_parent_star_stmt_const_1(): queries = parse_query("assign a1; Select a1 such that Parent*(a1, 10)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [] def test_pkb_parent_star_stmt_const_2(): queries = parse_query("while w1; Select w1 such that Parent*(w1, 6)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [3, 5] def test_pkb_parent_star_const_stmt(): queries = parse_query("stmt s1; Select s1 such that Parent*(1, s1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 3, 4, 5, 6, 7, 8, 9, 10, 11] def test_pkb_parent_star_const_stmt_1(): queries = parse_query("assign a1; Select a1 such that Parent*(1, a1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 4, 6, 7, 9, 11] def test_pkb_parent_star_const_stmt_2(): queries = parse_query("while w1; Select w1 such that Parent*(12, w1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [14] def test_pkb_parent_star_stmt_stmt(): queries = parse_query("stmt s1, s2; Select s1 such that Parent*(s1, s2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 3, 5, 8, 10, 12, 14] def test_pkb_parent_star_stmt_stmt_1(): queries = parse_query("if if; while w; Select w such that Parent*(if, w)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [3, 5, 8, 10] def test_pkb_parent_star_stmt_stmt_2(): queries = parse_query("if if; while w; Select if such that Parent*(w, if)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [] diff --git a/tests/pkb/test_uses.py b/tests/pkb/test_uses.py index d52111d..2455a59 100644 --- a/tests/pkb/test_uses.py +++ b/tests/pkb/test_uses.py @@ -1,4 +1,5 @@ from ats.parser.parser import parse +from ats.pkb.design_extractor import extract from ats.pkb.query_evaluator import evaluate_query from ats.pql.pql import parse_query @@ -38,83 +39,84 @@ def _get_ast_tree(): tree = _get_ast_tree() +context = extract(tree) def test_pkb_uses_const_variable(): queries = parse_query("""while w1; Select w1 such that Uses(1, "a")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] def test_pkb_uses_const_variable_1(): queries = parse_query("""variable v1; Select v1 such that Uses(1, v1)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == ["b"] def test_pkb_uses_const_variable_2(): queries = parse_query("""while w1; Select w1 such that Uses(2, "x")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 8, 12] def test_pkb_uses_const_variable_3(): queries = parse_query("""variable v1; Select v1 such that Uses(2, v1)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["a", "c", "d", "e", "f", "g", "x"] def test_pkb_uses_const_variable_4(): queries = parse_query("""variable v1; Select v1 such that Uses(12, v1)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["a", "b", "c", "d", "e", "f", "g", "x"] def test_pkb_uses_assign_variable(): queries = parse_query("""assign a1; Select a1 such that Uses(a1, "a")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [5, 9] def test_pkb_uses_assign_variable_1(): queries = parse_query("""assign a1; Select a1 such that Uses(a1, "c")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [3, 6, 10, 11] def test_pkb_uses_while_variable(): queries = parse_query("""while w1; Select w1 such that Uses(w1, "a")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 8, 12] def test_pkb_uses_if_variable(): queries = parse_query("""if i1; Select i1 such that Uses(i1, "f")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [4, 13] def test_pkb_uses_statements_variable(): queries = parse_query("""stmt s1; Select s1 such that Uses(s1, "c")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 3, 4, 6, 8, 10, 11, 12, 13, 14] def test_pkb_uses_procedure_variable(): queries = parse_query("""procedure p1; Select p1 such that Uses(p1, "a")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test", "test2"] def test_pkb_uses_procedure_variable_1(): queries = parse_query("""procedure p1; Select p1 such that Uses(p1, "j")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["test2"] def test_pkb_uses_procedure_variable_2(): queries = parse_query("""procedure p1; Select p1 such that Uses(p1, "q")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result == [] @@ -123,7 +125,7 @@ def test_pkb_uses_procedure_variable_2(): # queries = parse_query( # """procedure p1; variable v; Select p1 such that Uses(p1, v) with v.varName = "a" """ # ) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert sorted(result) == ["test"] @@ -134,7 +136,7 @@ def test_pkb_uses_procedure_variable_2(): # """ # ) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert result == True @@ -177,27 +179,28 @@ def _get_ast_tree_call(): tree_call = _get_ast_tree_call() +context_call = extract(tree_call) def test_pkb_uses_call_procedure_variable(): queries = parse_query("""procedure p1; Select p1 such that Uses(p1, "d")""") - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert sorted(result) == ["test1", "test2", "test3"] def test_pkb_uses_call_procedure_variable_1(): queries = parse_query("""procedure p1; Select p1 such that Uses(p1, "f")""") - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert sorted(result) == ["test4", "test5", "test6"] def test_pkb_uses_call_stmt_variable(): queries = parse_query("""stmt s1; Select s1 such that Uses(s1, "d")""") - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert sorted(result) == [2, 3, 4, 5] def test_pkb_uses_call_stmt_variable_1(): queries = parse_query("""stmt s1; Select s1 such that Uses(s1, "f")""") - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert sorted(result) == [6, 7, 8] From 1c6957e66654238613ede7d5f7c75c69340f67fb Mon Sep 17 00:00:00 2001 From: Michal_Parchanowicz Date: Tue, 13 Jun 2023 18:16:31 +0200 Subject: [PATCH 12/25] fix: fix boolean query --- main.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/main.py b/main.py index 581c4e8..de6e03e 100644 --- a/main.py +++ b/main.py @@ -78,7 +78,12 @@ def no_time_left(): output = ", ".join(str(part) for part in result) else: - output = result + if result: + print("true") + continue + else: + print("false") + continue print(output) except Exception: From ee132ce2f30840fe0153bb25d877bbe06bf206a8 Mon Sep 17 00:00:00 2001 From: Michal_Parchanowicz Date: Tue, 13 Jun 2023 18:33:49 +0200 Subject: [PATCH 13/25] feat: add prog_line --- ats/pkb/utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ats/pkb/utils.py b/ats/pkb/utils.py index 1eb8746..129d9ea 100644 --- a/ats/pkb/utils.py +++ b/ats/pkb/utils.py @@ -7,6 +7,7 @@ "while": nodes.StmtWhileNode, "if": nodes.StmtIfNode, "procedure": nodes.ProcedureNode, + "prog_line": nodes.StmtNode, } From 83e0a82d5fa85ae515f7fcbdb6d19aafedc2291a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Parchanowicz?= <85680066+MParchan@users.noreply.github.com> Date: Tue, 13 Jun 2023 18:45:32 +0200 Subject: [PATCH 14/25] Update design_extractor.py --- ats/pkb/design_extractor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ats/pkb/design_extractor.py b/ats/pkb/design_extractor.py index 9d37610..8803084 100644 --- a/ats/pkb/design_extractor.py +++ b/ats/pkb/design_extractor.py @@ -146,14 +146,14 @@ def on_node_exit(node: nodes.ASTNode, context): ) # extending procedure parents with nested calls - extend_parents = [] + """extend_parents = [] for name in call_order: if name in proc_parents: proc_parents[name].extend(extend_parents) proc_parents[name] = list(set(proc_parents[name])) extend_parents.extend(proc_parents[name]) else: - extend_parents = [] + extend_parents = []""" def process_relations(): # Build stack with procedures name and statements id From d08c4c70fdaf2193f1ed3494361320d94cfd95bb Mon Sep 17 00:00:00 2001 From: Michal_Parchanowicz Date: Tue, 13 Jun 2023 19:14:15 +0200 Subject: [PATCH 15/25] fix: fix uses and modiifes --- ats/pkb/design_extractor.py | 4 ++-- ats/pkb/query_evaluator.py | 4 ++++ 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/ats/pkb/design_extractor.py b/ats/pkb/design_extractor.py index 8803084..9d37610 100644 --- a/ats/pkb/design_extractor.py +++ b/ats/pkb/design_extractor.py @@ -146,14 +146,14 @@ def on_node_exit(node: nodes.ASTNode, context): ) # extending procedure parents with nested calls - """extend_parents = [] + extend_parents = [] for name in call_order: if name in proc_parents: proc_parents[name].extend(extend_parents) proc_parents[name] = list(set(proc_parents[name])) extend_parents.extend(proc_parents[name]) else: - extend_parents = []""" + extend_parents = [] def process_relations(): # Build stack with procedures name and statements id diff --git a/ats/pkb/query_evaluator.py b/ats/pkb/query_evaluator.py index c26c711..5a8a18e 100644 --- a/ats/pkb/query_evaluator.py +++ b/ats/pkb/query_evaluator.py @@ -100,6 +100,8 @@ def resolve_node(param): if isinstance(param, int): return context["statements"][param] else: + if param == relation["parameters"][0]: + return context["procedures"][param[1:-1]] return param[1:-1] return process_relation( @@ -117,6 +119,8 @@ def resolve_node(param): if isinstance(param, int): return context["statements"][param] else: + if param == relation["parameters"][0]: + return context["procedures"][param[1:-1]] return param[1:-1] return process_relation( From 402f11eed2568dc41740136c6937ecb96a6e03ba Mon Sep 17 00:00:00 2001 From: Michal_Parchanowicz Date: Tue, 13 Jun 2023 19:22:20 +0200 Subject: [PATCH 16/25] fix: uses and modifies --- ats/pkb/design_extractor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ats/pkb/design_extractor.py b/ats/pkb/design_extractor.py index 9d37610..8803084 100644 --- a/ats/pkb/design_extractor.py +++ b/ats/pkb/design_extractor.py @@ -146,14 +146,14 @@ def on_node_exit(node: nodes.ASTNode, context): ) # extending procedure parents with nested calls - extend_parents = [] + """extend_parents = [] for name in call_order: if name in proc_parents: proc_parents[name].extend(extend_parents) proc_parents[name] = list(set(proc_parents[name])) extend_parents.extend(proc_parents[name]) else: - extend_parents = [] + extend_parents = []""" def process_relations(): # Build stack with procedures name and statements id From 4332b8408852421f77fc1462fe93cea557baca3c Mon Sep 17 00:00:00 2001 From: Kasper Seweryn Date: Tue, 13 Jun 2023 22:22:58 +0200 Subject: [PATCH 17/25] chore: rebase --- tests/pkb/test_boolean.py | 29 ++++++------------------ tests/pkb/test_follows.py | 17 +++++++------- tests/pkb/test_follows_deep.py | 12 +++++----- tests/pkb/test_multiple_such_that.py | 34 +++++++++++++++------------- tests/pkb/test_uses.py | 4 ++-- 5 files changed, 42 insertions(+), 54 deletions(-) diff --git a/tests/pkb/test_boolean.py b/tests/pkb/test_boolean.py index 29a63d4..c84a2b2 100644 --- a/tests/pkb/test_boolean.py +++ b/tests/pkb/test_boolean.py @@ -81,7 +81,7 @@ def test_pkb_boolean_false_stmt_constant(): def test_pkb_boolean_true_proc_calls(): queries = parse_query("""procedure p; Select BOOLEAN such that Calls(p, "test")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is True @@ -89,13 +89,13 @@ def test_pkb_boolean_false_stmt_stmt_follows_with_condition(): queries = parse_query( "stmt s1, s2; Select BOOLEAN such that Follows(s1, s2) with s1.stmt# = 1 and s2.stmt# = 3" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is False def test_pkb_boolean_true_while_uses(): queries = parse_query("""while w; Select BOOLEAN such that Uses(w,"f")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is True @@ -103,19 +103,19 @@ def test_pkb_boolean_false_while_uses_condition(): queries = parse_query( """while w; variable v1; Select BOOLEAN such that Uses(w, v1) with v1.varName = "x" """ ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is False def test_pkb_boolean_true_assign_while_next(): queries = parse_query("assign a; while w; Select BOOLEAN such that Next(a, w)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is True def test_pkb_boolean_false_while_while_next(): queries = parse_query("while w1, w2; Select BOOLEAN such that Next(w1, w2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is False @@ -126,20 +126,5 @@ def test_pkb_boolean_true(): Select BOOLEAN such that Calls ("test3", "test5") """ ) - tree = parse( - """ - procedure test1 { - call test5; - } - - procedure test3 { - call test5; - } - - procedure test5 { - call test1; - } - """ - ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert result is True diff --git a/tests/pkb/test_follows.py b/tests/pkb/test_follows.py index dc892f4..321e828 100644 --- a/tests/pkb/test_follows.py +++ b/tests/pkb/test_follows.py @@ -197,6 +197,7 @@ def _get_ast_tree3(): tree3 = _get_ast_tree() +context3 = extract(tree3) def test_pkb_follows_modifies(): @@ -204,7 +205,7 @@ def test_pkb_follows_modifies(): """stmt s1, s2; while w1; Select w1 such that Follows(s1, s2) and Modifies(s1, "a")""" ) - result = evaluate_query(tree3, queries[0]) + result = evaluate_query(queries[0], context3) assert result == [5] @@ -213,7 +214,7 @@ def test_pkb_follows_modifies_2(): """stmt s1, s2; while w1; Select s1 such that Follows(s1, w1) and Modifies(w1, "a")""" ) - result = evaluate_query(tree3, queries[0]) + result = evaluate_query(queries[0], context3) assert result == [4] @@ -222,7 +223,7 @@ def test_pkb_follows_modifies_next(): """stmt s1, s2; assign a1; Select s1 such that Follows(s1, s2) and Modifies(a1, "a") and Next(a1, 2)""" ) - result = evaluate_query(tree3, queries[0]) + result = evaluate_query(queries[0], context3) assert result == [1, 2, 3, 4, 6] @@ -231,7 +232,7 @@ def test_pkb_follows_modifies_next_2(): """stmt s1, s2; assign a1; Select a1 such that Follows(1, s2) and Modifies(1, "c") and Next(a1, 2)""" ) - result = evaluate_query(tree3, queries[0]) + result = evaluate_query(queries[0], context3) assert result == [] @@ -240,7 +241,7 @@ def test_pkb_follows_uses(): """stmt s1, s2; while w1; Select s1 such that Follows(s1, w1) and Uses(w1, "a")""" ) - result = evaluate_query(tree3, queries[0]) + result = evaluate_query(queries[0], context3) assert result == [4] @@ -249,7 +250,7 @@ def test_pkb_follows_uses_2(): """stmt s1, s2; assign a1; Select a1 such that Follows(a1, s1) and Uses(s1, "a")""" ) - result = evaluate_query(tree3, queries[0]) + result = evaluate_query(queries[0], context3) assert result == [1, 2, 3, 4, 6] @@ -258,7 +259,7 @@ def test_pkb_follows_uses_parent(): """stmt s1, s2; while w1; Select s1 such that Follows(s1, s2) and Uses(w1, "a") and Parent(s2, s1)""" ) - result = evaluate_query(tree3, queries[0]) + result = evaluate_query(queries[0], context3) assert result == [6] @@ -267,5 +268,5 @@ def test_pkb_follows_uses_parent_2(): """stmt s1, s2; while w1; Select w1 such that Follows(s1, s2) and Uses(w1, "a") and Parent(s1, s2)""" ) - result = evaluate_query(tree3, queries[0]) + result = evaluate_query(queries[0], context3) assert result == [5] diff --git a/tests/pkb/test_follows_deep.py b/tests/pkb/test_follows_deep.py index abf9e27..453c412 100644 --- a/tests/pkb/test_follows_deep.py +++ b/tests/pkb/test_follows_deep.py @@ -139,19 +139,19 @@ def test_pkb_follows_star_stmt_stmt_3(): def test_pkb_follows_star_stmt_stmt_4(): queries = parse_query("while w1, w2; Select w1 such that Follows*(w2, w1)") - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [12, 14] def test_pkb_follows_star_stmt_stmt_5(): queries = parse_query("while w1, w2; Select w1 such that Follows*(w1, w2)") - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [2, 12] def test_pkb_follows_star_stmt_stmt_6(): queries = parse_query("assign a1, a2; Select a1 such that Follows*(a2, a1)") - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [4, 7, 8, 9, 11] @@ -159,7 +159,7 @@ def test_pkb_follows_star_stmt_stmt_7(): queries = parse_query( "assign a1, a2; while w1; Select w1 such that Follows*(a2, a1)" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [2, 12, 14] @@ -167,7 +167,7 @@ def test_pkb_follows_follows_star_1(): queries = parse_query( "stmt s1, s2; Select s1 such that Follows(1, s1) and Follows*(s1, s2)" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [2] @@ -175,5 +175,5 @@ def test_pkb_follows_star_parent_1(): queries = parse_query( "stmt s1, s2; Select s1 such that Follows*(1, s1) and Parent(2, s2)" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert sorted(result) == [2, 4, 5, 12, 14] diff --git a/tests/pkb/test_multiple_such_that.py b/tests/pkb/test_multiple_such_that.py index 7ba7102..79f9a4a 100644 --- a/tests/pkb/test_multiple_such_that.py +++ b/tests/pkb/test_multiple_such_that.py @@ -74,6 +74,7 @@ def _get_ast_tree_call(): tree_call = _get_ast_tree_call() +context_call = extract(tree_call) def test_pkb_parent_and_uses(): @@ -84,7 +85,7 @@ def test_pkb_parent_and_uses(): Select a1 such that Parent(w1, a1) and Uses(a1, "x") """ ) - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert result == [7] @@ -96,7 +97,7 @@ def test_pkb_parent_deep_and_uses(): Select a1 such that Parent*(w1, a1) and Uses(a1, "i") """ ) - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert result == [9] @@ -107,7 +108,7 @@ def test_pkb_Next_deep_and_modifies(): Select s1 such that Next*(13, s1) and Modifies(s1, "x") """ ) - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert result == [15] @@ -118,7 +119,7 @@ def test_pkb_Next_deep_and_uses(): Select s1 such that Next*(13, s1) and Uses(s1, "z") """ ) - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert result == [14, 15] @@ -130,7 +131,7 @@ def test_pkb_next_and_modifies(): Select s1 such that Next(a1, s1) and Modifies(s1, "z") """ ) - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert result == [2, 3, 6, 8, 13] @@ -141,7 +142,7 @@ def test_pkb_next_and_modifies_2(): Select a2 such that Next(a1, a2) and Modifies(a2, "z") """ ) - result = evaluate_query(tree_call, queries[0]) + result = evaluate_query(queries[0], context_call) assert result == [2, 13] @@ -182,13 +183,14 @@ def _get_ast_tree2(): tree2 = _get_ast_tree2() +context2 = extract(tree2) def test_pkb_modifies_follows(): queries = parse_query( """assign a; while w; Select a such that Modifies(a, "a") and Follows(a, w)""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == [1, 11] @@ -196,7 +198,7 @@ def test_pkb_calls_uses(): queries = parse_query( """procedure p; Select p such that Calls(p,"test") and Uses(p, "e")""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == ["test2"] @@ -204,7 +206,7 @@ def test_pkb_uses_modifies(): queries = parse_query( """while w; Select w such that Uses(w, "e") and Modifies(w, "a")""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == [2, 12] @@ -212,7 +214,7 @@ def test_pkb_parent_modifies_next(): queries = parse_query( """while w; assign a1, a2; Select a1 such that Parent(w, a1) and Modifies(a1, "c") and Next(a1, a2)""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == [9] @@ -220,7 +222,7 @@ def test_pkb_follows_parent_modifies(): queries = parse_query( """procedure p; while w; if if; assign a; Select a such that Parent(w, if) and Follows(w, a) and Modifies(a, "i")""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == [16] @@ -228,7 +230,7 @@ def test_pkb_parent_parent(): queries = parse_query( """stmt s; while w; assign a; Select s such that Parent(w, s) and Parent(s, a)""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == [4, 13] @@ -236,7 +238,7 @@ def test_pkb_next_modifies(): queries = parse_query( """stmt s; assign a; Select a such that Next(a, s) and Modifies(a, "a")""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == [3, 1, 11, 15] @@ -244,7 +246,7 @@ def test_pkb_parent_modifies(): queries = parse_query( """while w; if if; Select w such that Parent(w, if) and Modifies(w, "b")""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == [2, 12] @@ -252,7 +254,7 @@ def test_pkb_calls_parent(): queries = parse_query( """procedure p; if if; while w; Select p such that Calls(p, "test") and Parent(if, w)""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == [] @@ -260,5 +262,5 @@ def test_pkb_parent_next(): queries = parse_query( """stmt s1, s2; assign a; Select s2 such that Parent(s1, s2) and Next(s2, a)""" ) - result = evaluate_query(tree2, queries[0]) + result = evaluate_query(queries[0], context2) assert result == [9, 4, 13] diff --git a/tests/pkb/test_uses.py b/tests/pkb/test_uses.py index 9ebb966..9f02437 100644 --- a/tests/pkb/test_uses.py +++ b/tests/pkb/test_uses.py @@ -122,13 +122,13 @@ def test_pkb_uses_procedure_variable_2(): def test_pkb_uses_assign_variable_2(): queries = parse_query("""assign a1; Select a1 such that Uses(a1, "f")""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [6, 15] def test_pkb_uses_const_variable_5(): queries = parse_query("""variable v1; Select v1 such that Uses(8, v1)""") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == ["a", "b", "c"] From f4c80bd2acb9e5ea7ee4d826b344f8132b49084c Mon Sep 17 00:00:00 2001 From: Kasper Seweryn Date: Tue, 13 Jun 2023 22:30:27 +0200 Subject: [PATCH 18/25] refactor: cleanup code --- main.py | 25 ++++++++++--------------- 1 file changed, 10 insertions(+), 15 deletions(-) diff --git a/main.py b/main.py index de6e03e..b6ef989 100644 --- a/main.py +++ b/main.py @@ -50,7 +50,7 @@ context = extract(tree) print(evaluate_query(queries[0], context)) - elif len(sys.argv) > 0: + elif len(sys.argv) > 0: # pragma no cover def no_time_left(): print("\nPreparationTimeout") @@ -71,23 +71,18 @@ def no_time_left(): queries = parse_query(query) result = evaluate_query(queries[0], context) - if not isinstance(result, bool): - if len(result) == 0: - print("none") - continue + if isinstance(result, bool): + print("true" if result else "false") + continue - output = ", ".join(str(part) for part in result) - else: - if result: - print("true") - continue - else: - print("false") - continue + if len(result) == 0: + print("none") + continue + + print(", ".join(str(part) for part in result)) - print(output) except Exception: import traceback - exc_info = traceback.format_exc().replace("\n", "") + exc_info = traceback.format_exc().replace("\n", " ") print("#" + exc_info) From a1fdca3b13e40096fdc7c960692110d90df3db6f Mon Sep 17 00:00:00 2001 From: Kasper Seweryn Date: Tue, 13 Jun 2023 23:08:08 +0200 Subject: [PATCH 19/25] fix: fix failing test due to rebasing mistake --- tests/pkb/test_boolean.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/tests/pkb/test_boolean.py b/tests/pkb/test_boolean.py index c84a2b2..090ba21 100644 --- a/tests/pkb/test_boolean.py +++ b/tests/pkb/test_boolean.py @@ -120,11 +120,25 @@ def test_pkb_boolean_false_while_while_next(): def test_pkb_boolean_true(): + tree = parse( + """ + procedure test1 { + call test5; + } + procedure test3 { + call test5; + } + procedure test5 { + call test1; + } + """ + ) queries = parse_query( """ procedure p; Select BOOLEAN such that Calls ("test3", "test5") """ ) + context = extract(tree) result = evaluate_query(queries[0], context) assert result is True From fa21f496429e17dd2b5ce05b1b7c872fda1d3319 Mon Sep 17 00:00:00 2001 From: Kasper Seweryn Date: Tue, 13 Jun 2023 23:27:15 +0200 Subject: [PATCH 20/25] feat: add `select x` support --- ats/pkb/design_extractor.py | 9 ++++++++- ats/pkb/query_evaluator.py | 26 +++++++++++++------------- tests/pkb/test_boolean.py | 16 ---------------- tests/pkb/test_other.py | 33 +++++++++++++++++++++++++++++++++ 4 files changed, 54 insertions(+), 30 deletions(-) create mode 100644 tests/pkb/test_other.py diff --git a/ats/pkb/design_extractor.py b/ats/pkb/design_extractor.py index 8803084..76c1e4e 100644 --- a/ats/pkb/design_extractor.py +++ b/ats/pkb/design_extractor.py @@ -26,14 +26,17 @@ def _dfs(node: nodes.ASTNode): def extract(tree: nodes.ProgramNode): + stmts = [] statements_by_type = { "procedure": [], "variable": set(), + "constant": set(), "assign": [], "while": [], - "stmt": [], + "stmt": stmts, "call": [], "if": [], + "prog_line": stmts, } statements = {} @@ -116,6 +119,10 @@ def on_node_enter(node: nodes.ASTNode, context: dict): call_order.index(node.name), proc_stmt_stack[0].name ) + # Find all constants + if isinstance(node, nodes.ConstantNode): + statements_by_type["constant"].add(int(node.value)) + # Find all variables if isinstance(node, nodes.VariableNode): variables[node] = node.name diff --git a/ats/pkb/query_evaluator.py b/ats/pkb/query_evaluator.py index 5a8a18e..10b59d4 100644 --- a/ats/pkb/query_evaluator.py +++ b/ats/pkb/query_evaluator.py @@ -1,5 +1,5 @@ from ats.ast.nodes import ProcedureNode -from ats.pkb.utils import process_relation +from ats.pkb.utils import map_result, process_relation def process_follows(query, context, relation): @@ -172,6 +172,18 @@ def relation_cb(node_a, node_b): def evaluate_query(query, context): all_results = set() + + if query["searching_variable"] != "BOOLEAN": + if len(query["conditions"]["relations"]) == 0: + all_results = set( + map( + map_result, + context["statements_by_type"][ + query["variables"][query["searching_variable"]] + ], + ) + ) + for i, relation in enumerate(query["conditions"]["relations"]): results = all_results if i == 0 else set() if relation["relation"] == "Follows": @@ -207,18 +219,6 @@ def evaluate_query(query, context): if results != all_results: all_results = all_results.intersection(results) - # assign a1; - # while w1, w2; - # Select a1 such that Parent(w1, a1) and Parent(w2, w1) with w2.stmt# = 5 - for i, condition in enumerate(query["conditions"]["attributes"]): - results = all_results if i == 0 else set() - - if results != all_results: - all_results = all_results.intersection(results) - - for i, condition in enumerate(query["conditions"]["patterns"]): - ... - if query["searching_variable"] == "BOOLEAN": return len(all_results) > 0 diff --git a/tests/pkb/test_boolean.py b/tests/pkb/test_boolean.py index 090ba21..a502627 100644 --- a/tests/pkb/test_boolean.py +++ b/tests/pkb/test_boolean.py @@ -85,28 +85,12 @@ def test_pkb_boolean_true_proc_calls(): assert result is True -def test_pkb_boolean_false_stmt_stmt_follows_with_condition(): - queries = parse_query( - "stmt s1, s2; Select BOOLEAN such that Follows(s1, s2) with s1.stmt# = 1 and s2.stmt# = 3" - ) - result = evaluate_query(queries[0], context) - assert result is False - - def test_pkb_boolean_true_while_uses(): queries = parse_query("""while w; Select BOOLEAN such that Uses(w,"f")""") result = evaluate_query(queries[0], context) assert result is True -def test_pkb_boolean_false_while_uses_condition(): - queries = parse_query( - """while w; variable v1; Select BOOLEAN such that Uses(w, v1) with v1.varName = "x" """ - ) - result = evaluate_query(queries[0], context) - assert result is False - - def test_pkb_boolean_true_assign_while_next(): queries = parse_query("assign a; while w; Select BOOLEAN such that Next(a, w)") result = evaluate_query(queries[0], context) diff --git a/tests/pkb/test_other.py b/tests/pkb/test_other.py new file mode 100644 index 0000000..a84bfb1 --- /dev/null +++ b/tests/pkb/test_other.py @@ -0,0 +1,33 @@ +from ats.parser.parser import parse +from ats.pkb.design_extractor import extract +from ats.pkb.query_evaluator import evaluate_query +from ats.pql.pql import parse_query + +tree = parse( + """ + procedure proc { + a = 8 + 1; + } + """ +) + + +def test_assign(): + context = extract(tree) + queries = parse_query("assign c; Select c") + result = evaluate_query(queries[0], context) + assert result == [1] + + +def test_constants(): + context = extract(tree) + queries = parse_query("constant c; Select c") + result = evaluate_query(queries[0], context) + assert sorted(result) == [1, 8] + + +def test_prog_line(): + context = extract(tree) + queries = parse_query("prog_line c; Select c") + result = evaluate_query(queries[0], context) + assert sorted(result) == [1] From c679599c4eb7011dc4224cc7d30dbcbe592d4252 Mon Sep 17 00:00:00 2001 From: Kasper Seweryn Date: Tue, 13 Jun 2023 23:30:51 +0200 Subject: [PATCH 21/25] feat: better error messages --- main.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/main.py b/main.py index b6ef989..be4adcf 100644 --- a/main.py +++ b/main.py @@ -81,8 +81,5 @@ def no_time_left(): print(", ".join(str(part) for part in result)) - except Exception: - import traceback - - exc_info = traceback.format_exc().replace("\n", " ") - print("#" + exc_info) + except Exception as e: + print("# " + e.args[0].replace("\n", " ")) From 008c6eb9c3cd29f5a9720673e11f2a038e5f0e89 Mon Sep 17 00:00:00 2001 From: Kasper Seweryn Date: Tue, 13 Jun 2023 23:47:38 +0200 Subject: [PATCH 22/25] feat: add error about attribute and pattern conditions --- ats/pkb/query_evaluator.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/ats/pkb/query_evaluator.py b/ats/pkb/query_evaluator.py index 10b59d4..4ca4bec 100644 --- a/ats/pkb/query_evaluator.py +++ b/ats/pkb/query_evaluator.py @@ -173,6 +173,12 @@ def relation_cb(node_a, node_b): def evaluate_query(query, context): all_results = set() + if ( + len(query["conditions"]["attributes"]) > 0 + or len(query["conditions"]["patterns"]) > 0 + ): + raise ValueError("Attribute and pattern conditions are not supported yet") + if query["searching_variable"] != "BOOLEAN": if len(query["conditions"]["relations"]) == 0: all_results = set( From 3b8cb6ce96f1021d30cc2c7e78a24b22dee4889f Mon Sep 17 00:00:00 2001 From: Kasper Seweryn Date: Wed, 14 Jun 2023 00:26:52 +0200 Subject: [PATCH 23/25] feat: break out when calling a relation with same params --- ats/pkb/utils.py | 6 ++++++ tests/pkb/test_calls.py | 6 ++++++ tests/pkb/test_calls_deep.py | 6 ++++++ tests/pkb/test_other.py | 5 +++-- 4 files changed, 21 insertions(+), 2 deletions(-) diff --git a/ats/pkb/utils.py b/ats/pkb/utils.py index 129d9ea..1305a75 100644 --- a/ats/pkb/utils.py +++ b/ats/pkb/utils.py @@ -59,6 +59,12 @@ def process_relation( ): results = set() + if is_variable(query, relation["parameters"][0]) and is_variable( + query, relation["parameters"][1] + ): + if relation["parameters"][0] == relation["parameters"][1]: + return results + class Break(Exception): pass diff --git a/tests/pkb/test_calls.py b/tests/pkb/test_calls.py index 416e088..356f6da 100644 --- a/tests/pkb/test_calls.py +++ b/tests/pkb/test_calls.py @@ -103,6 +103,12 @@ def test_pkb_calls_procedure_proc_invalid_1(): assert sorted(result) == [] +def test_pkb_calls_self(): + queries = parse_query("""procedure p; Select p such that Calls(p, p)""") + result = evaluate_query(queries[0], context) + assert sorted(result) == [] + + # def test_pkb_calls_with_condition(): # queries = parse_query( # """ diff --git a/tests/pkb/test_calls_deep.py b/tests/pkb/test_calls_deep.py index 93d4534..705489b 100644 --- a/tests/pkb/test_calls_deep.py +++ b/tests/pkb/test_calls_deep.py @@ -136,3 +136,9 @@ def test_pkb_calls_star_name_name_3(): ) result = evaluate_query(queries[0], context3) assert sorted(result) == [] + + +def test_pkb_calls_self(): + queries = parse_query("""procedure p; Select p such that Calls*(p, p)""") + result = evaluate_query(queries[0], context) + assert sorted(result) == [] diff --git a/tests/pkb/test_other.py b/tests/pkb/test_other.py index a84bfb1..f491b31 100644 --- a/tests/pkb/test_other.py +++ b/tests/pkb/test_other.py @@ -7,6 +7,7 @@ """ procedure proc { a = 8 + 1; + a = a; } """ ) @@ -16,7 +17,7 @@ def test_assign(): context = extract(tree) queries = parse_query("assign c; Select c") result = evaluate_query(queries[0], context) - assert result == [1] + assert result == [1, 2] def test_constants(): @@ -30,4 +31,4 @@ def test_prog_line(): context = extract(tree) queries = parse_query("prog_line c; Select c") result = evaluate_query(queries[0], context) - assert sorted(result) == [1] + assert sorted(result) == [1, 2] From 4bbcd5d044a5b9aba718b7613e9dafb9a4c46466 Mon Sep 17 00:00:00 2001 From: Kasper Seweryn Date: Wed, 14 Jun 2023 08:55:28 +0200 Subject: [PATCH 24/25] fix: allow Relation(_, _) --- ats/pkb/query_evaluator.py | 10 +++++----- ats/pkb/utils.py | 6 +++++- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/ats/pkb/query_evaluator.py b/ats/pkb/query_evaluator.py index 4ca4bec..0a2fb8d 100644 --- a/ats/pkb/query_evaluator.py +++ b/ats/pkb/query_evaluator.py @@ -173,11 +173,11 @@ def relation_cb(node_a, node_b): def evaluate_query(query, context): all_results = set() - if ( - len(query["conditions"]["attributes"]) > 0 - or len(query["conditions"]["patterns"]) > 0 - ): - raise ValueError("Attribute and pattern conditions are not supported yet") + # if ( + # len(query["conditions"]["attributes"]) > 0 + # or len(query["conditions"]["patterns"]) > 0 + # ): + # raise ValueError("Attribute and pattern conditions are not supported yet") if query["searching_variable"] != "BOOLEAN": if len(query["conditions"]["relations"]) == 0: diff --git a/ats/pkb/utils.py b/ats/pkb/utils.py index 1305a75..50e7b8a 100644 --- a/ats/pkb/utils.py +++ b/ats/pkb/utils.py @@ -63,7 +63,8 @@ def process_relation( query, relation["parameters"][1] ): if relation["parameters"][0] == relation["parameters"][1]: - return results + if relation["parameters"][0] is not Any: + return results class Break(Exception): pass @@ -77,6 +78,9 @@ def get_needle(stmt_a, stmt_b): def check_relation(stmt_a, stmt_b): nonlocal results + if stmt_a is None or stmt_b is None: + if stmt_a is stmt_b: + raise Break() try: if relation_cb(stmt_a, stmt_b): From aa5fa9fd7751c2924d7f9c9f00f1d944de35c470 Mon Sep 17 00:00:00 2001 From: Kasper Seweryn Date: Wed, 14 Jun 2023 09:08:40 +0200 Subject: [PATCH 25/25] fix: fix extended parents --- ats/pkb/design_extractor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ats/pkb/design_extractor.py b/ats/pkb/design_extractor.py index 76c1e4e..073a5bd 100644 --- a/ats/pkb/design_extractor.py +++ b/ats/pkb/design_extractor.py @@ -153,14 +153,14 @@ def on_node_exit(node: nodes.ASTNode, context): ) # extending procedure parents with nested calls - """extend_parents = [] + extend_parents = [] for name in call_order: if name in proc_parents: proc_parents[name].extend(extend_parents) proc_parents[name] = list(set(proc_parents[name])) extend_parents.extend(proc_parents[name]) else: - extend_parents = []""" + extend_parents = [] def process_relations(): # Build stack with procedures name and statements id