def generate_test_coverage(
self,
device: Device,
coverage_folder_local_path: str,
accumulated_output: str,
accumulated_errors: str,
script_path: str,
generation: int,
individual_index: int,
test_case_index: int,
unique_crashes: Set[str],
scripts_crash_status: Dict[str, bool]
) -> bool:
compiled_package_name: str = RequiredFeature('compiled_package_name').request()
result_dir: str = RequiredFeature('result_dir').request()
# clear app's data and state
output, errors, result_code = adb.shell_command(device, f"pm clear {compiled_package_name}")
accumulated_output += output
accumulated_errors += errors
if result_code != 0:
adb.log_evaluation_result(device, result_dir, script_path, False)
if self.verbose_level > 0:
logger.log_progress(f"\n{accumulated_output}\n{accumulated_errors}")
raise Exception(f"Unable to clear package for script_path {script_path} in device: {device.name}")
output, errors, result_code = adb.shell_command(
device,
f"am instrument {compiled_package_name}/{compiled_package_name}.EmmaInstrument.EmmaInstrumentation"
)
accumulated_output += output
accumulated_errors += errors
if result_code != 0:
adb.log_evaluation_result(device, result_dir, script_path, False)
if self.verbose_level > 0:
logger.log_progress(f"\n{accumulated_output}\n{accumulated_errors}")
raise Exception(f"Unable to instrument for script_path {script_path} in device: {device.name}")
script_name = script_path.split("/")[-1]
test_runner = RequiredFeature('test_runner').request()
test_runner.run(device, compiled_package_name, script_name)
return self.dump_script_coverage(
device,
coverage_folder_local_path,
accumulated_output,
accumulated_errors,
script_path,
generation,
individual_index,
test_case_index,
unique_crashes,
scripts_crash_status)
def generate_test_coverage(self, device: Device,
coverage_folder_local_path: str,
accumulated_output: str,
accumulated_errors: str, script_path: str,
generation: int, individual_index: int,
test_case_index: int, unique_crashes: Set[str],
scripts_crash_status: Dict[str, bool]) -> bool:
compiled_package_name: str = RequiredFeature(
'compiled_package_name').request()
result_dir: str = RequiredFeature('result_dir').request()
# clear app's data and state
output, errors, result_code = adb.shell_command(
device, f"pm clear {compiled_package_name}")
accumulated_output += str(output)
accumulated_errors += str(errors)
if result_code != 0:
adb.log_evaluation_result(device, result_dir, script_path, False)
if self.verbose_level > 0:
logger.log_progress(
f"\n{accumulated_output}\n{accumulated_errors}")
raise Exception(
f"Unable to clear package for script_path {script_path} in device: {device.name}"
)
# copy the covids file to the coverage_folder_local_path
ella_coverage_ids_file_path = f"{self.get_current_apk_output_folder(device)}/covids"
output, errors, result_code = run_cmd(
f"cp {ella_coverage_ids_file_path} {coverage_folder_local_path}/")
if result_code != 0:
raise Exception(
f"Unable to copy the coverage ids file for test script, path is: {ella_coverage_ids_file_path}"
)
# Run test case using the requested test runner.
# Internally, the test runner will take care of calling the methods AppInstrumentator#setup_for_test_run and
# AppInstrumentator#teardown_after_test_run, which will start and stop the ELLA server correspondingly.
script_name = script_path.split("/")[-1]
test_runner = RequiredFeature('test_runner').request()
test_runner.run(device, compiled_package_name, script_name)
return self.dump_script_coverage(device, coverage_folder_local_path,
accumulated_output,
accumulated_errors, script_path,
generation, individual_index,
test_case_index, unique_crashes,
scripts_crash_status)
class Evolutiz(object):
def __init__(self) -> None:
self.device_manager = RequiredFeature('device_manager').request()
self.strategy = RequiredFeature('strategy').request()
self.test_suite_evaluator = RequiredFeature('test_suite_evaluator').request()
self.test_runner = RequiredFeature('test_runner').request()
self.population_generator = RequiredFeature('population_generator').request()
self.toolbox = RequiredFeature('toolbox').request()
self.result_dir = RequiredFeature('result_dir').request()
self.budget_manager = RequiredFeature('budget_manager').request()
self.test_runner.register_crossover_operator(self.toolbox)
self.test_runner.register_mutation_operator(self.toolbox)
self.test_suite_evaluator.register_selection_operator(self.toolbox)
self.apk_preparer = ApkPreparer()
features.provide('apk_preparer', self.apk_preparer)
self.history = RequiredFeature('history').request()
self.toolbox.decorate("mate", self.history.decorator)
self.toolbox.decorate("mutate", self.history.decorator)
def run(self) -> None:
self.apk_preparer.prepare()
emulators_number = RequiredFeature('emulators_number').request()
if (emulators_number < 1):
return
logger.log_progress("\nSetting up devices.")
minimum_api = RequiredFeature('minimum_api').request()
mapper = MapperOnDevices(DeviceSetupThread.setup, minimum_api=minimum_api)
try:
mapper.run()
except Exception as e:
logger.log_progress(f"An error happened setting up devices: {str(traceback.format_exc())}")
return
devices = self.device_manager.get_devices()
for device in devices:
if device.state == State.setting_up:
raise Exception(f"An error occurred setting up devices before starting Evolutiz run")
# run the strategy
population = self.strategy.run()
self.write_summary_files()
def write_summary_files(self) -> None:
if RequiredFeature('write_hall_of_fame').request():
self.test_suite_evaluator.dump_hall_of_fame_to_file()
if RequiredFeature('write_history').request():
history_file = open(f"{self.result_dir}/history.pickle", 'wb')
pickle.dump(self.history, history_file)
history_file.close()
if RequiredFeature('write_logbook').request():
self.test_suite_evaluator.dump_logbook_to_file()