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 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 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 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 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 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 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 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 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 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 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 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 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 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")
def testUnionRename(self):
from iegen import Set
from iegen.parser import PresParser
pset1=PresParser.parse_set('{[a]:a>10}')
pset2=PresParser.parse_set('{[a]:a<5}')
pset3=PresParser.parse_set('{[a]:a=7}')
set1=Set('{[a]:a>10}')
set2=Set('{[b]:b<5}')
set3=Set('{[c]:c=7}')
unioned=set1.union(set2).union(set3)
unioned_res=Set(sets=[pset1,pset2,pset3])
self.failUnless(unioned==unioned_res,'%s!=%s'%(unioned,unioned_res))
pset1=PresParser.parse_set('{[a]:a>10}')
pset2=PresParser.parse_set('{[a]:a<5}')
pset3=PresParser.parse_set('{[a]:a=7}')
set1=Set('{[a]:a>10}')
set2=Set('{[b]:b<5}')
set3=Set('{[c]:c=7}')
unioned=unioned.union(set1)
unioned_res=Set(sets=[pset1,pset2,pset3])
self.failUnless(unioned==unioned_res,'%s!=%s'%(unioned,unioned_res))
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 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 testResultPresent(self):
from iegen.ast.visitor import IsVarVisitor
from iegen.parser import PresParser
set = PresParser.parse_set("{[]}")
v = IsVarVisitor("a").visit(set)
self.failUnless(hasattr(v, "is_var"), "IsVarVisitor doesn't place result in the 'is_var' property.")
self.failUnless(
hasattr(v, "is_symbolic_var"), "IsVarVisitor doesn't place result in the 'is_symbolic_var' property."
)
self.failUnless(
hasattr(v, "is_constraint_var"), "IsVarVisitor doesn't place result in the 'is_constraint_var' property."
)
self.failUnless(hasattr(v, "is_tuple_var"), "IsVarVisitor doesn't place result in the 'is_tuple_var' property.")
def testRenameWithConstraintSet(self):
from iegen.ast.visitor import UniqueTupleVarsVisitor
from iegen.ast import PresSet, VarTuple, Conjunction, Equality, NormExp, VarExp, FuncExp
from iegen.parser import PresParser
set = PresSet(
VarTuple([VarExp(1, "a"), VarExp(1, "b"), VarExp(1, "a")]),
Conjunction([Equality(NormExp([VarExp(1, "b"), FuncExp(-1, "f", [NormExp([VarExp(1, "a")], 0)])], 0))]),
)
changed = UniqueTupleVarsVisitor().visit(set).changed
set_res = PresParser.parse_set("{[a,b,a0]: b=f(a) and a=a0}")
self.failUnless(set_res == set, "%s!=%s" % (set_res, set))
self.failUnless(True == changed, "changed!=True")
def testStr(self):
from iegen import Set,Symbolic
from iegen.parser import PresParser
set_str1='{[a]: -1a+5=0}'
pset1=PresParser.parse_set(set_str1)
set_str2='{[b]: -1b+6=0}'
pset2=PresParser.parse_set(set_str2)
set_str3='{[c]: -1c+7=0}'
pset3=PresParser.parse_set(set_str3)
set=Set(sets=[pset1])
set_str='%s'%(set_str1)
self.failUnless(str(set)==set_str,'%s!=%s'%(str(set),set_str))
set=Set(sets=[pset1,pset2])
set_str='{[a]: -1a+5=0} union {[a]: -1a+6=0}'
self.failUnless(str(set)==set_str,'%s!=%s'%(str(set),set_str))
set=Set(sets=[pset1,pset2,pset3])
set_str='{[a]: -1a+5=0} union {[a]: -1a+6=0} union {[a]: -1a+7=0}'
self.failUnless(str(set)==set_str,'%s!=%s'%(str(set),set_str))
def testLikePresSet(self):
from iegen import Set
from iegen.ast import VarTuple,Conjunction,Node
from iegen.parser import PresParser
class DummyPresSet(Node):
def __init__(self):
self.tuple_set=VarTuple([])
self.conjunct=Conjunction([])
self.symbolics=[]
def arity(self):
return 0
def apply_visitor(self,visitor):
visitor.visitPresSet(self)
set=PresParser.parse_set('{[]}')
Set(sets=[set,DummyPresSet()])
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 __init__(self, set_string=None, symbolics=None, sets=None):
symbolics = [] if symbolics is None else symbolics
if None is not set_string and None is sets:
# Ensure we are given Symbolic objects
raise_objs_not_like_types(
symbolics,
Symbolic,
"Set construction failure: symbolics must be a collect of objects that look like a Symbolic",
)
self.sets = [PresParser.parse_set(set_string, symbolics)]
elif None is not sets and None is set_string:
if len(symbolics) > 0:
raise ValueError("Cannot specify symbolics when specifying a collection of sets.")
if len(sets) > 0:
self.sets = sets
else:
raise ValueError("Must specify at least one set in the sets collection.")
else:
raise ValueError("Set.__init__ takes either a set string or a collection of sets.")
def testNonPresSetFail(self):
from iegen import Set
from iegen.parser import PresParser
set=PresParser.parse_set('{[]}')
Set(sets=[set,'hello!'])
