def get_setting(session, name, force_default=False): schema = SCHEMA.get(name) if not schema: raise KeyError("No such setting %s" % name) if not force_default: setting = session.query(model.SystemConfig).get(name) else: setting = None if setting: if setting.value is not None: if schema['type'] == 'numerical': return float(setting.value) elif schema['type'] == 'boolean': return setting.value.lower() == 'true' else: return setting.value elif setting.data is not None: return setting.data elif 'default_value' in schema: return schema['default_value'] elif 'default_file_path' in schema: path = os.path.join(get_package_dir(), schema['default_file_path']) with open(path, 'rb') as f: return f.read() raise KeyError("No such setting %s" % name)
def configure_logging(): package_dir = get_package_dir() logconf_path = os.path.join(package_dir, "logging.cfg") if not os.path.exists(logconf_path): print("Warning: log config file %s does not exist." % logconf_path) else: logging.config.fileConfig(logconf_path)
def get_resource(name, context=None): ''' @param name - the name of the resource to load, without the file extension. ''' if (name, context) in cache: return cache[(name, context)] if name in cache: config = cache[name] else: directory = get_package_dir() conf_path_stem = '%s/%s' % (directory, name) extensions = ('yml', 'yaml', 'json') for ext in extensions: conf_path = '%s.%s' % (conf_path_stem, ext) try: with open(conf_path) as f: config = yaml.load(f) break except FileNotFoundError: continue else: raise FileNotFoundError("No resource like %s.{%s}" % (conf_path_stem, ','.join(extensions))) cache[name] = config if context is not None: config = [d for d in config if d.get('context', context) == context] cache[(name, context)] = config return config
def run_randoop(projectCP, class_name, randoop_jar_path, testdir, search_budget): def remove_randoop_error_test(testdir): for test in os.listdir(testdir): if "ErrorTest" in test: test_file = os.path.join(testdir, test) os.unlink(test_file) #if not test_file.endswith(".java"): # continue #if not test[-1:].isdigit(): # Randoop generates a test file without tests. # continue """def change_class_name(test_dir, new_classname): utils.rename_class(test_dir, "RegressionTest", new_classname)""" utils.make_dirs_if_not_exist(testdir) sep = os.path.pathsep err_file = os.path.join(testdir, "err.txt") out_file = os.path.join(testdir, "out.txt") package = class_name.split(".")[0:-1] packages_dir = utils.get_package_dir(package) command = 'java -classpath {}{}{} randoop.main.Main gentests --testclass={} --time-limit={} --usethreads=true --junit-package-name={} --npe-on-non-null-input=expected --junit-output-dir={} > {} 2> {}'.format( projectCP, sep, randoop_jar_path, class_name, search_budget, packages_dir.replace(os.path.sep, ".")[:-1], testdir, out_file, err_file) utils.print_command(command) try: subprocess.check_output(command, shell=True) except Exception as e: print("Error al correr randoop con el comando '{}'".format(command, e)) testdir_full = os.path.join(testdir, packages_dir) remove_randoop_error_test(testdir_full)
def get_minimal_settings(): package_dir = get_package_dir() return { "template_path": os.path.join(package_dir, "..", "client"), "login_url": "/login/", "cookie_secret": 'dummy' }
def get_file_path_jncss(strategy, class_name, test_dir, results_dir_name, bug_type, stopping_condition, search_budget, criterion, runid, javancss_jar_path): package = class_name.split(".")[0:-1] package_dir = utils.get_package_dir(package) if "randoop".upper() in criterion.upper(): only_class_name = "RegressionTest?.java" #Randoop genera varios .java, c/u con 500 tests else: only_class_name = class_name.split(".")[-1] + "_ESTest.java" test_suite_file_path = os.path.join(test_dir, package_dir, only_class_name) result_jncss_temp = os.path.join( results_dir_name, "javancss_temp", "{}_{}_{}_{}_{}_{}".format(strategy, bug_type, stopping_condition, search_budget, class_name, criterion)) utils.make_dirs_if_not_exist(result_jncss_temp) result_jncss_temp = os.path.join(result_jncss_temp, "{}.txt".format(runid)) command = "java -jar {} {} > {}".format(javancss_jar_path, test_suite_file_path, result_jncss_temp) utils.print_command(command) utils.lock_if_windows() try: subprocess.check_output(command, shell=True) except Exception as e: print("Error al ejecutar el comando '{}'. Error {}".format(command, e)) finally: utils.release_if_windows() return result_jncss_temp
def workaround_test(test_dir, class_name, file_name, add_fails, assert_type): packages = class_name.split(".")[0:-1] packages_dir = utils.get_package_dir(packages) java_file = os.path.join(test_dir, packages_dir, file_name) utils.replace_assert_catch_in_test(java_file, assert_type) if (add_fails): utils.add_fails_in_test(java_file)
def cp_testsuite_if_exists_in_other_results(curr_bug_type, subdir_testgen, generated_test_report_evosuite_dir, class_name, name): other_bug_type = BugType.ALL.name.lower() if ( curr_bug_type.upper() == BugType.ERRPROT.name) else BugType.ERRPROT.name.lower() other_generated_test_dir = subdir_testgen.replace(curr_bug_type, other_bug_type) other_generated_test_report_evosuite_dir = generated_test_report_evosuite_dir.replace( curr_bug_type, other_bug_type) test_file_path = os.path.join( other_generated_test_dir, "test", utils.get_package_dir(class_name.split(".")[0:-1]), name + "_ESTest.java") testsuite_exists = check_if_exists_testgendir_in_other_bug_type( other_generated_test_dir, other_generated_test_report_evosuite_dir, class_name, test_file_path) if (testsuite_exists): if os.path.exists(subdir_testgen): shutil.rmtree(subdir_testgen) shutil.copytree(other_generated_test_dir, subdir_testgen) print("copy {}".format(test_file_path)) #if other_bug_type == ERRPROT, then i need to move original test file (with asserts) if (other_bug_type.upper() == BugType.ERRPROT.name): test_file_path = test_file_path.replace(other_bug_type, curr_bug_type) os.unlink(test_file_path) shutil.move(test_file_path + ".original", test_file_path) return testsuite_exists
def read_app_version(): package_dir = get_package_dir() try: with open(os.path.join(package_dir, '..', 'version.txt')) as f: version = f.readline().strip() except FileNotFoundError: version = None template.aq_version = version
def exist_subject(bin_original_code_dir, bin_instrumented_code_dir, class_name): package_dir = utils.get_package_dir(class_name.split(".")[0:-1]) if os.path.exists(os.path.join( bin_original_code_dir, package_dir)) and os.path.exists( os.path.join(bin_instrumented_code_dir, package_dir)): return True return False
def bower_versions(): if '_bower_versions' in cache: return cache['_bower_versions'] directory = os.path.join(get_package_dir(), '..', 'client', 'bower_components') versions = {} for path in Path(directory).glob('*/.bower.json'): with path.open() as f: component_meta = yaml.load(f) if 'version' in component_meta: name = component_meta['name'] name = name.replace('-', '_') versions[name] = component_meta['version'] cache['_bower_versions'] = versions return versions
def cp_testsuite_if_exists_in_other_results(curr_bug_type, subdir_testgen, generated_test_report_evosuite_dir, class_name, criterion): other_bug_type = BugType.ALL.name.lower() if ( curr_bug_type.upper() == BugType.ERRPROT.name) else BugType.ERRPROT.name.lower() other_generated_test_dir = subdir_testgen.replace(curr_bug_type, other_bug_type) other_generated_test_report_evosuite_dir = generated_test_report_evosuite_dir.replace( curr_bug_type, other_bug_type) other_full_test_dir = os.path.join( other_generated_test_dir, "test", utils.get_package_dir(class_name.split(".")[0:-1])) testsuite_exists = check_if_exists_testgendir_in_other_bug_type( other_generated_test_report_evosuite_dir, other_full_test_dir, criterion) if (testsuite_exists): if os.path.exists(subdir_testgen): shutil.rmtree(subdir_testgen) shutil.copytree(other_generated_test_dir, subdir_testgen) print("TEST ALREADY GENERATED! copying from {}".format( other_generated_test_dir)) #if other_bug_type == ERRPROT, then i need to move original test file (with asserts) if (other_bug_type.upper() == BugType.ERRPROT.name): curr_full_test_dir = other_full_test_dir.replace( other_bug_type, curr_bug_type) for test_file_name in os.listdir(curr_full_test_dir): if not test_file_name.endswith(".original"): test_file_path = os.path.join(curr_full_test_dir, test_file_name) os.unlink(test_file_path) for test_file_name in os.listdir(curr_full_test_dir): if test_file_name.endswith(".original"): #test_file_path = test_file_path.replace(other_bug_type, curr_bug_type) #os.unlink(test_file_path) test_file_path = os.path.join(curr_full_test_dir, test_file_name) shutil.move(test_file_path, test_file_path.replace(".original", "")) return testsuite_exists
def setup_mujava(origin_mutants_dir, subject_name, subdir_mutants, original_code_dir): def mk_and_cp_operator_mutant_dir(src_dir, subject_name, operator_dir_name, packages_dir): new_dirs = os.path.join(subdir_mutants, subject_name, operator_dir_name) new_dirs_packages = os.path.join(new_dirs, packages_dir) src_dir = os.path.join(src_dir, operator_dir_name) # si existe el directorio, ya deberia contener los .class, entonces no copio los mutantes ni compilo if not os.path.exists(new_dirs): shutil.copytree(src_dir, new_dirs_packages) utils.compile_workdir(new_dirs, new_dirs, new_dirs, original_code_dir) print("Setting up mujava...") packages = subject_name.split(".")[0:-1] packages_dir = utils.get_package_dir(packages) class_mutant_dir = os.path.join(origin_mutants_dir, "class_mutants") traditional_mutant_dir = os.path.join(origin_mutants_dir, "traditional_mutants") for operator_dir_name in os.listdir(class_mutant_dir): if not os.path.isdir(os.path.join(class_mutant_dir, operator_dir_name)): continue mk_and_cp_operator_mutant_dir(class_mutant_dir, subject_name, operator_dir_name, packages_dir) for method_dir_name in os.listdir(traditional_mutant_dir): method_dir = os.path.join(traditional_mutant_dir, method_dir_name) if not os.path.isdir(method_dir): continue for operator_dir_name in os.listdir(method_dir): if not os.path.isdir(os.path.join(method_dir, operator_dir_name)): continue mk_and_cp_operator_mutant_dir(method_dir, subject_name, operator_dir_name, packages_dir) print("Mujava setup ready!")
def start_web_server(): settings = get_settings() default_settings() application = tornado.web.Application(get_mappings(), **settings) try: # If port is a string, *some* GNU/Linux systems try to look up the port # in /etc/services. So try to interpret it as an integer. # http://www.ducea.com/2006/09/11/error-servname-not-supported-for-ai_socktype/ # https://github.com/pika/pika/issues/352#issuecomment-18704043 port = int(tornado.options.options.port) except ValueError: port = tornado.options.options.port max_buffer_size = 10 * 1024**2 # 10MB config_dir = os.path.join(get_package_dir(), '..', 'config') if os.path.isfile(os.path.join(config_dir, "fullchain.pem")): # Some certificate. `fullchain.pem` should contain all the certificates # concatenated together: # https://docs.python.org/3.4/library/ssl.html#certificate-chains ssl_opts = { "certfile": os.path.join(config_dir, "fullchain.pem"), "keyfile": os.path.join(config_dir, "privkey.pem") } elif os.path.isdir("/etc/letsencrypt/live/aquamark"): # Certificate provided by Let's Encrypt ssl_opts = { "certfile": "/etc/letsencrypt/live/aquamark/fullchain.pem", "keyfile": "/etc/letsencrypt/live/aquamark/privkey.pem" } else: ssl_opts = None if ssl_opts is not None: logging.getLogger('tornado.general').addFilter(ssl_log_filter) # Disable old, vulnerable SSL versions # https://blog.qualys.com/ssllabs/2014/10/15/ssl-3-is-dead-killed-by-the-poodle-attack ssl_opts['ciphers'] = 'DEFAULT:!SSLv2:!SSLv3:!RC4:!EXPORT:!DES' http_server = tornado.httpserver.HTTPServer(application, max_body_size=max_buffer_size, ssl_options=ssl_opts) http_server.listen(port) if log.isEnabledFor(logging.INFO): log.info("Tornado version: %s", tornado.version) log.debug("Tornado settings: %s", settings) log.info("Starting web application. Will be available on port %s", port) hostname = socket.gethostname() ip = None try: # Try to get Docker container IP with open('/etc/hosts', 'r') as f: for line in f: match = re.match(r'^(\S+)\s+%s$' % hostname, line) if match: ip = match.group(1) break except OSError: pass protocol = ssl_opts and 'https' or 'http' log.info("Try opening %s://%s:%s", protocol, hostname, port) if ip: log.info(" or %s://%s:%s", protocol, ip, port) log.info("Bound to: %s:%s", ip, port) tornado.ioloop.IOLoop.instance().start()
def get_mappings(): package_dir = get_package_dir() return [ (r"/login/?", authn.LoginHandler, { 'path': os.path.join(package_dir, "..", "client") }), (r"/impersonate/(.*)", authn.ImpersonateHandler, {}), (r"/logout/?", authn.LogoutHandler), (r"/()", template.TemplateHandler, { 'path': '../client/templates/' }), (r"/(.*\.html)", tornado.web.StaticFileHandler, { 'path': os.path.join(package_dir, "../client/templates/") }), (r"/(manifest.json|css/user_style.css)", template.UnauthenticatedTemplateHandler, { 'path': '../client/' }), (r"/ping.*", protocol.PingHandler, {}), (r"/bower_components/(.*)", tornado.web.StaticFileHandler, { 'path': os.path.join(package_dir, "..", "client", "bower_components") }), (r"/minify/(.*)", compile_handlers.MinifyHandler, { 'path': '/minify/', 'root': os.path.join(package_dir, "..", "client") }), (r"/(.*\.css)", compile_handlers.CssHandler, { 'root': os.path.join(package_dir, "..", "client") }), (r"/images/icon-(.*)\.png", crud.image.IconHandler, {}), (r"/systemconfig.json", crud.config.SystemConfigHandler, {}), (r"/systemconfig/(.*)", crud.config.SystemConfigItemHandler, {}), (r"/custom_query/?([^/]*).json", crud.custom.CustomQueryHandler, {}), (r"/custom_query/?([^/]*)/history.json", crud.custom.CustomQueryHistoryHandler, {}), (r"/geo/(.*).json", crud.org.LocationSearchHandler, {}), (r"/surveygroup/?([^/]*).json", crud.surveygroup.SurveyGroupHandler, {}), (r"/surveygroup/icon/([^/]*)", crud.surveygroup.SurveyGroupIconHandler, {}), (r"/organisation/?([^/]*).json", crud.org.OrgHandler, {}), (r"/organisation/?([^/]*)/survey/?([^/]*).json", crud.org.PurchasedSurveyHandler, {}), (r"/user/?([^/]*).json", crud.user.UserHandler, {}), (r"/subscription/()([^/]*).json", crud.activity.SubscriptionHandler, {}), (r"/subscription/([^/]*)/(.*).json", crud.activity.SubscriptionHandler, {}), (r"/activity/?([^/]*).json", crud.activity.ActivityHandler, {}), (r"/card.json", crud.activity.CardHandler, {}), (r"/password.json", crud.user.PasswordHandler, {}), (r"/program/?([^/]*).json", crud.program.ProgramHandler, {}), (r"/program/?([^/]*)/history.json", crud.program.ProgramTrackingHandler, {}), (r"/survey/?([^/]*).json", crud.survey.SurveyHandler, {}), (r"/survey/?([^/]*)/program.json", crud.program.ProgramHistoryHandler, { 'mapper': model.Survey }), (r"/qnode/?([^/]*).json", crud.qnode.QuestionNodeHandler, {}), (r"/qnode/?([^/]*)/program.json", crud.program.ProgramHistoryHandler, { 'mapper': model.QuestionNode }), (r"/measure/?([^/]*).json", crud.measure.MeasureHandler, {}), (r"/measure/?([^/]*)/program.json", crud.program.ProgramHistoryHandler, { 'mapper': model.Measure }), (r"/response_type/?([^/]*).json", crud.response_type.ResponseTypeHandler, {}), (r"/response_type/?([^/]*)/program.json", crud.program.ProgramHistoryHandler, { 'mapper': model.ResponseType }), (r"/submission/?([^/]*).json", crud.submission.SubmissionHandler, {}), (r"/submission/([^/]*)/rnode/?([^/]*).json", crud.rnode.ResponseNodeHandler, {}), (r"/submission/([^/]*)/response/?([^/]*).json", crud.response.ResponseHandler, {}), (r"/submission/([^/]*)/response/?([^/]*)/history.json", crud.response.ResponseHistoryHandler, {}), (r"/submission/([^/]*)/measure/([^/]*)/attachment.json", crud.attachment.ResponseAttachmentsHandler, {}), (r"/submission/([^/]*)/measure/([^/]*)/submeasure/([^/]*)/attachment.json", crud.attachment.ResponseSubmeasureAttachmentsHandler, {}), (r"/attachment/([^/]*)(?:/(.*))?", crud.attachment.AttachmentHandler, {}), (r"/report/sub/stats/program/([^/]*)/survey/([^/]*).json", StatisticsHandler, {}), (r"/report/diff.json", DiffHandler, {}), (r"/report/prog/export/([^/]*)/survey/([^/]*)/([^.]+)\.(.+)", ExportProgramHandler, {}), (r"/report/exportAssetReport/([^/]*)/survey/([^/]*)/program/([^/]*)/([^.]+)\.(.+)", ExportAssetHandler, {}), (r"/report/sub/temporal/([^/]*)\.(.+)", TemporalReportHandler, {}), (r"/report/sub/export/([^/]*)/([^.]+)\.(.+)", ExportSubmissionHandler, {}), (r"/report/custom_query/reformat\.sql", report.custom.SqlFormatHandler, {}), (r"/report/custom_query/identifiers\.json", report.custom.SqlIdentifierHandler, {}), (r"/report/custom_query/preview\.(.+)", report.custom.CustomQueryPreviewHandler, {}), (r"/report/custom_query/config\.json", report.custom.CustomQueryConfigHandler, {}), (r"/report/custom_query/([^.]+)/\w+\.(.+)", report.custom.CustomQueryReportHandler, {}), (r"/import/structure.json", ImportStructureHandler, {}), (r"/import/submission.json", ImportSubmissionHandler, {}), (r"/redirect", protocol.RedirectHandler), (r"/remap.json", crud.remap.IdMapperHandler), # test use session to keep status #(r"/status", authn.StatusHandler), ######################## (r"/(.*)", tornado.web.StaticFileHandler, { 'path': os.path.join(package_dir, "..", "client") }), ]
def run(self): if self.method in [ EpatestingMethod.ONLY_TESTGEN.value, EpatestingMethod.BOTH.value, EpatestingMethod.BOTH_WITHOUT_MUJAVA.value ]: print('GENERATING TESTS') code_dir = self.instrumented_code_dir if "epa".upper( ) in self.criterion.upper() else self.original_code_dir if "mining".upper() in self.criterion.upper( ) or "Compiler_" in self.name: #hack for Compiler code_dir = self.mining_code_dir bin_code_dir = self.bin_instrumented_code_dir if "epa".upper( ) in self.criterion.upper() else self.bin_original_code_dir if "mining".upper() in self.criterion.upper( ) or "Compiler_" in self.name: #hack for Compiler bin_code_dir = self.bin_mining_code_dir if len(self.extra_classpath) != 0: bin_code_dir += os.path.pathsep + self.extra_classpath # if exists testsuite in other bug_type, copy it! testsuite_exists = False curr_bug_type = self.bug_type try: lock.acquire() testsuite_exists = cp_testsuite_if_exists_in_other_results( curr_bug_type, self.subdir_testgen, self.generated_test_report_evosuite_dir, self.class_name, self.criterion) except Exception as e: testsuite_exists = False print( "error copying from other bug_type folder to {}. Error {}". format(self.subdir_testgen, e)) finally: lock.release() if (not testsuite_exists): if self.criterion == "randoop": run_randoop(projectCP=bin_code_dir, class_name=self.class_name, randoop_jar_path=self.randoop_jar_path, testdir=self.generated_test_dir, search_budget=self.search_budget) else: run_evosuite( evosuite_jar_path=self.evosuite_jar_path, strategy=self.strategy_value, projectCP=bin_code_dir, class_name=self.class_name, criterion=self.criterion, epa_path=self.epa_path, inferred_epa_xml_path=self.inferred_epa_xml, test_dir=self.generated_test_dir, stopping_condition=self.stopping_condition, search_budget=self.search_budget, report_dir=self.generated_test_report_evosuite_dir) add_fails = False if (self.bug_type.upper() == BugType.ERRPROT.name): # If is run in errprot mode, then always remove asserts and specific exceptions self.assert_type = AssertType.NO_ASSERT_EXCEPTION.name #if("JDBCResultSet" in self.name): #add_fails= True; if self.assert_type.upper() in [ AssertType.NO_ASSERT.name, AssertType.NO_ASSERT_EXCEPTION.name ]: if "randoop".upper() in self.criterion.upper(): test_dir = self.generated_test_dir packages_dir = utils.get_package_dir( self.class_name.split(".")[:-1]) test_dir_sub = os.path.join(test_dir, packages_dir) for test_file_name in os.listdir(test_dir_sub): test_file = os.path.join(test_dir_sub, test_file_name) if not test_file.endswith(".java"): continue # ErrorTest files are generated by randoop. Contains error test. That fails in PIT if "ErrorTest" in test_file: continue workaround_test(self.generated_test_dir, self.class_name, test_file_name, add_fails, self.assert_type) else: test_file_name = self.class_name.split( ".")[-1] + "_ESTest.java" workaround_test(self.generated_test_dir, self.class_name, test_file_name, add_fails, self.assert_type) utils.compile_workdir(self.generated_test_dir, self.generated_test_dir, bin_code_dir, self.junit_jar, self.evosuite_classes, self.evosuite_runtime_jar_path, self.extra_classpath) criterion = get_alternative_criterion_names(self.criterion) if self.method in [ EpatestingMethod.ONLY_METRICS.value, EpatestingMethod.BOTH.value, EpatestingMethod.BOTH_WITHOUT_MUJAVA.value, EpatestingMethod.ONLY_METRICS_WITHOUT_MUJAVA.value ]: print('GENERATING METRICS') packages_dir = utils.get_package_dir( self.class_name.split(".")[:-1]) test_dir_sub = os.path.join(self.generated_test_dir, packages_dir) if not os.path.exists(test_dir_sub): print("not found test folder ! '{}'".format(test_dir_sub)) exit(1) bin_code_dir = self.bin_instrumented_code_dir if "epa".upper( ) in self.criterion.upper() else self.bin_original_code_dir if "mining".upper() in self.criterion.upper( ) or "Compiler_" in self.name: #hack for Compiler bin_code_dir = self.bin_mining_code_dir if len(self.extra_classpath) != 0: bin_code_dir += os.path.pathsep + self.extra_classpath ###to compile test suite #utils.compile_workdir(self.generated_test_dir, self.generated_test_dir, bin_code_dir, self.junit_jar, self.evosuite_classes, self.evosuite_runtime_jar_path, self.extra_classpath) #measure_evosuite(evosuite_jar_path=self.evosuite_jar_path, projectCP=self.bin_instrumented_code_dir, testCP=self.generated_test_dir, class_name=self.class_name, epa_path=self.epa_path, report_dir=self.generated_report_evosuite_dir, criterion="epatransition", inferred_epa_xml_path="", force_inferred_epa=False) #measure_evosuite(evosuite_jar_path=self.evosuite_jar_path, projectCP=self.bin_instrumented_code_dir, testCP=self.generated_test_dir, class_name=self.class_name, epa_path=self.epa_path, report_dir=self.generated_report_evosuite_dir, criterion="epaexception", inferred_epa_xml_path="", force_inferred_epa=False) #measure_evosuite(evosuite_jar_path=self.evosuite_jar_path, projectCP=self.bin_instrumented_code_dir, testCP=self.generated_test_dir, class_name=self.class_name, epa_path=self.epa_path, report_dir=self.generated_report_evosuite_dir, criterion="epaadjacentedges", inferred_epa_xml_path="", force_inferred_epa=False) # Hack to generate inferred epa for randoop. For other criteria it is generated in the generation process - only needed one true in force_inferred_epa force_inferred_epa_value = True if "randoop".upper( ) in self.criterion.upper() else False measure_evosuite(evosuite_jar_path=self.evosuite_jar_path, projectCP=bin_code_dir, testCP=self.generated_test_dir, class_name=self.class_name, epa_path=self.epa_path, report_dir=self.generated_report_evosuite_dir, criterion="epatransitionmining", inferred_epa_xml_path=self.inferred_epa_xml, force_inferred_epa=force_inferred_epa_value) measure_evosuite(evosuite_jar_path=self.evosuite_jar_path, projectCP=self.bin_mining_code_dir, testCP=self.generated_test_dir, class_name=self.class_name, epa_path=self.epa_path, report_dir=self.generated_report_evosuite_dir, criterion="epaexceptionmining", inferred_epa_xml_path="", force_inferred_epa=False) measure_evosuite(evosuite_jar_path=self.evosuite_jar_path, projectCP=self.bin_mining_code_dir, testCP=self.generated_test_dir, class_name=self.class_name, epa_path=self.epa_path, report_dir=self.generated_report_evosuite_dir, criterion="epaadjacentedgesmining", inferred_epa_xml_path="", force_inferred_epa=False) #if force_inferred_epa_value: # return # Run Pitest to measure targetTests = "{}_ESTest".format(self.class_name) if "randoop".upper() in self.criterion.upper(): targetTests = "{}.RegressionTest".format( utils.get_package_name_from_qualifiedname(self.class_name)) pitest_measure( self.generated_report_pitest_dir, self.class_name, targetTests, self.original_code_dir.replace("mining", "original"), self.generated_test_dir) #pitest_measure(self.generated_report_pitest_dir, self.class_name, self.original_code_dir, self.generated_test_dir, utils.get_package_dir(self.class_name.split(".")[0:-1])) #TODO: add strategy if self.method in [ EpatestingMethod.ONLY_METRICS.value, EpatestingMethod.BOTH.value ]: mujava_measure( self.bug_type, self.name, criterion, self.subdir_mutants, self.error_prot_list, self.ignore_mutants_list, self.bin_original_code_dir.replace("mining", "original"), self.generated_test_dir, self.class_name, self.junit_jar, self.hamcrest_jar_path, self.generated_report_mujava) # Resume the reports generated all_report_dir = os.path.join(self.subdir_metrics, 'all_reports') command_mkdir_report = 'mkdir {}'.format(all_report_dir) #utils.print_command(command_mkdir_report) if not os.path.exists(all_report_dir): os.makedirs(all_report_dir) copy_pitest_csv(self.name, self.generated_report_pitest_dir, all_report_dir) statistics_csv = os.path.join(self.generated_report_evosuite_dir, "statistics.csv") copy_csv(statistics_csv, 'epacoverage_{}'.format(self.name), all_report_dir) statistics_testgen_csv = "" if not self.criterion == "randoop": try: statistics_testgen_csv = os.path.join( self.generated_test_report_evosuite_dir, "statistics.csv") copy_csv(statistics_testgen_csv, 'statistics_testgen_{}'.format(self.name), all_report_dir) except: print( "statistics_testgen_csv (generated by Evosuite) not found" ) mujava_csv = os.path.join(self.generated_report_mujava, "mujava_report.csv") if os.path.exists(mujava_csv): copy_csv(mujava_csv, 'mujava_{}'.format(self.name), all_report_dir) else: print("Does not exists mujava file {}".format(mujava_csv)) epacoverage_csv = os.path.join( all_report_dir, "epacoverage_{}.csv".format(self.name)) if self.criterion != "randoop": statistics_testgen_csv = os.path.join( all_report_dir, "statistics_testgen_{}.csv".format(self.name)) jacoco_csv = os.path.join(all_report_dir, "{}_jacoco.csv".format(self.name)) mutations_csv = os.path.join(all_report_dir, "{}_mutations.csv".format(self.name)) pit_mutants_histogram(self.strategy_name, self.bug_type, criterion, self.search_budget, self.stopping_condition, mutations_csv, self.generated_test_dir, self.generated_pitest_killer_test, self.runid) # For test suite LOC result_jncss_temp = get_file_path_jncss( self.strategy_name, self.class_name, self.generated_test_dir, self.results_dir_name, self.bug_type, self.stopping_condition, self.search_budget, criterion, self.runid, self.javancss_jar_path) # For covered exceptions goals testgen_log_file_path = os.path.join(self.subdir_testgen, "testgen_out.txt") make_report_resume.resume( self.class_name, epacoverage_csv, statistics_testgen_csv, jacoco_csv, mutations_csv, self.resume_csv, self.runid, self.stopping_condition, self.search_budget, criterion, self.bug_type, self.strategy_name, mujava_csv, result_jncss_temp, testgen_log_file_path) if self.method in [EpatestingMethod.ONLY_PIT_MUTANTS_HISTOGRAM.value]: mutations_csv = get_mutation_csv_pit( self.generated_report_pitest_dir) pit_mutants_histogram(self.strategy_name, self.bug_type, criterion, self.search_budget, self.stopping_condition, mutations_csv, self.generated_test_dir, self.generated_pitest_killer_test, self.runid) # Hack (for old executions) if self.method in [ EpatestingMethod.ONLY_TEST_SUITE_LOC_AND_EXCEPTION.value ]: #Para TS LOC result_jncss_temp = get_file_path_jncss( self.class_name, self.generated_test_dir, self.results_dir_name, self.bug_type, self.stopping_condition, self.search_budget, criterion, self.runid, self.javancss_jar_path) # Para obtener exceptions #################### testgen_log_file_path = os.path.join(self.subdir_testgen, "testgen_out.txt") # Este archivo tiene la cantidad de goals cubiertos para cada criterio (-measureCoverage) all_report_dir = os.path.join(self.subdir_metrics, 'all_reports') epacoverage_csv = os.path.join( all_report_dir, "epacoverage_{}.csv".format(self.name)) # Este archivo tiene la suma de goals cubiertos (incluyendo criterio exception) statistics_testgen_csv = os.path.join( all_report_dir, "statistics_testgen_{}.csv".format(self.name)) utils.make_dirs_if_not_exist(self.subdir_metrics) make_report_resume.resume_test_suite_loc_and_exceptions( self.class_name, self.resume_csv, self.runid, self.stopping_condition, self.search_budget, criterion, self.bug_type, result_jncss_temp, testgen_log_file_path, epacoverage_csv, statistics_testgen_csv)
def exist_subject(bin_code_dir, class_name): package_dir = utils.get_package_dir(class_name.split(".")[0:-1]) if os.path.exists(os.path.join(bin_code_dir, package_dir)): return True return False
def copy_test(inputs, output, id, n, qualified_name, keywords_to_remove_file, replace_in_imports, replace_original_testsuite): def get_rename_test(java_file, class_name, new_test_file_name, replace_in_imports): replace_import = "=" in replace_in_imports old = "" new = "" if replace_import: old = replace_in_imports.split("=")[0] new = replace_in_imports.split("=")[1] new_file = "" test_name = class_name + "_ESTest" with open(java_file) as file: for line in file: if replace_import and old in line: line = re.sub(old,new, line.rstrip())+"\n" if(test_name in line): line = re.sub(test_name,new_test_file_name, line.rstrip()) new_file += line return new_file def remove_flacky_test(new_test_file_name, java_file, keywords_to_remove_file): def get_keywords_to_remove(keywords_to_remove_file, wich): with open(keywords_to_remove_file) as f: lines = f.readlines() #lines = [line.strip() for line in lines] keywords_to_remove = [] for line in lines: line = line.strip() # line comment if line.startswith("#") or len(line) == 0: continue if("ALL" in line): keywords_to_remove.extend(line.split('=')[1].strip().split(",")) continue if(wich in line): keywords_to_remove.extend(line.split('=')[1].strip().split(",")) return keywords_to_remove def remove_line(line, keywords_to_remove_array): remove_line = False for key in keywords_to_remove_array: if key in line: remove_line = True break return remove_line new_file = "" keywords_to_remove_all = get_keywords_to_remove(keywords_to_remove_file, "ALL") file = java_file.split("\n") start = False test = "" remove_test = False #with open(java_file) as file: for line in file: line += "\n" if("@Test" in line): start =True if not remove_test and len(test) != 0: new_file += test +"\n" elif remove_test: remove_test = False test = "" if remove_test: continue if(not start): if(not remove_line(line, keywords_to_remove_all)): new_file += line continue if(start): test += line if(remove_line(line, get_keywords_to_remove(keywords_to_remove_file, new_test_file_name))): remove_test = True if remove_test: new_file += "\n}" else: new_file += test return new_file def get_short_criterion(criterion): #criterion = criterion.replace("line_branch_exception", "lbe") #criterion = criterion.replace("epaadjacentedgesmining", "pairs") criterion = criterion.replace("line_branch_exception_epaadjacentedgesmining", "pa") criterion = criterion.replace("line_branch_exception", "d") return criterion inputs_array = inputs.split(",") id = "ID"+id for input in inputs_array: print("parsing path " + input + "...") i = 0 class_name = qualified_name.split(".")[-1] package_dir = utils.get_package_name_from_qualifiedname(qualified_name) package_dir = utils.get_package_dir(package_dir.split(".")) criterion = get_short_criterion(input.split(os.path.sep)[-1]) file_name = class_name+"_ESTest.java" test_file = os.path.join(input, str(i), "test", package_dir, file_name) while(i < n): while (not os.path.exists(test_file) and i < n): i += 1 test_file = os.path.join(input, str(i), "test", package_dir, file_name) if i >= n: break new_test_file_name = class_name + "_" + id + "_" + criterion + "_" + str(i) + "_ESTest.java" new_test_file_name_without_extension = new_test_file_name.split(".")[0] test_file_output = os.path.join(output, new_test_file_name) new_test_file = get_rename_test(test_file, class_name, new_test_file_name_without_extension, replace_in_imports) new_test_file = remove_flacky_test(new_test_file_name_without_extension, new_test_file, keywords_to_remove_file) utils.save_file(test_file_output, new_test_file) ###Replace_original TS if replace_original_testsuite == "True": new_test_file = get_rename_test(test_file_output, new_test_file_name_without_extension.replace("_ESTest",""), class_name+"_ESTest", replace_in_imports) utils.save_file(test_file, new_test_file) i += 1 test_file = os.path.join(input, str(i), "test", package_dir, file_name) print("saved files to "+ output + "...")