| # Copyright 2014 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import itertools |
| import logging |
| import os |
| import posixpath |
| |
| from pylib import constants |
| from pylib import ports |
| from pylib.base import test_run |
| from pylib.device import device_errors |
| from pylib.gtest import gtest_test_instance |
| |
| from pylib.local import local_test_server_spawner |
| from pylib.local.device import local_device_environment |
| from pylib.local.device import local_device_test_run |
| from pylib.utils import device_temp_file |
| |
| _COMMAND_LINE_FLAGS_SUPPORTED = True |
| |
| _EXTRA_COMMAND_LINE_FILE = ( |
| 'org.chromium.native_test.NativeTestActivity.CommandLineFile') |
| _EXTRA_COMMAND_LINE_FLAGS = ( |
| 'org.chromium.native_test.NativeTestActivity.CommandLineFlags') |
| _EXTRA_TEST_LIST = ( |
| 'org.chromium.native_test.NativeTestInstrumentationTestRunner' |
| '.TestList') |
| |
| _MAX_SHARD_SIZE = 256 |
| |
| # TODO(jbudorick): Move this up to the test instance if the net test server is |
| # handled outside of the APK for the remote_device environment. |
| _SUITE_REQUIRES_TEST_SERVER_SPAWNER = [ |
| 'components_browsertests', 'content_unittests', 'content_browsertests', |
| 'net_unittests', 'unit_tests' |
| ] |
| |
| # TODO(jbudorick): Move this inside _ApkDelegate once TestPackageApk is gone. |
| def PullAppFilesImpl(device, package, files, directory): |
| device_dir = device.GetApplicationDataDirectory(package) |
| host_dir = os.path.join(directory, str(device)) |
| for f in files: |
| device_file = posixpath.join(device_dir, f) |
| host_file = os.path.join(host_dir, *f.split(posixpath.sep)) |
| host_file_base, ext = os.path.splitext(host_file) |
| for i in itertools.count(): |
| host_file = '%s_%d%s' % (host_file_base, i, ext) |
| if not os.path.exists(host_file): |
| break |
| device.PullFile(device_file, host_file) |
| |
| class _ApkDelegate(object): |
| def __init__(self, test_instance): |
| self._activity = test_instance.activity |
| self._apk = test_instance.apk |
| self._package = test_instance.package |
| self._runner = test_instance.runner |
| |
| self._component = '%s/%s' % (self._package, self._runner) |
| self._extras = test_instance.extras |
| |
| def Install(self, device): |
| device.Install(self._apk) |
| |
| def Run(self, test, device, flags=None, **kwargs): |
| extras = dict(self._extras) |
| |
| with device_temp_file.DeviceTempFile(device.adb) as command_line_file: |
| device.WriteFile(command_line_file.name, '_ %s' % flags if flags else '_') |
| extras[_EXTRA_COMMAND_LINE_FILE] = command_line_file.name |
| |
| with device_temp_file.DeviceTempFile(device.adb) as test_list_file: |
| if test: |
| device.WriteFile(test_list_file.name, '\n'.join(test)) |
| extras[_EXTRA_TEST_LIST] = test_list_file.name |
| |
| return device.StartInstrumentation( |
| self._component, extras=extras, raw=False, **kwargs) |
| |
| def PullAppFiles(self, device, files, directory): |
| PullAppFilesImpl(device, self._package, files, directory) |
| |
| def Clear(self, device): |
| device.ClearApplicationState(self._package) |
| |
| |
| class _ExeDelegate(object): |
| def __init__(self, tr, exe): |
| self._exe_host_path = exe |
| self._exe_file_name = os.path.split(exe)[-1] |
| self._exe_device_path = '%s/%s' % ( |
| constants.TEST_EXECUTABLE_DIR, self._exe_file_name) |
| deps_host_path = self._exe_host_path + '_deps' |
| if os.path.exists(deps_host_path): |
| self._deps_host_path = deps_host_path |
| self._deps_device_path = self._exe_device_path + '_deps' |
| else: |
| self._deps_host_path = None |
| self._test_run = tr |
| |
| def Install(self, device): |
| # TODO(jbudorick): Look into merging this with normal data deps pushing if |
| # executables become supported on nonlocal environments. |
| host_device_tuples = [(self._exe_host_path, self._exe_device_path)] |
| if self._deps_host_path: |
| host_device_tuples.append((self._deps_host_path, self._deps_device_path)) |
| device.PushChangedFiles(host_device_tuples) |
| |
| def Run(self, test, device, flags=None, **kwargs): |
| cmd = [ |
| self._test_run.GetTool(device).GetTestWrapper(), |
| self._exe_device_path, |
| ] |
| if test: |
| cmd.append('--gtest_filter=%s' % ':'.join(test)) |
| if flags: |
| cmd.append(flags) |
| cwd = constants.TEST_EXECUTABLE_DIR |
| |
| env = { |
| 'LD_LIBRARY_PATH': |
| '%s/%s_deps' % (constants.TEST_EXECUTABLE_DIR, self._exe_file_name), |
| } |
| try: |
| gcov_strip_depth = os.environ['NATIVE_COVERAGE_DEPTH_STRIP'] |
| external = device.GetExternalStoragePath() |
| env['GCOV_PREFIX'] = '%s/gcov' % external |
| env['GCOV_PREFIX_STRIP'] = gcov_strip_depth |
| except (device_errors.CommandFailedError, KeyError): |
| pass |
| |
| # TODO(jbudorick): Switch to just RunShellCommand once perezju@'s CL |
| # for long shell commands lands. |
| with device_temp_file.DeviceTempFile(device.adb) as script_file: |
| script_contents = ' '.join(cmd) |
| logging.info('script contents: %r' % script_contents) |
| device.WriteFile(script_file.name, script_contents) |
| output = device.RunShellCommand(['sh', script_file.name], cwd=cwd, |
| env=env, **kwargs) |
| return output |
| |
| def PullAppFiles(self, device, files, directory): |
| pass |
| |
| def Clear(self, device): |
| device.KillAll(self._exe_file_name, blocking=True, timeout=30, quiet=True) |
| |
| |
| class LocalDeviceGtestRun(local_device_test_run.LocalDeviceTestRun): |
| |
| def __init__(self, env, test_instance): |
| assert isinstance(env, local_device_environment.LocalDeviceEnvironment) |
| assert isinstance(test_instance, gtest_test_instance.GtestTestInstance) |
| super(LocalDeviceGtestRun, self).__init__(env, test_instance) |
| |
| if self._test_instance.apk: |
| self._delegate = _ApkDelegate(self._test_instance) |
| elif self._test_instance.exe: |
| self._delegate = _ExeDelegate(self, self._test_instance.exe) |
| |
| self._servers = {} |
| |
| #override |
| def TestPackage(self): |
| return self._test_instance.suite |
| |
| #override |
| def SetUp(self): |
| |
| def individual_device_set_up(dev, host_device_tuples): |
| # Install test APK. |
| self._delegate.Install(dev) |
| |
| # Push data dependencies. |
| external_storage = dev.GetExternalStoragePath() |
| host_device_tuples = [ |
| (h, d if d is not None else external_storage) |
| for h, d in host_device_tuples] |
| dev.PushChangedFiles(host_device_tuples) |
| |
| 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, self.GetTool(dev))) |
| |
| for s in self._servers[str(dev)]: |
| s.SetUp() |
| |
| self._env.parallel_devices.pMap(individual_device_set_up, |
| self._test_instance.GetDataDependencies()) |
| |
| #override |
| def _ShouldShard(self): |
| return True |
| |
| #override |
| def _CreateShards(self, tests): |
| device_count = len(self._env.devices) |
| shards = [] |
| for i in xrange(0, device_count): |
| unbounded_shard = tests[i::device_count] |
| shards += [unbounded_shard[j:j+_MAX_SHARD_SIZE] |
| for j in xrange(0, len(unbounded_shard), _MAX_SHARD_SIZE)] |
| return shards |
| |
| #override |
| def _GetTests(self): |
| tests = self._delegate.Run( |
| None, self._env.devices[0], flags='--gtest_list_tests') |
| tests = gtest_test_instance.ParseGTestListTests(tests) |
| tests = self._test_instance.FilterTests(tests) |
| return tests |
| |
| #override |
| def _RunTest(self, device, test): |
| # Run the test. |
| output = self._delegate.Run( |
| test, device, timeout=900, retries=0) |
| for s in self._servers[str(device)]: |
| s.Reset() |
| if self._test_instance.app_files: |
| self._delegate.PullAppFiles(device, self._test_instance.app_files, |
| self._test_instance.app_file_dir) |
| self._delegate.Clear(device) |
| |
| # Parse the output. |
| # TODO(jbudorick): Transition test scripts away from parsing stdout. |
| results = self._test_instance.ParseGTestOutput(output) |
| return results |
| |
| #override |
| def TearDown(self): |
| def individual_device_tear_down(dev): |
| for s in self._servers[str(dev)]: |
| s.TearDown() |
| |
| self._env.parallel_devices.pMap(individual_device_tear_down) |
| |
