def test_init(self):
     init_nusmv()
     # Should not produce error
     fsm = BddFsm.from_filename("tests/pynusmv/models/admin.smv")
     reset_nusmv()
     # Should not produce error
     fsm = BddFsm.from_filename("tests/pynusmv/models/admin.smv")
     deinit_nusmv()

 def test_from_string(self):
     model = """
     MODULE main
         VAR test : 0..1;
     """
     fsm = BddFsm.from_string(model)
     self.assertIsNotNone(fsm)

 def test_from_string_fail(self):
     model = """
     MODULE main
         VAR qsdf : sdfqsdf;
     """
     with self.assertRaises(NuSMVCannotFlattenError):
         fsm = BddFsm.from_string(model)

 def print_vars_and_trans(self, modelpath):
     fsm = BddFsm.from_filename(modelpath)
     self.assertIsNotNone(fsm)
     
     propDb = glob.prop_database()
     master = propDb.master
     
     print("MODEL:", modelpath)
     print("============================================================")
     
     sexpfsm_ptr = nsprop.Prop_get_scalar_sexp_fsm(master._ptr)
     var_list = nssexp.SexpFsm_get_vars_list(sexpfsm_ptr)
     
     var_list_length = nsutils.NodeList_get_length(var_list)
     print("var_list length:", var_list_length)
     
     var_list_iter = nsutils.NodeList_get_first_iter(var_list)
     while var_list_iter is not None:
         item = nsutils.NodeList_get_elem_at(var_list, var_list_iter)
         
         print(nsnode.sprint_node(item))
         print("--------------------------")
         
         var_init = nssexp.SexpFsm_get_var_init(sexpfsm_ptr, item)
         print(nsnode.sprint_node(var_init))
                     
         print("--------------------------")
         
         var_trans = nssexp.SexpFsm_get_var_trans(sexpfsm_ptr, item)
         print(nsnode.sprint_node(var_trans))
         
         print("--------------------------")
         print()
         
         var_list_iter = nsutils.ListIter_get_next(var_list_iter)

 def test_symb_table_new_layer(self):
     fsm = BddFsm.from_filename("tests/pynusmv/models/counters.smv")
     symb_table = fsm.bddEnc.symbTable
     
     self.assertIsNotNone(symb_table)
     self.assertTrue("translation" not in symb_table.layer_names)
     
     symb_table.create_layer("translation")
     self.assertTrue("translation" in symb_table.layer_names)

 def test_symb_table_layer_names(self):
     fsm = BddFsm.from_filename("tests/pynusmv/models/counters.smv")
     symb_table = fsm.bddEnc.symbTable
     
     self.assertIsNotNone(symb_table)
     self.assertIsNotNone(symb_table._ptr)
     
     self.assertEqual(len(symb_table.layer_names), 2)
     self.assertIn("model", symb_table.layer_names)
     self.assertIn("model_bool", symb_table.layer_names)

    def test_count_inputs_no_in_model(self):
        fsm = BddFsm.from_filename("tests/pynusmv/models/modules.smv")
        self.assertIsNotNone(fsm)

        ni = evalSexp(fsm, "n.inmod")
        mi = evalSexp(fsm, "m.inmod")
        top = evalSexp(fsm, "top")
        true = evalSexp(fsm, "TRUE")

        self.assertEqual(0, fsm.count_inputs(ni))

    def test_pick_no_inputs(self):
        fsm = BddFsm.from_filename("tests/pynusmv/models/modules.smv")
        self.assertIsNotNone(fsm)

        ni = evalSexp(fsm, "n.inmod")
        mi = evalSexp(fsm, "m.inmod")
        top = evalSexp(fsm, "top")
        true = evalSexp(fsm, "TRUE")

        with self.assertRaises(NuSMVBddPickingError):
            fsm.pick_all_inputs(ni)

 def test_symb_table_declare_variable(self):
     fsm = BddFsm.from_filename("tests/pynusmv/models/counters.smv")
     symb_table = fsm.bddEnc.symbTable
     
     self.assertIsNotNone(symb_table)
     
     var = node.Identifier.from_string("ran")
     type_ = node.Scalar(("rc1", "rc2"))
     
     self.assertTrue(symb_table.can_declare_var("model", var))
     symb_table.declare_state_var("model", var, type_)
     self.assertFalse(symb_table.can_declare_var("model", var))

 def test_post_counters(self):
     fsm = BddFsm.from_filename("tests/pynusmv/models/counters.smv")
     self.assertIsNotNone(fsm)
     
     c1c0 = evalSexp(fsm, "c1.c = 0")
     c1c1 = evalSexp(fsm, "c1.c = 1")
     c2c0 = evalSexp(fsm, "c2.c = 0")
     c2c1 = evalSexp(fsm, "c2.c = 1")
     rc1 = evalSexp(fsm, "run = rc1")
     rc2 = evalSexp(fsm, "run = rc2")
     
     self.assertEqual(fsm.post(c1c0 & c2c0), (c1c1 & c2c0) | (c1c0 & c2c1))

 def test_fairness(self):
     fsm = BddFsm.from_filename("tests/pynusmv/models/counters-fair.smv")
     self.assertIsNotNone(fsm)
     
     false = BDD.false(fsm.bddEnc.DDmanager)
     true = BDD.true(fsm.bddEnc.DDmanager)
     rc1 = evalSexp(fsm, "run = rc1")
     rc2 = evalSexp(fsm, "run = rc2")
     
     fairBdds = fsm.fairness_constraints
     self.assertEqual(len(fairBdds), 2)
     for fair in fairBdds:
         self.assertTrue(fair == rc1 or fair == rc2)

    def test_gc(self):
        """
        This test should not produce a segfault due to freed memory after
        deiniting NuSMV. This is thanks to the PyNuSMV GC system that keeps
        track of all wrapped pointers and free them when deiniting NuSMV, if
        needed.
        """
        init_nusmv()

        fsm = BddFsm.from_filename("tests/pynusmv/models/admin.smv")
        init = fsm.init

        deinit_nusmv()

 def do_read(self, arg):
     """
     Read file as SMV model to get FSM.
     usage: read FILEPATH
     """
     if len(arg) < 1:
         print("[ERROR] read command needs the SMV model path.")
     else:
         if self.fsm is not None:
             reset_nusmv()
         try:
             self.fsm = BddFsm.from_filename(arg)
             self.fsmpath = arg
         except Exception as e:
             print("[ERROR]", e)

 def test_fairness_from_nusmv(self):
     fsm = BddFsm.from_filename("tests/pynusmv/models/counters-fair.smv")
     self.assertIsNotNone(fsm)
     
     from pynusmv.nusmv.fsm.bdd import bdd as nsbddfsm
     
     justiceList = nsbddfsm.BddFsm_get_justice(fsm._ptr)
     fairnessList = nsbddfsm.justiceList2fairnessList(justiceList)
     
     ite = nsbddfsm.FairnessList_begin(fairnessList)
     fairBdds = []
     while not nsbddfsm.FairnessListIterator_is_end(ite):
         fairBdds.append(nsbddfsm.JusticeList_get_p(justiceList, ite))
         ite = nsbddfsm.FairnessListIterator_next(ite)
     self.assertEqual(len(fairBdds), 2)

