def test_corpusDefaultsToInstance(self, _):
args = createSkiaGoldArgs()
sgp = gold_utils.SkiaGoldProperties(args)
with tempfile_ext.NamedTemporaryDirectory() as working_dir:
sgsm = gold_utils.SkiaGoldSessionManager(working_dir, sgp)
keys_file = os.path.join(working_dir, 'keys.json')
with open(keys_file, 'w') as f:
json.dump({}, f)
session = sgsm.GetSkiaGoldSession(keys_file, None, 'instance')
self.assertEqual(session._keys_file, keys_file)
self.assertEqual(session._corpus, 'instance')
self.assertEqual(session._instance, 'instance')
def test_separateSessionsFromInstance(self, session_mock):
session_mock.return_value = None
args = createSkiaGoldArgs()
sgp = gold_utils.SkiaGoldProperties(args)
with tempfile_ext.NamedTemporaryDirectory() as working_dir:
sgsm = gold_utils.SkiaGoldSessionManager(working_dir, sgp)
keys_file = os.path.join(working_dir, 'keys.json')
with open(keys_file, 'w') as f:
json.dump({}, f)
session1 = sgsm.GetSkiaGoldSession(keys_file, 'corpus',
'instance1')
session2 = sgsm.GetSkiaGoldSession(keys_file, 'corpus',
'instance2')
self.assertNotEqual(session1, session2)
self.assertEqual(session_mock.call_count, 2)
def test_matchingSessionReused(self, session_mock):
session_mock.return_value = None
args = createSkiaGoldArgs()
sgp = gold_utils.SkiaGoldProperties(args)
with tempfile_ext.NamedTemporaryDirectory() as working_dir:
sgsm = gold_utils.SkiaGoldSessionManager(working_dir, sgp)
keys_file = os.path.join(working_dir, 'keys.json')
with open(keys_file, 'w') as f:
json.dump({}, f)
session1 = sgsm.GetSkiaGoldSession(keys_file, 'corpus', 'instance')
session2 = sgsm.GetSkiaGoldSession(keys_file, 'corpus', 'instance')
self.assertEqual(session1, session2)
# For some reason, session_mock.assert_called_once() always passes,
# so check the call count directly.
self.assertEqual(session_mock.call_count, 1)
def test_ArgsForwardedToSession(self, _):
args = createSkiaGoldArgs()
sgp = gold_utils.SkiaGoldProperties(args)
with tempfile_ext.NamedTemporaryDirectory() as working_dir:
sgsm = gold_utils.SkiaGoldSessionManager(working_dir, sgp)
keys_file = os.path.join(working_dir, 'keys.json')
with open(keys_file, 'w') as f:
json.dump({}, f)
session = sgsm.GetSkiaGoldSession(keys_file, 'corpus', 'instance')
self.assertEqual(session._keys_file, keys_file)
self.assertEqual(session._corpus, 'corpus')
self.assertEqual(session._instance, 'instance')
# Make sure the session's working directory is a subdirectory of the
# manager's working directory.
self.assertEqual(os.path.dirname(session._working_dir),
working_dir)
def SetUp(self):
@local_device_environment.handle_shard_failures_with(
self._env.BlacklistDevice)
@trace_event.traced
def individual_device_set_up(device, host_device_tuples):
steps = []
if self._test_instance.replace_system_package:
@trace_event.traced
def replace_package(dev):
# We need the context manager to be applied before modifying any
# shared preference files in case the replacement APK needs to be
# set up, and it needs to be applied while the test is running.
# Thus, it needs to be applied early during setup, but must still be
# applied during _RunTest, which isn't possible using 'with' without
# applying the context manager up in test_runner. Instead, we
# manually invoke its __enter__ and __exit__ methods in setup and
# teardown.
system_app_context = system_app.ReplaceSystemApp(
dev, self._test_instance.replace_system_package.package,
self._test_instance.replace_system_package.replacement_apk)
# Pylint is not smart enough to realize that this field has
# an __enter__ method, and will complain loudly.
# pylint: disable=no-member
system_app_context.__enter__()
# pylint: enable=no-member
self._context_managers[str(dev)].append(system_app_context)
steps.append(replace_package)
if self._test_instance.use_webview_provider:
@trace_event.traced
def use_webview_provider(dev):
# We need the context manager to be applied before modifying any
# shared preference files in case the replacement APK needs to be
# set up, and it needs to be applied while the test is running.
# Thus, it needs to be applied early during setup, but must still be
# applied during _RunTest, which isn't possible using 'with' without
# applying the context manager up in test_runner. Instead, we
# manually invoke its __enter__ and __exit__ methods in setup and
# teardown.
webview_context = webview_app.UseWebViewProvider(
dev, self._test_instance.use_webview_provider)
# Pylint is not smart enough to realize that this field has
# an __enter__ method, and will complain loudly.
# pylint: disable=no-member
webview_context.__enter__()
# pylint: enable=no-member
self._context_managers[str(dev)].append(webview_context)
steps.append(use_webview_provider)
def install_helper(apk,
modules=None,
fake_modules=None,
permissions=None,
additional_locales=None):
@instrumentation_tracing.no_tracing
@trace_event.traced
def install_helper_internal(d, apk_path=None):
# pylint: disable=unused-argument
d.Install(apk,
modules=modules,
fake_modules=fake_modules,
permissions=permissions,
additional_locales=additional_locales)
return install_helper_internal
def incremental_install_helper(apk, json_path, permissions):
@trace_event.traced
def incremental_install_helper_internal(d, apk_path=None):
# pylint: disable=unused-argument
installer.Install(d, json_path, apk=apk, permissions=permissions)
return incremental_install_helper_internal
permissions = self._test_instance.test_apk.GetPermissions()
if self._test_instance.test_apk_incremental_install_json:
steps.append(incremental_install_helper(
self._test_instance.test_apk,
self._test_instance.
test_apk_incremental_install_json,
permissions))
else:
steps.append(
install_helper(
self._test_instance.test_apk, permissions=permissions))
steps.extend(
install_helper(apk) for apk in self._test_instance.additional_apks)
# The apk under test needs to be installed last since installing other
# apks after will unintentionally clear the fake module directory.
# TODO(wnwen): Make this more robust, fix crbug.com/1010954.
if self._test_instance.apk_under_test:
permissions = self._test_instance.apk_under_test.GetPermissions()
if self._test_instance.apk_under_test_incremental_install_json:
steps.append(
incremental_install_helper(
self._test_instance.apk_under_test,
self._test_instance.apk_under_test_incremental_install_json,
permissions))
else:
steps.append(
install_helper(self._test_instance.apk_under_test,
self._test_instance.modules,
self._test_instance.fake_modules, permissions,
self._test_instance.additional_locales))
@trace_event.traced
def set_debug_app(dev):
# Set debug app in order to enable reading command line flags on user
# builds
package_name = None
if self._test_instance.apk_under_test:
package_name = self._test_instance.apk_under_test.GetPackageName()
elif self._test_instance.test_apk:
package_name = self._test_instance.test_apk.GetPackageName()
else:
logging.error("Couldn't set debug app: no package name found")
return
cmd = ['am', 'set-debug-app', '--persistent']
if self._test_instance.wait_for_java_debugger:
cmd.append('-w')
cmd.append(package_name)
dev.RunShellCommand(cmd, check_return=True)
@trace_event.traced
def edit_shared_prefs(dev):
for setting in self._test_instance.edit_shared_prefs:
shared_pref = shared_prefs.SharedPrefs(
dev, setting['package'], setting['filename'],
use_encrypted_path=setting.get('supports_encrypted_path', False))
pref_to_restore = copy.copy(shared_pref)
pref_to_restore.Load()
self._shared_prefs_to_restore.append(pref_to_restore)
shared_preference_utils.ApplySharedPreferenceSetting(
shared_pref, setting)
@trace_event.traced
def set_vega_permissions(dev):
# Normally, installation of VrCore automatically grants storage
# permissions. However, since VrCore is part of the system image on
# the Vega standalone headset, we don't install the APK as part of test
# setup. Instead, grant the permissions here so that it can take
# screenshots.
if dev.product_name == 'vega':
dev.GrantPermissions('com.google.vr.vrcore', [
'android.permission.WRITE_EXTERNAL_STORAGE',
'android.permission.READ_EXTERNAL_STORAGE'
])
@instrumentation_tracing.no_tracing
def push_test_data(dev):
device_root = posixpath.join(dev.GetExternalStoragePath(),
'chromium_tests_root')
host_device_tuples_substituted = [
(h, local_device_test_run.SubstituteDeviceRoot(d, device_root))
for h, d in host_device_tuples]
logging.info('Pushing data dependencies.')
for h, d in host_device_tuples_substituted:
logging.debug(' %r -> %r', h, d)
local_device_environment.place_nomedia_on_device(dev, device_root)
dev.PushChangedFiles(host_device_tuples_substituted,
delete_device_stale=True)
if not host_device_tuples_substituted:
dev.RunShellCommand(['rm', '-rf', device_root], check_return=True)
dev.RunShellCommand(['mkdir', '-p', device_root], check_return=True)
@trace_event.traced
def create_flag_changer(dev):
if self._test_instance.flags:
self._CreateFlagChangerIfNeeded(dev)
logging.debug('Attempting to set flags: %r',
self._test_instance.flags)
self._flag_changers[str(dev)].AddFlags(self._test_instance.flags)
valgrind_tools.SetChromeTimeoutScale(
dev, self._test_instance.timeout_scale)
steps += [
set_debug_app, edit_shared_prefs, push_test_data, create_flag_changer,
set_vega_permissions
]
def bind_crash_handler(step, dev):
return lambda: crash_handler.RetryOnSystemCrash(step, dev)
steps = [bind_crash_handler(s, device) for s in steps]
try:
if self._env.concurrent_adb:
reraiser_thread.RunAsync(steps)
else:
for step in steps:
step()
if self._test_instance.store_tombstones:
tombstones.ClearAllTombstones(device)
except device_errors.CommandFailedError:
if not device.IsOnline():
raise
# A bugreport can be large and take a while to generate, so only capture
# one if we're using a remote manager.
if isinstance(
self._env.output_manager,
remote_output_manager.RemoteOutputManager):
logging.error(
'Error when setting up device for tests. Taking a bugreport for '
'investigation. This may take a while...')
report_name = '%s.bugreport' % device.serial
with self._env.output_manager.ArchivedTempfile(
report_name, 'bug_reports') as report_file:
device.TakeBugReport(report_file.name)
logging.error('Bug report saved to %s', report_file.Link())
raise
self._env.parallel_devices.pMap(
individual_device_set_up,
self._test_instance.GetDataDependencies())
# Created here instead of on a per-test basis so that the downloaded
# expectations can be re-used between tests, saving a significant amount
# of time.
self._skia_gold_work_dir = tempfile.mkdtemp()
self._skia_gold_session_manager = gold_utils.SkiaGoldSessionManager(
self._skia_gold_work_dir, self._test_instance.skia_gold_properties)
if self._test_instance.wait_for_java_debugger:
apk = self._test_instance.apk_under_test or self._test_instance.test_apk
logging.warning('*' * 80)
logging.warning('Waiting for debugger to attach to process: %s',
apk.GetPackageName())
logging.warning('*' * 80)