def test_library_length(self): string = ''' MACHINE LibraryStrings CONSTANTS length PROPERTIES /* compute the length of a string */ length: STRING --> INTEGER & length = %x.(x:STRING|STRING_LENGTH(x)) DEFINITIONS STRING_LENGTH(x) == length(x); EXTERNAL_FUNCTION_STRING_LENGTH == STRING --> INTEGER; ASSERTIONS length("abc") = 3; length("") = 0; length("hello") = 5 END ''' # Build AST string_to_file(string, file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() dh = DefinitionHandler(env, str_ast_to_python_ast) dh.repl_defs(root) mch = parse_ast(root, env) type_check_bmch(root, env, mch) assert isinstance(get_type_by_name(env, "length"), PowerSetType) assert isinstance(get_type_by_name(env, "length").data, CartType) assert isinstance(get_type_by_name(env, "length").data.left.data, StringType) assert isinstance(get_type_by_name(env, "length").data.right.data, IntegerType) arbitrary_init_machine(root, env, mch) # init VARIABLES and eval INVARIANT assert isinstance(root.children[4], AAssertionsMachineClause) interpret(root.children[4], env)
def test_genAST_pred_rel_image(self): # Build AST: string_to_file("#PREDICATE f=r[S]", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["S","r","f"]) env.set_value("S", frozenset(["a"])) env.set_value("f", frozenset(["1"])) env.set_value("r", frozenset([("a","1"),("b","42"),("c","777")])) assert interpret(root.children[0],env) env.set_value("f", frozenset(["1","42"])) env.set_value("r", frozenset([("a","1"),("a","42"),("c","777")])) assert interpret(root.children[0],env) env.set_value("S", frozenset(["a","c"])) env.set_value("f", frozenset(["1","42","777"])) env.set_value("r", frozenset([("a","1"),("a","42"),("c","777")])) assert interpret(root.children[0],env) env.set_value("S", frozenset(["c"])) env.set_value("f", frozenset(["777"])) env.set_value("r", frozenset([("a","1"),("a","42"),("c","777")])) assert interpret(root.children[0],env) env.set_value("r", frozenset([(3,5), (3,9), (6,3), (9,2)])) env.set_value("S", frozenset([1, 2, 3])) env.set_value("f", frozenset([5,9])) assert interpret(root.children[0],env)
def test_simple_set_pred_inters(self): # Build AST: S <: S /\ T idExp = AIdentifierExpression("S") idExp2 = AIdentifierExpression("S") idExp3 = AIdentifierExpression("T") insExp = AIntersectionExpression() insExp.children.append(idExp2) insExp.children.append(idExp3) inclPred = ASubsetPredicate() inclPred.children.append(idExp) inclPred.children.append(insExp) # Test env = Environment() env.add_ids_to_frame(["S","T"]) env.set_value("S", frozenset(["aa","bb"])) env.set_value("T", frozenset(["bb","cc","dd"])) assert not interpret(inclPred, env) env.set_value("S", frozenset(["aa","bb"])) env.set_value("T", frozenset(["aa","bb","cc","dd"])) assert interpret(inclPred, env) env.set_value("S", frozenset(["aa","bb"])) env.set_value("T", frozenset(["cc","dd"])) assert not interpret(inclPred, env)
def test_genAST_pred_part_bij_fun(self): # Build AST string_to_file("#PREDICATE F=S>+>>T", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) env = Environment() env.add_ids_to_frame(["S","T","F"]) env.set_value("S", frozenset(["a","b"])) env.set_value("T", frozenset(["x","y","z"])) env.set_value("F", frozenset([])) assert interpret(root.children[0],env) env.set_value("S", frozenset(["a","b"])) env.set_value("T", frozenset(["x","y"])) l = [frozenset([("a","x"),("b","y")])] l.append(frozenset([("a","y"),("b","x")])) env.set_value("F", frozenset(l)) assert interpret(root.children[0],env) env.set_value("S", frozenset(["a","b","c"])) env.set_value("T", frozenset(["x","y"])) l = [frozenset([("a","x"),("b","y")])] l.append(frozenset([("a","x"),("c","y")])) l.append(frozenset([("a","y"),("b","x")])) l.append(frozenset([("a","y"),("c","x")])) l.append(frozenset([("b","x"),("c","y")])) l.append(frozenset([("b","y"),("c","x")])) env.set_value("F", frozenset(l)) assert interpret(root.children[0],env)
def test_simple_set_pred_setex(self): # Build AST: yy:{aa,bb,cc} idExp = AIdentifierExpression("yy") idExp2 = AIdentifierExpression("aa") idExp3 = AIdentifierExpression("bb") idExp4 = AIdentifierExpression("cc") sexExp = ASetExtensionExpression("3") sexExp.children.append(idExp2) sexExp.children.append(idExp3) sexExp.children.append(idExp4) belPred = AMemberPredicate() belPred.children.append(idExp) belPred.children.append(sexExp) #Test env = Environment() env.add_ids_to_frame(["yy","aa","bb","cc"]) env.set_value("yy", "aa") env.set_value("aa", "aa") #FIXME: maybe this is a Bug.. env.set_value("bb", "bb") # env.set_value("cc", "cc") # assert interpret(belPred, env) env.set_value("yy", "yy") assert not interpret(belPred, env)
def test_simple_set_pred_not_str_subset(self): # Build AST: A/<<:B idExp = AIdentifierExpression("A") idExp2 = AIdentifierExpression("B") notinclstrPred = ANotSubsetStrictPredicate() notinclstrPred.children.append(idExp) notinclstrPred.children.append(idExp2) #Test env = Environment() env.add_ids_to_frame(["A","B"]) env.set_value("A", frozenset(["aa"])) env.set_value("B", frozenset(["aa","bb"])) assert not interpret(notinclstrPred, env) env.set_value("B", frozenset(["aa"])) env.set_value("A", frozenset(["aa","bb"])) assert interpret(notinclstrPred, env) env.set_value("B", frozenset()) env.set_value("A", frozenset()) assert interpret(notinclstrPred, env) env.set_value("B", frozenset(["aa","bb"])) env.set_value("A", frozenset(["aa","bb"])) assert interpret(notinclstrPred, env)
def test_simple_pred_impl3(self): # Build AST: z=42 => 1+1=2 intExp4 = AIntegerExpression(42) idExp = AIdentifierExpression("z") eqPred2 = AEqualPredicate() eqPred2.children.append(idExp) eqPred2.children.append(intExp4) intExp = AIntegerExpression(1) intExp2 = AIntegerExpression(1) intExp3 = AIntegerExpression(2) addExp = AAddExpression() addExp.children.append(intExp) addExp.children.append(intExp2) eqPred = AEqualPredicate() eqPred.children.append(addExp) eqPred.children.append(intExp3) implPred = AImplicationPredicate() implPred.children.append(eqPred2) implPred.children.append(eqPred) #Test env = Environment() # True=>True is True env.add_ids_to_frame(["z"]) env.set_value("z", 42) assert interpret(implPred, env) # False=>True is True env.set_value("z", 41) assert interpret(implPred, env)
def test_genAST_pred_rel_overriding(self): # Build AST: string_to_file("#PREDICATE f=r1 <+ r2", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["r1","r2","f"]) env.set_value("f", frozenset([("a","1"),("b","42"),("c","777"),("d","17")])) env.set_value("r1", frozenset([("d","17")])) env.set_value("r2", frozenset([("a","1"),("b","42"),("c","777")])) assert interpret(root.children[0],env) env.set_value("f", frozenset([("a","1"),("b","41"),("c","777"),("d","17")])) env.set_value("r2", frozenset([("d","17"),("b","41")])) env.set_value("r1", frozenset([("a","1"),("b","42"),("c","777")])) assert interpret(root.children[0],env) env.set_value("r1", frozenset([(2,7), (3,4), (5,1), (9,5)])) env.set_value("r2", frozenset([(3,5), (3,9), (6,3), (9,2)])) env.set_value("f", frozenset([(3,5), (3,9), (6,3), (9,2), (2,7), (5,1)])) assert interpret(root.children[0],env) env.set_value("f", frozenset([("a","1"),("b","42"),("c","777")])) env.set_value("r2", frozenset([])) env.set_value("r1", frozenset([("a","1"),("b","42"),("c","777")])) assert interpret(root.children[0],env) env.set_value("f", frozenset([("a","1"),("b","42"),("c","777")])) env.set_value("r2", frozenset([("a","1"),("b","42"),("c","777")])) env.set_value("r1", frozenset([])) assert interpret(root.children[0],env)
def test_simple_pred_impl(self): # Build AST: z>=42 => z>41 idExp = AIdentifierExpression("z") intExp = AIntegerExpression(42) geqPred = AGreaterEqualPredicate() geqPred.children.append(idExp) geqPred.children.append(intExp) idExp2 = AIdentifierExpression("z") intExp2 = AIntegerExpression(41) gtPred = AGreaterPredicate() gtPred.children.append(idExp2) gtPred.children.append(intExp2) implPred = AImplicationPredicate() implPred.children.append(geqPred) implPred.children.append(gtPred) #Test env = Environment() # True=>True is True env.add_ids_to_frame(["z"]) env.set_value("z", 42) assert interpret(implPred, env) env = Environment() env.add_ids_to_frame(["z"]) env.set_value("z", 43) assert interpret(implPred, env) env = Environment() # False=>False is True env.add_ids_to_frame(["z"]) env.set_value("z", 41) assert interpret(implPred, env)
def test_genAST_pred_rel_direct_prod(self): # Build AST: string_to_file("#PREDICATE f= p >< q", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["q","p","f"]) env.set_value("f", frozenset([])) env.set_value("p", frozenset([])) env.set_value("q", frozenset([])) assert interpret(root.children[0],env) env.set_value("f", frozenset([])) env.set_value("p", frozenset([("x","1"),("y","2")])) env.set_value("q", frozenset([("a","3"),("b","4")])) assert interpret(root.children[0],env) env.set_value("f", frozenset([("x",("1","3"))])) env.set_value("p", frozenset([("x","1"),("y","2")])) env.set_value("q", frozenset([("x","3"),("b","4")])) assert interpret(root.children[0],env) env.set_value("f", frozenset([(7,(11,20)), (2,(11,21))])) env.set_value("p", frozenset([(8,10), (7,11), (2,11), (6,12)])) env.set_value("q", frozenset([(1,20), (7,20), (2,21), (1,22)])) assert interpret(root.children[0],env)
def test_genAST_set_gen_inter(self): # Build AST: string_to_file("#PREDICATE U:POW(POW(S)) & u=inter(U)", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["S","U","u"]) env.set_value("S", frozenset(["a","b","c"])) env.set_value("U", frozenset([frozenset(["a","b","c"])])) env.set_value("u", frozenset(["a","b","c"])) assert interpret(root.children[0],env) env.set_value("U", frozenset([frozenset(["a","b","c"]),frozenset(["a"])])) env.set_value("u", frozenset(["a"])) assert interpret(root.children[0],env) env.set_value("U", frozenset([frozenset(["a","b"]),frozenset(["c"])])) env.set_value("u", frozenset([])) assert interpret(root.children[0],env) env.set_value("U", frozenset([frozenset(["a","b"]),frozenset(["c"]),frozenset(["a"])])) env.set_value("u", frozenset([])) assert interpret(root.children[0],env) env.set_value("U", frozenset([frozenset(["a","b"]),frozenset(["c","b"]),frozenset(["a","b"])])) env.set_value("u", frozenset(["b"])) assert interpret(root.children[0],env)
def test_genAST_pred_simple_closure(self): # Build AST string_to_file("#PREDICATE f=closure(r)", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["r","f"]) env.set_value("f", frozenset([(1,3),(3,1),(1,1),(3,3)])) env.set_value("r", frozenset([(1,3),(3,1)])) assert interpret(root.children[0],env) env.set_value("f", frozenset([(1,7),(6,2),(8,4),(1,1),(6,6),(8,8),(2,2),(4,4),(7,7)])) env.set_value("r", frozenset([(1,7),(6,2),(8,4)])) assert interpret(root.children[0],env) env.set_value("f", frozenset([(1,7),(6,4),(8,4),(1,1),(6,6),(8,8),(4,4),(7,7)])) env.set_value("r", frozenset([(1,7),(6,4),(8,4)])) assert interpret(root.children[0],env) env.set_value("f", frozenset([(3,1),(1,1),(3,3)])) env.set_value("r", frozenset([(3,1),(1,1)])) assert interpret(root.children[0],env) env.set_value("f", frozenset([(1,3),(1,1),(3,3)])) env.set_value("r", frozenset([(1,3),(1,1)])) assert interpret(root.children[0],env)
def test_simple_model_checking0(self): path = "examples/rpython_performance/Lift2.mch" if os.name=='nt': path="examples\rpython_performance\Lift2" ast_string = file_to_AST_str(path) root = str_ast_to_python_ast(ast_string) # Test env = Environment() mch = parse_ast(root, env) type_check_bmch(root, env, mch) # also checks all included, seen, used and extend env._max_int = 2**31 solution_file_read = False bstates = set_up_constants(root, env, mch, solution_file_read) assert len(bstates)==0 # no setup possible bstates = exec_initialisation(root, env, mch, solution_file_read) assert len(bstates)==1 # only one possibility (floor:=4) assert len(env.state_space.seen_states)==0 assert isinstance(bstates[0], BState) env.state_space.set_current_state(bstates[0]) assert len(env.state_space.seen_states)==1 invatiant = root.children[2] assert isinstance(invatiant, AInvariantMachineClause) assert interpret(invatiant, env) assert len(env.state_space.stack)==2 next_states = calc_next_states(env, mch) assert len(next_states)==2 assert len(env.state_space.stack)==2 # init and empty setup assert env.get_value('floor')==4 env.state_space.undo() assert len(env.state_space.stack)==1 # setup assert len(env.state_space.seen_states)==1 for n_state in next_states: bstate = n_state.bstate assert isinstance(bstate, BState) if not env.state_space.is_seen_state(bstate): env.state_space.set_current_state(bstate) assert len(env.state_space.stack)==3 # dec, inc, setup assert len(env.state_space.seen_states)==3 assert env.get_value('floor')==3 or env.get_value('floor')==5 # TODO: Bstate needs refactoring. # - Remove init state # - dont map None to values if parsing unit is no machine # - check empty on stack length 0 # model checking loop while not env.state_space.empty(): assert interpret(invatiant, env) next_states = calc_next_states(env, mch) env.state_space.undo() for n_state in next_states: bstate = n_state.bstate if not env.state_space.is_seen_state(bstate): env.state_space.set_current_state(bstate) assert len(env.state_space.seen_states)==100
def test_genAST_pred_nat1(self): # Build AST: string_to_file("#PREDICATE x:NAT1", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["x"]) env.set_value("x", 2) assert interpret(root.children[0],env) env.set_value("x", 0) assert not interpret(root.children[0],env)
def test_genAST_not_member(self): # Build AST string_to_file("#PREDICATE x/:S", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["x","S"]) env.set_value("x", "x") env.set_value("S", frozenset(["x","y","z"])) assert not interpret(root.children[0], env) env.set_value("S", frozenset(["a","b","c"])) assert interpret(root.children[0], env)
def test_library_append(self): string = ''' MACHINE m DEFINITIONS EXTERNAL_FUNCTION_STRING_APPEND == STRING*STRING --> STRING; STRING_APPEND(x,y) == append(x,y); STRING_LENGTH(x) == length(x); EXTERNAL_FUNCTION_STRING_LENGTH == STRING --> INTEGER; ABSTRACT_CONSTANTS append, length PROPERTIES append = %(x,y).(x: STRING & y: STRING | STRING_APPEND(x,y)) & length: STRING --> INTEGER & length = %x.(x:STRING|STRING_LENGTH(x)) ASSERTIONS append("abc","abc") = "abcabc"; append("","abc") = "abc"; append("abc","") = "abc"; /*{x|x:{"abc","abcabc","hello"} & #(prefx).(append(prefx,"c")=x)} = {"abcabc","abc"};*/ {x|x/="" & #y.(append(x,y)="abc" & y/="")} = {"a","ab"}; /* compute true prefixes */ {x|x/="" & #y.(append(y,x)="abc" & y/="")} = {"c","bc"}; /* compute true postfixes */ {y|y/="" & #(x,z).(append(x,append(y,z))="abc" & length(x)+length(z)>0)} = /* compute true substrings */ {"a","ab","b","bc","c"}; {y|y/="" & #(x,z).(append(append(x,y),z)="abc" & length(x)+length(z)>0)} = /* compute true substrings */ {"a","ab","b","bc","c"} END''' # TODO: prolog-style args # {x|x:{"abc","abcabc","hello"} & #(prefx).(append(prefx,"c")=x)} = {"abcabc","abc"}; # Build AST string_to_file(string, file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() dh = DefinitionHandler(env, str_ast_to_python_ast) dh.repl_defs(root) mch = parse_ast(root, env) type_check_bmch(root, env, mch) assert isinstance(get_type_by_name(env, "append"), PowerSetType) assert isinstance(get_type_by_name(env, "append").data, CartType) assert isinstance(get_type_by_name(env, "append").data.left.data, CartType) assert isinstance(get_type_by_name(env, "append").data.left.data.left.data, StringType) assert isinstance(get_type_by_name(env, "append").data.left.data.right.data, StringType) assert isinstance(get_type_by_name(env, "append").data.right.data, StringType) arbitrary_init_machine(root, env, mch) # init VARIABLES and eval INVARIANT assert isinstance(root.children[4], AAssertionsMachineClause) interpret(root.children[4], env)
def test_CartesianProductOverride(self): string = ''' MACHINE CartesianProductOverride SETS S;T CONSTANTS a,b,c PROPERTIES /* Rule Hypotheses */ a : S <-> T & dom(a) = b & c <: T & /* Rule Conclusion */ not( a <+ b * c = b * c ) END''' # Build AST string_to_file(string, file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() mch = parse_ast(root, env) type_check_bmch(root, env, mch) # also checks all included, seen, used and extend arbitrary_init_machine(root, env, mch) # eval CONSTANTS and PROPERTIES assert isinstance(root.children[3], APropertiesMachineClause) assert interpret(root.children[3], env)
def test_genAST_subst_def2(self): string=''' MACHINE Test VARIABLES z, b, x INVARIANT x:NAT & z:NAT & b:BOOL INITIALISATION x:=2 ; Assign(x+1, z) ; Assign(TRUE, b) DEFINITIONS Assign(Expr, VarName) == VarName := Expr; END''' string_to_file(string, file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) #Test env = Environment() dh = DefinitionHandler(env, str_ast_to_python_ast) dh.repl_defs(root) mch = parse_ast(root, env) type_check_bmch(root, env, mch) # also checks all included, seen, used and extend arbitrary_init_machine(root, env, mch)# init VARIABLES and eval INVARIANT invariant = root.children[2] assert isinstance(invariant, AInvariantMachineClause) assert interpret(invariant, env) assert env.get_value("z")==3 assert env.get_value("b")==True assert env.get_value("x")==2
def test_genAST_para_def(self): # Build AST string =''' MACHINE Test VARIABLES z INVARIANT z:MyType INITIALISATION z:= Expr(2) DEFINITIONS Expr(X) == 1+X; MyType == NAT; END''' string_to_file(string, file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() dh = DefinitionHandler(env, str_ast_to_python_ast) dh.repl_defs(root) mch = parse_ast(root, env) type_check_bmch(root, env, mch) # also checks all included, seen, used and extend arbitrary_init_machine(root, env, mch) # init VARIABLES and eval INVARIANT invariant = root.children[2] assert isinstance(invariant, AInvariantMachineClause) assert interpret(invariant, env) assert env.get_value("z")==3
def test_examples_no_query_op(self): string = ''' MACHINE Query VARIABLES xx INVARIANT xx:NAT INITIALISATION xx:=1 OPERATIONS no_query = xx:=2 END''' # Build AST string_to_file(string, file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() mch = parse_ast(root, env) type_check_bmch(root, env, mch) # also checks all included, seen, used and extend arbitrary_init_machine(root, env, mch) # init VARIABLES and eval INVARIANT assert isinstance(root.children[2], AInvariantMachineClause) assert interpret(root.children[2], env)
def test_simple_pred_aequ(self): # Build AST: 7<8 <=> 6+1<8 intExp = AIntegerExpression(7) intExp2 = AIntegerExpression(8) lsPred = ALessPredicate() lsPred.children.append(intExp) lsPred.children.append(intExp2) intExp3 = AIntegerExpression(6) intExp4 = AIntegerExpression(1) intExp5 = AIntegerExpression(8) addExp = AAddExpression() addExp.children.append(intExp3) addExp.children.append(intExp4) lsPred2 = ALessPredicate() lsPred2.children.append(addExp) lsPred2.children.append(intExp5) eqaPred = AEquivalencePredicate() eqaPred.children.append(lsPred) eqaPred.children.append(lsPred2) #Test env = Environment() assert interpret(eqaPred, env)
def test_genAST_pred_rel_dom(self): # Build AST: string_to_file("#PREDICATE S=dom(f)", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["S","f"]) env.set_value("S", frozenset(["a"])) env.set_value("f", frozenset([("a","x")])) assert interpret(root.children[0],env) env.set_value("f", frozenset([("1","x"),("2","y"),("3","z"),("1","y")])) env.set_value("S", frozenset(["1","2","3"])) assert interpret(root.children[0],env)
def test_genAST_pred_seq_perm(self): # Build AST: string_to_file("#PREDICATE s=perm(S)", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) env = Environment() env._min_int = -1 env._max_int = 5 env.add_ids_to_frame(["s","S"]) env.set_value("S", frozenset(["a","b"])) env.set_value("s", frozenset([frozenset([(2, 'a'), (1, 'b')]), frozenset([(1, 'a'), (2, 'b')])])) assert interpret(root.children[0],env) env.set_value("s", frozenset([])) assert not interpret(root.children[0],env)
def test_examples_simple_testset(self): string = ''' MACHINE TestSet SETS ID={aa, bb, cc} CONSTANTS iv PROPERTIES iv:ID VARIABLES xx INVARIANT xx:ID INITIALISATION xx:=iv END''' # Build AST string_to_file(string, file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() mch = parse_ast(root, env) type_check_bmch(root, env, mch) # also checks all included, seen, used and extend arbitrary_init_machine(root, env, mch) # init VARIABLES and eval INVARIANT assert isinstance(root.children[5], AInvariantMachineClause) assert interpret(root.children[5], env)
def test_genAST_pred_rel_inverse(self): # Build AST: string_to_file("#PREDICATE f=r~", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["r","f"]) env.set_value("f", frozenset([("1","a"),("42","b"),("777","c")])) env.set_value("r", frozenset([("a","1"),("b","42"),("c","777")])) assert interpret(root.children[0],env) env.set_value("f", frozenset([])) env.set_value("r", frozenset([])) assert interpret(root.children[0],env)
def test_examples_simple_bakery1(self): string =''' MACHINE Bakery1 ABSTRACT_VARIABLES p1, p2, y1, y2 INVARIANT p1:0..2 & p2:0..2 & y1:NATURAL & y2:NATURAL & (p1=2 => p2<2) & (p2=2 => p1<2) INITIALISATION p1,p2,y1,y2 := 0,0,0,0 END''' # Build AST string_to_file(string, file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() mch = parse_ast(root, env) type_check_bmch(root, env, mch) # also checks all included, seen, used and extend arbitrary_init_machine(root, env, mch) # init VARIABLES and eval INVARIANT assert isinstance(root.children[2], AInvariantMachineClause) assert interpret(root.children[2], env)
def test_simple_model_checking2(self): path = "examples/rpython_performance/SigmaLoop.mch" if os.name=='nt': path="examples/rpython_performance\SigmaLoop" ast_string = file_to_AST_str(path) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env._max_int = 2**31 mch = parse_ast(root, env) type_check_bmch(root, env, mch) # also checks all included, seen, used and extend solution_file_read = False bstates = set_up_constants(root, env, mch, solution_file_read) assert len(bstates)==0 # no setup possible bstates = exec_initialisation(root, env, mch, solution_file_read) assert len(bstates)==1 # only one possibility (sum:=45) assert len(env.state_space.seen_states)==0 assert isinstance(bstates[0], BState) env.state_space.set_current_state(bstates[0]) assert len(env.state_space.seen_states)==1 invatiant = root.children[2] assert isinstance(invatiant, AInvariantMachineClause) assert interpret(invatiant, env) assert len(env.state_space.stack)==2 next_states = calc_next_states(env, mch) assert len(next_states)==1 assert len(env.state_space.stack)==2 # init and empty setup assert env.get_value('sum')==55 env.state_space.set_current_state(next_states[0].bstate) assert env.get_value('sum')==55
def test_library_codes(self): string = ''' MACHINE LibraryStrings CONSTANTS codes, append PROPERTIES append = %(x,y).(x: STRING & y: STRING | STRING_APPEND(x,y)) & /* obtain the characters of a string as a B sequence of Ascii codes; it is reversible */ codes: STRING --> (INTEGER <-> INTEGER) & codes = %(s).(s:STRING|STRING_CODES(s)) DEFINITIONS STRING_CODES(x) == codes(x); EXTERNAL_FUNCTION_STRING_CODES == (STRING --> (INTEGER<->INTEGER)); EXTERNAL_FUNCTION_STRING_APPEND == STRING*STRING --> STRING; STRING_APPEND(x,y) == append(x,y) ASSERTIONS codes("") = <>; /* codes(" ") = [32]; the Java parser currently swallows whitespace within strings */ codes("abc") = [97,98,99]; {x| codes(x) = codes("abc") ^ codes("abc")} = {"abcabc"}; !(x,y).(x:{"abc","hello",""} & y:{"abc","hello",""} => codes(append(x,y)) = codes(x)^codes(y)) END ''' # FIXME: composition typechecking bug # {x| codes(x) = (codes("abc") ; succ) } = {"bcd"}; # TODO: prolog style args # {x| codes(x) = %i.(i:1..26|96+i)} = {"abcdefghijklmnopqrstuvwxyz"} # Build AST string_to_file(string, file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() dh = DefinitionHandler(env, str_ast_to_python_ast) dh.repl_defs(root) mch = parse_ast(root, env) type_check_bmch(root, env, mch) assert isinstance(get_type_by_name(env, "codes"), PowerSetType) assert isinstance(get_type_by_name(env, "codes").data, CartType) assert isinstance(get_type_by_name(env, "codes").data.left.data, StringType) assert isinstance(get_type_by_name(env, "codes").data.right.data.data, CartType) assert isinstance(get_type_by_name(env, "codes").data.right.data.data.left.data, IntegerType) assert isinstance(get_type_by_name(env, "codes").data.right.data.data.right.data, IntegerType) arbitrary_init_machine(root, env, mch) # init VARIABLES and eval INVARIANT assert isinstance(root.children[4], AAssertionsMachineClause) interpret(root.children[4], env)
def test_genAST_pred_le(self): # Build AST: string_to_file("#PREDICATE 6<=x", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) # Test env = Environment() env.add_ids_to_frame(["x"]) env.set_value("x", 1) assert not interpret(root, env) env.set_value("x", 6) assert interpret(root, env) env.set_value("x", 7) assert interpret(root, env)
def test_genAST_set_enum(self): # Build AST: string_to_file("#PREDICATE yy:{aa,bb,cc}", file_name) ast_string = file_to_AST_str(file_name) root = str_ast_to_python_ast(ast_string) #Test env = Environment() env.add_ids_to_frame(["yy","aa","bb","cc"]) env.set_value("yy", "aa") env.set_value("aa", "aa") #FIXME: maybe this is a Bug.. env.set_value("bb", "bb") # env.set_value("cc", "cc") # assert interpret(root.children[0], env) env.set_value("yy","yy") assert not interpret(root.children[0], env)
def main(arguments): """main function""" args = parser.parse_args(arguments) common.runtimeArgs = args inputfile = args.file fd = open(inputfile, "r") ss = fd.read() cil = irser.deserialize(ss) return interp.interpret(cil)