def run_junit_test_cases_with_coverage_on_project(project_dir,
custom_ant=None):
variants_dir = get_variants_dir(project_dir)
lib_paths = get_dependency_lib_dirs(project_dir)
for variant_dir in list_dir(variants_dir, full_path=True):
run_junit_test_cases_with_coverage(variant_dir=variant_dir,
lib_paths=lib_paths,
custom_ant=custom_ant)
def statement_coverage_of_variants(project_dir, spectrum_coverage_prefix=""):
stm_coverage_variants = {}
variants_dir = get_variants_dir(project_dir)
for variant in list_dir(variants_dir):
variant_dir = join_path(variants_dir, variant)
testing_coverage = statement_coverage(variant_dir, spectrum_coverage_prefix)
stm_coverage_variants[variant] = testing_coverage
return stm_coverage_variants
def get_failed_variant_dirs_from_config_report(mutated_project_dir):
configs_report_file_path = get_model_configs_report_path(
mutated_project_dir)
variants_dir = get_variants_dir(mutated_project_dir)
variant_dir_dict = {
get_file_name(vd): vd
for vd in list_dir(variants_dir, full_path=True)
}
failed_variant_dirs = []
with open(configs_report_file_path, "r") as report_csv:
reader = csv.reader(report_csv)
next(reader)
for i, row in enumerate(reader):
test_passed = row[-1] == "__PASSED__"
current_variant_name = row[0]
if not test_passed:
failed_variant_dirs.append(
variant_dir_dict.get(current_variant_name))
return failed_variant_dirs
def is_var_bug(mutated_project_dir,
filter_coverage,
spectrum_coverage_prefix=""):
num_of_failing_variants = 0
num_of_passing_variants = 0
variants_dir = get_variants_dir(mutated_project_dir)
variants_list = list_dir(variants_dir)
for variant in variants_list:
variant_dir = get_variant_dir(mutated_project_dir, variant)
test_coverage_dir = get_test_coverage_dir(variant_dir)
stm_coverage = statement_coverage(variant_dir,
spectrum_coverage_prefix)
spectrum_failed_file = get_spectrum_failed_coverage_file_name_with_version(
spectrum_coverage_prefix)
failed_file = join_path(test_coverage_dir, spectrum_failed_file)
if os.path.isfile(failed_file):
num_of_failing_variants += 1
elif stm_coverage >= filter_coverage:
num_of_passing_variants += 1
if num_of_failing_variants >= 1 and num_of_passing_variants >= 1:
return 1
return 0
def run_batch_junit_test_cases_on_project(project_dir,
custom_ant=None,
custom_variant_dirs=None):
if not custom_variant_dirs:
variants_dir = get_variants_dir(project_dir)
custom_variant_dirs = list_dir(variants_dir, full_path=True)
lib_paths = get_dependency_lib_dirs(project_dir)
for variant_dir in custom_variant_dirs:
are_all_tests_passed = run_batch_junit_test_cases(
variant_dir=variant_dir,
lib_paths=lib_paths,
custom_ant=custom_ant)
if are_all_tests_passed is True:
file_name = PASSED_TEST_FLAG_FILE_NAME
elif are_all_tests_passed is False:
file_name = FAILED_TEST_FLAG_FILE_NAME
else:
logger.warning(
f"Invalid are_all_tests_passed value {are_all_tests_passed} on variant {variant_dir}"
)
file_name = FAILED_TEST_FLAG_FILE_NAME
test_flag_file = join_path(variant_dir, file_name)
touch_file(test_flag_file)
def multiple_bugs_ranking(system_name,
buggy_systems_folder,
sbfl_metrics,
alpha=0.5,
normalization=NORMALIZATION_ENABLE,
aggregation=AGGREGATION_ARITHMETIC_MEAN,
filtering_coverage_rate=0.1,
coverage_version=""):
if os.path.exists(buggy_systems_folder):
mutated_projects = list_dir(buggy_systems_folder)
result_folder_dir = join_path(EXPERIMENT_RESULT_FOLDER,
"w=" + str(alpha))
if not os.path.exists(result_folder_dir):
os.makedirs(result_folder_dir)
system_result_dir = join_path(result_folder_dir, system_name)
if not os.path.exists(system_result_dir):
os.makedirs(system_result_dir)
normalization_result_dir = join_path(system_result_dir, normalization)
if not os.path.exists(normalization_result_dir):
os.makedirs(normalization_result_dir)
aggregation_result_dir = join_path(normalization_result_dir,
aggregation)
if not os.path.exists(aggregation_result_dir):
os.makedirs(aggregation_result_dir)
sheet = []
row = 0
experiment_file_name = join_path(aggregation_result_dir,
system_name + "_ranking_result.xlsx")
wb = Workbook(experiment_file_name)
for i in range(0, len(sbfl_metrics)):
sheet.append(wb.add_worksheet(sbfl_metrics[i]))
write_header_in_result_file(row, sheet[i])
row += 1
num_of_bugs = 0
for mutated_project_name in mutated_projects:
num_of_bugs += 1
mutated_project_dir = join_path(buggy_systems_folder,
mutated_project_name)
suspicious_isolation(mutated_project_dir, filtering_coverage_rate,
coverage_version)
search_spaces = get_suspicious_space(mutated_project_dir,
filtering_coverage_rate,
coverage_version)
buggy_statements = get_multiple_buggy_statements(
mutated_project_name, mutated_project_dir)
row_temp = row
if system_name == "ZipMe":
is_a_var_bug = is_var_bug_by_config(mutated_project_dir,
["Base", "Compress"])
else:
is_a_var_bug = is_var_bug_by_config(mutated_project_dir,
["Base"])
ranking_results, varcop_ranking_time = ranking_multiple_bugs(
buggy_statements, mutated_project_dir, search_spaces,
sbfl_metrics, aggregation, normalization, coverage_version,
filtering_coverage_rate, alpha)
fb_ranking_results = features_ranking_multiple_bugs(
buggy_statements, mutated_project_dir, search_spaces,
filtering_coverage_rate, sbfl_metrics)
for metric in range(0, len(sbfl_metrics)):
sheet[metric].write(row_temp, BUG_ID_COL, mutated_project_name)
row = write_result_to_file(
row_temp, sheet[metric],
ranking_results[sbfl_metrics[metric]],
fb_ranking_results[sbfl_metrics[metric]], search_spaces,
is_a_var_bug)
wb.close()
def features_ranking_multiple_bugs(buggy_statements,
mutated_project_dir,
search_spaces,
filter_coverage_rate,
spectrum_expressions,
spectrum_coverage_prefix=""):
statements_sets = {}
statements_sets[SS_STMS_IN_F_PRODUCTS] = get_set_of_stms(
search_spaces[SS_STMS_IN_F_PRODUCTS])
statements_sets[SS_SLICING] = get_set_of_stms(search_spaces[SS_SLICING])
total_variants = 0
variants_testing_coverage = {}
if filter_coverage_rate > 0:
variants_testing_coverage = statement_coverage_of_variants(
mutated_project_dir, spectrum_coverage_prefix)
failing_variants = get_failing_variants(mutated_project_dir)
features_info = {SS_STMS_IN_F_PRODUCTS: {}, SS_SLICING: {}}
variants_dir = get_variants_dir(mutated_project_dir)
for variant in list_dir(variants_dir):
if variant in failing_variants or (
filter_coverage_rate == 0 or
(variants_testing_coverage[variant] >= filter_coverage_rate)):
total_variants += 1
variant_dir = get_variant_dir(mutated_project_dir, variant)
features_info = get_coverage_infor_of_variants(
variant, variant_dir, failing_variants, features_info,
statements_sets, spectrum_coverage_prefix)
total_passes = total_variants - len(failing_variants)
total_fails = len(failing_variants)
# there are no passing variants with test coverage > threshold
if (total_passes == 0):
return -2, -2, -2
# there are no failing variants
if (total_fails == 0):
return -2, -2, -2
feature_based_rank = {}
for spectrum_expression in spectrum_expressions:
features_info[
SS_STMS_IN_F_PRODUCTS] = features_suspiciousness_calculation(
features_info[SS_STMS_IN_F_PRODUCTS], total_passes,
total_fails, spectrum_expression)
feature_based_rank[spectrum_expression] = {FB_RANK: {}, FB_TC_RANK: {}}
for stm in buggy_statements:
feature_rank, stm_rank = search_rank_worst_case(
stm, features_info[SS_STMS_IN_F_PRODUCTS],
features_info[SS_STMS_IN_F_PRODUCTS], spectrum_expression)
feature_based_rank[spectrum_expression][FB_RANK][stm] = {}
feature_based_rank[spectrum_expression][FB_RANK][stm][
RANK] = stm_rank
feature_based_rank[spectrum_expression][FB_RANK][stm][EXAM] = (
stm_rank / len(statements_sets[SS_STMS_IN_F_PRODUCTS])) * 100
for stm in buggy_statements:
if (stm in statements_sets[SS_SLICING]):
feature_rank, stm_rank = search_rank_worst_case(
stm, features_info[SS_STMS_IN_F_PRODUCTS],
features_info[SS_SLICING], spectrum_expression)
feature_based_rank[spectrum_expression][FB_TC_RANK][stm] = {}
feature_based_rank[spectrum_expression][FB_TC_RANK][stm][
RANK] = stm_rank
feature_based_rank[spectrum_expression][FB_TC_RANK][stm][
EXAM] = (stm_rank / len(statements_sets[SS_SLICING])) * 100
else:
feature_based_rank[spectrum_expression][
FB_TC_RANK] = feature_based_rank[spectrum_expression][
FB_RANK]
return feature_based_rank