def testEmptyMerge(self):
first = toPnf('q')
second = toPnf('p')
solu = defSix(first, second)
soluSet = set()
for x in solu:
soluSet.add(x.getName())
self.assertEqual(soluSet, {'q', 'p'})
def testCaseTrue(self):
objects = toPnf('tt')
derTT = derivatives(objects, 'tt')
solution = []
for x in derTT:
solution.append(x.getName())
self.assertEqual(solution, ['tt'])
def testAnd(self):
"""test case with operator and."""
testTableau = def17(toPnf('& p q'), False)
if testTableau[1] == ['({p,q},tt)']:
self.assertEqual(testTableau, ('& p q', ['({p,q},tt)']))
else:
self.assertEqual(testTableau, ('& p q', ['({q,p},tt)']))
def btestComplexityVer2(self):
"""Test more complex formulare"""
formulare = toPnf("| R p2 p1 & p2 p3")
alphabet = returnAlphabet()
testAutomat = automat(formulare, alphabet)
liste = calcEdges(testAutomat.transitionsTable)
testcase = [ele.split(" ") for ele in testAutomat.printStart]
for index, ele in enumerate(testcase):
testcase[index] = frozenset(ele)
setAtom = setLabels(liste, len(liste), testAutomat.alphabet)
for ele in setAtom:
print(setAtom[ele])
setAtom[ele] = set(setAtom[ele].split(" "))
self.assertEqual(testAutomat.printState, {"p1", "p2", "R p2 p1", "p3"})
self.assertEqual(testAutomat.printGoal, {"tt", "R p2 p1"})
self.assertEqual(
set(testcase),
{frozenset({'R', 'p2', 'p1'}),
frozenset({'p3', '&', 'p2'})})
self.assertEqual(
set(setAtom), {
("p1", "tt"): {'p1'},
("p2", "tt"): {'p2'},
("p3", "tt"): {'p3'},
("R p1 p2", "tt"): {'p1', '&', 'p2'},
("R p1 p2", "R p1 p2"): {'p1'}
})
def testUntil(self):
"""test case with operator and."""
testTableau = def17(toPnf('U p q'), False)
if testTableau[1] == ['({q},tt)', '({p},U)']:
self.assertEqual(testTableau, ('U p q', ['({q},tt)', '({p},U)']))
else:
self.assertEqual(testTableau, ('U p q', ['({p},U)', '({q},tt)']))
def testCaseFormula(self):
objects = toPnf('p1')
derF = derivatives(objects, '{p1}')
solution = []
for x in derF:
solution.append(x.getName())
self.assertEqual(solution, ['tt'])
def testEx2(self):
objects = toPnf('F p1')
derCaseAnd = derivatives(objects, '{p1}')
solution = []
for x in derCaseAnd:
solution.append(x.getName())
self.assertEqual(len(solution), 2)
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 testPDMedium2(self):
pd = derivatives(toPnf('& p2 | p1 p3'), "{p2}")
solu = set()
for x in pd:
solu.add(x.getName())
solu.add(x.getFirst().getName())
solu.add(x.getSec().getName())
self.assertEqual(solu, set())
def testRelease3(self):
pd = derivatives(toPnf('R | q1 p2 p3'), "{p3, q1}")
solu = set()
for x in pd:
solu.add(x.getName())
self.assertEqual({'R', 'tt'}, solu)
self.assertEqual(len(pd), 2)
def testNotEx1(self):
objects = toPnf('G F p1')
derCaseAnd = derivatives(objects, '{x}')
solution = []
for x in derCaseAnd:
solution.append(x.getName())
self.assertEqual(len(solution), 1)
self.assertEqual(solution[0], '&')
def testOr2(self):
"""| U q p | a b"""
pd = derivatives(toPnf('| U q p | a b'), "{a, p, b}")
self.assertEqual(len(pd), 3)
solu = set()
for x in pd:
solu.add(x.getName())
self.assertEqual(solu, {'tt'})
def testX1(self):
"""X R q p & a b"""
pd = derivatives(toPnf('X R q p & a b'), "{tt}")
self.assertEqual(len(pd), 1)
solu = set()
for x in pd:
solu.add(x.getName())
self.assertEqual(solu, {'R'})
def testPDMedium4(self):
pd = derivatives(toPnf('& p2 | p3 U p4 p2'), "{p3, p2}")
self.assertEqual(len(pd), 2)
solu = set()
for x in pd:
solu.add(x.getName())
solu.add(x.getFirst().getName())
solu.add(x.getSec().getName())
self.assertEqual(solu, {'&', 'tt'})
def testCaseOne(self):
objects = toPnf('& p1 p2')
derCaseAnd = derivatives(objects, '{p1, p2}')
solution = []
for x in derCaseAnd:
solution.append(x.getName())
solution.append(x.getFirst().getName())
solution.append(x.getSec().getName())
self.assertEqual(solution, ['&', 'tt', 'tt'])
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 testPDMedium(self):
pd = derivatives(toPnf('p2'), "{p2}")
solu = set()
for x in pd:
solu.add(x.getName())
self.assertEqual({'tt'}, solu)
pd = derivatives(toPnf('& p2 p3'), "{p2, p3}")
solu = set()
for x in pd:
solu.add(x.getName())
solu.add(x.getFirst().getName())
solu.add(x.getSec().getName())
self.assertEqual({'&', 'tt'}, solu)
pd = derivatives(toPnf('& p2 | p1 p3'), "{p2, p1, p3}")
solu = set()
for x in pd:
solu.add(x.getName())
solu.add(x.getFirst().getName())
solu.add(x.getSec().getName())
self.assertEqual(solu, {'&', 'tt'})
def testNegation(self):
"""test case with one element."""
formulare = toPnf('! p')
alphabet = returnAlphabet()
testAutomat = automat(formulare, alphabet)
liste = calcEdges(testAutomat.transitionsTable)
setAtom = setLabels(liste, len(liste), testAutomat.alphabet)
self.assertEqual(testAutomat.printState, {"p"})
self.assertEqual(testAutomat.printGoal, {"tt"})
self.assertEqual(testAutomat.printStart, {"p"})
self.assertEqual(setAtom, {("p", "tt"): "p"})
def testDummy(self):
self.assertEqual(1, 1)
objects = toPnf('& R p2 X p3 U p1 p3')
self.assertEqual(objects.getName(), '&')
self.assertEqual(objects.getFirst().getName(), 'R')
self.assertEqual(objects.getFirst().getFirst().getName(), 'p2')
self.assertEqual(objects.getFirst().getSec().getName(), 'X')
self.assertEqual(objects.getSec().getName(), 'U')
self.assertEqual(objects.getSec().getFirst().getName(), 'p1')
self.assertEqual(objects.getSec().getSec().getName(), 'p3')
def testOr(self):
"""Test for two elements which are interwinded by OR operator"""
formulare = toPnf('| p1 p2')
alphabet = returnAlphabet()
testAutomat = automat(formulare, alphabet)
liste = calcEdges(testAutomat.transitionsTable)
setAtom = setLabels(liste, len(liste), testAutomat.alphabet)
self.assertEqual(testAutomat.printState, {"p1", "p2"})
self.assertEqual(testAutomat.printGoal, {"tt"})
self.assertEqual(testAutomat.printStart, {"p1", "p2"})
self.assertEqual(setAtom, {("p1", "tt"): "p1", ("p2", "tt"): "p2"})
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 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 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 caseAnd(literal, inp1):
""" function for and operation of two formualas
Input has to be an & with the pointers to the interessting
subformulas"""
partMy = caseFormel(literal.getFirst(), inp1)
partPhi = caseFormel(literal.getSec(), inp1)
solution = set()
for i in partMy:
for j in partPhi:
AND = toPnf("&")
AND.setFirst(i)
AND.setSec(j)
solution.add(AND)
return solution
def testAnd(self):
"""Test for two elements which are interwinded by AND operator"""
formulare = toPnf('& p1 p2')
alphabet = returnAlphabet()
testAutomat = automat(formulare, alphabet)
liste = calcEdges(testAutomat.transitionsTable)
testcase = [ele.split(" ") for ele in testAutomat.printStart]
for index, ele in enumerate(testcase):
testcase[index] = set(ele)
setAtom = setLabels(liste, len(liste), testAutomat.alphabet)
self.assertEqual(testAutomat.printState, {"p1", "p2"})
self.assertEqual(testAutomat.printGoal, {"tt"})
self.assertEqual(testcase, [{"&", "p1", "p2"}])
self.assertEqual(setAtom, {("p1", "tt"): "p1", ("p2", "tt"): "p2"})
def test10ex1():
"""
>>> from LTL.tests.testDef10ExDoc import test10ex1
>>> test10ex1()
True
True
"""
objects = toPnf('G F p1')
derCaseAnd = derivatives(objects, '{p1}')
solution = []
for x in derCaseAnd:
solution.append(x.getName())
helper = (len(solution) == 2)
helper2 = (solution[1] == '&')
if helper is True and helper2 is True:
return True
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 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 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
