Exemplo n.º 1
0
 def test_full_witness(self):
     fsm = self.model()
     
     spec = parseCTLK("EF (EX nK<'c1'> 'c2.payer' & EG nD<'c1','c2'> 'c3.payer')")[0]
     self.assertIsNotNone(spec)
     state = fsm.pick_one_state(fsm.init & evalCTLK(fsm, spec))
     self.assertIsNotNone(state)
     
     expl = explain_witness(fsm, state, spec)
     self.assertIsNotNone(expl)
     
     
     spec = parseCTLK("E[nE<'c1','c2'> 'c3.payer' U"
                     " E[ nC<'c1','c3'> ('c1.payer' | 'c2.payer') W"
                     " nC<'c2'> ('c1.coin = head' <-> 'c2.coin = head')]]")[0]
     self.assertIsNotNone(spec)
     state = fsm.pick_one_state(fsm.init & evalCTLK(fsm, spec))
     self.assertIsNotNone(state)
     
     expl = explain_witness(fsm, state, spec)
     self.assertIsNotNone(expl)
     
     
     spec = parseCTLK("AG(~'c1.payer' | E<'c1'> ('c1.payer' -> "
                      "C<'c2','c3'> AF 'c1.payer'))")[0]
     self.assertIsNotNone(spec)
     state = fsm.pick_one_state(fsm.init & evalCTLK(fsm, spec))
     self.assertIsNotNone(state)
     
     expl = explain_witness(fsm, state, spec)
     self.assertIsNotNone(expl)
Exemplo n.º 2
0
 def test_c_dincry(self):
     fsm = self.model()
     
     c1p = eval_simple_expression(fsm, "c1.payer")
     c2p = eval_simple_expression(fsm, "c2.payer")
     c3p = eval_simple_expression(fsm, "c3.payer")
     c1h = eval_simple_expression(fsm, "c1.coin = head")
     c2h = eval_simple_expression(fsm, "c2.coin = head")
     c3h = eval_simple_expression(fsm, "c3.coin = head")
     odd = eval_simple_expression(fsm, "countsay = odd")
     even = eval_simple_expression(fsm, "countsay = even")
     unk = eval_simple_expression(fsm, "countsay = unknown")
     true = eval_simple_expression(fsm, "TRUE")
     false = eval_simple_expression(fsm, "FALSE")
     
     specs = parseCTLK("'countsay = odd' -> "
                       "C<'c1','c2','c3'> "
                       "('c1.payer' | 'c2.payer' | 'c3.payer')")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     oc123 = evalCTLK(fsm, spec)        
     self.assertTrue(fsm.reachable_states <= oc123)
     
     specs = parseCTLK("'countsay = even' -> "
                       "C<'c1','c2','c3'> "
                       "(~'c1.payer' & ~'c2.payer' & ~'c3.payer')")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     ec123 = evalCTLK(fsm, spec)        
     self.assertTrue(fsm.reachable_states <= ec123)
