class TestParserExtensibility(TestCase): def setUp(self): self.ts_parser = TSSmtLibParser() self.smt_parser = SmtLibParser() def test_wrong(self): txt = """ (declare-fun A () Bool) (declare-fun B () Bool) (assert (and A B)) (check-sat) (exit) """ with self.assertRaises(UnknownSmtLibCommandError): self.ts_parser.get_ts(cStringIO(txt)) script = self.smt_parser.get_script(cStringIO(txt)) self.assertIsNotNone(script) def test_basic(self): txt = """ (declare-fun A () Bool) (declare-fun B () Bool) (init (and A B)) (trans (=> A (next A))) (exit) """ with self.assertRaises(UnknownSmtLibCommandError): self.smt_parser.get_script(cStringIO(txt)) ts = self.ts_parser.get_ts(cStringIO(txt)) self.assertIsNotNone(ts)
class TestParserExtensibility(TestCase): def setUp(self): self.ts_parser = TSSmtLibParser() self.smt_parser = SmtLibParser() def test_wrong(self): txt = """ (declare-fun A () Bool) (declare-fun B () Bool) (assert (and A B)) (check-sat) (exit) """ with self.assertRaises(UnknownSmtLibCommandError): self.ts_parser.get_ts(StringIO(txt)) script = self.smt_parser.get_script(StringIO(txt)) self.assertIsNotNone(script) def test_basic(self): txt = """ (declare-fun A () Bool) (declare-fun B () Bool) (init (and A B)) (trans (=> A (next A))) (exit) """ with self.assertRaises(UnknownSmtLibCommandError): self.smt_parser.get_script(StringIO(txt)) ts = self.ts_parser.get_ts(StringIO(txt)) self.assertIsNotNone(ts)
def test_typing_define_fun(self): script = """ (define-fun x () Int 8.2) """ p = SmtLibParser() buffer = StringIO(script) with self.assertRaises(PysmtSyntaxError): p.get_script(buffer)
def test_incomplete_stream(self): txt = """ (declare-fun A () Bool) (declare-fun B () Bool) (assert (and A """ parser = SmtLibParser() with self.assertRaises(PysmtSyntaxError): parser.get_script(StringIO(txt))
def test_parse_exception(self): from pysmt.exceptions import PysmtSyntaxError smtlib_input = "(declare-const x x x Int)" +\ "(check-sat)" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) try: parser.get_script(buffer_) self.assertFalse(True) except PysmtSyntaxError as ex: self.assertEqual(ex.pos_info[0], 0) self.assertEqual(ex.pos_info[1], 19)
def test_parse_exception(self): from pysmt.exceptions import PysmtSyntaxError smtlib_input = "(declare-const x x x Int)" +\ "(check-sat)" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) try: parser.get_script(buffer_) self.assertFalse(True) except PysmtSyntaxError as ex: self.assertEqual(ex.pos_info[0], 0) self.assertEqual(ex.pos_info[1], 19)
def main(): config = parseArgs(sys.argv[1:]) logging.basicConfig(format='[%(name)s] %(levelname)s: %(message)s', level=config.getLogLevel()) folderName = os.path.join(os.path.dirname(__file__), 'smtlib') onlyfiles = [ os.path.join(folderName, f) for f in os.listdir(folderName) if os.path.isfile(os.path.join(folderName, f)) and f.endswith(".smt2") ] for filePath in onlyfiles: with open(filePath, "r") as f: print(filePath) reset_env() parser = SmtLibParser() parser._reset() script = parser.get_script(f) status = "unsat" for f in script.filter_by_command_name("set-info"): if f.args[0] == ":status": status = f.args[1] assert (status == "sat" or status == "unsat") a = AblectorSolver(get_env(), QF_AUFBV, config) script.evaluate(a) b = BoolectorSolver(get_env(), QF_AUFBV, generate_models=True) if a.last_result: # Check if assignment actually makes sense... assert (status == "sat") with open(filePath) as f: newScriptSrc = "" content = f.readlines() for line in content: if line.startswith(";ASSERT "): varName = line[8:].strip() print(varName + ": " + a.btor.Match_by_symbol(varName).assignment) newScriptSrc += "(assert (= " + varName + " #b" + a.btor.Match_by_symbol( varName).assignment + "))\n" else: newScriptSrc += line parser._reset() scriptWithValues = parser.get_script( io.StringIO(newScriptSrc)) scriptWithValues.evaluate(b) assert (b.last_result) print("SAT") else: assert (status == "unsat") print("UNSAT")
def collect_symbolic_path(log_path, project_path): """ This function will read the output log of a klee concolic execution and extract the partial path conditions """ emitter.normal("\textracting path conditions") ppc_list = list() last_sym_path = "" if os.path.exists(log_path): source_path = "" path_condition = "" with open(log_path, 'r') as trace_file: for line in trace_file: if '[path:ppc]' in line: if project_path in line or definitions.DIRECTORY_LIB in line: source_path = str(line.replace("[path:ppc]", '')).split(" : ")[0] source_path = source_path.strip() source_path = os.path.abspath(source_path) path_condition = str(line.replace("[path:ppc]", '')).split(" : ")[1] continue if source_path: if "(exit)" not in line: path_condition = path_condition + line else: ppc_list.append((source_path, path_condition)) last_sym_path = path_condition source_path = "" path_condition = "" # constraints['last-sym-path'] = last_sym_path # print(constraints.keys()) parser = SmtLibParser() script = parser.get_script(cStringIO(last_sym_path)) formula = script.get_last_formula() return ppc_list, formula
def test_define_funs_arg_and_fun(self): smtlib_script = "\n".join(['(define-fun f ((n Int)) Int n)', '(declare-fun n () Real)']) stream = cStringIO(smtlib_script) parser = SmtLibParser() _ = parser.get_script(stream) # No exceptions are thrown self.assertTrue(True)
def test_dumped_logic(self): # Dumped logic matches the logic in the example. # # There are a few cases where we use a logic # that does not exist in SMT-LIB, and the SMT-LIB # serialization logic will find a logic that # is more expressive. We need to adjust the test # for those cases (see rewrite dict below). rewrite = { logics.QF_BOOL: logics.QF_UF, logics.BOOL: logics.LRA, logics.QF_NIRA: logics.AUFNIRA, } fs = get_example_formulae() for (f_out, _, _, logic) in fs: buf_out = StringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = StringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) for cmd in script_in: if cmd.name == "set-logic": logic_in = cmd.args[0] self.assertEqual(logic_in, rewrite.get(logic, logic)) break else: # Loops exited normally print("-"*40) print(script_in)
def configure(inpcode, options): global solver global solver_name if ("pysmt" in options): solver_name = options["pysmt"] elif ("smtpipe" in options): solver_name = "custom: " + options["smtpipe"].split("/")[-1] solver_cmd = options["smtpipe"] # solver_logics = [BOOL, LIA, LRA, NIA, NRA, QF_LRA, QF_NIA, QF_NRA, QF_UFLIA, QF_UFLRA, QF_UFNIA, QF_UFNRA, UFLIRA, UFLRA, UFNIA, AUFNIRA] # solver_logics = [AUFNIRA] solver_logic = eval(options["pipe_logic"]) solver_logics = [solver_logic] env = get_env() env.factory.add_generic_solver(solver_name, solver_cmd, solver_logics) verbprint = utils.verbprint verbprint(2, "Parsing the input...", False) parser = SmtLibParser() script = parser.get_script(inpcode) formula = script.get_last_formula() # print "Got a formula: " + str(f) verbprint(2, "done.", True) verbprint(2, "Initializing the solver...", False) if ("smtpipe" in options): solver = Solver(name=solver_name, logic=solver_logic) #solver = SmtLibSolver(options["smtpipe"], env, LRA) else: solver = Solver(name=solver_name) verbprint(2, "done.", True) verbprint(2, "Loading the input file in the solver...", False) solver.add_assertion(formula) verbprint(2, "done.", True)
def test_dumped_logic(self): # Dumped logic matches the logic in the example fs = get_example_formulae() for (f_out, _, _, logic) in fs: buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) for cmd in script_in: if cmd.name == "set-logic": logic_in = cmd.args[0] if logic == logics.QF_BOOL: self.assertEqual(logic_in, logics.QF_UF) elif logic == logics.BOOL: self.assertEqual(logic_in, logics.LRA) else: self.assertEqual(logic_in, logic, script_in) break else: # Loops exited normally print("-"*40) print(script_in)
def test_dumped_logic(self): # Dumped logic matches the logic in the example fs = get_example_formulae() for (f_out, _, _, logic) in fs: buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) for cmd in script_in: if cmd.name == "set-logic": logic_in = cmd.args[0] if logic == logics.QF_BOOL: self.assertEqual(logic_in, logics.QF_UF) elif logic == logics.BOOL: self.assertEqual(logic_in, logics.LRA) else: self.assertEqual(logic_in, logic, script_in) break else: # Loops exited normally print("-" * 40) print(script_in)
def test_define_fun_serialize_complex_type(self): smtlib_script = '(define-fun f ((var (_ BitVec 32))) (_ BitVec 32) var)' stream = StringIO(smtlib_script) parser = SmtLibParser() script = parser.get_script(stream) # No exceptions are thrown self.assertEqual(smtlib_script.replace('var', '__var0'), script.commands[0].serialize_to_string())
def extract_var_relationship(var_expr_map): # preserve user-input : program variable relationship # include program variable names for program specification parser = SmtLibParser() relationship = None for expr_map in var_expr_map: prog_var_name, prog_var_expr = expr_map[0] angelic_var_name, angelic_var_expr = expr_map[1] prog_dependent_var_list = set( re.findall("\(select (.+?) \(_ ", prog_var_expr)) angelic_dependent_var_list = set( re.findall("\(select (.+?) \(_ ", angelic_var_expr)) dependent_var_list = set( list(prog_dependent_var_list) + list(angelic_dependent_var_list)) str_script = "(set-logic QF_AUFBV )\n" str_script += "(declare-fun " + prog_var_name + " () (Array (_ BitVec 32) (_ BitVec 8) ) )\n" for var_d in dependent_var_list: str_script += "(declare-fun " + var_d + " () (Array (_ BitVec 32) (_ BitVec 8) ) )\n" str_script += "(assert (= " + prog_var_expr + " " + angelic_var_expr + " ))\n" str_script += "(assert (= " + prog_var_name + " " + angelic_var_name + " ))\n" str_script += "(exit)\n" script = parser.get_script(cStringIO(str_script)) formula = script.get_last_formula() if not relationship: relationship = formula else: relationship = And(relationship, formula) return relationship
def test_define_funs_arg_and_fun(self): smtlib_script = "\n".join(['(define-fun f ((n Int)) Int n)', '(declare-fun n () Real)']) stream = StringIO(smtlib_script) parser = SmtLibParser() _ = parser.get_script(stream) # No exceptions are thrown self.assertTrue(True)
def test_parse_bvconst_width(self): smtlib_input = "(assert (> #x10 #x10))" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) expr = parser.get_script(buffer_).get_last_formula() const = expr.args()[0] self.assertEqual(const.bv_width(), 8, const.bv_width())
def test_parse_bvconst_width(self): smtlib_input = "(assert (> #x10 #x10))" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) expr = parser.get_script(buffer_).get_last_formula() const = expr.args()[0] self.assertEqual(const.bv_width(), 8, const.bv_width())
def test_parse_declare_const(self): smtlib_input = """ (declare-const s Int) (check-sat)""" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) script = parser.get_script(buffer_) self.assertIsNotNone(script)
def test_define_funs_same_args(self): # n is defined once as an Int and once as a Real smtlib_script = "\n".join(['(define-fun f ((n Int)) Int n)', '(define-fun f ((n Real)) Real n)']) stream = cStringIO(smtlib_script) parser = SmtLibParser() _ = parser.get_script(stream) # No exceptions are thrown self.assertTrue(True)
def test_define_funs_same_args(self): smtlib_script = "\n".join([ '(define-fun f ((n Int)) Int n)', '(define-fun f ((n Real)) Real n)' ]) stream = cStringIO(smtlib_script) parser = SmtLibParser() script = parser.get_script(stream)
def test_smtlib_define_fun_serialization(self): smtlib_input = "(define-fun init ((x Bool)) Bool (and x (and x (and x (and x (and x (and x x)))))))" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) s = parser.get_script(buffer_) for c in s: res = c.serialize_to_string(daggify=False) self.assertEqual(res.replace('__x0', 'x'), smtlib_input)
def test_smtlib_define_fun_serialization(self): smtlib_input = "(define-fun init ((x Bool)) Bool (and x (and x (and x (and x (and x (and x x)))))))" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) s = parser.get_script(buffer_) for c in s: res = c.serialize_to_string(daggify=False) self.assertEqual(res.replace('__x0', 'x'), smtlib_input)
def test_define_funs_same_args(self): # n is defined once as an Int and once as a Real smtlib_script = "\n".join(['(define-fun f ((n Int)) Int n)', '(define-fun f ((n Real)) Real n)']) stream = StringIO(smtlib_script) parser = SmtLibParser() _ = parser.get_script(stream) # No exceptions are thrown self.assertTrue(True)
def test_parse_declare_const(self): smtlib_input = """ (declare-const s Int) (check-sat)""" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) script = parser.get_script(buffer_) self.assertIsNotNone(script)
def bmc_summarize(smtin_filename="UNNAMED_in.smt2", smtout_filename="UNNAMED_out.smt2"): parser = SmtLibParser() with open(smtin_filename, 'r+') as f: smtlib = parser.get_script(f) asserts = list(smtlib.filter_by_command_name([smtcmd.ASSERT])) defs = list(smtlib.filter_by_command_name([smtcmd.DEFINE_FUN])) decls = list(smtlib.filter_by_command_name([smtcmd.DECLARE_FUN])) #print(smtlib.get_last_formula()) func_summary = None for stmt in asserts: #print(stmt) if stmt.args[0].is_iff() or stmt.args[0].is_equals(): assert stmt.args[0].arg(0).is_symbol() and stmt.args[0].arg(1) #print("Assertion on a symbolic equation.") symbol_table[stmt.args[0].arg(0).symbol_name()] = stmt.args[0].arg( 1) #pattern match for assertion on summary (PROPERTY: !(... = 0) ) if stmt.args[0].is_not(): safety_prop = stmt.args[0].arg(0) if (safety_prop.is_equals() or safety_prop.is_iff() ) and safety_prop.arg(1).is_bv_constant(0): func_summary = safety_prop.arg(0) summarizer = IdentityDagWalker() try: summary = summarizer.walk(func_summary) except: print("Could not summarize the summary.") import pdb pdb.set_trace() #Exception raised. #import pdb; pdb.set_trace() #PLAY WITH REPRESENTATION in pdb if desired #Print to stdout in SMTLib format: print(";Summary looks like:\n") print(summary.to_smtlib(False) + "\n") #Rewrite back into SMTLibScript, then print simplification back to file newscript = SmtLibScript() newscript.add(smtcmd.SET_OPTION, [':produce-models', 'true']) newscript.add(smtcmd.SET_LOGIC, ["QF_AUFBV"]) for decl in decls: newscript.add_command(decl) newscript.add( smtcmd.ASSERT, [Not(Equals(summary, BVZero(width=32))) ]) #NOTE: need the !(...=0) structure again, for the assertion newscript.add(smtcmd.CHECK_SAT, []) newscript.add(smtcmd.EXIT, []) with open(smtout_filename, 'w+') as f: newscript.serialize(f, daggify=False)
def test_parser_params(self): txt = """ (define-fun x ((y Int)) Bool (> y 0)) (declare-fun z () Int) (declare-fun y () Bool) (assert (and y (x z))) """ parser = SmtLibParser() script = parser.get_script(StringIO(txt)) self.assertEqual(len(get_env().formula_manager.get_all_symbols()), len(script.get_declared_symbols()) + len(script.get_define_fun_parameter_symbols()))
def test_complex_annotations_values(self): source ="""\ (declare-fun |"v__AT0"| () Bool) (define-fun .def_1 () Bool (! |"v__AT0"| :next (+ 1 meaningless))) """ buf = StringIO(source) parser = SmtLibParser() script = parser.get_script(buf) ann = script.annotations v0 = self.env.formula_manager.get_symbol('"v__AT0"') v1_str = next(iter(ann[v0]["next"])) self.assertEquals(v1_str, "(+ 1 meaningless)")
def test_annotations_colon_values(self): source ="""\ (declare-fun |"v__AT0"| () Bool) (define-fun .def_1 () Bool (! |"v__AT0"| :next :this_is_considered_a_value)) """ buf = StringIO(source) parser = SmtLibParser() script = parser.get_script(buf) ann = script.annotations v0 = self.env.formula_manager.get_symbol('"v__AT0"') v1_str = next(iter(ann[v0]["next"])) self.assertEquals(v1_str, ":this_is_considered_a_value")
def test_complex_annotations_values(self): source = """\ (declare-fun |"v__AT0"| () Bool) (define-fun .def_1 () Bool (! |"v__AT0"| :next (+ 1 meaningless))) """ buf = StringIO(source) parser = SmtLibParser() script = parser.get_script(buf) ann = script.annotations v0 = self.env.formula_manager.get_symbol('"v__AT0"') v1_str = next(iter(ann[v0]["next"])) self.assertEquals(v1_str, "(+ 1 meaningless)")
def test_annotations_colon_values(self): source = """\ (declare-fun |"v__AT0"| () Bool) (define-fun .def_1 () Bool (! |"v__AT0"| :next :this_is_considered_a_value)) """ buf = StringIO(source) parser = SmtLibParser() script = parser.get_script(buf) ann = script.annotations v0 = self.env.formula_manager.get_symbol('"v__AT0"') v1_str = next(iter(ann[v0]["next"])) self.assertEquals(v1_str, ":this_is_considered_a_value")
def test_nary_bvconcat(self): txt = """ (set-logic QF_BV ) (declare-fun INPUT () (Array (_ BitVec 32) (_ BitVec 8) ) ) (declare-fun A () (_ BitVec 64))(assert (= A (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) (select INPUT #x00000000))) #x0000000000000000)))) (declare-fun B () (_ BitVec 64))(assert (= B (concat ((_ extract 63 56) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) ((_ extract 7 0) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) (select INPUT #x00000000))) #x0000000000000000))))) #x0000000000000000))) ((_ extract 55 48) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) ((_ extract 7 0) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) (select INPUT #x00000000))) #x0000000000000000))))) #x0000000000000000))) ((_ extract 47 40) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) ((_ extract 7 0) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) (select INPUT #x00000000))) #x0000000000000000))))) #x0000000000000000))) ((_ extract 39 32) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) ((_ extract 7 0) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) (select INPUT #x00000000))) #x0000000000000000))))) #x0000000000000000))) ((_ extract 31 24) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) ((_ extract 7 0) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) (select INPUT #x00000000))) #x0000000000000000))))) #x0000000000000000))) ((_ extract 23 16) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) ((_ extract 7 0) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) (select INPUT #x00000000))) #x0000000000000000))))) #x0000000000000000))) ((_ extract 15 8) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) ((_ extract 7 0) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) (select INPUT #x00000000))) #x0000000000000000))))) #x0000000000000000))) ((_ extract 7 0) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) ((_ extract 7 0) (bvor #x0000000000000000 (bvshl ((_ zero_extend 32) ((_ zero_extend 24) (select INPUT #x00000000))) #x0000000000000000))))) #x0000000000000000)))))) (assert (= A B)) (check-sat)""" parser = SmtLibParser() script = parser.get_script(StringIO(txt)) f_in = script.get_last_formula() self.assertSat(f_in)
def test_int_promotion_define_fun(self): script = """ (define-fun x () Int 8) (define-fun y () Real 8) """ p = SmtLibParser() buffer = StringIO(script) s = p.get_script(buffer) get_type = get_env().stc.get_type for cmd in s: self.assertEqual(cmd.args[2], get_type(cmd.args[3]))
def test_parse_examples_daggified(self): fs = get_example_formulae() for (f_out, _, _, _) in fs: buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out, daggify=True) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertEqual(f_in, f_out)
def extract_formula_from_file(spec_file_path): spec_dir_path = "/".join(spec_file_path.split("/")[:-1]) spec_file_name = spec_file_path.split("/")[-1] current_dir = os.getcwd() os.chdir(spec_dir_path) # emitter.normal("\textracting program specification") smt_parser = SmtLibParser() assertion_formula = None with Path(spec_file_name).open() as f: script = smt_parser.get_script(f) assertion_formula = script.get_last_formula() os.chdir(current_dir) return assertion_formula
def test_interpreting_annotations(self): source = """\ (declare-fun |"v__AT0"| () Bool) (declare-fun |"v__AT1"| () Bool) (define-fun .def_1 () Bool (! |"v__AT0"| :next |"v__AT1"|)) """ buf = StringIO(source) parser = SmtLibParser() script = parser.get_script(buf) ann = script.annotations v0 = self.env.formula_manager.get_symbol('"v__AT0"') v1_str = next(iter(ann[v0]["next"])) self.env.formula_manager.get_symbol(v1_str) self.assertEquals(v1_str, '"v__AT1"')
def test_string_constant_quote_escaping_parsing(self): script = """ (declare-const x String) (assert (= x "a""b")) (assert (= x "\"\"")) (assert (= x "\"\"\"\"")) """ p = SmtLibParser() buffer = cStringIO(script) s = p.get_script(buffer) self.assertEqual('a"b', s.commands[1].args[0].arg(1).constant_value()) self.assertEqual('"', s.commands[2].args[0].arg(1).constant_value()) self.assertEqual('""', s.commands[3].args[0].arg(1).constant_value())
def test_string_constant_quote_escaping_parsing(self): script = """ (declare-const x String) (assert (= x "a""b")) (assert (= x "\"\"")) (assert (= x "\"\"\"\"")) """ p = SmtLibParser() buffer = cStringIO(script) s = p.get_script(buffer) self.assertEqual('a"b', s.commands[1].args[0].arg(1).constant_value()) self.assertEqual('"', s.commands[2].args[0].arg(1).constant_value()) self.assertEqual('""', s.commands[3].args[0].arg(1).constant_value())
def do_parse(self, smt_file): parser = SmtLibParser() smt = open(smt_file, 'r') smt_raw = smt.read() smt.close() try: smt_script = parser.get_script(cStringIO(smt_raw)) except Exception as exc: self.logger.error("parse(): {}".format(exc)) return None return smt_script
def test_interpreting_annotations(self): source ="""\ (declare-fun |"v__AT0"| () Bool) (declare-fun |"v__AT1"| () Bool) (define-fun .def_1 () Bool (! |"v__AT0"| :next |"v__AT1"|)) """ buf = StringIO(source) parser = SmtLibParser() script = parser.get_script(buf) ann = script.annotations v0 = self.env.formula_manager.get_symbol('"v__AT0"') v1_str = next(iter(ann[v0]["next"])) self.env.formula_manager.get_symbol(v1_str) self.assertEquals(v1_str, '"v__AT1"')
def assertion_stack_to_tree_list(self, assertions): sl = assertions.split("(assert") asserts = ["(assert" + x for x in sl[1:]] if len(asserts) > 50: asserts[-100] = "\n".join(asserts[:-49]) asserts = asserts[-50:] asserts_bool = [] new_str = sl[0] for assertion in asserts: if "assert" not in assertion: continue if assertion.count("\n") > 40 or assertion.count("assert") > 1: asserts_bool.append(True) else: asserts_bool.append(False) new_str += assertion assertions = new_str ind = 0 try: smt_parser = SmtLibParser() script = smt_parser.get_script(cStringIO(assertions)) except: return try: assert_list = script.commands command_ind = 0 while (command_ind < len(assert_list) and assert_list[command_ind].name != "assert"): command_ind += 1 for assert_ind in range(len(asserts)): if asserts_bool[assert_ind] == True: new_tree = self.assertion_to_tree(None, asserts[assert_ind]) else: new_tree = self.assertion_to_tree(assert_list[command_ind], asserts[assert_ind]) command_ind += 1 if new_tree != None: self.tree_list.append(new_tree) # for command in assert_list: # if command.name == "assert": # new_tree = self.assertion_to_tree(command, asserts[ind]) # if new_tree != None: # self.tree_list.append(new_tree) # ind += 1 assert_list = None except: traceback.print_exc() return
def test_parse_examples_daggified_bv(self): fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic != logics.QF_BV: # See test_parse_examples_daggified continue buf_out = StringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out, daggify=True) buf_in = StringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertValid(Iff(f_in, f_out), f_in.serialize())
def test_parse_examples_daggified_bv(self): fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic != logics.QF_BV: # See test_parse_examples_daggified continue buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out, daggify=True) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertValid(Iff(f_in, f_out), f_in.serialize())
def test_parse_examples(self): fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic == logics.QF_BV: # See test_parse_examples_bv continue buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertEqual(f_in.simplify(), f_out.simplify())
def test_parse_bvx_var(self): """bvX is a valid identifier.""" smtlib_input = """ (declare-fun bv1 () (_ BitVec 8)) (assert (bvult (_ bv0 8) (bvmul (bvadd bv1 (_ bv1 8)) (_ bv5 8)))) (check-sat)""" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) script = parser.get_script(buffer_) # Check Parsed result iscript = iter(script) cmd = next(iscript) self.assertEqual(cmd.name, DECLARE_FUN) bv1 = cmd.args[0] self.assertEqual(bv1.symbol_type().width, 8) cmd = next(iscript) parsed_f = cmd.args[0] target_f = BVULT(BV(0, 8), BVMul(BVAdd(bv1, BV(1, 8)), BV(5, 8))) self.assertEqual(parsed_f, target_f)
def test_parse_examples_bv(self): """For BV we represent a superset of the operators defined in SMT-LIB. We verify the correctness of the serialization process by checking the equivalence of the original and serialized expression. """ fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic != logics.QF_BV: continue buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertValid(Iff(f_in, f_out))
def test_declare_sort(self): class SmtLibIgnore(SmtLibIgnoreMixin): declare_sort_history = [] def declare_sort(self, name, arity): self.declare_sort_history.append((name, arity)) mock = SmtLibIgnore() parser = SmtLibParser() smtlib_script = '\n'.join(['(declare-sort s0 0)', \ '(declare-sort s1 1)', \ '(declare-const c0 s0)', \ '(declare-const c1 (s1 Int))']) outstream = cStringIO(smtlib_script) script = parser.get_script(outstream) script.evaluate(solver=mock) self.assertEqual(len(mock.declare_sort_history), 2) s0_name, s0_arity = mock.declare_sort_history[0] s1_name, s1_arity = mock.declare_sort_history[1] self.assertEqual(s0_name, "s0") self.assertEqual(s0_arity, 0) self.assertEqual(s1_name, "s1") self.assertEqual(s1_arity, 1)
(assert (=> y (> q p))) (check-sat) (assert .def_1) (check-sat) (pop) (check-sat) """ # We read the SMT-LIB Script by creating a Parser. # From here we can get the SMT-LIB script. parser = SmtLibParser() # The method SmtLibParser.get_script takes a buffer in input. We use # cStringIO to simulate an open file. # See SmtLibParser.get_script_fname() if to pass the path of a file. script = parser.get_script(cStringIO(DEMO_SMTLIB)) # The SmtLibScript provides an iterable representation of the commands # that are present in the SMT-LIB file. # # Printing a summary of the issued commands for cmd in script: print(cmd.name) print("*"*50) # SmtLibScript provides some utilities to perform common operations: e.g, # # - Checking if a command is present assert script.contains_command("check-sat") # - Counting the occurrences of a command assert script.count_command_occurrences("assert") == 3
def test_define_funs_same_args(self): smtlib_script = "\n".join(['(define-fun f ((n Int)) Int n)', '(define-fun f ((n Real)) Real n)']) stream = cStringIO(smtlib_script) parser = SmtLibParser() script = parser.get_script(stream)
def test_parse_define_fun_bind(self): smtlib_input = "(declare-fun y () Bool)"\ "(define-fun .def_1 ((z Bool)) Bool (and z z))" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) parser.get_script(buffer_)
def test_define_funs_arg_and_fun(self): smtlib_script = "\n".join(['(define-fun f ((n Int)) Int n)', '(declare-fun n () Real)']) stream = cStringIO(smtlib_script) parser = SmtLibParser() script = parser.get_script(stream)
def main(opts): start = time.time() parser = SmtLibParser() with open(opts.filename) as src: script = parser.get_script(src) assertions = [cmd.args[0] for cmd in script.filter_by_command_name(commands.ASSERT)] ground, quantified = [], [] strings = set() flags = set() for f in assertions: if f.is_forall(): assert f.arg(0).is_implies(), f quantified.append(f) flags |= collect_flags(f) else: ground.append(f) strings |= collect_strings(f) info('; Got %d assertions, %d ground and %d quantified, and %d strings', len(assertions), len(ground), len(quantified), len(strings)) index_set = {} cur = assertions i = 1 seen = set() mainsolver = Solver(name=opts.solver, logic=logics.QF_AUFBV) modelsolver = Solver(name=opts.solver, logic=logics.QF_AUFBV) for g in ground: mainsolver.add_assertion(g) while True: info('; iteration %d...', i) i += 1 info('; computing index set from %d formulas', len(cur)) index_set = {} for formula in cur: d = get_index_set(formula) index_set.update(d) cur = [] for s in index_set: for e in index_set[s]: for axiom in quantified: inst = instantiate(axiom, s, e) if inst is not None and inst not in seen: cur.append(inst) seen.add(inst) info('; adding %d instantiations...', len(cur)) model = get_ground_model(mainsolver, ground, cur) if model is None: show("unsat") break else: ok, extra = is_good(modelsolver, model, strings, flags, quantified) if ok: if VERBOSITY > 0: show_model(model, extra) show("sat") if opts.get_values: for cmd in \ script.filter_by_command_name(commands.GET_VALUE): try: vals = ["(%s %s)" % (to_smt(t), to_smt(model.get_value(t))) for t in cmd.args] show("(%s)", " ".join(vals)) except Exception, e: show('(error "%s")', str(e).replace('"', '\\"')) break else: for (qv, v, axiom) in extra: for inst in get_instances(opts, model, strings, qv, v, axiom): if inst not in seen: cur.append(inst) seen.add(inst) mainsolver.add_assertion(inst)