def list_tests(d): def _run(dev): with device_temp_file.DeviceTempFile( dev.adb, suffix='.json', dir=dev. GetExternalStoragePath()) as dev_test_list_json: junit4_runner_class = self._test_instance.junit4_runner_class test_package = self._test_instance.test_package extras = {} extras['log'] = 'true' extras[_EXTRA_TEST_LIST] = dev_test_list_json.name target = '%s/%s' % (test_package, junit4_runner_class) timeout = 120 if self._test_instance.wait_for_java_debugger: timeout = None test_list_run_output = dev.StartInstrumentation( target, extras=extras, retries=0, timeout=timeout) if any(test_list_run_output): logging.error('Unexpected output while listing tests:') for line in test_list_run_output: logging.error(' %s', line) with tempfile_ext.NamedTemporaryDirectory() as host_dir: host_file = os.path.join(host_dir, 'list_tests.json') dev.PullFile(dev_test_list_json.name, host_file) with open(host_file, 'r') as host_file: return json.load(host_file) return crash_handler.RetryOnSystemCrash(_run, d)
def list_tests(dev): timeout = 30 retries = 1 if self._test_instance.wait_for_java_debugger: timeout = None flags = [ f for f in self._test_instance.flags if f not in ['--wait-for-debugger', '--wait-for-java-debugger'] ] flags.append('--gtest_list_tests') # TODO(crbug.com/726880): Remove retries when no longer necessary. for i in range(0, retries + 1): logging.info('flags:') for f in flags: logging.info(' %s', f) with self._ArchiveLogcat(dev, 'list_tests'): raw_test_list = crash_handler.RetryOnSystemCrash( lambda d: self._delegate.Run( None, d, flags=' '.join(flags), timeout=timeout), device=dev) tests = gtest_test_instance.ParseGTestListTests(raw_test_list) if not tests: logging.info('No tests found. Output:') for l in raw_test_list: logging.info(' %s', l) if i < retries: logging.info('Retrying...') else: break return tests
def install_helper(apk, permissions): @trace_event.traced("apk_path") def install_helper_internal(d, apk_path=apk.path): # pylint: disable=unused-argument d.Install(apk, permissions=permissions) return lambda: crash_handler.RetryOnSystemCrash( install_helper_internal, dev)
def run_tests_on_device(dev, tests, results): for test in tests: if exit_now.isSet(): thread.exit() result = None rerun = None try: result, rerun = crash_handler.RetryOnSystemCrash( lambda d, t=test: self._RunTest(d, t), device=dev) if isinstance(result, base_test_result.BaseTestResult): results.AddResult(result) elif isinstance(result, list): results.AddResults(result) else: raise Exception('Unexpected result type: %s' % type(result).__name__) except: if isinstance(tests, test_collection.TestCollection): rerun = test raise finally: if isinstance(tests, test_collection.TestCollection): if rerun: tests.add(rerun) tests.test_completed() logging.info('Finished running tests on this device.')
def incremental_install_helper(apk, script): @trace_event.traced("apk_path") def incremental_install_helper_internal(d, apk_path=apk.path): # pylint: disable=unused-argument local_device_test_run.IncrementalInstall(d, apk, script) return lambda: crash_handler.RetryOnSystemCrash( incremental_install_helper_internal, dev)
def list_tests(dev): raw_test_list = crash_handler.RetryOnSystemCrash( lambda d: self._delegate.Run( None, d, flags='--gtest_list_tests', timeout=30), device=dev) tests = gtest_test_instance.ParseGTestListTests(raw_test_list) if not tests: logging.info('No tests found. Output:') for l in raw_test_list: logging.info(' %s', l) return tests
def victim(): trigger_cmd = 'echo -n %s > %s; sleep 20' % ( cmd_helper.SingleQuote(trigger_text), cmd_helper.SingleQuote(trigger_file.name)) crash_handler.RetryOnSystemCrash( lambda d: d.RunShellCommand(trigger_cmd, shell=True, check_return=True, retries=1, as_root=True, timeout=180), device=self.device) self.assertEquals( trigger_text, self.device.ReadFile(trigger_file.name, retries=0).strip()) return True
def run_tests_on_device(dev, tests, results): for test in tests: if exit_now.isSet(): thread.exit() result = None rerun = None try: result, rerun = crash_handler.RetryOnSystemCrash( lambda d, t=test: self._RunTest(d, t), device=dev) if isinstance(result, base_test_result.BaseTestResult): results.AddResult(result) elif isinstance(result, list): results.AddResults(result) else: raise Exception( 'Unexpected result type: %s' % type(result).__name__) except device_errors.CommandTimeoutError: if isinstance(test, list): results.AddResults( base_test_result.BaseTestResult( self._GetUniqueTestName(t), base_test_result.ResultType.TIMEOUT) for t in test) else: results.AddResult( base_test_result.BaseTestResult( self._GetUniqueTestName(test), base_test_result.ResultType.TIMEOUT)) except Exception as e: # pylint: disable=broad-except if isinstance(tests, test_collection.TestCollection): rerun = test if (isinstance(e, device_errors.DeviceUnreachableError) or not isinstance(e, base_error.BaseError)): # If we get a device error but believe the device is still # reachable, attempt to continue using it. Otherwise, raise # the exception and terminate this run_tests_on_device call. raise finally: if isinstance(tests, test_collection.TestCollection): if rerun: tests.add(rerun) tests.test_completed() logging.info('Finished running tests on this device.')
def individual_device_set_up(dev, host_device_tuples): def install_apk(d): # Install test APK. self._delegate.Install(d) def push_test_data(): # Push data dependencies. device_root = self._delegate.GetTestDataRoot(dev) host_device_tuples_substituted = [ (h, local_device_test_run.SubstituteDeviceRoot( d, device_root)) for h, d in host_device_tuples ] dev.PushChangedFiles(host_device_tuples_substituted, delete_device_stale=True) if not host_device_tuples: dev.RemovePath(device_root, force=True, recursive=True, rename=True) dev.RunShellCommand(['mkdir', '-p', device_root], check_return=True) def init_tool_and_start_servers(): tool = self.GetTool(dev) tool.CopyFiles(dev) tool.SetupEnvironment() self._servers[str(dev)] = [] if self.TestPackage() in _SUITE_REQUIRES_TEST_SERVER_SPAWNER: self._servers[str(dev)].append( local_test_server_spawner.LocalTestServerSpawner( ports.AllocateTestServerPort(), dev, tool)) for s in self._servers[str(dev)]: s.SetUp() steps = ( lambda: crash_handler.RetryOnSystemCrash(install_apk, dev), push_test_data, init_tool_and_start_servers) if self._env.concurrent_adb: reraiser_thread.RunAsync(steps) else: for step in steps: step()
def run_tests_on_device(dev, tests, results, quickbuild): for test in tests: if exit_now.isSet(): thread.exit() result = None rerun = None try: result, rerun = crash_handler.RetryOnSystemCrash( lambda d, t=test: self._RunTest(d, t), device=dev) if isinstance(result, base_test_result.BaseTestResult): result.SetAnnotations(test) results.AddResult(result) print_unknown_error(dev, result, quickbuild) elif isinstance(result, list): for r in result: r.SetAnnotations(test) results.AddResults(result) for r in result: print_unknown_error(dev, r, quickbuild) else: raise Exception( 'Unexpected result type: %s' % type(result).__name__) except Exception as e: # pylint: disable=broad-except if isinstance(tests, test_collection.TestCollection): rerun = test if (isinstance(e, device_errors.DeviceUnreachableError) or not isinstance(e, base_error.BaseError)): # If we get a device error but believe the device is still # reachable, attempt to continue using it. Otherwise, raise # the exception and terminate this run_tests_on_device call. raise if is_emualtor(): reboot_emulator() else: raise finally: if isinstance(tests, test_collection.TestCollection): if rerun: tests.add(rerun) tests.test_completed() logging.info('Finished running tests on this device.')
def list_tests(dev): timeout = 30 retries = 1 if self._test_instance.wait_for_java_debugger: timeout = None flags = [ f for f in self._test_instance.flags if f not in ['--wait-for-debugger', '--wait-for-java-debugger'] ] flags.append('--gtest_list_tests') # TODO(crbug.com/726880): Remove retries when no longer necessary. for i in range(0, retries+1): logging.info('flags:') for f in flags: logging.info(' %s', f) try: raw_test_list = crash_handler.RetryOnSystemCrash( lambda d: self._delegate.Run( None, d, flags=' '.join(flags), timeout=timeout), device=dev) except device_errors.AdbCommandFailedError: logging.exception('Test listing failed.') # Allow subsequent error handling to dump logcat. raw_test_list = [] tests = gtest_test_instance.ParseGTestListTests(raw_test_list) if not tests: logging.info('No tests found. Output:') for l in raw_test_list: logging.info(' %s', l) logging.info('Logcat:') for line in dev.adb.Logcat(dump=True): logging.info(line) dev.adb.Logcat(clear=True) if i < retries: logging.info('Retrying...') else: break return tests
def GetCharging(self, timeout=None, retries=None): """Gets the charging state of the device. Args: timeout: timeout in seconds retries: number of retries Returns: True if the device is charging, false otherwise. """ # Wrapper function so that we can use `RetryOnSystemCrash`. def GetBatteryInfoHelper(device): return self.GetBatteryInfo() battery_info = crash_handler.RetryOnSystemCrash( GetBatteryInfoHelper, self._device) for k in ('AC powered', 'USB powered', 'Wireless powered'): if (k in battery_info and battery_info[k].lower() in ('true', '1', 'yes')): return True return False
def bind_crash_handler(step, dev): return lambda: crash_handler.RetryOnSystemCrash(step, dev)
def run_tests_on_device(dev, tests, results): consecutive_device_errors = 0 for test in tests: if exit_now.isSet(): thread.exit() result = None rerun = None try: result, rerun = crash_handler.RetryOnSystemCrash( lambda d, t=test: self._RunTest(d, t), device=dev) consecutive_device_errors = 0 if isinstance(result, base_test_result.BaseTestResult): results.AddResult(result) elif isinstance(result, list): results.AddResults(result) else: raise Exception('Unexpected result type: %s' % type(result).__name__) except device_errors.CommandTimeoutError: # Test timeouts don't count as device errors for the purpose # of bad device detection. consecutive_device_errors = 0 if isinstance(test, list): results.AddResults( base_test_result.BaseTestResult( self._GetUniqueTestName(t), base_test_result.ResultType.TIMEOUT) for t in test) else: results.AddResult( base_test_result.BaseTestResult( self._GetUniqueTestName(test), base_test_result.ResultType.TIMEOUT)) except Exception as e: # pylint: disable=broad-except if isinstance(tests, test_collection.TestCollection): rerun = test if (isinstance(e, device_errors.DeviceUnreachableError) or not isinstance(e, base_error.BaseError)): # If we get a device error but believe the device is still # reachable, attempt to continue using it. Otherwise, raise # the exception and terminate this run_tests_on_device call. raise consecutive_device_errors += 1 if consecutive_device_errors >= 3: # We believe the device is still reachable and may still be usable, # but if it fails repeatedly, we shouldn't attempt to keep using # it. logging.error( 'Repeated failures on device %s. Abandoning.', str(dev)) raise logging.exception( 'Attempting to continue using device %s despite failure (%d/3).', str(dev), consecutive_device_errors) finally: if isinstance(tests, test_collection.TestCollection): if rerun: tests.add(rerun) tests.test_completed() logging.info('Finished running tests on this device.')
def run_tests_on_device(dev, tests, results): # This is performed here instead of during setup because restarting the # device clears app compatibility flags, which will happen if a device # needs to be recovered. SetAppCompatibilityFlagsIfNecessary(self._installed_packages, dev) consecutive_device_errors = 0 for test in tests: if not test: logging.warning('No tests in shared. Continuing.') tests.test_completed() continue if exit_now.isSet(): thread.exit() result = None rerun = None try: result, rerun = crash_handler.RetryOnSystemCrash( lambda d, t=test: self._RunTest(d, t), device=dev) consecutive_device_errors = 0 if isinstance(result, base_test_result.BaseTestResult): results.AddResult(result) elif isinstance(result, list): results.AddResults(result) else: raise Exception('Unexpected result type: %s' % type(result).__name__) except device_errors.CommandTimeoutError: # Test timeouts don't count as device errors for the purpose # of bad device detection. consecutive_device_errors = 0 # TODO(crbug.com/1181389): Remove this workaround once the deadlocks # in ArCore are resolved def GetResultTypeForTest(t): if 'WebXrAr' in self._GetUniqueTestName(t): return base_test_result.ResultType.PASS return base_test_result.ResultType.TIMEOUT if isinstance(test, list): results.AddResults( base_test_result.BaseTestResult( self._GetUniqueTestName(t), GetResultTypeForTest(t)) for t in test) else: results.AddResult( base_test_result.BaseTestResult( self._GetUniqueTestName(test), GetResultTypeForTest(test))) except Exception as e: # pylint: disable=broad-except if isinstance(tests, test_collection.TestCollection): rerun = test if (isinstance(e, device_errors.DeviceUnreachableError) or not isinstance(e, base_error.BaseError)): # If we get a device error but believe the device is still # reachable, attempt to continue using it. Otherwise, raise # the exception and terminate this run_tests_on_device call. raise consecutive_device_errors += 1 if consecutive_device_errors >= 3: # We believe the device is still reachable and may still be usable, # but if it fails repeatedly, we shouldn't attempt to keep using # it. logging.error( 'Repeated failures on device %s. Abandoning.', str(dev)) raise logging.exception( 'Attempting to continue using device %s despite failure (%d/3).', str(dev), consecutive_device_errors) finally: if isinstance(tests, test_collection.TestCollection): if rerun: tests.add(rerun) tests.test_completed() logging.info('Finished running tests on this device.')