Exemplo n.º 3
0
    def test_d_simple(self):
        fsm = self.simplemodel()

        lt = eval_simple_expression(fsm, "at.local")
        lf = eval_simple_expression(fsm, "af.local")
        g = eval_simple_expression(fsm, "global")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("'af.local' -> D<'at','af'> 'af.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        geg = evalCTLK(fsm, spec)
        self.assertEqual(geg, true)

        specs = parseCTLK("'af.local' & D<'at'> 'af.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        geg = evalCTLK(fsm, spec)
        self.assertEqual(geg, false)

        specs = parseCTLK("'af.local' -> D<'af'> 'af.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        geg = evalCTLK(fsm, spec)
        self.assertEqual(geg, true)
Exemplo n.º 4
0
    def test_ex(self):
        fsm = self.model()

        c1p = eval_simple_expression(fsm, "c1.payer")
        c2p = eval_simple_expression(fsm, "c2.payer")
        c3p = eval_simple_expression(fsm, "c3.payer")
        c1h = eval_simple_expression(fsm, "c1.coin = head")
        c2h = eval_simple_expression(fsm, "c2.coin = head")
        c3h = eval_simple_expression(fsm, "c3.coin = head")
        odd = eval_simple_expression(fsm, "countsay = odd")
        unk = eval_simple_expression(fsm, "countsay = unknown")

        specs = parseCTLK("EX ('c1.payer' & ~'c2.payer' & ~'c3.payer')")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        ex = evalCTLK(fsm, spec)
        self.assertEqual(ex, c1p & ~c2p & ~c3p & fsm.bddEnc.statesMask)

        specs = parseCTLK("EX 'countsay = odd'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        ex = evalCTLK(fsm, spec)

        self.assertTrue(odd & fsm.bddEnc.statesMask <= ex)
        self.assertTrue(
            (unk & c1p & ~c2p & ~c3p) & fsm.bddEnc.statesMask <= ex)
        self.assertTrue((unk & c1p & c2p & c3p) & fsm.bddEnc.statesMask <= ex)
Exemplo n.º 5
0
    def test_d_simple(self):
        fsm = self.simplemodel()

        lt = eval_simple_expression(fsm, "at.local")
        lf = eval_simple_expression(fsm, "af.local")
        g = eval_simple_expression(fsm, "global")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("'af.local' -> D<'at','af'> 'af.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        geg = evalCTLK(fsm, spec) 
        self.assertEqual(geg, true)
        
        specs = parseCTLK("'af.local' & D<'at'> 'af.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        geg = evalCTLK(fsm, spec) 
        self.assertEqual(geg, false)
        
        specs = parseCTLK("'af.local' -> D<'af'> 'af.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        geg = evalCTLK(fsm, spec) 
        self.assertEqual(geg, true)
Exemplo n.º 6
0
 def test_ex(self):
     fsm = self.model()
     
     c1p = eval_simple_expression(fsm, "c1.payer")
     c2p = eval_simple_expression(fsm, "c2.payer")
     c3p = eval_simple_expression(fsm, "c3.payer")
     c1h = eval_simple_expression(fsm, "c1.coin = head")
     c2h = eval_simple_expression(fsm, "c2.coin = head")
     c3h = eval_simple_expression(fsm, "c3.coin = head")
     odd = eval_simple_expression(fsm, "countsay = odd")
     unk = eval_simple_expression(fsm, "countsay = unknown")
     
     specs = parseCTLK("EX ('c1.payer' & ~'c2.payer' & ~'c3.payer')")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     ex = evalCTLK(fsm, spec)
     self.assertEqual(ex, c1p & ~c2p & ~c3p & fsm.bddEnc.statesMask)
     
     specs = parseCTLK("EX 'countsay = odd'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     ex = evalCTLK(fsm, spec)
         
     self.assertTrue(odd & fsm.bddEnc.statesMask <= ex)
     self.assertTrue((unk & c1p & ~c2p & ~c3p) & fsm.bddEnc.statesMask
                     <= ex)
     self.assertTrue((unk & c1p & c2p & c3p) & fsm.bddEnc.statesMask
                     <= ex)
Exemplo n.º 7
0
    def test_c_dincry(self):
        fsm = self.model()

        c1p = eval_simple_expression(fsm, "c1.payer")
        c2p = eval_simple_expression(fsm, "c2.payer")
        c3p = eval_simple_expression(fsm, "c3.payer")
        c1h = eval_simple_expression(fsm, "c1.coin = head")
        c2h = eval_simple_expression(fsm, "c2.coin = head")
        c3h = eval_simple_expression(fsm, "c3.coin = head")
        odd = eval_simple_expression(fsm, "countsay = odd")
        even = eval_simple_expression(fsm, "countsay = even")
        unk = eval_simple_expression(fsm, "countsay = unknown")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("'countsay = odd' -> "
                          "C<'c1','c2','c3'> "
                          "('c1.payer' | 'c2.payer' | 'c3.payer')")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        oc123 = evalCTLK(fsm, spec)
        self.assertTrue(fsm.reachable_states <= oc123)

        specs = parseCTLK("'countsay = even' -> "
                          "C<'c1','c2','c3'> "
                          "(~'c1.payer' & ~'c2.payer' & ~'c3.payer')")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        ec123 = evalCTLK(fsm, spec)
        self.assertTrue(fsm.reachable_states <= ec123)
Exemplo n.º 8
0
    def test_e_dincry(self):
        fsm = self.model()

        c1p = eval_simple_expression(fsm, "c1.payer")
        c2p = eval_simple_expression(fsm, "c2.payer")
        c3p = eval_simple_expression(fsm, "c3.payer")
        c1h = eval_simple_expression(fsm, "c1.coin = head")
        c2h = eval_simple_expression(fsm, "c2.coin = head")
        c3h = eval_simple_expression(fsm, "c3.coin = head")
        odd = eval_simple_expression(fsm, "countsay = odd")
        even = eval_simple_expression(fsm, "countsay = even")
        unk = eval_simple_expression(fsm, "countsay = unknown")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("'countsay = even' -> E<'c1','c2'> ~'c1.payer'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        een1 = evalCTLK(fsm, spec)
        self.assertEqual(een1, true)

        specs = parseCTLK("E<'c2','c3'> ~'c1.payer'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        en1 = evalCTLK(fsm, spec)
        self.assertTrue(even & fsm.reachable_states <= en1)
Exemplo n.º 9
0
 def test_e_dincry(self):
     fsm = self.model()
     
     c1p = eval_simple_expression(fsm, "c1.payer")
     c2p = eval_simple_expression(fsm, "c2.payer")
     c3p = eval_simple_expression(fsm, "c3.payer")
     c1h = eval_simple_expression(fsm, "c1.coin = head")
     c2h = eval_simple_expression(fsm, "c2.coin = head")
     c3h = eval_simple_expression(fsm, "c3.coin = head")
     odd = eval_simple_expression(fsm, "countsay = odd")
     even = eval_simple_expression(fsm, "countsay = even")
     unk = eval_simple_expression(fsm, "countsay = unknown")
     true = eval_simple_expression(fsm, "TRUE")
     false = eval_simple_expression(fsm, "FALSE")
     
     specs = parseCTLK("'countsay = even' -> E<'c1','c2'> ~'c1.payer'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     een1 = evalCTLK(fsm, spec)                
     self.assertEqual(een1, true)
     
     specs = parseCTLK("E<'c2','c3'> ~'c1.payer'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     en1 = evalCTLK(fsm, spec)  
     self.assertTrue(even & fsm.reachable_states <= en1)
Exemplo n.º 10
0
 def test_full_countex(self):
     fsm = self.model()
     
     spec = parseCTLK("'c2.payer' -> A[AX ('c1.payer' | ~'c1.payer')"
                      " U K<'c1'> ('c2.payer')]")[0]
     self.assertIsNotNone(spec)
     self.assertTrue((fsm.init & ~evalCTLK(fsm, spec)).isnot_false())
     state = fsm.pick_one_state(fsm.init & ~evalCTLK(fsm, spec))
     self.assertIsNotNone(state)
     
     expl = explain_countex(fsm, state, spec)
     self.assertIsNotNone(expl)
     
     print(xml_countex(fsm, expl, spec))
     
     
     spec = parseCTLK("AG(~'c1.payer' | E<'c1'> ('c1.payer' -> "
                      "C<'c2','c3'> AF 'c1.payer'))")[0]
     self.assertIsNotNone(spec)
     self.assertTrue((fsm.init & ~evalCTLK(fsm, spec)).isnot_false())
     state = fsm.pick_one_state(fsm.init & ~evalCTLK(fsm, spec))
     self.assertIsNotNone(state)
     
     expl = explain_countex(fsm, state, spec)
     self.assertIsNotNone(expl)
     
     print(xml_countex(fsm, expl, spec))
Exemplo n.º 11
0
    def test_k(self):
        fsm = self.simplemodel()

        lt = eval_simple_expression(fsm, "at.local")
        lf = eval_simple_expression(fsm, "af.local")
        g = eval_simple_expression(fsm, "global")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("K<'at'> 'at.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        katt = evalCTLK(fsm, spec)
        self.assertEqual(katt, lt)
        
        specs = parseCTLK("K<'at'> 'af.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        katf = evalCTLK(fsm, spec)
        self.assertEqual(katf, false)
        
        specs = parseCTLK("K<'at'> 'global'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        katf = evalCTLK(fsm, spec)
        self.assertEqual(katf, g)
Exemplo n.º 12
0
    def test_k(self):
        fsm = self.simplemodel()

        lt = eval_simple_expression(fsm, "at.local")
        lf = eval_simple_expression(fsm, "af.local")
        g = eval_simple_expression(fsm, "global")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("K<'at'> 'at.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        katt = evalCTLK(fsm, spec)
        self.assertEqual(katt, lt)

        specs = parseCTLK("K<'at'> 'af.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        katf = evalCTLK(fsm, spec)
        self.assertEqual(katf, false)

        specs = parseCTLK("K<'at'> 'global'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        katf = evalCTLK(fsm, spec)
        self.assertEqual(katf, g)
Exemplo n.º 13
0
 def test_init(self):
     fsm = self.model()
     
     specs = parseCTLK("Init")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     
     self.assertEqual(fsm.init, evalCTLK(fsm, spec))
Exemplo n.º 14
0
    def test_reachable(self):
        fsm = self.model()

        specs = parseCTLK("Reachable")
        self.assertEqual(len(specs), 1)
        spec = specs[0]

        self.assertEqual(fsm.reachable_states, evalCTLK(fsm, spec))
Exemplo n.º 15
0
 def test_reachable(self):
     fsm = self.model()
     
     specs = parseCTLK("Reachable")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     
     self.assertEqual(fsm.reachable_states, evalCTLK(fsm, spec))
Exemplo n.º 16
0
    def test_init(self):
        fsm = self.model()

        specs = parseCTLK("Init")
        self.assertEqual(len(specs), 1)
        spec = specs[0]

        self.assertEqual(fsm.init, evalCTLK(fsm, spec))
Exemplo n.º 17
0
 def test_k_ex(self):
     fsm = self.simplemodel()
     
     lt = eval_simple_expression(fsm, "at.local")
     lf = eval_simple_expression(fsm, "af.local")
     g = eval_simple_expression(fsm, "global")
     true = eval_simple_expression(fsm, "TRUE")
     
     specs = parseCTLK("K<'at'> EX 'global'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     kex = evalCTLK(fsm, spec)
     self.assertEqual(kex, true)
     
     specs = parseCTLK("K<'at'> EX ~'global'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     kexn = evalCTLK(fsm, spec)
     self.assertEqual(kexn, true)
Exemplo n.º 18
0
    def test_true(self):
        fsm = self.model()

        true = eval_simple_expression(fsm, "TRUE")

        specs = parseCTLK("True")
        self.assertEqual(len(specs), 1)
        spec = specs[0]

        self.assertEqual(true, evalCTLK(fsm, spec))
Exemplo n.º 19
0
 def test_true(self):
     fsm = self.model()
     
     true = eval_simple_expression(fsm, "TRUE")
     
     specs = parseCTLK("True")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     
     self.assertEqual(true, evalCTLK(fsm, spec))
Exemplo n.º 20
0
 def test_false(self):
     fsm = self.model()
     
     false = eval_simple_expression(fsm, "FALSE")
     
     specs = parseCTLK("False")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     
     self.assertEqual(false, evalCTLK(fsm, spec))
Exemplo n.º 21
0
    def test_k_ex(self):
        fsm = self.simplemodel()

        lt = eval_simple_expression(fsm, "at.local")
        lf = eval_simple_expression(fsm, "af.local")
        g = eval_simple_expression(fsm, "global")
        true = eval_simple_expression(fsm, "TRUE")

        specs = parseCTLK("K<'at'> EX 'global'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        kex = evalCTLK(fsm, spec)
        self.assertEqual(kex, true)

        specs = parseCTLK("K<'at'> EX ~'global'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        kexn = evalCTLK(fsm, spec)
        self.assertEqual(kexn, true)
Exemplo n.º 22
0
    def test_false(self):
        fsm = self.model()

        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("False")
        self.assertEqual(len(specs), 1)
        spec = specs[0]

        self.assertEqual(false, evalCTLK(fsm, spec))
Exemplo n.º 23
0
    def test_not(self):
        fsm = self.model()

        c1p = eval_simple_expression(fsm, "c1.payer")

        specs = parseCTLK("~'c1.payer'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]

        c1pCTLK = evalCTLK(fsm, spec)
        self.assertEqual(~c1p, c1pCTLK)
Exemplo n.º 24
0
 def test_not(self):
     fsm = self.model()
     
     c1p = eval_simple_expression(fsm, "c1.payer")
     
     specs = parseCTLK("~'c1.payer'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     
     c1pCTLK = evalCTLK(fsm, spec)
     self.assertEqual(~c1p, c1pCTLK)
Exemplo n.º 25
0
    def test_implies(self):
        fsm = self.model()

        c1p = eval_simple_expression(fsm, "c1.payer")
        odd = eval_simple_expression(fsm, "countsay = odd")

        specs = parseCTLK("'c1.payer' -> 'countsay = odd'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]

        c1pico = evalCTLK(fsm, spec)
        self.assertEqual(c1p.imply(odd), c1pico)
Exemplo n.º 26
0
 def test_iff(self):
     fsm = self.model()
     
     c1p = eval_simple_expression(fsm, "c1.payer")
     odd = eval_simple_expression(fsm, "countsay = odd")
     
     specs = parseCTLK("'c1.payer' <-> 'countsay = odd'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     
     c1pico = evalCTLK(fsm, spec)
     self.assertEqual(c1p.iff(odd), c1pico)
Exemplo n.º 27
0
    def test_and(self):
        fsm = self.model()

        c1p = eval_simple_expression(fsm, "c1.payer")
        odd = eval_simple_expression(fsm, "countsay = odd")

        specs = parseCTLK("'c1.payer' & 'countsay = odd'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]

        c1paco = evalCTLK(fsm, spec)
        self.assertEqual(c1p & odd, c1paco)
Exemplo n.º 28
0
 def test_full_countex(self):
     fsm = self.model()
     
     spec = parseCTLK("'c2.payer' -> A[AX ('c1.payer' | ~'c1.payer')"
                      " U K<'c1'> ('c2.payer')]")[0]
     self.assertIsNotNone(spec)
     self.assertTrue((fsm.init & ~evalCTLK(fsm, spec)).isnot_false())
     state = fsm.pick_one_state(fsm.init & ~evalCTLK(fsm, spec))
     self.assertIsNotNone(state)
     
     expl = explain_countex(fsm, state, spec)
     self.assertIsNotNone(expl)
     
     
     spec = parseCTLK("AG(~'c1.payer' | E<'c1'> ('c1.payer' -> "
                      "C<'c2','c3'> AF 'c1.payer'))")[0]
     self.assertIsNotNone(spec)
     self.assertTrue((fsm.init & ~evalCTLK(fsm, spec)).isnot_false())
     state = fsm.pick_one_state(fsm.init & ~evalCTLK(fsm, spec))
     self.assertIsNotNone(state)
     
     expl = explain_countex(fsm, state, spec)
     self.assertIsNotNone(expl)
Exemplo n.º 29
0
 def test_simple_ex(self):
     fsm = self.simplemodel()
     
     lt = eval_simple_expression(fsm, "at.local")
     lf = eval_simple_expression(fsm, "af.local")
     g = eval_simple_expression(fsm, "global")
     
     specs = parseCTLK("EX 'af.local'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     ex = evalCTLK(fsm, spec)
     # ex : 
     #  l1, !l2, !g
     #  !l1, l2, g
     #  l1, l2, g
     #  !l1, !l2, !g
     self.assertEqual(ex, lf.iff(g))
     
     specs = parseCTLK("EX ('af.local' & 'at.local' & 'global')")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     ex = evalCTLK(fsm, spec)
     self.assertEqual(ex, lt & ~lf & ~g | ~lt & lf & g)
Exemplo n.º 30
0
    def test_simple_ex(self):
        fsm = self.simplemodel()

        lt = eval_simple_expression(fsm, "at.local")
        lf = eval_simple_expression(fsm, "af.local")
        g = eval_simple_expression(fsm, "global")

        specs = parseCTLK("EX 'af.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        ex = evalCTLK(fsm, spec)
        # ex :
        #  l1, !l2, !g
        #  !l1, l2, g
        #  l1, l2, g
        #  !l1, !l2, !g
        self.assertEqual(ex, lf.iff(g))

        specs = parseCTLK("EX ('af.local' & 'at.local' & 'global')")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        ex = evalCTLK(fsm, spec)
        self.assertEqual(ex, lt & ~lf & ~g | ~lt & lf & g)
Exemplo n.º 31
0
 def test_false(self):
     fsm = self.simplemodel()
     
     spec = parseCTLK("False")[0]
     self.assertIsNotNone(spec)
     state = fsm.pick_one_state(fsm.init & ~evalCTLK(fsm, spec))
     self.assertIsNotNone(state)
     
     expl = explain_countex(fsm, state, spec)
     self.assertIsNotNone(expl)
     self.assertEqual(type(expl), Tlacenode)
     self.assertEqual(expl.state, state)
     self.assertEqual(len(expl.atomics), 0)
     self.assertEqual(len(expl.branches), 0)
     self.assertEqual(len(expl.universals), 0)
Exemplo n.º 32
0
 def test_init(self):
     fsm = self.simplemodel()
     
     spec = parseCTLK("Init")[0]
     self.assertIsNotNone(spec)
     state = fsm.pick_one_state(fsm.init & evalCTLK(fsm, spec))
     self.assertIsNotNone(state)
     
     expl = explain_witness(fsm, state, spec)
     self.assertIsNotNone(expl)
     self.assertEqual(type(expl), Tlacenode)
     self.assertEqual(expl.state, state)
     self.assertEqual(len(expl.atomics), 1)
     self.assertEqual(type(expl.atomics[0]), Init)
     self.assertEqual(len(expl.branches), 0)
     self.assertEqual(len(expl.universals), 0)
Exemplo n.º 33
0
 def test_d_distributedmodel(self):  
     glob.load_from_file("tests/tools/ctlk/distributed_knowledge.smv")
     fsm = glob.mas()
     self.assertIsNotNone(fsm)
     
     l1 = eval_simple_expression(fsm, "a1.local")
     l2 = eval_simple_expression(fsm, "a2.local")
     l3 = eval_simple_expression(fsm, "a3.local")
     true = eval_simple_expression(fsm, "TRUE")
     false = eval_simple_expression(fsm, "FALSE")
     
     specs = parseCTLK("'a1.local' -> D<'a1','a2'> 'a1.local'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     a1da1 = evalCTLK(fsm, spec)        
     self.assertEqual(true, a1da1)
Exemplo n.º 34
0
    def test_d_distributedmodel(self):
        glob.load_from_file("tests/tools/ctlk/distributed_knowledge.smv")
        fsm = glob.mas()
        self.assertIsNotNone(fsm)

        l1 = eval_simple_expression(fsm, "a1.local")
        l2 = eval_simple_expression(fsm, "a2.local")
        l3 = eval_simple_expression(fsm, "a3.local")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("'a1.local' -> D<'a1','a2'> 'a1.local'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        a1da1 = evalCTLK(fsm, spec)
        self.assertEqual(true, a1da1)
Exemplo n.º 35
0
 def test_reachable(self):
     fsm = self.simplemodel()
     
     lt = eval_simple_expression(fsm, "at.local")
     lf = eval_simple_expression(fsm, "af.local")
     g = eval_simple_expression(fsm, "global")
     true = eval_simple_expression(fsm, "TRUE")
     false = eval_simple_expression(fsm, "FALSE")
     
     spec = parseCTLK("Reachable")[0]
     self.assertIsNotNone(spec)
     state = fsm.pick_one_state(~lt & ~lf & ~g)
     self.assertIsNotNone(state)
     self.assertTrue(state <= evalCTLK(fsm, spec))
     
     expl = explain_witness(fsm, state, spec)
     self.assertIsNotNone(expl)
     self.assertEqual(type(expl), Tlacenode)
     self.assertEqual(expl.state, state)
     self.assertEqual(len(expl.atomics), 0)
     self.assertEqual(len(expl.branches), 1)
     self.assertEqual(len(expl.universals), 0)
     
     branch = expl.branches[0]
     self.assertEqual(type(branch), TemporalBranch)
     self.assertEqual(type(branch.specification), Reachable)
     path = branch.path
     self.assertIsNone(branch.loop)
     for (s, i, sp) in zip(path[::2], path[1::2], path[2::2]):
         self.assertIsNotNone(s)
         self.assertTrue(s.state <= fsm.reachable_states)
         self.assertEqual(len(s.atomics), 0)
         self.assertEqual(len(s.branches), 0)
         self.assertEqual(len(s.universals), 0)
         self.assertIsNotNone(sp)
         self.assertTrue(sp.state <= fsm.reachable_states)
         self.assertEqual(len(sp.branches), 0)
         self.assertEqual(len(sp.universals), 0)
         self.assertTrue(i <=
                            fsm.get_inputs_between_states(sp.state, s.state))
     self.assertEqual(len(path[-1].atomics), 1)
     self.assertEqual(type(path[-1].atomics[0]), Init)
     
     print(xml_witness(fsm, expl, spec))
Exemplo n.º 36
0
 def test_reachable(self):
     fsm = self.simplemodel()
     
     lt = eval_simple_expression(fsm, "at.local")
     lf = eval_simple_expression(fsm, "af.local")
     g = eval_simple_expression(fsm, "global")
     true = eval_simple_expression(fsm, "TRUE")
     false = eval_simple_expression(fsm, "FALSE")
     
     spec = parseCTLK("Reachable")[0]
     self.assertIsNotNone(spec)
     state = fsm.pick_one_state(~lt & ~lf & ~g)
     self.assertIsNotNone(state)
     self.assertTrue(state <= evalCTLK(fsm, spec))
     
     expl = explain_witness(fsm, state, spec)
     self.assertIsNotNone(expl)
     self.assertEqual(type(expl), Tlacenode)
     self.assertEqual(expl.state, state)
     self.assertEqual(len(expl.atomics), 0)
     self.assertEqual(len(expl.branches), 1)
     self.assertEqual(len(expl.universals), 0)
     
     branch = expl.branches[0]
     self.assertEqual(type(branch), TemporalBranch)
     self.assertEqual(type(branch.specification), Reachable)
     path = branch.path
     self.assertIsNone(branch.loop)
     for (s, i, sp) in zip(path[::2], path[1::2], path[2::2]):
         self.assertIsNotNone(s)
         self.assertTrue(s.state <= fsm.reachable_states)
         self.assertEqual(len(s.atomics), 0)
         self.assertEqual(len(s.branches), 0)
         self.assertEqual(len(s.universals), 0)
         self.assertIsNotNone(sp)
         self.assertTrue(sp.state <= fsm.reachable_states)
         self.assertEqual(len(sp.branches), 0)
         self.assertEqual(len(sp.universals), 0)
         self.assertTrue(i <=
                            fsm.get_inputs_between_states(sp.state, s.state))
     self.assertEqual(len(path[-1].atomics), 1)
     self.assertEqual(type(path[-1].atomics[0]), Init)
Exemplo n.º 37
0
 def test_k_dincry(self):
     fsm = self.model()
     
     c1p = eval_simple_expression(fsm, "c1.payer")
     c2p = eval_simple_expression(fsm, "c2.payer")
     c3p = eval_simple_expression(fsm, "c3.payer")
     c1h = eval_simple_expression(fsm, "c1.coin = head")
     c2h = eval_simple_expression(fsm, "c2.coin = head")
     c3h = eval_simple_expression(fsm, "c3.coin = head")
     odd = eval_simple_expression(fsm, "countsay = odd")
     unk = eval_simple_expression(fsm, "countsay = unknown")
     true = eval_simple_expression(fsm, "TRUE")
     false = eval_simple_expression(fsm, "FALSE")
     
     specs = parseCTLK("AG ('c1.payer' "
                                   "-> K<'c1'> (~'c2.payer' & ~'c3.payer'))")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     ik = evalCTLK(fsm, spec)                
     self.assertTrue(fsm.init <= ik)
Exemplo n.º 38
0
    def test_k_dincry(self):
        fsm = self.model()

        c1p = eval_simple_expression(fsm, "c1.payer")
        c2p = eval_simple_expression(fsm, "c2.payer")
        c3p = eval_simple_expression(fsm, "c3.payer")
        c1h = eval_simple_expression(fsm, "c1.coin = head")
        c2h = eval_simple_expression(fsm, "c2.coin = head")
        c3h = eval_simple_expression(fsm, "c3.coin = head")
        odd = eval_simple_expression(fsm, "countsay = odd")
        unk = eval_simple_expression(fsm, "countsay = unknown")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("AG ('c1.payer' "
                          "-> K<'c1'> (~'c2.payer' & ~'c3.payer'))")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        ik = evalCTLK(fsm, spec)
        self.assertTrue(fsm.init <= ik)
Exemplo n.º 39
0
 def test_d_dincry(self):
     fsm = self.model()
     
     c1p = eval_simple_expression(fsm, "c1.payer")
     c2p = eval_simple_expression(fsm, "c2.payer")
     c3p = eval_simple_expression(fsm, "c3.payer")
     c1h = eval_simple_expression(fsm, "c1.coin = head")
     c2h = eval_simple_expression(fsm, "c2.coin = head")
     c3h = eval_simple_expression(fsm, "c3.coin = head")
     odd = eval_simple_expression(fsm, "countsay = odd")
     even = eval_simple_expression(fsm, "countsay = even")
     unk = eval_simple_expression(fsm, "countsay = unknown")
     true = eval_simple_expression(fsm, "TRUE")
     false = eval_simple_expression(fsm, "FALSE")
     
     specs = parseCTLK("('c1.payer' & 'countsay != unknown') "
                       "-> D<'c2','c3'> 'c1.payer'")
     self.assertEqual(len(specs), 1)
     spec = specs[0]
     cud1 = evalCTLK(fsm, spec)        
     self.assertTrue(fsm.reachable_states <= cud1)
Exemplo n.º 40
0
    def test_d_dincry(self):
        fsm = self.model()

        c1p = eval_simple_expression(fsm, "c1.payer")
        c2p = eval_simple_expression(fsm, "c2.payer")
        c3p = eval_simple_expression(fsm, "c3.payer")
        c1h = eval_simple_expression(fsm, "c1.coin = head")
        c2h = eval_simple_expression(fsm, "c2.coin = head")
        c3h = eval_simple_expression(fsm, "c3.coin = head")
        odd = eval_simple_expression(fsm, "countsay = odd")
        even = eval_simple_expression(fsm, "countsay = even")
        unk = eval_simple_expression(fsm, "countsay = unknown")
        true = eval_simple_expression(fsm, "TRUE")
        false = eval_simple_expression(fsm, "FALSE")

        specs = parseCTLK("('c1.payer' & 'countsay != unknown') "
                          "-> D<'c2','c3'> 'c1.payer'")
        self.assertEqual(len(specs), 1)
        spec = specs[0]
        cud1 = evalCTLK(fsm, spec)
        self.assertTrue(fsm.reachable_states <= cud1)