def setUp(self):
init_nusmv()
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
" tests/pynusmv/models/admin.smv")
self.assertEqual(ret, 0)
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0)
def init_model(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
"tests/pynusmv/models/admin.smv")
self.assertEqual(ret, 0, "cannot read the model")
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0, "cannot build the model")
propDb = glob.prop_database()
master = propDb.master
fsm = propDb.master.bddFsm
return fsm
def test_nsmc(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
" tests/pynusmv/models/admin.smv")
self.assertEqual(ret, 0)
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0)
# Check CTL specs
propDb = nsprop.PropPkg_get_prop_database()
for i in range(nsprop.PropDb_get_size(propDb)):
p = nsprop.PropDb_get_prop_at_index(propDb, i)
if nsprop.Prop_get_type(p) == nsprop.Prop_Ctl:
nsmc.Mc_CheckCTLSpec(p)
def test_run_checkctlspec(self):
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
" tests/pynusmv/models/admin.smv")
self.assertEqual(ret, 0)
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0)
node, err = nsparser.ReadSimpExprFromString("admin = alice")
self.assertIsNotNone(node)
node = nsnode.car(node)
self.assertIsNotNone(node)
node = Spec(node)
self.assertIsNotNone(node)
def test_precedences(self):
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
" tests/pynusmv/models/admin.smv")
self.assertEqual(ret, 0)
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0)
propDb = glob.prop_database()
self.assertTrue(len(propDb) >= 2)
prop = propDb[1]
spec = prop.exprcore.cdr # Ignoring NULL context
self.assertEqual(spec.type, nsparser.AND)
self.assertEqual(spec.car.type, nsparser.EF)
self.assertEqual(spec.cdr.type, nsparser.EF)
def test_run_checkctlspec(self):
from pynusmv_lower_interface.nusmv.cinit import cinit
from pynusmv_lower_interface.nusmv.cmd import cmd
cinit.NuSMVCore_init_data()
cinit.NuSMVCore_init(None, 0)
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
" tests/pynusmv/models/admin.smv")
self.assertEqual(ret, 0)
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0)
ret = cmd.Cmd_SecureCommandExecute("check_ctlspec")
self.assertEqual(ret, 0)
cinit.NuSMVCore_quit()
def test_build_model(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
" tests/pynusmv/models/admin.smv")
self.assertEqual(ret, 0)
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0)
propDb = prop.PropPkg_get_prop_database()
fsm_ptr = prop.PropDb_master_get_bdd_fsm(propDb)
self.assertIsNotNone(fsm_ptr)
fsm = BddFsm(fsm_ptr)
enc = fsm.bddEnc
self.assertIsNotNone(enc)
init = fsm.init
self.assertIsNotNone(init)
def init_nusmv(collecting=True):
"""
Initialize NuSMV. Must be called only once before calling
:func:`deinit_nusmv`.
:param collecting: Whether or not collecting pointer wrappers to free them
before deiniting nusmv.
.. warning: Deactivating the collection of pointer wrappers may provoke
segmentation faults when deiniting nusmv without correctly
freeing all pointer wrappers in advance.
On the other hand, collection may blow memory.
"""
global __collector, __collecting
if __collector is not None:
raise NuSMVInitError("Cannot initialize NuSMV twice.")
else:
__collecting = collecting
__collector = set()
nscinit.NuSMVCore_init_data()
nscinit.NuSMVCore_init(None, 0) # No addons specified
nscinit.NuSMVCore_init_cmd_options()
# Set NuSMV in interactive mode to avoid fast termination when errors
# nsopt.unset_batch(nsopt.OptsHandler_get_instance())
# Initialize option commands (set, unset)
# to be able to set parser_is_lax
nsopt.init_options_cmd()
nscmd.Cmd_SecureCommandExecute("set parser_is_lax")
return _PyNuSMVContext()
def test_check_violated_spec(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute(
"read_model -i "
"tests/pynusmv_tools/tlace/admin.smv")
self.assertEqual(ret, 0, "cannot read the model")
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0, "cannot build the model")
propDb = glob.prop_database()
master = propDb.master
fsm = propDb.master.bddFsm
self.assertTrue(propDb.get_size() >= 1, "propDb has no properties")
prop = propDb.get_prop_at_index(0)
spec = prop.exprcore
res = check(fsm, spec)
self.assertFalse(res[0], "spec should be violated")
self.assertIsNotNone(res[1], "TLACE should be given")
def test_elements(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
"tests/pynusmv/models/admin.smv")
self.assertEqual(ret, 0, "cannot read the model")
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0, "cannot build the model")
propDb = glob.prop_database()
master = propDb.master
fsm = propDb.master.bddFsm
init = fsm.init
ln = BDDList.from_tuple((init, BDD.true(init._manager), init))
self.assertEqual(len(ln), 3)
self.assertSequenceEqual((init, BDD.true(init._manager), init),
ln.to_tuple())
del ln
def test_check_satisfied_spec(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute(
"read_model -i"
"tests/pynusmv_tools/tlace/admin.smv")
self.assertEqual(ret, 0, "cannot read the model")
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0, "cannot build the model")
propDb = glob.prop_database()
master = propDb.master
fsm = propDb.master.bddFsm
self.assertTrue(propDb.get_size() >= 3, "propDb misses some props")
prop = propDb.get_prop_at_index(2)
self.assertIsNotNone(prop, "prop should not be None")
spec = prop.exprcore
res = check(fsm, spec)
self.assertTrue(res[0], "spec should be satisfied")
self.assertIsNone(res[1], "TLACE should not exist")
def test_mc(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
" tests/pynusmv/models/admin.smv")
self.assertEqual(ret, 0)
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0)
ret = {
"(EF admin = alice -> AG (admin != none -> admin = alice))": False,
"(EF admin = alice & EF admin = bob)": True
}
propDb = glob.prop_database()
fsm = propDb.master.bddFsm
for p in propDb:
if p.type == prop.propTypes["CTL"]:
spec = p.expr
self.assertEqual(mc.check_ctl_spec(fsm, spec), ret[str(spec)])
def test_print_violated_spec_admin_ax(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute(
"read_model -i "
"tests/pynusmv_tools/tlace/admin.smv")
self.assertEqual(ret, 0, "cannot read the model")
ret = cmd.Cmd_SecureCommandExecute("go")
self.assertEqual(ret, 0, "cannot build the model")
propDb = glob.prop_database()
master = propDb.master
fsm = propDb.master.bddFsm
self.assertTrue(len(propDb) >= 6, "propDb has no properties")
prop = propDb[5]
spec = prop.exprcore
res = check(fsm, spec)
self.assertFalse(res[0], "spec should be violated")
self.assertIsNotNone(res[1], "TLACE should be given")
print(xml_representation(fsm, res[1], spec))
def test_flat_command_allow_prop_db(self):
glob.load_from_file("tests/pynusmv/models/counters.smv")
ret = nscmd.Cmd_SecureCommandExecute("flatten_hierarchy")
self.assertEqual(ret, 0)
pd = glob.prop_database()
self.assertIsNotNone(pd)
def test_load_allow_flattening_with_command(self):
glob.load_from_file("tests/pynusmv/models/counters.smv")
ret = nscmd.Cmd_SecureCommandExecute("flatten_hierarchy")
self.assertEqual(ret, 0)
def test_trans(self):
# Parse a model
#nsparser.ReadSMVFromFile("tests/pynusmv/models/modules.smv")
#parsed_tree = nsparser.cvar.parsed_tree
nscmd.Cmd_SecureCommandExecute(
"read_model -i tests/pynusmv/models/modules.smv")
nscmd.Cmd_SecureCommandExecute("flatten_hierarchy")
st = nscompile.Compile_get_global_symb_table()
# main = nsnode.find_node(
# nsparser.ATOM,
# nsnode.string2node(nsutils.find_string("main")),
# None)
#
# # Flatten
# nscompile.CompileFlatten_init_flattener()
# st = nscompile.Compile_get_global_symb_table()
# layer = nssymb_table.SymbTable_create_layer(st, "model",
# nssymb_table.SYMB_LAYER_POS_BOTTOM)
# nssymb_table.SymbTable_layer_add_to_class(st, "model", "Model Class")
# nssymb_table.SymbTable_set_default_layers_class_name(st, "Model Class")
#
# #hierarchy = nscompile.Compile_FlattenHierarchy(
# # st, layer, main, None, None, 1, 0, None)
#
# hierarchy = nscompile.FlatHierarchy_create(st)
# instances = nsutils.new_assoc()
#
# nscompile.Compile_ConstructHierarchy(st, layer, main, None, None,
# hierarchy, None, instances)
#
# fhtrans = nscompile.FlatHierarchy_get_trans(hierarchy)
# print("NON FLATTENED")
# print(nsnode.sprint_node(fhtrans))
#
# print(fhtrans.type) #169 = AND
# print(car(fhtrans)) #None
# print(cdr(fhtrans).type) #130 = CONTEXT
# print(car(cdr(fhtrans)).type) #208 = DOT
# print(car(car(cdr(fhtrans)))) #None
# print(cdr(car(cdr(fhtrans))).type) #161 = ATOM
# print(nsnode.sprint_node(cdr(car(cdr(fhtrans))))) #m
#
# print(cdr(cdr(fhtrans)).type) #192 = EQUAL
#
#
#
# trans = nscompile.Compile_FlattenSexp(st, cdr(fhtrans), None)
# print("FLATTENED")
# print(nsnode.sprint_node(trans))
layers = nssymb_table.SymbTable_get_class_layer_names(st, None)
variables = nssymb_table.SymbTable_get_layers_sf_i_vars(st, layers)
ite = nsutils.NodeList_get_first_iter(variables)
while not nsutils.ListIter_is_end(ite):
variable = nsutils.NodeList_get_elem_at(variables, ite)
print(nsnode.sprint_node(variable))
ite = nsutils.ListIter_get_next(ite)
top = nsnode.find_node(nsparser.ATOM,
nsnode.string2node(nsutils.find_string("top")),
None)
trans = nssexp.Expr_equal(nssexp.Expr_next(top, st), top, st)
flattrans = nscompile.Compile_FlattenSexp(st, trans, None)
inmod = nsnode.find_node(
nsparser.ATOM, nsnode.string2node(nsutils.find_string("inmod")),
None)
t = nsnode.find_node(nsparser.ATOM,
nsnode.string2node(nsutils.find_string("t")),
None)
m = nsnode.find_node(nsparser.ATOM,
nsnode.string2node(nsutils.find_string("m")),
None)
my = nsnode.find_node(nsparser.ATOM,
nsnode.string2node(nsutils.find_string("my")),
None)
n = nsnode.find_node(nsparser.ATOM,
nsnode.string2node(nsutils.find_string("n")),
None)
mymod = nsnode.find_node(
nsparser.ATOM, nsnode.string2node(nsutils.find_string("mymod")),
None)
main = nsnode.find_node(
nsparser.ATOM, nsnode.string2node(nsutils.find_string("main")),
None)
minmod = nsnode.find_node(nsparser.DOT,
nsnode.find_node(nsparser.DOT, None, m),
inmod)
ftrans = nssexp.Expr_equal(
nssexp.Expr_next(inmod, st),
nssexp.Expr_or(inmod, nsnode.find_node(nsparser.DOT, my, inmod)),
st)
print(nsnode.sprint_node(ftrans))
res, err = nsparser.ReadNextExprFromString(
"next(inmod) = (inmod | my.inmod) IN n")
self.assertEqual(err, 0)
trans = car(res)
print(nsnode.sprint_node(trans))
conttrans = nsnode.find_node(nsparser.CONTEXT,
nsnode.find_node(nsparser.DOT, None, n),
ftrans)
print(nsnode.sprint_node(conttrans))
fflattrans = nscompile.Compile_FlattenSexp(st, conttrans, None)
flattrans = nscompile.Compile_FlattenSexp(st, trans, None)
print(nsnode.sprint_node(fflattrans))
print(nsnode.sprint_node(flattrans))
def test_load_and_flat_allow_encoding_with_command(self):
glob.load_from_file("tests/pynusmv/models/counters.smv")
glob.flatten_hierarchy()
ret = nscmd.Cmd_SecureCommandExecute("encode_variables")