def test_spos(self,delaytest=False):
"""Run analysis and check if all expected spos are created."""
try:
for creffile in self.get_cref_files():
self.testresults.set_spos()
cfilename = creffile.name
cfilefilename = UF.get_cfile_filename(self.tgtxpath,cfilename)
if not os.path.isfile(cfilefilename):
raise XmlFileNotFoundError(xfilefilename)
capp = CApplication(self.sempath,cfilename=cfilename,contractpath=self.contractpath)
cappfile = capp.get_single_file()
capp.update_spos()
capp.collect_post_assumes()
spos = cappfile.get_spos()
if delaytest: continue
for cfun in creffile.get_functions():
fname = cfun.name
if self.saveref:
if cfun.has_spos():
print('Spos not created for ' + fname + ' in ' + cfilename +
' (delete first)')
else:
self.create_reference_spos(cfilename,fname,spos[fname])
else:
refspos = cfun.get_spos()
funspos = [ spo for spo in spos if spo.cfun.name == fname ]
if funspos is None and len(refspos) == 0:
self.testresults.add_spo_count_success(cfilename,fname)
elif len(refspos) == len(funspos):
self.testresults.add_spo_count_success(cfilename,fname)
self.check_spos(cfilename,fname,funspos,refspos)
else:
self.testresults.add_spo_count_error(
cfilename,fname,len(funspos),len(refspos))
raise FunctionSPOError(cfilename + ':' + fname + ' (' + str(len(funspos)) + ')')
except FunctionSPOError as detail:
self.print_test_results()
print('')
print('*' * 80)
print('Function SPO error: ' + str(detail))
print('*' * 80)
exit()
if self.saveref:
self.testsetref.save()
exit()
def test_ppos(self):
"""Create primary proof obligations and check if created as expected."""
if not os.path.isfile(self.config.canalyzer):
raise AnalyzerMissingError(self.config.canalyzer)
self.testresults.set_ppos()
saved = False
try:
for creffile in self.get_cref_files():
creffilename = creffile.name
creffilefilename = UF.get_cfile_filename(self.tgtxpath,creffilename)
if not os.path.isfile(creffilefilename):
raise XmlFileNotFoundError(creffilefilename)
capp = CApplication(self.sempath,cfilename=creffilename,contractpath=self.contractpath)
am = AnalysisManager(capp,onefile=True,verbose=self.verbose)
am.create_file_primary_proofobligations(creffilename)
cfile = capp.get_single_file()
capp.collect_post_assumes()
ppos = cfile.get_ppos()
for creffun in creffile.get_functions():
fname = creffun.name
cfun = cfile.get_function_by_name(fname)
if self.saveref:
if creffun.has_ppos():
print('Ppos not created for ' + fname + ' (delete first)')
else:
self.create_reference_ppos(creffilename,fname,cfun.get_ppos())
saved = True
else:
refppos = creffun.get_ppos()
funppos = [ ppo for ppo in ppos if ppo.cfun.name == fname ]
if len(refppos) == len(funppos):
self.testresults.add_ppo_count_success(creffilename,fname)
self.check_ppos(creffilename,fname,funppos,refppos)
else:
self.testresults.add_ppo_count_error(
creffilename,fname,len(funppos),len(refppos))
raise FunctionPPOError(creffilename + ':' + fname)
except FunctionPPOError as detail:
self.print_test_results()
print('Function PPO error: ' + str(detail))
exit()
if self.saveref and saved:
self.testsetref.save()
exit()
capp = CApplication(sempath,
contractpath=contractpath,
excludefiles=excludefiles)
# assume wordsize of 64
# use unreachability as a means of proof obligation discharge
am = AnalysisManager(capp,
wordsize=args.wordsize,
unreachability=True,
thirdpartysummaries=[UF.get_juliet_summaries()])
with timing('analysis of ' + args.path):
am.create_app_primary_proofobligations(processes=args.maxprocesses)
capp.collect_post_assumes()
for i in range(1):
am.generate_and_check_app('llrvisp', processes=args.maxprocesses)
capp.reinitialize_tables()
capp.update_spos()
for i in range(5):
capp.update_spos()
am.generate_and_check_app('llrvisp', processes=args.maxprocesses)
capp.reinitialize_tables()
def filefilter(filename):
return (not (filename in ["io", "main_linux", "std_thread"]))
with timing('summarize'):