def check_and_explain(allargs):
    """
    Check specs on the given NuSMV model and compute TLACEs when needed.
    
    Build the model from a given file, check every CTL spec in it
    and compute and store TLACEs when needed.
    
    allargs -- a sys.args-like arguments list, without script name.
    """
    
    # Parse arguments
    parser = argparse.ArgumentParser(description='CTL model checker '
                                                 'with TLACE generation.')
    # Populate arguments: for now, only the model
    parser.add_argument('model', help='the NuSMV model with specifications')
    args = parser.parse_args(allargs)
    
    # Initialize the model
    fsm = BddFsm.from_filename(args.model)
    propDb = glob.prop_database()
    
    # Check all CTL properties
    for prop in propDb:
        #  Check type
        if prop.type == propTypes['CTL']:
            spec = prop.exprcore
    
            (satisfied, cntex) = check_ctl_spec(fsm, spec)
            # Print the result and the TLACE if any
            print('Specification',str(spec), 'is', str(satisfied),
                  file=sys.stderr)
        
            if not satisfied:
                print(xml_representation(fsm, cntex, spec))
            
            print()

 def cardgame_post_fair(self):
     fsm = BddFsm.from_filename("tests/pynusmv/models/"
                                "cardgame-post-fair.smv")
     self.assertIsNotNone(fsm)
     return fsm

 def model(self):
     fsm = BddFsm.from_filename("tests/pynusmv/models/constraints.smv")
     self.assertIsNotNone(fsm)
     return fsm

 def init_model(self):
     fsm = BddFsm.from_filename("tests/pynusmv/models/admin.smv")
     return (fsm, fsm.bddEnc, fsm.bddEnc.DDmanager)

 def model(self, modelpath):
     fsm = BddFsm.from_filename(modelpath)
     self.assertIsNotNone(fsm)
     return fsm

 def nameche_model(self):
     fsm = BddFsm.from_filename("tests/tools/ctl/nameche08R1.smv")
     self.assertIsNotNone(fsm)
     return fsm