| OLD | NEW |
|---|
| (Empty) |
| 1 # Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 # Use of this source code is governed by a BSD-style license that can be | |
| 3 # found in the LICENSE file. | |
| 4 | |
| 5 import itertools | |
| 6 import logging | |
| 7 import os | |
| 8 import posixpath | |
| 9 | |
| 10 from pylib import constants | |
| 11 from pylib import ports | |
| 12 from pylib.base import test_run | |
| 13 from pylib.device import device_errors | |
| 14 from pylib.gtest import gtest_test_instance | |
| 15 | |
| 16 from pylib.local import local_test_server_spawner | |
| 17 from pylib.local.device import local_device_environment | |
| 18 from pylib.local.device import local_device_test_run | |
| 19 from pylib.utils import device_temp_file | |
| 20 | |
| 21 _COMMAND_LINE_FLAGS_SUPPORTED = True | |
| 22 | |
| 23 _EXTRA_COMMAND_LINE_FILE = ( | |
| 24 'org.chromium.native_test.NativeTestActivity.CommandLineFile') | |
| 25 _EXTRA_COMMAND_LINE_FLAGS = ( | |
| 26 'org.chromium.native_test.NativeTestActivity.CommandLineFlags') | |
| 27 _EXTRA_TEST_LIST = ( | |
| 28 'org.chromium.native_test.NativeTestInstrumentationTestRunner' | |
| 29 '.TestList') | |
| 30 | |
| 31 _MAX_SHARD_SIZE = 256 | |
| 32 | |
| 33 # TODO(jbudorick): Move this up to the test instance if the net test server is | |
| 34 # handled outside of the APK for the remote_device environment. | |
| 35 _SUITE_REQUIRES_TEST_SERVER_SPAWNER = [ | |
| 36 'components_browsertests', 'content_unittests', 'content_browsertests', | |
| 37 'net_unittests', 'unit_tests' | |
| 38 ] | |
| 39 | |
| 40 # TODO(jbudorick): Move this inside _ApkDelegate once TestPackageApk is gone. | |
| 41 def PullAppFilesImpl(device, package, files, directory): | |
| 42 device_dir = device.GetApplicationDataDirectory(package) | |
| 43 host_dir = os.path.join(directory, str(device)) | |
| 44 for f in files: | |
| 45 device_file = posixpath.join(device_dir, f) | |
| 46 host_file = os.path.join(host_dir, *f.split(posixpath.sep)) | |
| 47 host_file_base, ext = os.path.splitext(host_file) | |
| 48 for i in itertools.count(): | |
| 49 host_file = '%s_%d%s' % (host_file_base, i, ext) | |
| 50 if not os.path.exists(host_file): | |
| 51 break | |
| 52 device.PullFile(device_file, host_file) | |
| 53 | |
| 54 class _ApkDelegate(object): | |
| 55 def __init__(self, test_instance): | |
| 56 self._activity = test_instance.activity | |
| 57 self._apk = test_instance.apk | |
| 58 self._package = test_instance.package | |
| 59 self._runner = test_instance.runner | |
| 60 | |
| 61 self._component = '%s/%s' % (self._package, self._runner) | |
| 62 self._extras = test_instance.extras | |
| 63 | |
| 64 def Install(self, device): | |
| 65 device.Install(self._apk) | |
| 66 | |
| 67 def Run(self, test, device, flags=None, **kwargs): | |
| 68 extras = dict(self._extras) | |
| 69 | |
| 70 with device_temp_file.DeviceTempFile(device.adb) as command_line_file: | |
| 71 device.WriteFile(command_line_file.name, '_ %s' % flags if flags else '_') | |
| 72 extras[_EXTRA_COMMAND_LINE_FILE] = command_line_file.name | |
| 73 | |
| 74 with device_temp_file.DeviceTempFile(device.adb) as test_list_file: | |
| 75 if test: | |
| 76 device.WriteFile(test_list_file.name, '\n'.join(test)) | |
| 77 extras[_EXTRA_TEST_LIST] = test_list_file.name | |
| 78 | |
| 79 return device.StartInstrumentation( | |
| 80 self._component, extras=extras, raw=False, **kwargs) | |
| 81 | |
| 82 def PullAppFiles(self, device, files, directory): | |
| 83 PullAppFilesImpl(device, self._package, files, directory) | |
| 84 | |
| 85 def Clear(self, device): | |
| 86 device.ClearApplicationState(self._package) | |
| 87 | |
| 88 | |
| 89 class _ExeDelegate(object): | |
| 90 def __init__(self, tr, exe): | |
| 91 self._exe_host_path = exe | |
| 92 self._exe_file_name = os.path.split(exe)[-1] | |
| 93 self._exe_device_path = '%s/%s' % ( | |
| 94 constants.TEST_EXECUTABLE_DIR, self._exe_file_name) | |
| 95 deps_host_path = self._exe_host_path + '_deps' | |
| 96 if os.path.exists(deps_host_path): | |
| 97 self._deps_host_path = deps_host_path | |
| 98 self._deps_device_path = self._exe_device_path + '_deps' | |
| 99 else: | |
| 100 self._deps_host_path = None | |
| 101 self._test_run = tr | |
| 102 | |
| 103 def Install(self, device): | |
| 104 # TODO(jbudorick): Look into merging this with normal data deps pushing if | |
| 105 # executables become supported on nonlocal environments. | |
| 106 host_device_tuples = [(self._exe_host_path, self._exe_device_path)] | |
| 107 if self._deps_host_path: | |
| 108 host_device_tuples.append((self._deps_host_path, self._deps_device_path)) | |
| 109 device.PushChangedFiles(host_device_tuples) | |
| 110 | |
| 111 def Run(self, test, device, flags=None, **kwargs): | |
| 112 cmd = [ | |
| 113 self._test_run.GetTool(device).GetTestWrapper(), | |
| 114 self._exe_device_path, | |
| 115 ] | |
| 116 if test: | |
| 117 cmd.append('--gtest_filter=%s' % ':'.join(test)) | |
| 118 if flags: | |
| 119 cmd.append(flags) | |
| 120 cwd = constants.TEST_EXECUTABLE_DIR | |
| 121 | |
| 122 env = { | |
| 123 'LD_LIBRARY_PATH': | |
| 124 '%s/%s_deps' % (constants.TEST_EXECUTABLE_DIR, self._exe_file_name), | |
| 125 } | |
| 126 try: | |
| 127 gcov_strip_depth = os.environ['NATIVE_COVERAGE_DEPTH_STRIP'] | |
| 128 external = device.GetExternalStoragePath() | |
| 129 env['GCOV_PREFIX'] = '%s/gcov' % external | |
| 130 env['GCOV_PREFIX_STRIP'] = gcov_strip_depth | |
| 131 except (device_errors.CommandFailedError, KeyError): | |
| 132 pass | |
| 133 | |
| 134 # TODO(jbudorick): Switch to just RunShellCommand once perezju@'s CL | |
| 135 # for long shell commands lands. | |
| 136 with device_temp_file.DeviceTempFile(device.adb) as script_file: | |
| 137 script_contents = ' '.join(cmd) | |
| 138 logging.info('script contents: %r' % script_contents) | |
| 139 device.WriteFile(script_file.name, script_contents) | |
| 140 output = device.RunShellCommand(['sh', script_file.name], cwd=cwd, | |
| 141 env=env, **kwargs) | |
| 142 return output | |
| 143 | |
| 144 def PullAppFiles(self, device, files, directory): | |
| 145 pass | |
| 146 | |
| 147 def Clear(self, device): | |
| 148 device.KillAll(self._exe_file_name, blocking=True, timeout=30, quiet=True) | |
| 149 | |
| 150 | |
| 151 class LocalDeviceGtestRun(local_device_test_run.LocalDeviceTestRun): | |
| 152 | |
| 153 def __init__(self, env, test_instance): | |
| 154 assert isinstance(env, local_device_environment.LocalDeviceEnvironment) | |
| 155 assert isinstance(test_instance, gtest_test_instance.GtestTestInstance) | |
| 156 super(LocalDeviceGtestRun, self).__init__(env, test_instance) | |
| 157 | |
| 158 if self._test_instance.apk: | |
| 159 self._delegate = _ApkDelegate(self._test_instance) | |
| 160 elif self._test_instance.exe: | |
| 161 self._delegate = _ExeDelegate(self, self._test_instance.exe) | |
| 162 | |
| 163 self._servers = {} | |
| 164 | |
| 165 #override | |
| 166 def TestPackage(self): | |
| 167 return self._test_instance.suite | |
| 168 | |
| 169 #override | |
| 170 def SetUp(self): | |
| 171 | |
| 172 def individual_device_set_up(dev, host_device_tuples): | |
| 173 # Install test APK. | |
| 174 self._delegate.Install(dev) | |
| 175 | |
| 176 # Push data dependencies. | |
| 177 external_storage = dev.GetExternalStoragePath() | |
| 178 host_device_tuples = [ | |
| 179 (h, d if d is not None else external_storage) | |
| 180 for h, d in host_device_tuples] | |
| 181 dev.PushChangedFiles(host_device_tuples) | |
| 182 | |
| 183 self._servers[str(dev)] = [] | |
| 184 if self.TestPackage() in _SUITE_REQUIRES_TEST_SERVER_SPAWNER: | |
| 185 self._servers[str(dev)].append( | |
| 186 local_test_server_spawner.LocalTestServerSpawner( | |
| 187 ports.AllocateTestServerPort(), dev, self.GetTool(dev))) | |
| 188 | |
| 189 for s in self._servers[str(dev)]: | |
| 190 s.SetUp() | |
| 191 | |
| 192 self._env.parallel_devices.pMap(individual_device_set_up, | |
| 193 self._test_instance.GetDataDependencies()) | |
| 194 | |
| 195 #override | |
| 196 def _ShouldShard(self): | |
| 197 return True | |
| 198 | |
| 199 #override | |
| 200 def _CreateShards(self, tests): | |
| 201 device_count = len(self._env.devices) | |
| 202 shards = [] | |
| 203 for i in xrange(0, device_count): | |
| 204 unbounded_shard = tests[i::device_count] | |
| 205 shards += [unbounded_shard[j:j+_MAX_SHARD_SIZE] | |
| 206 for j in xrange(0, len(unbounded_shard), _MAX_SHARD_SIZE)] | |
| 207 return shards | |
| 208 | |
| 209 #override | |
| 210 def _GetTests(self): | |
| 211 tests = self._delegate.Run( | |
| 212 None, self._env.devices[0], flags='--gtest_list_tests') | |
| 213 tests = gtest_test_instance.ParseGTestListTests(tests) | |
| 214 tests = self._test_instance.FilterTests(tests) | |
| 215 return tests | |
| 216 | |
| 217 #override | |
| 218 def _RunTest(self, device, test): | |
| 219 # Run the test. | |
| 220 output = self._delegate.Run( | |
| 221 test, device, timeout=900, retries=0) | |
| 222 for s in self._servers[str(device)]: | |
| 223 s.Reset() | |
| 224 if self._test_instance.app_files: | |
| 225 self._delegate.PullAppFiles(device, self._test_instance.app_files, | |
| 226 self._test_instance.app_file_dir) | |
| 227 self._delegate.Clear(device) | |
| 228 | |
| 229 # Parse the output. | |
| 230 # TODO(jbudorick): Transition test scripts away from parsing stdout. | |
| 231 results = self._test_instance.ParseGTestOutput(output) | |
| 232 return results | |
| 233 | |
| 234 #override | |
| 235 def TearDown(self): | |
| 236 def individual_device_tear_down(dev): | |
| 237 for s in self._servers[str(dev)]: | |
| 238 s.TearDown() | |
| 239 | |
| 240 self._env.parallel_devices.pMap(individual_device_tear_down) | |
| 241 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2392643003:
Removes files from //build that we don't need (Closed)
