def testNext(self):
objects = toPnf('U p1 p3')
linFac = lf(objects)
solu = set()
for x in linFac:
for y in x:
if type(y) == frozenset:
for z in y:
solu.add(z.getName())
else:
solu.add(y.getName())
# linfacs have to be something like
# {(p3,tt),(p1 , & tt U p1 p3)}
self.assertEqual(solu, {'tt', 'p1', 'p3', 'U'})
objects = toPnf('X p3')
linFac = lf(objects)
soluX = []
for x in linFac:
for y in x:
soluX.append(y.getName())
self.assertEqual(soluX, ['tt', 'p3'])
objects = toPnf('R p2 X p3')
linFac = lf(objects)
helper = set()
for x in linFac:
for y in x:
if type(y) == frozenset:
for z in y:
helper.add(z.getName())
else:
helper.add(y.getName())
# linfactors have to be something like
# {({p2,tt},& tt p3) ,(tt, & R p2 X p3 p3)}
self.assertEqual(helper, {'p2', '&', 'tt', 'p3'})
objects = toPnf('& R p2 X p3 U p1 p3')
linFac = lf(objects)
self.assertEqual(len(linFac), 4)
between = set()
for x in linFac:
for y in x:
if type(y) == frozenset:
for z in y:
between.add(z.getName())
else:
between.add(y.getName())
self.assertEqual({'&', 'p3', 'p1', 'p2', 'tt'}, between)
def caseFormel(formular, inp1):
"""function for case literal."""
lfPhi = lf(formular)
solution = set()
for act in lfPhi:
current = checkX(act[0], inp1)
if (current is True):
solution.add(act[1])
return solution
def testX(self):
""" X R q & a b
gotta be something like {tt, {R q & a b}}"""
linfacs = lf(toPnf("X R q & a b"))
solu = set()
for x in linfacs:
for y in x:
solu.add(y.getName())
self.assertEqual(solu, {"tt", "R"})
def testlfL(self):
objects = toPnf('l')
linFac = lf(objects)
for i in linFac:
first = i[0]
sec = i[1]
if type(first) == frozenset:
for x in first:
first = x
self.assertEqual(('l', 'tt'), (first.getName(), sec.getName()))
del first
del sec
def testlfNextSimple(self):
objects = toPnf('X p')
linFac = lf(objects)
solution = []
for x in linFac:
for y in x:
solution.append(y.getName())
self.assertEqual(['tt', 'p'], solution)
first = objects.getFirst()
del first
objects.setFirst(None)
del objects
def testlfFu(self):
objects = toPnf('F p')
linFac = lf(objects)
solution = set()
for x in linFac:
for y in x:
if type(y) == frozenset:
for z in y:
solution.add(z.getName())
else:
solution.add(y.getName())
self.assertEqual(solution, {'tt', 'p', 'U'})
def testOr(self):
"""should be something like {({p},tt)({b},tt)({q},uqp)({a},tt)}"""
linfacs = lf(toPnf("| U q p | a b"))
solution = set()
for x in linfacs:
for y in x:
if type(y) == frozenset:
for z in y:
solution.add(z.getName())
else:
solution.add(y.getName())
self.assertEqual(len(linfacs), 4)
self.assertEqual(solution, {'p', 'b', 'q', 'U', 'a', 'tt'})
def testgfp():
"""
>>> from LTL.tests.unitTestDef8ex2 import testgfp
>>> testgfp()
True
"""
obs2 = toPnf('G F u')
lin2 = lf(obs2)
solution = set()
for x in lin2:
for y in x:
if type(y) == frozenset:
for t in y:
solution.add(t.getName())
else:
solution.add(y.getName())
return solution == set({'u', 'R', 'tt', '&'})
def makeGraph(node):
"""Build a tree as seen in Example 6.
input is the formula and the Graph is build from the pointers.
This is done in a recursive way and is stopped when a loop is found
or maximal resolution is reached."""
print(node.getName())
firstState = preState(node)
globalNodes.append(firstState)
if firstState.Name in globalVisited or firstState.Name == 'tt':
return # firstState
globalVisited.add(firstState.Name)
for x in lf(firstState.nameObj):
actual = State(x)
globalNodes.append(actual)
firstState.Pointers.add(actual)
for x in firstState.Pointers:
x.Pointers.add(makeGraph(x.nameObj[1]))
return firstState
def testlfUntilSimple(self):
objects = toPnf('U p q')
linFac = lf(objects)
solution = set()
for x in linFac:
for y in x:
if type(y) == frozenset:
for z in y:
solution.add(z.getName())
else:
solution.add(y.getName())
self.assertEqual(solution, {'tt', 'U', 'p', 'q'})
first = objects.getFirst()
sec = objects.getSec()
del first
del sec
objects.setFirst(None)
objects.setSec(None)
del objects
def testLfOrSimple(self):
objects = toPnf('| p q')
linFac = lf(objects)
helper = set()
for x in linFac:
helper.add(x[1].getName())
for y in x[0]:
helper.add(y.getName())
self.assertEqual({'tt', 'q', 'p'}, helper)
first = objects.getFirst()
second = objects.getSec()
del first
del second
objects.setFirst(None)
objects.setSec(None)
del objects
def testLfAndSimple(self):
objects = toPnf('& p q')
linFac = lf(objects)
check = set()
for x in linFac:
for y in x:
if type(y) == tuple or type(y) == frozenset:
for z in y:
check.add(z.getName())
else:
check.add(y.getName())
self.assertEqual({'p', 'q', 'tt'}, check)
first = objects.getFirst()
second = objects.getSec()
del first
del second
objects.setFirst(None)
objects.setSec(None)
del objects
def testFirst(self):
inp = toPnf('R | q1 p2 p3')
linfacs = lf(inp)
self.assertEqual(len(linfacs), 3)
total = set()
for i in linfacs:
solu = set()
for j in i:
if(type(j) == frozenset):
for o in j:
solu.add(o.getName())
else:
solu.add(j.getName())
if(j.getName() == 'R'):
self.assertEqual('|', j.getFirst().getName())
self.assertEqual('q1', j.getFirst().getFirst().getName())
self.assertEqual('p2', j.getFirst().getSec().getName())
self.assertEqual('p3', j.getSec().getName())
total.add(frozenset(solu))
self.assertEqual({frozenset({'p3', 'tt', 'p2'}), frozenset({'p3', 'R'}), frozenset({'p3', 'tt', 'q1'})}, total)
def testLfFp(self):
objects = toPnf('F p')
linFac = lf(objects)
solution = set()
for x in linFac:
for y in x:
if type(y) == frozenset:
for z in y:
solution.add(z.getName())
elif type(y) == tuple:
for z in y:
solution.add(z.getName())
else:
solution.add(y.getName())
self.assertEqual({'tt', 'p', 'U'}, solution)
first = objects.getFirst()
sec = objects.getSec()
del first
del sec
objects.setFirst(None)
objects.setSec(None)
del objects
def testReleaseSimple(self):
gc.collect()
ob = toPnf('R p q')
linFaca = lf(ob)
sol = set()
for x in linFaca:
for y in x:
if type(y) == frozenset:
for i in y:
sol.add(i.getName())
elif type(y) == tuple:
for t in y:
sol.add(t.getName())
else:
sol.add(y.getName())
self.assertEqual(sol, {'tt', 'q', 'p', 'R'})
first = ob.getFirst()
sec = ob.getSec()
del first
del sec
ob.setFirst(None)
ob.setSec(None)
del ob
def testlfF(self):
objects = toPnf('ff')
linFac = lf(objects)
self.assertEqual(set(), linFac)
del linFac
