diff --git a/chrome/telemetry_gpu_integration_test.isolate b/chrome/telemetry_gpu_integration_test.isolate new file mode 100644 index 00000000000000..100bc85fb611a8 --- /dev/null +++ b/chrome/telemetry_gpu_integration_test.isolate @@ -0,0 +1,34 @@ +# Copyright (c) 2015 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. +{ + 'includes': [ + '../tools/perf/chrome_telemetry_build/telemetry_chrome_test.isolate', + ], + 'conditions': [ + ['OS=="android" or OS=="linux" or OS=="mac" or OS=="win"', { + # This isolate allows any of the GPU tests, including the WebGL + # conformance tests, to be run. However, extra command line arguments + # must be supplied in order to run any one of them. + 'variables': { + 'files': [ + '../content/test/gpu/', + '../content/test/data/gpu/', + # For GpuProcess.video + '../content/test/data/media/bear.ogv', + # For webgl_conformance + '../third_party/webgl/', + # Other dependencies of the tests and their harness. + '../testing/test_env.py', + '../testing/xvfb.py', + '../testing/scripts/common.py', + '../testing/scripts/run_gpu_integration_test_as_googletest.py', + ], + 'command': [ + '../testing/scripts/run_gpu_integration_test_as_googletest.py', + '../content/test/gpu/run_gpu_integration_test.py', + ], + }, + }], + ] +} diff --git a/chrome/test/BUILD.gn b/chrome/test/BUILD.gn index 3472fcd3c1b5d9..1ce9d0d1842f7d 100644 --- a/chrome/test/BUILD.gn +++ b/chrome/test/BUILD.gn @@ -282,6 +282,39 @@ group("telemetry_gpu_test") { ] } +# TODO(GYP_GONE): Delete this after we've converted everything to GN. +# The _run targets exist only for compatibility w/ GYP. +group("telemetry_gpu_integration_test_run") { + testonly = true + deps = [ + ":telemetry_gpu_integration_test", + ] +} + +group("telemetry_gpu_integration_test") { + testonly = true + deps = [ + "//tools/perf/chrome_telemetry_build:telemetry_chrome_test", + ] + + data = [ + # For isolate contract. + "//testing/scripts/common.py", + "//testing/xvfb.py", + "//testing/scripts/run_gpu_integration_test_as_googletest.py", + + "//content/test/gpu/", + "//content/test/data/gpu/", + + # For GpuProcess.video + "//content/test/data/media/bear.ogv", + + # For webgl_conformance + "//third_party/webgl/", + "//content/test/gpu/run_gpu_integration_test.py", + ] +} + if (!is_android) { # GYP version: chrome/chrome_tests.gypi:test_support_ui source_set("test_support_ui") { diff --git a/content/test/gpu/run_gpu_integration_test.py b/content/test/gpu/run_gpu_integration_test.py index c92bc06f6ad94e..4d5908e9f00dd5 100755 --- a/content/test/gpu/run_gpu_integration_test.py +++ b/content/test/gpu/run_gpu_integration_test.py @@ -3,6 +3,7 @@ # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. +import argparse import json import sys @@ -13,8 +14,6 @@ from telemetry.testing import browser_test_runner -abbr_json_arg = '--write-abbreviated-json-results-to=' - def PostprocessJSON(file_name): def TrimPrefix(s): return s[1 + s.rfind('.'):] @@ -33,10 +32,14 @@ def main(): # Postprocess the outputted JSON to trim all of the prefixes from # the test names, to keep them as similar to the old form as # possible -- and keep them from getting crazily long. - for arg in rest_args: - if arg.startswith(abbr_json_arg): - PostprocessJSON(arg[len(abbr_json_arg):]) - break + parser = argparse.ArgumentParser(description='Temporary argument parser') + parser.add_argument( + '--write-abbreviated-json-results-to', metavar='FILENAME', + action='store', + help=('Full path for json results')) + option, _ = parser.parse_known_args(rest_args) + if option.write_abbreviated_json_results_to: + PostprocessJSON(option.write_abbreviated_json_results_to) if __name__ == '__main__': sys.exit(main()) diff --git a/testing/scripts/run_gpu_integration_test_as_googletest.py b/testing/scripts/run_gpu_integration_test_as_googletest.py new file mode 100755 index 00000000000000..3174c6138528d7 --- /dev/null +++ b/testing/scripts/run_gpu_integration_test_as_googletest.py @@ -0,0 +1,118 @@ +#!/usr/bin/env python +# Copyright 2015 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. + +"""Runs an isolate bundled Telemetry GPU integration test. + +This script attempts to emulate the contract of gtest-style tests +invoked via recipes. The main contract is that the caller passes the +argument: + + --isolated-script-test-output=[FILENAME] + +json is written to that file in the format produced by +common.parse_common_test_results. + +This script is intended to be the base command invoked by the isolate, +followed by a subsequent Python script. It could be generalized to +invoke an arbitrary executable. +""" + +import argparse +import json +import os +import shutil +import sys +import tempfile +import traceback + +import common + +# Add src/testing/ into sys.path for importing xvfb. +sys.path.append(os.path.join(os.path.dirname(__file__), '..')) +import xvfb + +# Unfortunately we need to copy these variables from ../test_env.py. +# Importing it and using its get_sandbox_env breaks test runs on Linux +# (it seems to unset DISPLAY). +CHROME_SANDBOX_ENV = 'CHROME_DEVEL_SANDBOX' +CHROME_SANDBOX_PATH = '/opt/chromium/chrome_sandbox' + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + '--isolated-script-test-output', type=str, + required=True) + parser.add_argument('--xvfb', help='Start xvfb.', action='store_true') + args, rest_args = parser.parse_known_args() + xvfb_proc = None + openbox_proc = None + xcompmgr_proc = None + env = os.environ.copy() + # Assume we want to set up the sandbox environment variables all the + # time; doing so is harmless on non-Linux platforms and is needed + # all the time on Linux. + env[CHROME_SANDBOX_ENV] = CHROME_SANDBOX_PATH + if args.xvfb and xvfb.should_start_xvfb(env): + xvfb_proc, openbox_proc, xcompmgr_proc = xvfb.start_xvfb(env=env, + build_dir='.') + assert xvfb_proc and openbox_proc and xcompmgr_proc, 'Failed to start xvfb' + # Compatibility with gtest-based sharding. + total_shards = None + shard_index = None + if 'GTEST_TOTAL_SHARDS' in env: + total_shards = int(env['GTEST_TOTAL_SHARDS']) + del env['GTEST_TOTAL_SHARDS'] + if 'GTEST_SHARD_INDEX' in env: + shard_index = int(env['GTEST_SHARD_INDEX']) + del env['GTEST_SHARD_INDEX'] + sharding_args = [] + if total_shards is not None and shard_index is not None: + sharding_args = [ + '--total-shards=%d' % total_shards, + '--shard-index=%d' % shard_index + ] + try: + valid = True + rc = 0 + try: + rc = common.run_command([sys.executable] + rest_args + sharding_args + [ + '--write-abbreviated-json-results-to', args.isolated_script_test_output, + ], env=env) + valid = bool(rc == 0) + except Exception: + traceback.print_exc() + valid = False + + if not valid: + failures = ['(entire test suite)'] + with open(args.isolated_script_test_output, 'w') as fp: + json.dump({ + 'valid': valid, + 'failures': failures, + }, fp) + + return rc + + finally: + xvfb.kill(xvfb_proc) + xvfb.kill(openbox_proc) + xvfb.kill(xcompmgr_proc) + + +# This is not really a "script test" so does not need to manually add +# any additional compile targets. +def main_compile_targets(args): + json.dump([], args.output) + + +if __name__ == '__main__': + # Conform minimally to the protocol defined by ScriptTest. + if 'compile_targets' in sys.argv: + funcs = { + 'run': None, + 'compile_targets': main_compile_targets, + } + sys.exit(common.run_script(sys.argv[1:], funcs)) + sys.exit(main())