def get_bads(mode):
if mode == "exp":
return ExpBADS(ConfigsManager.get_instance().get_exp_a(),
ConfigsManager.get_instance().get_exp_b(),
ConfigsManager.get_instance().get_exp_c())
else:
LoggingUtils.get_instance().error('Unsupported BADS type - %s' %
mode)
def run(self):
self.logger.info('Starting SBST-DPG. Project path - %s' %
self.project_path)
self.load_configs()
self.defect_predictor = DefectPredictorFactory.get_defect_predictor(
ConfigsManager.get_instance().get_defect_predictor())
self.run_defect_predictor()
self.collect_classes_in_project(
ConfigsManager.get_instance().get_src_path())
self.collect_defect_prediction_results()
self.bads = BADSFactory.get_bads(
ConfigsManager.get_instance().get_bads_mode())
self.run_bads()
self.sbst = SbstFactory.get_sbst(
ConfigsManager.get_instance().get_sbst())
self.run_sbst()
def get_group_size(self, num_classes):
grouping = ConfigsManager.get_instance().get_grouping()
if 'p' in grouping:
loc_p = grouping.find('p')
grouping = grouping[0:loc_p]
return math.ceil((int(grouping) * num_classes) / 100)
else:
return 1
def assign_tiers(self, project):
tier_threshold = ConfigsManager.get_instance().get_tier_threshold()
self.logger.debug('Assigning tiers. Tier threshold - %f' %
tier_threshold)
classes = project.get_classes()
num_classes = len(classes)
num_classes_first_tier = math.ceil(num_classes * tier_threshold)
for clazz in classes.values():
if clazz.get_rank() <= num_classes_first_tier:
clazz.set_tier(1)
self.logger.debug('%s - %d' % (clazz.get_fq_class_name(), 1))
else:
clazz.set_tier(2)
self.logger.debug('%s - %d' % (clazz.get_fq_class_name(), 2))
def assign_time_budgets(self, project, time_spent_dp):
self.logger.debug('Assigning time budgets to classes.')
t_min_of_tiers = dict()
t_min_of_tiers[1] = ConfigsManager.get_instance().get_t_min_first_tier(
)
t_min_of_tiers[2] = ConfigsManager.get_instance(
).get_t_min_second_tier()
self.logger.debug('t_min of tier 1 - %d seconds' % t_min_of_tiers[1])
self.logger.debug('t_min of tier 2 - %d seconds' % t_min_of_tiers[2])
num_classes = len(project.get_classes())
num_classes_of_tiers = dict()
num_classes_of_tiers[1] = sum(
map(lambda x: x.get_tier() == 1, project.get_clazzes()))
num_classes_of_tiers[2] = sum(
map(lambda x: x.get_tier() == 2, project.get_clazzes()))
t_total = ConfigsManager.get_instance().get_t_total() * num_classes
t_total_of_tiers = dict()
t_total_of_tiers[1] = ConfigsManager.get_instance(
).get_t_total_first_tier() * num_classes_of_tiers[1]
t_total_of_tiers[2] = ConfigsManager.get_instance(
).get_t_total_second_tier() * num_classes_of_tiers[2]
self.logger.debug(
't_total per class of tier 1 - %d seconds' %
ConfigsManager.get_instance().get_t_total_first_tier())
self.logger.debug(
't_total per class of tier 2 - %d seconds' %
ConfigsManager.get_instance().get_t_total_second_tier())
self.logger.debug('t_total of tier 1 - %d seconds' %
t_total_of_tiers[1])
self.logger.debug('t_total of tier 2 - %d seconds' %
t_total_of_tiers[2])
time_spent_dp_of_tiers = dict()
time_spent_dp_of_tiers[1] = (time_spent_dp /
num_classes) * num_classes_of_tiers[1]
time_spent_dp_of_tiers[2] = (time_spent_dp /
num_classes) * num_classes_of_tiers[2]
self.logger.debug('Time spent by DP for tier 1 - %f seconds' %
time_spent_dp_of_tiers[1])
self.logger.debug('Time spent by DP for tier 2 - %f seconds' %
time_spent_dp_of_tiers[2])
self.assign_time_budgets_in_tier(1, project, t_total_of_tiers[1],
num_classes_of_tiers[1],
t_min_of_tiers[1],
time_spent_dp_of_tiers[1])
self.assign_time_budgets_in_tier(2, project, t_total_of_tiers[2],
num_classes_of_tiers[2],
t_min_of_tiers[2],
time_spent_dp_of_tiers[2])
def load_defect_scores(self, project, workspace):
self.logger.debug('Loading defect scores...')
schwa_output_file = ConfigsManager.get_instance(
).get_defect_predictor_out()
with open(os.path.join(workspace,
schwa_output_file)) as schwa_output_csv:
schwa_output_reader = csv.reader(schwa_output_csv, delimiter=",")
for schwa_result_row in schwa_output_reader:
fq_class_name = schwa_result_row[0]
defect_score = schwa_result_row[1]
if project.class_exists(fq_class_name):
project.set_defect_score(fq_class_name, defect_score)
self.logger.debug('%s - %s' %
(fq_class_name, defect_score))
else:
self.logger.debug(
'Ignoring %s since it is not a Java class (source file)'
% fq_class_name)
def run(self, project, project_path, current_path, sbst_dpg_workspace):
self.logger.info('Running EvoSuite...')
project_cp = os.path.join(
project_path,
ConfigsManager.get_instance().get_project_cp())
for fq_class_name in project.get_classes():
clazz = project.get_classes()[fq_class_name]
time_budget = clazz.get_time_budget()
tests_dir = sbst_dpg_workspace + '/evosuite-tests'
report_dir = sbst_dpg_workspace + '/evosuite-report'
covered_goals_fp = report_dir + '/covered.goals'
evosuite_logs_out = sbst_dpg_workspace + '/evosuite_logs_out.log'
run_evosuite_command = current_path + "/evosuite_utils/run-evosuite.sh"
self.logger.info(
'Generating tests for %s, time budget - %d seconds' %
(fq_class_name, time_budget))
subprocess.check_call([
run_evosuite_command, fq_class_name, project_cp,
str(time_budget), covered_goals_fp, tests_dir, report_dir,
'120', '120', '120', '4000', evosuite_logs_out,
current_path + '/evosuite_utils'
])
def load_configs(self):
self.logger.info('Loading configurations to ConfigsManager.')
ConfigsManager.get_instance().load_configs()
def __init__(self, project_path):
self.project_path = project_path
self.sbst_dpg_workspace = os.path.join(self.project_path, "sbst_dpg")
self.configs_manager = ConfigsManager.create_instance(
self.sbst_dpg_workspace)
self.logger = LoggerFactory.get_logger(__class__.__name__)
def __init__(self):
self.primary_logger_type = ConfigsManager.get_instance(
).primary_logger_type
self.log_level = ConfigsManager.get_instance().log_level