Пример #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))
Пример #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))
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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))
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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))
Пример #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))
Пример #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]))
Пример #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]))
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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))
Пример #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)
Пример #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))
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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)
Пример #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))
Пример #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))