mirror of
https://github.com/flutter/flutter.git
synced 2025-06-03 00:51:18 +00:00
242 lines
8.1 KiB
Python
242 lines
8.1 KiB
Python
# 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)
|
|
|