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_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_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_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_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 test_run_checkctlspec(self):
from pynusmv.nusmv.cinit import cinit
from pynusmv.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_check_violated_spec(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute("read_model -i "
"tests/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_check_satisfied_spec(self):
# Initialize the model
ret = cmd.Cmd_SecureCommandExecute("read_model -i"
"tests/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/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_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_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_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")
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))