def test_constraint_forAll2(self):
# !x.(P=>Q)
# Build AST:
string_to_file("#PREDICATE f={(1,7),(2,8),(3,9)} & S={1,2,3} & !(x,y).(y:INTEGER &(x:S & f(x)<y) & y<42 =>y:T)", file_name)
ast_string = file_to_AST_str(file_name)
root = str_ast_to_python_ast(ast_string)
# Test
env = Environment()
lst = [("S", PowerSetType(IntegerType())),("f", PowerSetType(CartType(PowerSetType(IntegerType()), PowerSetType(IntegerType()))))]
type_with_known_types(root, env, lst, ["T"])
assert isinstance(get_type_by_name(env, "x"), IntegerType)
assert isinstance(get_type_by_name(env, "y"), IntegerType)
assert isinstance(get_type_by_name(env, "T"), PowerSetType)
assert isinstance(get_type_by_name(env, "T").data, IntegerType)
env.add_ids_to_frame(["f","S","T"])
env.set_value("f", frozenset([(1,7),(2,8),(3,9)]))
env.set_value("S", frozenset([1,2,3]))
env.set_value("T", frozenset(range(10,42)))
env._min_int = -2**8
env._max_int = 2**8
unqantPred = root.children[0].children[1]
assert isinstance(unqantPred, AForallPredicate)
varList = unqantPred.children[0:-1]
P = unqantPred.children[-1].children[0]
Q = unqantPred.children[-1].children[1]
domain = compute_using_external_solver(P, env, varList)
assert frozenset([x["x"] for x in domain])==frozenset([1,2,3])
domain = compute_using_external_solver(P, env, varList)
assert frozenset([x["y"] for x in domain])==frozenset(range(8,42))
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_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_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_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_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_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_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_all_ids_known(self):
string_to_file("#PREDICATE x=y & x=42", 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(["x","y"])
assert all_ids_known(root, env)==False
def test_all_ids_known4(self):
string_to_file("#PREDICATE ID={x|x>0 & x<10}", 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(["ID"])
assert all_ids_known(root, env)==False
def test_all_ids_known5(self):
string_to_file("#PREDICATE ID={x|x>0 & x<10}", 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(["ID"])
env.set_value("ID", frozenset([1,2,3])) # would be false
assert all_ids_known(root, env)==True
def test_all_ids_known6(self):
string_to_file("#PREDICATE {(1,2)}: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"])
env.set_value("S", frozenset([1,2,3,4,5]))
env.set_value("T", frozenset([1,2,3,4,5]))
assert all_ids_known(root, env)==True
def test_simple_set_expr_card(self):
# Build AST: card(S)
idExp = AIdentifierExpression("S")
cardExp = ACardExpression()
cardExp.children.append(idExp)
#Test
env = Environment()
env.add_ids_to_frame(["S"])
env.set_value("S", frozenset(["aa","bb"]))
assert interpret(cardExp, env)==2
def test_genAST_pred_fun_app4(self):
# Build AST:
string_to_file("#PREDICATE f={((1,1,1),42),((2,2,2),777)} & zz=f(2,2,2)", 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(["zz","f"])
env.set_value("f", frozenset([(((1,1),1),42),(((2,2),2),777)]))
env.set_value("zz", 777)
assert interpret(root.children[0],env)
def test_genAST_string(self):
# Build AST
string_to_file("#PREDICATE s=\"Hallo Welt\"", 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"])
env.set_value("s", "Hallo Welt")
assert interpret(root.children[0],env)
def test_genAST_pred_set_contains3(self):
# Build AST:
string_to_file("#PREDICATE x:{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", "x")
assert interpret(root.children[0],env)
def test_genAST_max(self):
# Build AST:
string_to_file("#PREDICATE S={1,2,3,4,5} & max(S)=5", 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"])
type_with_known_types(root.children[0], env, [], ["S"])
env.set_value("S", frozenset([1, 2, 3, 4, 5]))
assert interpret(root, env)
def test_genAST_pred_seq_append(self):
# Build AST:
string_to_file("#PREDICATE s:perm(S) => s<-a:seq(S)", 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","S","a"])
env.set_value("S", frozenset(["a","b"]))
env.set_value("s", frozenset([(2, 'a'), (1, 'b')]))
env.set_value("a", "a")
assert interpret(root.children[0],env)
def test_genAST_pred_set_orderd_pair(self):
# Build AST:
string_to_file("#PREDICATE x|->y:{(x,y)}", 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","y"])
env.set_value("x", "x")
env.set_value("y", "y")
assert interpret(root.children[0],env)
def test_genAST_pred_seq_reverse(self):
# Build AST:
string_to_file("#PREDICATE s=[a,b] & rev(s)=[b,a]", 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(["a","b","s"])
env.set_value("s", frozenset([(1, 'a'), (2, 'b')]))
env.set_value("a", "a")
env.set_value("b", "b")
assert interpret(root.children[0],env)
def test_types_card(self):
# Build AST
string_to_file("#PREDICATE card(S)=3", file_name)
ast_string = file_to_AST_str(file_name)
root = str_ast_to_python_ast(ast_string)
# Type
env = Environment()
env.add_ids_to_frame(["S"])
env.set_value("S", frozenset(["Huey", "Dewey", "Louie"]))
lst = [("S", PowerSetType(SetType("X")))]
type_with_known_types(root, env, lst, [])
def test_genAST_pred_rel_id(self):
# Build AST:
string_to_file("#PREDICATE r=id(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"])
env.set_value("S", frozenset(["a","b","c"]))
env.set_value("r", frozenset([("a","a"),("b","b"),("c","c")]))
assert interpret(root.children[0],env)
def test_genAST_pred_minint(self):
# Build AST
string_to_file("#PREDICATE x>MININT", 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)
type_with_known_types(root.children[0], env, [], "x")
assert interpret(root.children[0], env)
def test_genAST_pred_set_diff2(self):
# Build AST:
string_to_file("#PREDICATE A={1,2,3,4,5} & B={3,4,5,6,7} & C = A\B", 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(["A","B","C"])
env.set_value("A", frozenset([1,2,3,4,5]))
env.set_value("B", frozenset([3,4,5,6,7]))
env.set_value("C", frozenset([1,2]))
assert interpret(root.children[0],env)
def test_genAST_pred_set_cart(self):
# Build AST:
string_to_file("#PREDICATE u:S*T", 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(["T","S","u"])
env.set_value("S", frozenset(["a","b"]))
env.set_value("T", frozenset(["x","y"]))
env.set_value("u", ("a","x"))
assert interpret(root.children[0],env)
def test_genAST_pred_exist_subset_nat(self):
# Build AST:
string_to_file("#PREDICATE #(x).(x:S & x>4999) & S={5000}", 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"])
env.set_value("S", frozenset([5000]))
env._max_int = 2 ** 16
type_with_known_types(root.children[0], env, [], ["S"])
assert interpret(root.children[0], env)
def test_genAST_pred_sigma2(self):
# Build AST:
string_to_file("#PREDICATE 4=(SIGMA zz . (zz:POW(ID) | card(zz)))", 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(["ID"])
lst = [("ID", PowerSetType(SetType("ID")))]
env.set_value("ID", frozenset(["a", "b"]))
type_with_known_types(root.children[0], env, lst, "")
assert interpret(root.children[0], env)
