Beispiel #1
0
 def test_eag_explain(self):
     fsm = self.init_model()
     self.assertIsNotNone(fsm)
     
     spec = parseArctl("E<'run = rc1'>G 'c1.c <= 2'")[0]
     specbdd = evalArctl(fsm, spec)
     
     s = fsm.pick_one_state(specbdd & fsm.init)
     self.assertTrue((specbdd & fsm.init).isnot_false())
     self.assertIsNotNone(s)
     self.assertTrue(s.isnot_false())
     
     ac = evalStr(fsm, "'run = rc1'")
     phi = evalStr(fsm, "'c1.c <= 2'")
     
     (path, (inputs, loop)) = explain_eag(fsm, s, ac, phi)
     
     # loop and inputs are not None: the explanation is an infinite path
     self.assertIsNotNone(inputs)
     self.assertIsNotNone(loop)
     
     # Check that path contains states of phi and psi
     self.assertTrue(s == path[0])
     for state, inputs in zip(path[::2], path[1::2]):
         self.assertTrue(state <= phi)
         self.assertTrue(inputs <= ac)
     self.assertTrue(path[-1] <= phi)
     
     # Check that path is a path of fsm
     for s, i, sp in zip(path[::2], path[1::2], path[2::2]):
         self.assertTrue(sp <= fsm.post(s, i))
         
     # Check that loop is effectively a loop
     self.assertTrue(loop in path)
     self.assertTrue(loop <= fsm.post(path[-1], inputs))
Beispiel #2
0
    def test_eau_explain(self):
        fsm = self.init_model()
        self.assertIsNotNone(fsm)

        spec = parseArctl("E<'TRUE'>['c1.c < 2' U 'c1.c = 2']")[0]
        specbdd = evalArctl(fsm, spec)

        s = fsm.pick_one_state(specbdd & fsm.init)
        self.assertTrue((specbdd & fsm.init).isnot_false())
        self.assertIsNotNone(s)
        self.assertTrue(s.isnot_false())

        ac = evalStr(fsm, "'TRUE'")
        phi = evalStr(fsm, "'c1.c < 2'")
        psi = evalStr(fsm, "'c1.c = 2'")

        path = explain_eau(fsm, s, ac, phi, psi)

        # Check that path contains states of phi and psi
        self.assertTrue(s == path[0])
        for state, inputs in zip(path[::2], path[1::2]):
            self.assertTrue(state <= phi)
            self.assertTrue(inputs <= ac)
        self.assertTrue(path[-1] <= psi)

        # Check that path is a path of fsm
        for s, i, sp in zip(path[::2], path[1::2], path[2::2]):
            self.assertTrue(sp <= fsm.post(s, i))
