def get_emulators_running(result_dir: str) -> None:
"""Reboot all devices before starting a repetition."""
device_manager = RequiredFeature('device_manager').request()
if len(device_manager.get_devices(refresh=True)) > 0:
device_manager.shutdown_emulators(remove=True)
device_manager.boot_emulators(wait_to_be_ready=True)
class CheckInstrumentation(Strategy):
def __init__(self) -> None:
super(CheckInstrumentation, self).__init__()
self.device_manager = RequiredFeature('device_manager').request()
self.sampling_size = self.device_manager.get_total_number_of_devices_expected(
)
def run(self) -> None:
app_path = RequiredFeature('app_path').request()
self.population_generator.generate(self.sampling_size, gen=0)
# did we crash?
devices = self.device_manager.get_devices()
assert len(devices) == 1
device = devices[0]
crashed = crash_handler.handle(device, '', 0, 0, 0, set())
if crashed:
logger.log_progress(f"\nApp {app_path} CRASHED")
else:
logger.log_progress(f"\nApp {app_path} PASSED")
def run(self) -> List[Any]:
device_manager = RequiredFeature('device_manager').request()
if self.idle_devices_only:
devices = device_manager.get_idle_devices()
else:
devices = device_manager.get_devices()
if self.minimum_api is not None:
devices = [
device for device in devices
if device.api_level() >= self.minimum_api
]
total_devices = len(devices)
if total_devices == 0:
raise Exception(
f"No devices found with api level greater or equal than "
f"{str(self.minimum_api)} to apply function mapper.")
# prepare devices queue
devices_to_use: Queue[Device] = Queue(elements=devices)
# prepare output queue
output_queue: Queue[Output] = Queue() # type: ignore
# prepare items to map queue
if self.items_to_map is None:
for i in range(0, total_devices):
thread = MultipleQueueConsumerThread(
self.func,
devices_queue=devices_to_use,
devices_are_consumable=True,
extra_args=self.extra_args,
extra_kwargs=self.extra_kwargs,
output_queue=output_queue,
fail_times_limit=self.fail_times_limit,
default_output=self.default_output,
name=f"MQCThread-{str(i)}")
thread.start()
watchdog_thread = WatchDogThread(output_queue, total_devices)
self.wait_for_watchdog_to_finish(device_manager, watchdog_thread)
else:
items_queue = Queue(elements=self.items_to_map)
for i in range(0, total_devices):
thread = MultipleQueueConsumerThread(
self.func,
items_queue=items_queue,
items_are_consumable=True,
devices_queue=devices_to_use,
devices_are_consumable=False,
extra_args=self.extra_args,
extra_kwargs=self.extra_kwargs,
output_queue=output_queue,
fail_times_limit=self.fail_times_limit,
default_output=self.default_output,
name=f"MQCThread-{str(i)}")
thread.start()
watchdog_thread = WatchDogThread(output_queue,
len(self.items_to_map))
self.wait_for_watchdog_to_finish(device_manager, watchdog_thread)
# collect output
results = output_queue.pop_all()
return results
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()
def kill_test_runner_in_all_devices(self) -> None:
device_manager = RequiredFeature('device_manager').request()
for device in device_manager.get_devices():
self.kill_test_runner_in_device(device)