class Checker(object): def __init__(self, devices, app, strategy_list, emulator_path, android_system, root_path, resource_path, testcase_count, event_num, timeout, setting_random_denominator, rest_interval, choice): self.timeout = timeout self.app = app self.devices = devices self.guest_devices = self.devices[1:len(self.devices)] self.emulator_path = emulator_path self.android_system = android_system self.root_path = root_path self.resource_path = resource_path self.strategy_list = strategy_list self.testcase_count = testcase_count self.event_num = event_num self.setting_random_denominator = setting_random_denominator self.rest_interval = rest_interval self.injector = Injector( devices=devices, app=app, strategy_list=strategy_list, emulator_path=emulator_path, android_system=android_system, root_path=root_path, resource_path=resource_path, testcase_count=testcase_count, event_num=event_num, timeout=timeout, setting_random_denominator=setting_random_denominator, rest_interval=rest_interval, choice=choice) self.utils = Utils(devices=devices) def set_strategy(self, strategy): self.strategy = strategy def check_keyboard(self): for device in self.devices: device.use.set_clipboard('text', 'label') lines = device.state.lines if "com.sohu.inputmethod.sogou:id/imeview_keyboard" in lines or "com.baidu.input_huawei" in lines: print("close_keyboard") device.close_keyboard() def check_samestate(self): if self.devices[0].state.same_but_not_language(self.devices[1].state): return True return False def check_foreground(self): packagelist = [ self.app.package_name, "com.google.android.permissioncontroller", "com.android.packageinstaller", "com.android.permissioncontroller" ] lines = self.devices[0].use.dump_hierarchy() for package in packagelist: if package in lines: return True return False def check_start(self, times, strategy): print("start") def check_login(self): print("") def check_setting_request(self): flag = False for device in self.guest_devices: if device.strategy == "permission": if self.check_permission_request(device): self.devices[1].permission = True return True elif device.strategy == "wifi_off": if self.check_network_request(device): return True elif device.strategy == "notification": if self.check_notification_request(device): return True return flag def check_notification_request(self, device): Flag = False notificationlist = ["notification"] requestlist = ["unavailable", "try again"] lines2 = device.use.dump_hierarchy() if (self.containsAny(lines2.lower(), notificationlist) and self.containsAny(lines2.lower(), requestlist)): print("Allow notification") Flag = True return Flag def check_network_request(self, device): Flag = False wifilist = ["wifi", "network"] requestlist = ["unavailable", "try again"] lines2 = device.use.dump_hierarchy() if (self.containsAny(lines2.lower(), wifilist) and self.containsAny(lines2.lower(), requestlist)): print("Allow network") self.injector.turn_on_wifi() for device in self.devices: if device.use(textContains="retry").count > 0: device.use(textContains="retry").click() time.sleep(self.rest_interval * 1) Flag = True return Flag def check_permission_request(self, device): Flag = False while device.use(className="android.widget.Button", packageName="com.google.android.permissioncontroller" ).count > 0: print("Allow permission:permissioncontroller") device.use( className="android.widget.Button", packageName="com.google.android.permissioncontroller").click() time.sleep(self.rest_interval * 1) Flag = True while device.use(className="android.widget.Button", packageName="com.android.packageinstaller").count > 0: print("Allow permission:packageinstaller") device.use(className="android.widget.Button", packageName="com.android.packageinstaller", instance=1).click() time.sleep(self.rest_interval * 1) Flag = True permissionlist = ["permission", "authoriz"] requestlist = ["allow", "request", "ensure", "require"] speciallist = ["migrate"] lines2 = device.use.dump_hierarchy() if self.android_system == "a6s" and device.use( packageName="com.android.settings", text="Permissions").count > 0: device.use(packageName="com.android.settings", text="Permissions").click() time.sleep(self.rest_interval * 1) while device.use(text="OFF", className="android.widget.Switch").count > 0: device.use(text="OFF", className="android.widget.Switch").click() while device.use(packageName=self.app.package_name).count < 1: device.use.press("back") time.sleep(self.rest_interval * 1) elif self.android_system == "a6s" and device.use( packageName="com.android.settings", text="APPS").count > 0: device.use(scrollable=True, instance=0).scroll.to(text=self.app.app_name) device.use(text=self.app.app_name).click() device.use(text="Battery").wait(timeout=3.0) device.use(scrollable=True, instance=0).scroll.to(text="Permissions") self.check_permission_request(device) elif (self.containsAny(lines2.lower(), permissionlist) and self.containsAny(lines2.lower(), requestlist)) or self.containsAny( lines2.lower(), speciallist): print("Allow permission") again_flag = 1 if device.use(text="allow").count > 0: device.use(text="allow").click() again_flag = 0 elif device.use(text="yes").count > 0: device.use(text="yes").click() again_flag = 0 elif device.use(text="Settings").count > 0: device.use(text="Settings").click() again_flag = 0 elif device.use( text= "Allow storage permissions in order to fully enjoy WeChat features." ).count > 0: device.use(textContains="Allow").click() again_flag = 0 elif device.use(className="android.widget.Button").count > 0: device.use(className="android.widget.Button").click() again_flag = 0 if again_flag == 0: time.sleep(self.rest_interval * 3) self.check_permission_request(device) Flag = True return Flag def containsAny(self, seq, aset): return True if any(i in seq for i in aset) else False def check_loading(self): wait_time = 0 for device in self.devices: if device.use(className="android.widget.ProgressBar" ).count > 0 and wait_time < self.rest_interval * 5: time.sleep(self.rest_interval * 5) wait_time = wait_time + self.rest_interval * 5 print("wait load") elif wait_time > self.rest_interval * 20 or wait_time == self.rest_interval * 20: print("so long wait") return wait_time def check_crash(self): for device in self.devices: device.last_crash_logcat = device.crash_logcat f_crash = open(self.root_path + "/" + device.device_serial + "_logcat.txt", 'r', encoding='utf-8') device.crash_logcat = f_crash.read() if device.use(text="Close app").count > 0: device.use(text="Close app").click() if device.crash_logcat != device.last_crash_logcat: crash_info = device.crash_logcat[ len(device.last_crash_logcat):len(device.crash_logcat) - 1] + '\n' return crash_info return None
class Executor(object): def __init__(self, devices, app, strategy_list, pro_click, pro_longclick, pro_scroll, pro_home, pro_edit, pro_naturalscreen, pro_leftscreen, pro_back, pro_splitscreen, emulator_path, android_system, root_path, resource_path, testcase_count, start_testcase_count, event_num, timeout, policy_name, setting_random_denominator, serial_or_parallel, emulator_name, is_login_app, rest_interval, trace_path, choice): self.policy_name = policy_name self.timeout = timeout self.pro_click = pro_click self.pro_longclick = pro_longclick self.pro_scroll = pro_scroll self.pro_home = pro_home self.pro_edit = pro_edit self.pro_naturalscreen = pro_naturalscreen self.pro_leftscreen = pro_leftscreen self.pro_back = pro_back self.pro_splitscreen = pro_splitscreen self.app = app self.devices = devices self.emulator_path = emulator_path self.android_system = android_system self.resource_path = resource_path self.strategy_list = strategy_list self.testcase_count = testcase_count self.start_testcase_count = start_testcase_count self.event_num = event_num self.setting_random_denominator = setting_random_denominator self.root_path = root_path self.policy = self.get_policy() self.serial_or_parallel = serial_or_parallel self.emulator_name = emulator_name self.is_login_app = is_login_app self.rest_interval = rest_interval self.guest_devices = self.devices[1:len(self.devices)] self.trace_path = trace_path self.choice = choice self.injector = Injector( devices=devices, app=app, strategy_list=strategy_list, emulator_path=emulator_path, android_system=android_system, root_path=root_path, resource_path=resource_path, testcase_count=testcase_count, event_num=event_num, timeout=timeout, setting_random_denominator=setting_random_denominator, rest_interval=rest_interval, choice=choice) self.checker = Checker( devices=devices, app=app, strategy_list=strategy_list, emulator_path=emulator_path, android_system=android_system, root_path=root_path, resource_path=resource_path, testcase_count=testcase_count, event_num=event_num, timeout=timeout, setting_random_denominator=setting_random_denominator, rest_interval=rest_interval, choice=self.choice) self.utils = Utils(devices=devices) def get_policy(self): if self.policy_name == "random": print("Policy: Random") policy = RandomPolicy(self.devices, self.app, self.emulator_path, self.android_system, self.root_path, self.pro_click, self.pro_longclick, self.pro_scroll, self.pro_edit, self.pro_naturalscreen, self.pro_leftscreen, self.pro_back, self.pro_splitscreen, self.pro_home) else: print("No valid input policy specified. Using policy \"none\".") policy = None return policy def execute_event(self, device, event, num): try: have_view_action = ["click", "longclick", "edit", "scroll"] feature = "" if event.action in have_view_action and event.view is not None: if device.use(resourceId=event.view.resourceId ).count == 0 or device.use( className=event.view.className).count == 0: lines = device.use.dump_hierarchy() if (event.view.resourceId != "" and event.view.resourceId not in lines) or ( event.view.className != "" and event.view.className not in lines): return False if event.action.startswith("setting_"): self.injector.replay_setting(event, self.strategy_list) elif event.action == "check_setting_request": self.checker.check_setting_request() elif event.action == "check_login": self.checker.check_login() elif event.action == "click": feature = device.click(event.view, self.strategy_list) elif event.action == "longclick": device.longclick(event.view, self.strategy_list) elif event.action == "edit": device.edit(event.view, self.strategy_list, event.text) elif event.action == "scroll": device.scroll(event.view, self.strategy_list) elif event.action == "back": device.use.press("back") elif event.action == "home": device.use.press("home") elif event.action == "naturalscreen": device.use.set_orientation("n") elif event.action == "leftscreen": device.use.set_orientation("l") elif event.action == "start": device.start_app(self.app) elif event.action == "stop": device.stop_app(self.app) elif event.action == "clear": device.clear_app(self.app, self.is_login_app) elif event.action == "restart": device.restart(self.emulator_path, self.emulator_name) print(device.device_serial + ":" + feature + ":end execute\n") time.sleep(self.rest_interval * 1) return True except Exception as ex: if num == 0: print(ex) return self.execute_event(device, event, 1) else: print(ex) return False def replay(self, strategy): #init self.injector.init_setting() action_list = ["click", "long_click", "edit"] self.devices[1].set_strategy(strategy) path = os.path.join(self.root_path, "strategy_" + strategy) self.error_path = os.path.join(path, "error_replay") self.utils.create_dir(self.error_path) self.f_replay_record = open(os.path.join(path, "error_replay.txt"), 'w', encoding='utf-8') self.error_event_lists = [] self.f_replay = open(os.path.join(path, "error_realtime.txt"), 'r', encoding='utf-8') lines = self.f_replay.readlines() for line in lines: self.error_event_lists.append(line) if "Start::" in line: #init dir for each error print("Start") record_flag = False linelist = line.split("::") self.utils.create_dir( os.path.join(self.error_path, linelist[1])) self.screen_path = os.path.join(self.error_path, linelist[1], "screen/") self.utils.create_dir(self.screen_path) f_read_trace = open(os.path.join(self.error_path, linelist[1], "read_trace.txt"), 'w', encoding='utf-8') print(self.screen_path) elif "End::" in line: #end if record_flag == True: for theline in self.error_event_lists: self.f_replay_record.write(theline) self.f_replay_record.flush() self.error_event_lists = [] record_flag = False f_read_trace.close() self.utils.generate_html( os.path.join(self.error_path, linelist[1]), self.error_path, linelist[1]) elif line.strip() != "": print("-----------------------" + '\n' + line) f_read_trace.write(line) f_read_trace.flush() #replay each event elementlist = line.split("::") event = self.get_replay_event(elementlist, line) event.print_event() if elementlist[1] == "save_state": self.save_state(event.device.device_num, self.screen_path, elementlist[0], self.f_replay_record) else: if event.action in action_list: self.utils.draw_event(event) args = (event.device, event, 0) self.devices[event.device.device_num].set_thread( self.execute_event, args) if event.device.device_num == 1: self.utils.start_thread() for device in self.devices: if device.thread is not None: success_flag = device.thread.get_result() if not success_flag: record_flag = True device.set_thread(None, None) time.sleep(self.rest_interval * 1) if "device1" in line and "save_state" in line and self.devices[ 0].state is not None and self.devices[ 1].state is not None and not self.devices[ 0].state.same(self.devices[1].state): print("different!") event = Event(None, "wrong", self.devices[1], elementlist[0]) self.utils.draw_event(event) if "::start::" in line: self.checker.check_start(0, strategy) def get_replay_event(self, elementlist, line): view = None if elementlist[4].strip() != "None": view = View(elementlist[4], None, []) if elementlist[2] == "device0": event = Event(view, elementlist[1], self.devices[0], elementlist[0]) elif elementlist[2] == "device1": event = Event(view, elementlist[1], self.devices[1], elementlist[0]) else: print(line + "error") return event def start_app(self, event_count): for device in self.devices: args = (self.app, ) device.set_thread(device.start_app, args) self.utils.start_thread() for device in self.guest_devices: self.utils.write_read_event( "::start::all devices::None::None" + '\n', event_count, None, "all devices", device.device_num) event = Event(None, "start", device, event_count) self.utils.write_event(event, device.device_num, device.f_trace) self.utils.draw_event(event) def clear_app(self, event_count): for device in self.devices: device.clear_app(self.app, self.is_login_app) device.use.set_orientation("n") for device in self.guest_devices: device.error_event_lists.clear() device.wrong_event_lists.clear() device.wrong_flag = True self.utils.write_read_event( "::clear::all devices::None::None" + '\n', event_count, None, "all devices", device.device_num) event = Event(None, "clear", device, event_count) self.utils.write_event(event, device.device_num, device.f_trace) self.utils.draw_event(event) def clear_and_restart_app(self, event_count, strategy): for device in self.devices: device.clear_app(self.app, self.is_login_app) device.use.set_orientation("n") for device in self.guest_devices: device.error_event_lists.clear() device.wrong_event_lists.clear() device.wrong_flag = True event = Event(None, "naturalscreen", device, event_count) self.utils.write_event(event, device.device_num, device.f_trace) event = Event(None, "clear", device, event_count) event_count = self.write_draw_and_save_all(device, event, event_count) if event_count > 3: event = self.injector.change_setting_after_run( event_count, strategy) if event is not None: event_count = self.write_draw_and_save_one(event, event_count) #check keyboard self.checker.check_keyboard() for device in self.devices: args = (self.app, ) device.set_thread(device.start_app, args) self.utils.start_thread() self.checker.check_start(0, strategy) for device in self.guest_devices: event = Event(None, "start", device, event_count) event_count = self.write_draw_and_save_all(device, event, event_count) if self.checker.check_login(): event = Event(None, "check_login", self.devices[1], event_count) event_count = self.write_draw_and_save_one(event, event_count) event = self.injector.change_setting_before_run(event_count, strategy) if event is not None: event_count = self.write_draw_and_save_one(event, event_count) return event_count def back_to_app(self, event_count, strategy): for device in self.devices: device.use.press("back") print("Back") time.sleep(self.rest_interval * 1) if not self.checker.check_foreground(): for device in self.devices: device.stop_app(self.app) args = (self.app, ) device.set_thread(device.start_app, args) self.utils.start_thread() self.checker.check_start(1, strategy) for device in self.guest_devices: self.utils.write_read_event( "::restart::all devices::None::None" + '\n', event_count, None, "all devices", device.device_num) event = Event(None, "back", device, event_count) self.utils.write_event(event, device.device_num, device.f_trace) event = Event(None, "home", device, event_count) self.utils.write_event(event, device.device_num, device.f_trace) event = Event(None, "start", device, event_count) self.utils.write_event(event, device.device_num, device.f_trace) self.utils.draw_event(event) else: for device in self.guest_devices: self.utils.write_read_event( "::back::all devices::None::None" + '\n', event_count, None, "all devices", device.device_num) event = Event(None, "back", device, event_count) self.utils.write_event(event, device.device_num, device.f_trace) self.utils.draw_event(event) def save_all_state(self, event_count): time.sleep(self.rest_interval * 1) for device in self.guest_devices: self.save_state(0, device.path + "screen/", event_count, device.f_trace) self.save_state(device.device_num, device.path + "screen/", event_count, device.f_trace) event = Event(None, "save_state", device, event_count) event.set_count(device.device_num) self.utils.write_event(event, device.device_num, device.f_trace) return event_count + 1 def update_all_state(self, event_count): event_count = event_count - 1 time.sleep(self.rest_interval * 1) for device in self.guest_devices: self.update_state(0, device.path + "screen/", event_count, device.f_trace) self.update_state(device.device_num, device.path + "screen/", event_count, device.f_trace) event_count = event_count + 1 def save_state(self, device_count, path, event_count, f_trace): #get and save state of all devices lines = self.devices[device_count].screenshot_and_getstate( path, event_count) state = State(lines) self.devices[device_count].update_state(state) def update_state(self, device_count, path, event_count, f_trace): lines = self.devices[device_count].use.dump_hierarchy().splitlines() state = State(lines) self.devices[device_count].update_state(state) if self.devices[device_count].last_state != self.devices[ device_count].state: self.save_state(device_count, path, event_count, f_trace) def restart_devices(self, event_count): print("restart_devices") for device in self.devices: if device.is_emulator == 0: device.restart(self.emulator_path, self.emulator_name) for device in self.guest_devices: device.connect() device.error_event_lists.clear() device.wrong_event_lists.clear() device.wrong_flag = True self.utils.write_read_event( "::restart::all devices::None::None" + '\n', event_count, None, "all devices", device.device_num) event = Event(None, "restart", device, event_count) self.utils.write_event(event, device.device_num, device.f_trace) self.utils.draw_event(event) def wait_load(self, event_count): wait_time = self.checker.check_loading() if wait_time > 0: event_count = event_count - 1 event_count = self.save_all_state(event_count) def write_draw_and_save_one(self, event, event_count): self.utils.write_read_event(None, event_count, event, "all device", event.device.device_num) self.utils.write_one_device_event(event, event.device.device_num, event.device.f_trace) self.utils.draw_event(event) event_count = self.save_all_state(event_count) return event_count def write_draw_and_save_all(self, device, event, event_count): self.utils.write_read_event(None, event_count, event, "all device", event.device.device_num) self.utils.write_event(event, device.device_num, device.f_trace) self.utils.draw_event(event) event_count = self.save_all_state(event_count) return event_count def read_event(self, line, event_count): eventlist = line.split("::") action = eventlist[1] if eventlist[4] != "None\n": view = View(eventlist[4], None, []) event = Event(view, action, self.devices[0], event_count) else: event = Event(None, action, self.devices[0], event_count) return event def test(self): device = self.devices[1] self.devices[0].use.open_quick_settings() device.use.open_quick_settings() time.sleep(1) if device.use(description="Airplane mode", text="Off").count > 0: device.use(description="Airplane mode", text="Off").click() elif device.use(description="Airplane mode", text="Off").count > 0: device.use(description="Airplane mode", text="Off").click() def manual_test(self, strategy): #if execute serial, init the strategy of device1, otherwise, init all the guest devices' strategies if self.serial_or_parallel == 0: self.devices[0].set_strategy(strategy) self.devices[1].set_strategy(strategy) self.devices[1].make_strategy(self.root_path) else: for device in self.guest_devices: device.set_strategy(self.strategy_list[device.device_num - 1]) device.make_strategy(self.root_path) run_count = 0 for testcase_file in os.listdir(self.trace_path): testcase_f = open(os.path.join(self.trace_path, testcase_file), 'r', encoding='utf-8') lines = testcase_f.readlines() #create folder of new run run_count = run_count + 1 for device in self.guest_devices: device.make_strategy_runcount(run_count, self.root_path) #init setting event_count = 0.0 event_count = self.save_all_state(event_count) self.injector.init_setting() #clear and start app event_count = self.clear_and_restart_app(event_count, strategy) for line in lines: #if the state of any device is different from last state, stoat need to judge (loading, foreground, same) again change_flag = False self.update_all_state(event_count) for device in self.devices: if device.last_state != device.state: change_flag = True break if self.devices[0].last_state is not None and change_flag: #wait loading self.wait_load(event_count) #check whether app is foreground if not self.checker.check_foreground(): print("Not foreground") self.back_to_app(event_count, strategy) self.checker.check_loading() event_count = self.save_all_state(event_count) #check keyboard self.checker.check_keyboard() request_flag = 0 #judge whether all devices are same if not self.devices[0].state.same(self.devices[1].state): #judge whether the guest devices requests settings if self.checker.check_setting_request(): event = Event(None, "check_setting_request", self.devices[1], event_count) event_count = self.write_draw_and_save_one( event, event_count) request_flag = 1 #write wrong elif self.devices[1].wrong_flag == True: print("Write wrong!") self.utils.write_error( 1, run_count, self.devices[1].wrong_event_lists, self.devices[1].f_wrong, self.devices[1].wrong_num) self.devices[ 1].wrong_num = self.devices[1].wrong_num + 1 event = Event(None, "wrong", self.devices[1], event_count) self.utils.draw_event(event) #check login page and login if strategy != "language" and self.checker.check_login(): event = Event(None, "check_login", self.devices[1], event_count) event_count = self.write_draw_and_save_one( event, event_count) self.wait_load(event_count) #choice a new event to execute event = self.read_event(line, event_count) self.utils.draw_event(event) event.print_event() #execute event for device in self.devices: # success = self.execute_event(event,0) args = (device, event, 0) device.set_thread(self.execute_event, args) self.utils.start_thread() for device in self.devices: success = device.thread.get_result() if not success: fail_device = device.device_num break #device0 can not execute choice event, choice another event, skip this loop if not success and fail_device == 0: self.utils.print_dividing_line(False, event_count) continue #other devices cannot execute choice event due to setting, record fail, skip this loop elif not success: print("write error") self.utils.print_dividing_line(False, event_count) self.utils.write_read_event(None, event_count, event, "different", fail_device) self.utils.write_event(event, fail_device, self.devices[fail_device].f_trace) self.utils.draw_event(event) event_count = self.save_all_state(event_count) self.utils.write_error( fail_device, run_count, self.devices[fail_device].error_event_lists, self.devices[fail_device].f_error, self.devices[fail_device].error_num) self.devices[fail_device].error_num = self.devices[ fail_device].error_num + 1 event_count = self.clear_and_restart_app( event_count, strategy) continue #all devices execute success, record event and update state else: self.utils.print_dividing_line(True, event_count) self.utils.write_read_event(None, event_count, event, "all device", device.device_num) self.utils.write_event(event, device.device_num, device.f_trace) event_count = self.save_all_state(event_count) #check keyboard self.checker.check_keyboard() #injecte a setting change self.update_all_state(event_count) event = self.injector.inject_setting_during_run( event_count, strategy, request_flag) time.sleep(2) if event != None: self.checker.check_setting_request() event_count = self.write_draw_and_save_one( event, event_count) change_flag = False self.update_all_state(event_count) if not self.devices[0].last_state.same( self.devices[0].state ) and not self.devices[0].state.same( self.devices[1].state): self.checker.check_start(1, strategy) print("Different due to permission") change_flag = True break event = self.injector.change_setting_after_run( event_count, strategy) if event is not None: event_count = self.write_draw_and_save_one(event, event_count) #at the end of each run, generate a html file for device in self.guest_devices: self.utils.generate_html(device.path, device.path, run_count) def start(self, strategy): #if execute serial, init the strategy of device1, otherwise, init all the guest devices' strategies self.checker.set_strategy(strategy) if self.serial_or_parallel == 0: self.devices[0].set_strategy(strategy) self.devices[1].set_strategy(strategy) self.devices[1].make_strategy(self.root_path) else: for device in self.guest_devices: device.set_strategy(self.strategy_list[device.device_num - 1]) device.make_strategy(self.root_path) run_count = self.start_testcase_count while run_count < self.testcase_count: #create folder of new run run_count = run_count + 1 for device in self.guest_devices: device.use.press("back") device.use.press("back") device.make_strategy_runcount(run_count, self.root_path) #init setting event_count = 0.0 event_count = self.save_all_state(event_count) self.injector.init_setting() #clear and start app event_count = self.clear_and_restart_app(event_count, strategy) while event_count < self.event_num: #if the state of any device is different from last state, stoat need to judge (loading, foreground, same) again change_flag = False self.update_all_state(event_count) for device in self.devices: if device.last_state != device.state: change_flag = True break request_flag = 0 if self.devices[0].last_state is not None and change_flag: #wait loading self.wait_load(event_count) #check whether app is foreground if not self.checker.check_foreground(): print("Not foreground") self.back_to_app(event_count, strategy) self.checker.check_loading() event_count = self.save_all_state(event_count) #check keyboard self.checker.check_keyboard() #judge whether all devices are same if not self.devices[0].state.same(self.devices[1].state): #judge whether the guest devices requests settings if self.checker.check_setting_request(): event = Event(None, "check_setting_request", self.devices[1], event_count) event_count = self.write_draw_and_save_one( event, event_count) request_flag = 1 #write wrong elif self.app.package_name == "hk.alipay.wallet" and strategy == "wifi_off": self.injector.turn_on_wifi() for device in self.devices: device.use.press("back") event = Event(None, "wifi_back", self.devices[1], event_count) event_count = self.write_draw_and_save_one( event, event_count) request_flag = 1 elif self.devices[1].wrong_flag == True: print("Write wrong!") self.utils.write_error( 1, run_count, self.devices[1].wrong_event_lists, self.devices[1].f_wrong, self.devices[1].wrong_num) self.devices[ 1].wrong_num = self.devices[1].wrong_num + 1 event = Event(None, "wrong", self.devices[1], event_count) self.utils.draw_event(event) #check keyboard self.checker.check_keyboard() #check login page and login if strategy != "language" and self.checker.check_login(): event = Event(None, "check_login", self.devices[1], event_count) event_count = self.write_draw_and_save_one( event, event_count) self.wait_load(event_count) self.update_all_state(event_count) #choice a new event to execute event = self.policy.choice_event(self.devices[0], event_count) self.utils.draw_event(event) event.print_event() #execute event for device in self.devices: # success = self.execute_event(event,0) args = (device, event, 0) device.set_thread(self.execute_event, args) self.utils.start_thread() for device in self.devices: success = device.thread.get_result() if not success: fail_device = device.device_num break #device0 can not execute choice event, choice another event, skip this loop if not success and fail_device == 0: self.utils.print_dividing_line(False, event_count) continue #other devices cannot execute choice event due to setting, record fail, skip this loop elif not success: print("write error") self.utils.print_dividing_line(False, event_count) self.utils.write_read_event(None, event_count, event, "different", fail_device) self.utils.write_event(event, fail_device, self.devices[fail_device].f_trace) self.utils.draw_event(event) event_count = self.save_all_state(event_count) self.utils.write_error( fail_device, run_count, self.devices[fail_device].error_event_lists, self.devices[fail_device].f_error, self.devices[fail_device].error_num) self.devices[fail_device].error_num = self.devices[ fail_device].error_num + 1 event_count = self.clear_and_restart_app( event_count, strategy) continue #all devices execute success, record event and update state else: self.utils.print_dividing_line(True, event_count) self.utils.write_read_event(None, event_count, event, "all device", device.device_num) self.utils.write_event(event, device.device_num, device.f_trace) event_count = self.save_all_state(event_count) self.checker.check_keyboard() #injecte a setting change event = self.injector.inject_setting_during_run( event_count, strategy, request_flag) if event is not None: event_count = self.write_draw_and_save_one( event, event_count) event = self.injector.change_setting_after_run( event_count, strategy) if event is not None: event_count = self.write_draw_and_save_one(event, event_count) #at the end of each run, generate a html file for device in self.guest_devices: self.utils.generate_html(device.path, device.path, run_count)