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