def testDiffArity(self): from iegen import Set from iegen.parser import PresParser pset1=PresParser.parse_set('{[a]:a>10}') pset2=PresParser.parse_set('{[a,b]:b>10}') Set(sets=[pset1,pset2])
def testDiffBothArity(self): from iegen import Relation from iegen.parser import PresParser relation1=PresParser.parse_relation('{[a]->[b]:a>10}') relation2=PresParser.parse_relation('{[a,b]->[a,b]:b>10}') Relation(relations=[relation1,relation2])
def testSets(self): from iegen import Set from iegen.parser import PresParser set1=PresParser.parse_set('{[a]:a>10}') set2=PresParser.parse_set('{[b]:b>10}') set=Set(sets=[set1,set2])
def testSetsWithSymbolics(self): from iegen import Set,Symbolic from iegen.parser import PresParser set1=PresParser.parse_set('{[a]:a>10 and a<n}',[Symbolic('n')]) set2=PresParser.parse_set('{[b]:b>10 and b<m}',[Symbolic('m')]) set=Set(sets=[set1,set2])
def testRelationsWhtSymbolics(self): from iegen import Relation,Symbolic from iegen.parser import PresParser relation1=PresParser.parse_relation('{[a]->[b]:a>10 and a<n}',[Symbolic('n')]) relation2=PresParser.parse_relation('{[b]->[c]:b>10 and b<m}',[Symbolic('m')]) relation=Relation(relations=[relation1,relation2])
def testRelations(self): from iegen import Relation from iegen.parser import PresParser relation1=PresParser.parse_relation('{[a]->[b]:a>10}') relation2=PresParser.parse_relation('{[b]->[c]:b>10}') relation=Relation(relations=[relation1,relation2])
def testIsConstraintNoSearchVarTuple(self): from iegen.ast.visitor import IsVarVisitor from iegen.parser import PresParser set = PresParser.parse_set("{[a]}") relation = PresParser.parse_relation("{[a]->[b]}") self.failIf(IsVarVisitor("a").visit(set).is_constraint_var, "'a' is a constraint var in %s" % set) self.failIf(IsVarVisitor("a").visit(relation).is_constraint_var, "'a' is a constraint var in %s" % relation) self.failIf(IsVarVisitor("b").visit(relation).is_constraint_var, "'b' is a constraint var in %s" % relation)
def testIsTupleSearchVarTuple(self): from iegen.ast.visitor import IsVarVisitor from iegen.parser import PresParser set = PresParser.parse_set("{[a]}") relation = PresParser.parse_relation("{[a]->[b]}") self.failUnless(IsVarVisitor("a").visit(set).is_tuple_var, "'a' is a not tuple var in %s" % set) self.failUnless(IsVarVisitor("a").visit(relation).is_tuple_var, "'a' is a not tuple var in %s" % relation) self.failUnless(IsVarVisitor("b").visit(relation).is_tuple_var, "'b' is a not tuple var in %s" % relation)
def testOrder(self): from iegen import Set from iegen.parser import PresParser pset1=PresParser.parse_set('{[a]:a>10}') pset2=PresParser.parse_set('{[b]:b>10}') set1=Set(sets=[pset1,pset2]) set2=Set(sets=[pset2,pset1]) self.failUnless(set1==set2,'%s!=%s'%(set1,set2))
def testIsTupleNoSearchSymbolics(self): from iegen.ast.visitor import IsVarVisitor from iegen import Symbolic from iegen.parser import PresParser set = PresParser.parse_set("{[]}", [Symbolic("n")]) set.symbolics.append(Symbolic("n")) relation = PresParser.parse_relation("{[]->[]}") relation.symbolics.append(Symbolic("n")) self.failIf(IsVarVisitor("n").visit(set).is_tuple_var, "'n' is a tuple var in %s" % set) self.failIf(IsVarVisitor("n").visit(relation).is_tuple_var, "'n' is a tuple var in %s" % relation)
def testIsSymSearchSymbolics(self): from iegen.ast.visitor import IsVarVisitor from iegen import Symbolic from iegen.parser import PresParser set = PresParser.parse_set("{[]}") set.symbolics.append(Symbolic("n")) relation = PresParser.parse_relation("{[]->[]}") relation.symbolics.append(Symbolic("n")) self.failUnless(IsVarVisitor("n").visit(set).is_symbolic_var, "'n' is not a symbolic var in %s" % set) self.failUnless(IsVarVisitor("n").visit(relation).is_symbolic_var, "'n' is not a symbolic var in %s" % relation)
def testOrder(self): from iegen import Relation from iegen.parser import PresParser prelation1=PresParser.parse_relation('{[a]->[a]:a>10}') prelation2=PresParser.parse_relation('{[b]->[b]:b>11}') relation1=Relation(relations=[prelation1,prelation2]) prelation1=PresParser.parse_relation('{[a]->[a]:a>11}') prelation2=PresParser.parse_relation('{[b]->[b]:b>10}') relation2=Relation(relations=[prelation1,prelation2]) self.failUnless(relation1==relation2,'%s!=%s'%(relation1,relation2))
def testCollectTwice(self): from iegen.ast.visitor import CollectVarsVisitor from iegen.ast import Equality, NormExp, VarExp from iegen.parser import PresParser from iegen import Symbolic rel = PresParser.parse_relation("{[a]->[b]: a=n}", [Symbolic("n")]) v = CollectVarsVisitor(all_vars=True).visit(rel) rel = PresParser.parse_relation("{[c]->[d]: c=n}", [Symbolic("n")]) v.visit(rel) res = ["a", "b", "c", "d", "n"] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testTwoVarsSet(self): from iegen.ast.visitor import CollectVarsVisitor from iegen.parser import PresParser set = PresParser.parse_set("{[a,b,c]: a=1 and b=c}") v = CollectVarsVisitor().visit(set) res = ["a", "b", "c"] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars)) set = PresParser.parse_set("{[a,c,b]: a=1 and b=c}") v = CollectVarsVisitor().visit(set) res = ["a", "b", "c"] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testResultPresent(self): from iegen.ast.visitor import UniqueTupleVarsVisitor from iegen.parser import PresParser set = PresParser.parse_set("{[]}") v = UniqueTupleVarsVisitor().visit(set) self.failUnless(hasattr(v, "changed"), "UniqueTupleVarsVisitor doesn't place result in the 'changed' property.")
def testResultPresent(self): from iegen.ast.visitor import CollectVarsVisitor from iegen.parser import PresParser set = PresParser.parse_set("{[a]}") v = CollectVarsVisitor().visit(set) self.failUnless(hasattr(v, "vars"), "CollectVarsVisitor doesn't place result in the 'vars' property.")
def testMultipleRenameSet(self): from iegen.ast.visitor import UniqueTupleVarsVisitor from iegen.ast import PresSet, VarTuple, Conjunction, VarExp from iegen.parser import PresParser set = PresSet( VarTuple( [ VarExp(1, "a"), VarExp(1, "b"), VarExp(1, "c"), VarExp(1, "d"), VarExp(1, "c"), VarExp(1, "a"), VarExp(1, "b"), ] ), Conjunction([]), ) changed = UniqueTupleVarsVisitor().visit(set).changed set_res = PresParser.parse_set("{[a,b,c,d,c0,a0,b0]: c=c0 and a=a0 and b=b0 }") self.failUnless(set_res == set, "%s!=%s" % (set_res, set)) self.failUnless(True == changed, "changed!=True")
def testTwoVarsSet(self): from iegen.ast.visitor import CollectVarsVisitor from iegen import Symbolic from iegen.parser import PresParser set = PresParser.parse_set("{[a,b]: a=1 and b=m}", [Symbolic("n")]) v = CollectVarsVisitor().visit(set) res = ["a", "b"] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars)) set = PresParser.parse_set("{[b,a]: a=1 and b=m}", [Symbolic("n")]) v = CollectVarsVisitor().visit(set) res = ["a", "b"] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testThreeVarsRelation(self): from iegen.ast.visitor import CollectVarsVisitor from iegen import Symbolic from iegen.parser import PresParser rel = PresParser.parse_relation("{[a]->[b,c]: a=1 and b=c}") v = CollectVarsVisitor().visit(rel) res = ["a", "b", "c"] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars)) rel = PresParser.parse_relation("{[a,b]->[c]: a=1 and b=n}", [Symbolic("n")]) v = CollectVarsVisitor().visit(rel) res = ["a", "b", "c"] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testIsTupleNoSearchConstraints(self): from iegen.ast.visitor import IsVarVisitor from iegen.parser import PresParser from iegen.ast import Equality, Inequality, NormExp, VarExp set = PresParser.parse_set("{[]}") set.conjunct.constraints.append(Equality(NormExp([VarExp(1, "b")], 1))) set.conjunct.constraints.append(Inequality(NormExp([VarExp(-1, "a")], 10))) relation = PresParser.parse_relation("{[]->[]}") relation.conjunct.constraints.append(Equality(NormExp([VarExp(1, "b")], 1))) relation.conjunct.constraints.append(Inequality(NormExp([VarExp(-1, "a")], 10))) self.failIf(IsVarVisitor("a").visit(set).is_tuple_var, "'a' is a tuple var in %s" % set) self.failIf(IsVarVisitor("b").visit(set).is_tuple_var, "'b' is a tuple var in %s" % set) self.failIf(IsVarVisitor("a").visit(relation).is_tuple_var, "'a' is a tuple var in %s" % relation) self.failIf(IsVarVisitor("b").visit(relation).is_tuple_var, "'b' is a tuple var in %s" % relation)
def testNoVarsSet(self): from iegen.ast.visitor import CollectVarsVisitor from iegen.parser import PresParser set = PresParser.parse_set("{[]}") v = CollectVarsVisitor().visit(set) res = [] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testReturnsSelf(self): from iegen.ast.visitor import DFVisitor from iegen.parser import PresParser set = PresParser.parse_set("{[]}") v = DFVisitor() self.failUnless(v.visit(set) is v, "visit() method does not return 'self'")
def testNoVarsRelation(self): from iegen.ast.visitor import CollectVarsVisitor from iegen.parser import PresParser rel = PresParser.parse_relation("{[]->[]}") v = CollectVarsVisitor().visit(rel) res = [] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testOneVarSet(self): from iegen.ast.visitor import CollectVarsVisitor from iegen import Symbolic from iegen.parser import PresParser set = PresParser.parse_set("{[a]: a=n}", [Symbolic("n")]) v = CollectVarsVisitor().visit(set) res = ["a"] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testOneVarRelation(self): from iegen.ast.visitor import CollectVarsVisitor from iegen import Symbolic from iegen.parser import PresParser rel = PresParser.parse_relation("{[a]->[]: a=n}", [Symbolic("n")]) v = CollectVarsVisitor().visit(rel) res = ["a"] self.failUnless(res == v.vars, "%s!=%s" % (res, v.vars))
def testInverseConstraints(self): from iegen import Relation from iegen.parser import PresParser relation=Relation('{[a,b]->[c,d]:a>=n && b<5 and c+d=15}') prelation=PresParser.parse_relation('{[c,d]->[a,b]:b<5 and a>=n && c+d=15}') inverse=relation.inverse() inverse_res=Relation(relations=[prelation]) self.failUnless(inverse==inverse_res,'%s!=%s'%(inverse,inverse_res))
def testInverse(self): from iegen import Relation from iegen.parser import PresParser relation=Relation('{[a,b]->[c,d]}') prelation=PresParser.parse_relation('{[c,d]->[a,b]}') inverse=relation.inverse() inverse_res=Relation(relations=[prelation]) self.failUnless(inverse==inverse_res,'%s!=%s'%(inverse,inverse_res))
def testRenameRelationSimple3(self): from iegen.ast.visitor import UniqueTupleVarsVisitor from iegen.ast import PresRelation, VarTuple, Conjunction, VarExp from iegen.parser import PresParser rel = PresRelation(VarTuple([VarExp(1, "a")]), VarTuple([VarExp(1, "a")]), Conjunction([])) changed = UniqueTupleVarsVisitor().visit(rel).changed rel_res = PresParser.parse_relation("{[a]->[a0]: a=a0}") self.failUnless(rel_res == rel, "%s!=%s" % (rel_res, rel)) self.failUnless(True == changed, "changed!=True")
def testEmptyRelation(self): from iegen.ast.visitor import UniqueTupleVarsVisitor from iegen.ast import PresRelation, VarTuple, Conjunction from iegen.parser import PresParser rel = PresRelation(VarTuple([]), VarTuple([]), Conjunction([])) changed = UniqueTupleVarsVisitor().visit(rel).changed rel_res = PresParser.parse_relation("{[]->[]}") self.failUnless(rel_res == rel, "%s!=%s" % (rel_res, rel)) self.failUnless(False == changed, "changed!=False")
def testNoChangeSet(self): from iegen.ast.visitor import UniqueTupleVarsVisitor from iegen.ast import PresSet, VarTuple, Conjunction, VarExp from iegen.parser import PresParser set = PresSet(VarTuple([VarExp(1, "a"), VarExp(1, "b")]), Conjunction([])) changed = UniqueTupleVarsVisitor().visit(set).changed set_res = PresParser.parse_set("{[a,b]}") self.failUnless(set_res == set, "%s!=%s" % (set_res, set)) self.failUnless(False == changed, "changed!=False")