diff --git a/ats/pkb/design_extractor.py b/ats/pkb/design_extractor.py index 9d37610..073a5bd 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 329a46a..0a2fb8d 100644 --- a/ats/pkb/query_evaluator.py +++ b/ats/pkb/query_evaluator.py @@ -1,7 +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 +from ats.pkb.utils import map_result, process_relation def process_follows(query, context, relation): @@ -102,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( @@ -119,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( @@ -168,9 +170,26 @@ def relation_cb(node_a, node_b): ) -def evaluate_query(node: nodes.ProgramNode, query): - context = extract(node) +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( + 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": @@ -206,18 +225,6 @@ def evaluate_query(node: nodes.ProgramNode, query): 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/ats/pkb/utils.py b/ats/pkb/utils.py index 1eb8746..50e7b8a 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, } @@ -58,6 +59,13 @@ 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]: + if relation["parameters"][0] is not Any: + return results + class Break(Exception): pass @@ -70,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): diff --git a/main.py b/main.py index f79d244..be4adcf 100644 --- a/main.py +++ b/main.py @@ -1,12 +1,14 @@ import sys +from threading import Timer 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 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( """ @@ -45,17 +47,39 @@ Select BOOLEAN such that Calls(_, _) """ ) + context = extract(tree) + print(evaluate_query(queries[0], context)) - print(evaluate_query(tree, queries[0])) + elif len(sys.argv) > 0: # pragma no cover + + def no_time_left(): + print("\nPreparationTimeout") + exit(1) - elif len(sys.argv) > 0: with open(sys.argv[-1]) as f: code = f.read() tree = parse(code) - # TODO: Extract design patterns here! + context = extract(tree) print("Ready") + while True: + try: + t = Timer(60, no_time_left) + t.start() + query = input() + "\n" + input() + t.cancel() + + queries = parse_query(query) + result = evaluate_query(queries[0], context) + + if isinstance(result, bool): + print("true" if result else "false") + continue + + if len(result) == 0: + print("none") + continue - query = input() + "\n" + input() + print(", ".join(str(part) for part in result)) - # TODO: use PQL and PKB - print("8") + except Exception as e: + print("# " + e.args[0].replace("\n", " ")) 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; +} diff --git a/tests/pkb/test_boolean.py b/tests/pkb/test_boolean.py index 0f96002..a502627 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,83 +63,66 @@ 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 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 -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]) - 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 -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]) - 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 def test_pkb_boolean_true(): - queries = parse_query( - """ - procedure p; - 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]) + 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 diff --git a/tests/pkb/test_calls.py b/tests/pkb/test_calls.py index 959a3a3..356f6da 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,25 @@ 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) == [] + + +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) == [] @@ -124,7 +132,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 +143,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 +154,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..705489b 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,18 @@ 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) == [] + + +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_follows.py b/tests/pkb/test_follows.py index 16f8be3..321e828 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,7 +169,7 @@ def test_pkb_boolean_follows_with_condition(): """ ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context_if) assert result is False @@ -194,6 +197,7 @@ def _get_ast_tree3(): tree3 = _get_ast_tree() +context3 = extract(tree3) def test_pkb_follows_modifies(): @@ -201,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] @@ -210,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] @@ -219,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] @@ -228,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 == [] @@ -237,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] @@ -246,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] @@ -255,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] @@ -264,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 9b4d2d8..453c412 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,47 +110,48 @@ 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] 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] @@ -156,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] @@ -164,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] @@ -172,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_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 5bc7967..79f9a4a 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,7 +35,7 @@ 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] @@ -72,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(): @@ -82,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] @@ -94,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] @@ -105,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] @@ -116,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] @@ -128,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] @@ -139,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] @@ -180,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] @@ -194,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"] @@ -202,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] @@ -210,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] @@ -218,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] @@ -226,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] @@ -234,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] @@ -242,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] @@ -250,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 == [] @@ -258,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_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_other.py b/tests/pkb/test_other.py new file mode 100644 index 0000000..f491b31 --- /dev/null +++ b/tests/pkb/test_other.py @@ -0,0 +1,34 @@ +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; + a = a; + } + """ +) + + +def test_assign(): + context = extract(tree) + queries = parse_query("assign c; Select c") + result = evaluate_query(queries[0], context) + assert result == [1, 2] + + +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, 2] 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 75f7174..aef60ec 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,77 +37,78 @@ 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]) + queries = parse_query("stmt s1, s2; Select s1 such that Parent*(s1, s2)") + 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]) + queries = parse_query("if if; while w; Select w such that Parent*(if, w)") + 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]) + queries = parse_query("if if; while w; Select if such that Parent*(w, if)") + result = evaluate_query(queries[0], context) assert sorted(result) == [] def test_pkb_parent_star_stmt_stmt_3(): queries = parse_query("while w1; while w2; Select w1 such that Parent*(w1, w2)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [3, 8, 12] def test_pkb_parent_star_stmt_stmt_4(): queries = parse_query("while w1; assign a1; Select w1 such that Parent*(w1, a1)") - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [3, 5, 8, 10, 12, 14] @@ -114,7 +116,7 @@ def test_pkb_parent_star_uses(): queries = parse_query( """stmt s1; Select s1 such that Parent*(s1, 9) and Uses(s1, "a")""" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 8] @@ -122,7 +124,7 @@ def test_pkb_parent_star_uses_2(): queries = parse_query( """assign a1; Select a1 such that Parent*(1, 5) and Uses(a1, "a")""" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [] @@ -130,7 +132,7 @@ def test_pkb_parent_star_next(): queries = parse_query( "assign a1; while w1; Select a1 such that Parent*(w1, 10) and Next(a1, w1)" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 4, 6, 7, 9, 11, 13, 15] @@ -138,7 +140,7 @@ def test_pkb_parent_star_next_2(): queries = parse_query( "stmt s1; while w1; Select w1 such that Parent*(3, w1) and Next(1, s1)" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [5] @@ -146,7 +148,7 @@ def test_pkb_parent_star_modifies(): queries = parse_query( """assign a1; Select a1 such that Parent*(1, a1) and Modifies(a1, "a")""" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [2, 7] @@ -154,5 +156,5 @@ def test_pkb_parent_star_modifies_2(): queries = parse_query( """stmt s1; Select s1 such that Parent*(s1, 10) and Modifies(s1, "c")""" ) - result = evaluate_query(tree, queries[0]) + result = evaluate_query(queries[0], context) assert sorted(result) == [1, 8] diff --git a/tests/pkb/test_uses.py b/tests/pkb/test_uses.py index 6888e70..9f02437 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,95 +39,96 @@ 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 == [] 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"] @@ -135,7 +137,7 @@ def test_pkb_uses_const_variable_5(): # 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"] @@ -146,7 +148,7 @@ def test_pkb_uses_const_variable_5(): # """ # ) -# result = evaluate_query(tree, queries[0]) +# result = evaluate_query(queries[0], context) # assert result == True @@ -189,27 +191,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]