Beispiel #3
0
 def test_aax_finite(self):
     fsm = self.init_finite_model()
     aaxnc = evalStr(fsm, "A<'a'>X ~'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertEqual(fsm.init, aaxnc)
     self.assertEqual(aaxnc, c & i)
Beispiel #4
0
 def test_neaxt(self):
     fsm = self.init_finite_model()
     
     candi = evalStr(fsm, "('c' & ~'i')")
     neaxt = evalStr(fsm, "~E<'a'>X 'TRUE'")
     
     self.assertTrue(candi <= neaxt)
Beispiel #5
0
    def test_and(self):
        fsm = self.init_model()

        candi = evalStr(fsm, "('c' & 'i')")
        c = evalStr(fsm, "'c'")
        i = evalStr(fsm, "'i'")
        self.assertEqual(candi, c & i)
Beispiel #6
0
    def test_or(self):
        fsm = self.init_model()

        cordi = evalStr(fsm, "('c' | 'i')")
        c = evalStr(fsm, "'c'")
        i = evalStr(fsm, "'i'")
        self.assertEqual(cordi, c | i)
Beispiel #7
0
 def test_and(self):
     fsm = self.init_model()
     
     candi = evalStr(fsm, "('c' & 'i')")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertEqual(candi, c & i)
Beispiel #8
0
 def test_eau_explain(self):
     fsm = self.init_model()
     self.assertIsNotNone(fsm)
     
     spec = parseArctl("E<'TRUE'>['c1.c < 2' U 'c1.c = 2']")[0]
     specbdd = evalArctl(fsm, spec)
     
     s = fsm.pick_one_state(specbdd & fsm.init)
     self.assertTrue((specbdd & fsm.init).isnot_false())
     self.assertIsNotNone(s)
     self.assertTrue(s.isnot_false())
     
     ac = evalStr(fsm, "'TRUE'")
     phi = evalStr(fsm, "'c1.c < 2'")
     psi = evalStr(fsm, "'c1.c = 2'")
     
     path = explain_eau(fsm, s, ac, phi, psi)
     
     # Check that path contains states of phi and psi
     self.assertTrue(s == path[0])
     for state, inputs in zip(path[::2], path[1::2]):
         self.assertTrue(state <= phi)
         self.assertTrue(inputs <= ac)
     self.assertTrue(path[-1] <= psi)
     
     # Check that path is a path of fsm
     for s, i, sp in zip(path[::2], path[1::2], path[2::2]):
         self.assertTrue(sp <= fsm.post(s, i))
Beispiel #9
0
 def test_aax_finite(self):
     fsm = self.init_finite_model()
     aaxnc = evalStr(fsm, "A<'a'>X ~'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertEqual(fsm.init, aaxnc)
     self.assertEqual(aaxnc, c & i)
Beispiel #10
0
 def test_or(self):
     fsm = self.init_model()
     
     cordi = evalStr(fsm, "('c' | 'i')")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertEqual(cordi, c | i)
Beispiel #11
0
    def test_neaxt(self):
        fsm = self.init_finite_model()

        candi = evalStr(fsm, "('c' & ~'i')")
        neaxt = evalStr(fsm, "~E<'a'>X 'TRUE'")

        self.assertTrue(candi <= neaxt)
Beispiel #12
0
 def test_eag(self):
     fsm = self.init_model()
     enagc = evalStr(fsm, "E<~'a'>G 'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     
     self.assertTrue(fsm.init <= enagc)
     self.assertEqual(enagc, c)
Beispiel #13
0
    def test_eag(self):
        fsm = self.init_model()
        enagc = evalStr(fsm, "E<~'a'>G 'c'")
        c = evalStr(fsm, "'c'")
        i = evalStr(fsm, "'i'")

        self.assertTrue(fsm.init <= enagc)
        self.assertEqual(enagc, c)
Beispiel #14
0
    def test_iff(self):
        fsm = self.init_model()

        ciffi = evalStr(fsm, "('c' <-> 'i')")
        c = evalStr(fsm, "'c'")
        i = evalStr(fsm, "'i'")
        self.assertTrue(c & i <= ciffi)
        self.assertTrue(~c & ~i <= ciffi)
        self.assertEqual((c & i) | (~c & ~i), ciffi)
Beispiel #15
0
    def test_implies(self):
        fsm = self.init_model()

        cimpli = evalStr(fsm, "('c' -> 'i')")
        c = evalStr(fsm, "'c'")
        i = evalStr(fsm, "'i'")
        self.assertTrue(~c <= cimpli)
        self.assertTrue(i <= cimpli)
        self.assertEqual(~c | i, cimpli)
Beispiel #16
0
 def test_iff(self):
     fsm = self.init_model()
     
     ciffi = evalStr(fsm, "('c' <-> 'i')")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertTrue(c & i <= ciffi)
     self.assertTrue(~c & ~i <= ciffi)
     self.assertEqual((c & i) | (~c & ~i), ciffi)
Beispiel #17
0
    def test_aag(self):
        fsm = self.init_model()
        c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")

        anagc = evalStr(fsm, "A<~'a'>G 'c'")
        self.assertEqual(anagc, c)
        
        atgc = evalStr(fsm, "A<'TRUE'>G 'c'")
        self.assertEqual(atgc, c & ~i)
Beispiel #18
0
    def test_aag(self):
        fsm = self.init_model()
        c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")

        anagc = evalStr(fsm, "A<~'a'>G 'c'")
        self.assertEqual(anagc, c)

        atgc = evalStr(fsm, "A<'TRUE'>G 'c'")
        self.assertEqual(atgc, c & ~i)
Beispiel #19
0
 def test_implies(self):
     fsm = self.init_model()
     
     cimpli = evalStr(fsm, "('c' -> 'i')")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertTrue(~c <= cimpli)
     self.assertTrue(i <= cimpli)
     self.assertEqual(~c | i, cimpli)
Beispiel #20
0
    def test_eax(self):
        fsm = self.init_model()

        eaaxi = evalStr(fsm, "E<'a'>X 'i'")
        self.assertTrue((fsm.init & eaaxi).is_false())
        eaaxnc = evalStr(fsm, "E<'a'>X ~'c'")
        c = evalStr(fsm, "'c'")
        i = evalStr(fsm, "'i'")
        self.assertTrue(eaaxnc.isnot_false())
        self.assertEqual(eaaxnc, c.iff(i))
Beispiel #21
0
 def test_eax(self):
     fsm = self.init_model()
     
     eaaxi = evalStr(fsm, "E<'a'>X 'i'")
     self.assertTrue((fsm.init & eaaxi).is_false())
     eaaxnc = evalStr(fsm, "E<'a'>X ~'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertTrue(eaaxnc.isnot_false())
     self.assertEqual(eaaxnc, c.iff(i))
Beispiel #22
0
    def test_eax_explain(self):
        fsm = self.init_model()
        self.assertIsNotNone(fsm)

        spec = parseArctl("E<'TRUE'>X 'c1.c = 1'")[0]
        specbdd = evalArctl(fsm, spec)

        s = fsm.pick_one_state(specbdd & fsm.init)
        self.assertIsNotNone(s)

        ac = evalStr(fsm, "'TRUE'")
        phi = evalStr(fsm, "'c1.c = 1'")

        path = explain_eax(fsm, s, ac, phi)

        self.assertTrue(s == path[0])
        self.assertTrue(path[1] <= ac)
        self.assertTrue(path[2] <= phi)
        self.assertTrue(path[2] <= fsm.post(s, path[1]))
Beispiel #23
0
 def test_eax_explain(self):
     fsm = self.init_model()
     self.assertIsNotNone(fsm)
     
     spec = parseArctl("E<'TRUE'>X 'c1.c = 1'")[0]
     specbdd = evalArctl(fsm, spec)
     
     s = fsm.pick_one_state(specbdd & fsm.init)
     self.assertIsNotNone(s)
     
     ac = evalStr(fsm, "'TRUE'")
     phi = evalStr(fsm, "'c1.c = 1'")
     
     path = explain_eax(fsm, s, ac, phi)
     
     self.assertTrue(s == path[0])
     self.assertTrue(path[1] <= ac)
     self.assertTrue(path[2] <= phi)
     self.assertTrue(path[2] <= fsm.post(s, path[1]))
Beispiel #24
0
 def test_eaw(self):
     fsm = self.init_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     eacui = evalStr(fsm, "E<'a'>['c' W 'i']")
     self.assertEqual(c | i, eacui)
Beispiel #25
0
 def test_eau_finite(self):
     fsm = self.init_finite_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     enacuni = evalStr(fsm, "E<~'a'>['c'U~'i']")
     self.assertEqual(enacuni, c | ~i)
Beispiel #26
0
 def test_aau(self):
     fsm = self.init_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     aacuni = evalStr(fsm, "A<'a'>['c'U~'i']")
     self.assertEqual(aacuni, c | ~i)
Beispiel #27
0
 def test_aag_finite(self):
     fsm = self.init_finite_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     anagc = evalStr(fsm, "A<~'a'>G 'c'")
     self.assertEqual(anagc, c)
Beispiel #28
0
 def test_eau(self):
     fsm = self.init_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     eacui = evalStr(fsm, "E<'a'>['c' U 'i']")
     self.assertEqual(fsm.init | (~c & i), eacui)
Beispiel #29
0
    def test_eag_finite(self):
        fsm = self.init_finite_model()
        enagc = evalStr(fsm, "E<~'a'>G 'c'")
        c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")

        self.assertEqual(enagc, c)
Beispiel #30
0
    def test_aaf_finite(self):
        fsm = self.init_finite_model()
        aafni = evalStr(fsm, "A<'a'>F ~'i'")
        c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")

        self.assertEqual(aafni, c | ~i)
Beispiel #31
0
 def test_aaf_finite(self):
     fsm = self.init_finite_model()
     aafni = evalStr(fsm, "A<'a'>F ~'i'")
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     
     self.assertEqual(aafni, c | ~i)
Beispiel #32
0
 def test_eau_finite(self):
     fsm = self.init_finite_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     enacuni = evalStr(fsm, "E<~'a'>['c'U~'i']")
     self.assertEqual(enacuni, c | ~i)
Beispiel #33
0
 def test_eaf_finite(self):
     fsm = self.init_finite_model()
     eafnc = evalStr(fsm, "E<'a'>F ~'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertTrue(c.iff(i) <= eafnc)
Beispiel #34
0
 def test_aaf(self):
     fsm = self.init_model()
     aafni = evalStr(fsm, "A<'a'>F ~'i'")
     true = BDD.true(fsm.bddEnc.DDmanager)
     self.assertEqual(aafni, true)
Beispiel #35
0
 def test_eaf(self):
     fsm = self.init_model()
     eafnc = evalStr(fsm, "E<'a'>F ~'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertEqual(eafnc, ~(c & ~i))
Beispiel #36
0
 def test_aau(self):
     fsm = self.init_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     aacuni = evalStr(fsm, "A<'a'>['c'U~'i']")
     self.assertEqual(aacuni, c | ~i)
Beispiel #37
0
 def test_aax(self):
     fsm = self.init_model()
     aaxnc = evalStr(fsm, "A<'a'>X ~'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertEqual(aaxnc, c.iff(i))
Beispiel #38
0
 def test_aaw_finite(self):
     fsm = self.init_finite_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     aacuni = evalStr(fsm, "A<~'a'>['c'W~'i']")
     self.assertEqual(aacuni, c | ~i)
Beispiel #39
0
 def test_aaw_finite(self):
     fsm = self.init_finite_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     aacuni = evalStr(fsm, "A<~'a'>['c'W~'i']")
     self.assertEqual(aacuni, c | ~i)
Beispiel #40
0
 def test_aag_finite(self):
     fsm = self.init_finite_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     anagc = evalStr(fsm, "A<~'a'>G 'c'")
     self.assertEqual(anagc, c)
Beispiel #41
0
 def test_eau(self):
     fsm = self.init_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     eacui = evalStr(fsm, "E<'a'>['c' U 'i']")
     self.assertEqual(fsm.init | (~c & i), eacui)
Beispiel #42
0
 def test_eag_finite(self):
     fsm = self.init_finite_model()
     enagc = evalStr(fsm, "E<~'a'>G 'c'")
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     
     self.assertEqual(enagc, c)
Beispiel #43
0
 def test_eaw(self):
     fsm = self.init_model()
     c, i = evalStr(fsm, "'c'"), evalStr(fsm, "'i'")
     eacui = evalStr(fsm, "E<'a'>['c' W 'i']")
     self.assertEqual(c | i, eacui)
Beispiel #44
0
 def test_eaf_finite(self):
     fsm = self.init_finite_model()
     eafnc = evalStr(fsm, "E<'a'>F ~'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertTrue(c.iff(i) <= eafnc)
Beispiel #45
0
 def test_aaf(self):
     fsm = self.init_model()
     aafni = evalStr(fsm, "A<'a'>F ~'i'")
     true = BDD.true(fsm.bddEnc.DDmanager)
     self.assertEqual(aafni, true)
Beispiel #46
0
 def test_aax(self):
     fsm = self.init_model()
     aaxnc = evalStr(fsm, "A<'a'>X ~'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertEqual(aaxnc, c.iff(i))
Beispiel #47
0
 def test_eaf(self):
     fsm = self.init_model()
     eafnc = evalStr(fsm, "E<'a'>F ~'c'")
     c = evalStr(fsm, "'c'")
     i = evalStr(fsm, "'i'")
     self.assertEqual(eafnc, ~(c & ~i))