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)
