| # Copyright 2018 The Fuchsia 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("//build/board.gni") |
| import("//build/testing/environments.gni") |
| import("//build/testing/platforms.gni") |
| |
| declare_args() { |
| # A list of device types this build is allowed to run tests on. If set, only |
| # these device types will be used for tests. |
| allowed_test_device_types = [] |
| } |
| |
| _log_severity_allowed_val = [ |
| "FATAL", |
| "ERROR", |
| "WARN", |
| "INFO", |
| "DEBUG", |
| "TRACE", |
| ] |
| |
| # Call "expanding" the operation that takes a scope |
| # { |
| # x = a |
| # y = b |
| # z = c |
| # ... |
| # } |
| # and converts it to a list [{x=a}, {y=b}, {z=c},...]. |
| # |
| # Expand each scope of test platform dimensions and group them by architecture |
| # (i.e., cpu). The same thing is done below with each environment's dimensions |
| # scope to more easily compare. |
| # |
| # This is done outside of the template so that the results are cached on a |
| # per-toolchain basis, instead of done for each of the 3600+ invocations of |
| # the test_spec() template. |
| # |
| _target_platform_dims = [] |
| _other_platform_dims = [] |
| foreach(platform, test_platforms) { |
| platform_dims = [] # Clear from previous iteration. |
| foreach(key, all_dimension_keys) { |
| platform_dims += [ |
| { |
| forward_variables_from(platform, [ key ]) |
| }, |
| ] |
| } |
| |
| # Empty scopes may have been introduced to platform_dims, corresponding to |
| # non-existent keys; |
| # Add and then subtract an empty scope to remove them. |
| empty_dim = { # Clear from previous iteration. |
| } |
| platform_dims += [ empty_dim ] |
| platform_dims -= [ empty_dim ] |
| |
| if (!defined(platform.cpu) || platform.cpu == target_cpu) { |
| _target_platform_dims += [ platform_dims ] |
| } else { |
| _other_platform_dims += [ platform_dims ] |
| } |
| } |
| |
| # A given board, by definition, restrict which devices it meant for. |
| # We constrain the allowed device types and the dimensions considered as |
| # a function of this. |
| # TODO(joshuaseaton): Use board_name instead of cpu in the reasoning above. |
| allowed_device_types = allowed_test_device_types |
| |
| # If the build specified no test device types, add the default set. |
| # If they _did_ specify test device types, don't add any. |
| if (allowed_device_types == []) { |
| if (board_name == "x64") { |
| allowed_device_types = [ |
| "AEMU", |
| "QEMU", |
| "Intel NUC Kit NUC7i5DNHE", |
| "GCE", |
| ] |
| } else if (board_name == "arm64") { |
| allowed_device_types = [ |
| "QEMU", |
| "GCE", |
| ] |
| } else if (board_name == "riscv64" || board_name == "qemu-arm64") { |
| allowed_device_types = [ "QEMU" ] |
| } else if (board_name == "qemu-x64") { |
| allowed_device_types = [ |
| "AEMU", |
| "QEMU", |
| ] |
| } else if (board_name == "astro") { |
| allowed_device_types = [ "Astro" ] |
| } else if (board_name == "luis") { |
| allowed_device_types = [ "Luis" ] |
| } else if (board_name == "sherlock") { |
| allowed_device_types = [ "Sherlock" ] |
| } else if (board_name == "nelson") { |
| allowed_device_types = [ "Nelson" ] |
| } else if (board_name == "vim3") { |
| allowed_device_types = [ "Vim3" ] |
| } else if (board_name == "chromebook-x64") { |
| allowed_device_types = [ "Atlas" ] |
| } |
| } |
| |
| # Describes the target device environment in which a test should |
| # run. This specification is written to a tests.json file in the build |
| # directory, to be aggregated at test-time. |
| # |
| # The format is documented at |
| # https://fuchsia.dev/fuchsia-src/reference/testing/tests-json-format |
| # |
| # Parameters |
| # |
| # path (optional for fuchsia; required for host) |
| # [string]: The path on the target OS at which the test will be installed. |
| # |
| # name (optional) |
| # [string]: A name to associate with the test. Defaults to `package_url` |
| # for Fuchsia tests, or a variant-stable version of `path` for host. |
| # |
| # target (required) |
| # [label_with_toolchain]: The test target. This will be used directly as the |
| # `label` field. |
| # |
| # package_url (optional) |
| # [string] In the case of a fuchsia test, this describes the packaged test |
| # via a fuchsia package URL. See //docs/the-book/package_url.md for more |
| # details. |
| # |
| # package_label (optional) |
| # [string] In the case of a fuchsia test, this describes the GN label |
| # (with toolchain) of the fuchsia package. |
| # |
| # package_manifests (optional) |
| # [list of strings] In the case of a fuchsia test, this contains a set of |
| # paths to package manifests that describe the blobs needed by this test. |
| # |
| # component_label (optional) |
| # [string] In case of test component, this describes the Gn label (with |
| # toolchain) of the fuchsia component. |
| # |
| # deps (optional) |
| # [list of labels]: List of labels that the test depends on. |
| # |
| # product_bundle (optional) |
| # [string] The name of a product bundle describing the system against which |
| # the test should be run (describing the test itself in the case of boot |
| # tests). Associated product bundle artifacts can be looked up with this |
| # name in the product bundle build API module. This value is only respected |
| # when `isolated` is true. |
| # |
| # bootup_timeout_secs (optional) |
| # [int] The timeout in seconds the test expects the provided product_bundle |
| # and environment it's run against will take to boot up. This value is only |
| # respected when `isolated` is true. |
| # |
| # environments (optional, default: Emu for fuchsia; else a VM) |
| # [list of scopes] Device environments in which the test should run. |
| # |
| # Each scope in $environments contains: |
| # |
| # dimensions (required) |
| # [scope] Dimensions of bots to target. Valid dimensions are |
| # element-wise subsets of the test platform entries defined in |
| # //build/testing/platforms.gni. |
| # |
| # tags (optional) |
| # [list of strings] keys on which tests may be grouped. Tests with |
| # given tags will be run (1) together, and (2) only with support from |
| # the Infrastructure team. Labels are used as an escape hatch from the |
| # default testing pipeline for special tests or environments. |
| # |
| # |
| # log_settings (optional, default: see below properties) |
| # [json] Properties of logs produced by this test run. |
| # |
| # Following properties are supported: |
| # |
| # max_severity (optional, default: WARN) |
| # [string] Defines maximum severity of logs which can be produced by test |
| # environment. This can only be defined for test components. Test will fail |
| # if any component in its environment produces log with greater severity |
| # than defined here. |
| # |
| # min_severity (optional) |
| # [string] Defines minimum severity of logs for the test environment to produce, |
| # overriding default values in the binaries themselves (usually INFO). Messages |
| # below this severity will not be printed. |
| # |
| # parallel (optional) |
| # [int] Defines maximum concurrent test cases to run. This only works with v2 tests. |
| # If not defined, test runner will decide the default value. |
| # |
| # isolated (optional) |
| # [bool] Whether the test needs to be run in isolation to other tests. |
| # |
| # timeout_secs (optional) |
| # [int] The timeout in seconds for the test. |
| # |
| # os (optional) |
| # [string] The intended os for the test to run on. If not defined, the |
| # current_os will be used. |
| # |
| # cpu (optional) |
| # [string] The intended cpu for the test to run on. If not defined, the |
| # current_cpu will be used. |
| # |
| template("test_spec") { |
| testonly = true |
| |
| forward_variables_from(invoker, [ "environments" ]) |
| |
| # Set default environments: Emu for a fuchsia test, and VMs for linux and mac |
| # tests. |
| if (is_fuchsia || is_kernel) { |
| if (!defined(environments)) { |
| environments = basic_envs |
| } |
| } else if (is_linux || is_mac) { |
| if (!defined(environments)) { |
| environments = [ host_env ] |
| } |
| } else if (current_os == "unknown" && current_cpu == "wasm32") { |
| environments = [] |
| } else { |
| assert(false, "$current_os not supported") |
| } |
| |
| foreach(env, environments) { |
| empty_scope = { # Clear from previous iteration |
| } |
| assert(defined(env.dimensions) && env.dimensions != empty_scope, |
| "each environment must specify dimensions") |
| } |
| |
| if (is_fuchsia) { |
| _log_settings = { |
| } |
| if (defined(invoker.log_settings)) { |
| _log_settings = invoker.log_settings |
| } |
| if (!defined(_log_settings.max_severity)) { |
| _log_settings.max_severity = "WARN" |
| } |
| if (defined(_log_settings.min_severity)) { |
| assert( |
| _log_severity_allowed_val + [ _log_settings.min_severity ] - |
| [ _log_settings.min_severity ] != _log_severity_allowed_val, |
| "Invalid 'log_settings.min_severity': ${_log_settings.min_severity}, valid values are ${_log_severity_allowed_val}") |
| } |
| |
| assert( |
| _log_severity_allowed_val + [ _log_settings.max_severity ] - |
| [ _log_settings.max_severity ] != _log_severity_allowed_val, |
| "Invalid 'log_settings.max_severity': ${_log_settings.max_severity}, valid values are ${_log_severity_allowed_val}") |
| |
| if (defined(invoker.package_url)) { |
| s = string_split(invoker.package_url, ".cm") |
| is_v2_component = false |
| foreach(s, string_split(invoker.package_url, ".cm")) { |
| is_v2_component = s == "" |
| } |
| |
| # Running test cases in parallel is slow (https://fxbug.dev/42167081) for |
| # "coverage" variant. Run cases serially for that variant by default. |
| # Also let devs override the default if needed. |
| if (!defined(invoker.parallel) && is_v2_component && |
| select_variant + [ "coverage" ] - [ "coverage" ] != select_variant) { |
| _parallel = 1 |
| } |
| } |
| } else { |
| not_needed(invoker, [ "log_settings" ]) |
| } |
| |
| if (defined(invoker.parallel)) { |
| assert(is_fuchsia, "'parallel' can only be used when target is fuchsia.") |
| assert(invoker.parallel > 0) |
| assert(defined(invoker.package_url)) |
| assert(is_v2_component, "'parallel' only works for v2 test components.") |
| _parallel = invoker.parallel |
| } |
| |
| target_envs = [] |
| foreach(env, environments) { |
| dims = [] # Clear from previous iteration. |
| if (defined(env.dimensions)) { |
| dim = { |
| } |
| dim = env.dimensions |
| assert(!defined(dim.tags), |
| "tags are only valid in an environments scope, not in dimensions") |
| assert( |
| !defined(dim.dimensions), |
| "found nested dimensions environment field. Did you set `dimensions = some_env`? It should be `dimensions = some_env.dimensions`") |
| foreach(key, all_dimension_keys) { |
| dims += [ |
| { |
| forward_variables_from(env.dimensions, [ key ]) |
| }, |
| ] |
| } |
| } |
| empty_dim = { # Clear from previous iteration. |
| } |
| dims += [ empty_dim ] |
| dims -= [ empty_dim ] |
| |
| # Check if the environment's dimensions match those of a platform of the |
| # target architecture; if a match, include the environment among the |
| # test spec's. |
| # Note that in GN "A is a subset of B" is equivalent to `A + B - B == []`. |
| match = false |
| foreach(platform_dims, _target_platform_dims) { |
| if (dims + platform_dims - platform_dims == []) { |
| match = true |
| target_envs += [ env ] |
| } |
| } |
| |
| # If the environment's dimensions do not match a target architecture, ensure |
| # that they match those of a platform of another architecture. |
| if (!match) { |
| foreach(platform_dims, _other_platform_dims) { |
| match = match || dims + platform_dims - platform_dims == [] |
| } |
| if (!match) { |
| print("Could not match environment specifications for '$target_name':") |
| print("$env") |
| assert( |
| match, |
| "Consult //build/testing/platforms.gni for all allowable specifications") |
| } |
| } |
| } |
| |
| target_name_deps = [] |
| |
| # Rely on metadata reachable through deps to determine any runtime |
| # dependencies of the test; record them to a file. |
| runtime_deps_file = "" |
| if ((defined(invoker.deps) && invoker.deps != []) || |
| (defined(invoker.data_deps) && invoker.data_deps != []) || |
| (defined(invoker.public_deps) && invoker.public_deps != [])) { |
| runtime_deps_file = "$target_gen_dir/${target_name}.deps.json" |
| runtime_deps_target_name = "${target_name}_deps" |
| |
| generated_file(runtime_deps_target_name) { |
| forward_variables_from(invoker, |
| [ |
| "data_deps", |
| "deps", |
| "public_deps", |
| ]) |
| outputs = [ runtime_deps_file ] |
| data_keys = [ "test_runtime_deps" ] |
| walk_keys = [ "test_runtime_deps_barrier" ] |
| rebase = root_build_dir |
| output_conversion = "json" |
| } |
| |
| target_name_deps += [ ":$runtime_deps_target_name" ] |
| } |
| |
| _environments = [] |
| |
| # Also adds NUC11s if "nuc" environment was specified. |
| # TODO(b/237703450): Remove this logic when NUC11 is a |
| # standard environment. |
| foreach(env, target_envs) { |
| dims = [] |
| dims = env.dimensions |
| |
| if (defined(dims.device_type) && |
| dims.device_type == "Intel NUC Kit NUC7i5DNHE" && |
| target_name != "core-tests-hpet") { |
| new_nuc11_env = { |
| } |
| new_nuc11_env = { |
| forward_variables_from(env, "*", [ "dimensions" ]) |
| dimensions = { |
| device_type = "Intel NUC Kit NUC11TNHv5" |
| } |
| } |
| target_envs += [ new_nuc11_env ] |
| target_envs -= [ new_nuc11_env ] |
| target_envs += [ new_nuc11_env ] |
| } |
| } |
| |
| foreach(env, target_envs) { |
| dims = [] # Clear from previous iteration. |
| dims = env.dimensions |
| |
| if (defined(dims.os) && dims.os == "mac") { |
| # When running tests for a mac build, we only wish to run mac tests; we |
| # enforce the "mac" tag in that case to filter out other tests. |
| assert(defined(env.tags) && [ "mac" ] + env.tags - env.tags == [], |
| "Mac environments must have a tag of \"mac\"") |
| } |
| |
| has_allowed_device_type = defined(dims.device_type) && |
| allowed_device_types + [ dims.device_type ] - |
| [ dims.device_type ] != allowed_device_types |
| if (has_allowed_device_type || !defined(dims.device_type)) { |
| # GN idiom for adding to a list without adding duplicate elements. |
| _environments += [ env ] |
| _environments -= [ env ] |
| _environments += [ env ] |
| } |
| } |
| |
| test_spec = { |
| forward_variables_from(invoker, |
| [ |
| "product_bundle", |
| "bootup_timeout_secs", |
| ]) |
| test = { |
| forward_variables_from(invoker, |
| [ |
| "cpu", |
| "isolated", |
| "name", |
| "os", |
| "path", |
| "new_path", |
| "package_url", |
| "package_label", |
| "component_label", |
| "package_manifests", |
| "timeout_secs", |
| "build_rule", |
| "has_generated_manifest", |
| ]) |
| if (!defined(isolated) || !isolated) { |
| assert(!defined(product_bundle), |
| "product_bundle is only respected if isolated=true.") |
| assert(!defined(bootup_timeout_secs), |
| "bootup_timeout_secs is only respected if isolated=true.") |
| } |
| if (defined(_parallel)) { |
| parallel = _parallel |
| } |
| label = invoker.target |
| assert(label == get_label_info(label, "label_with_toolchain"), |
| "target '${label}' must be a label_with_toolchain.") |
| |
| if (is_fuchsia) { |
| log_settings = _log_settings |
| } |
| |
| if (!defined(package_url)) { |
| assert(defined(path), "path or package_url must be defined.") |
| if (is_linux || is_mac || |
| (defined(invoker.os) && |
| (invoker.os == "linux" || invoker.os == "mac"))) { |
| # Trim leading //. |
| path = rebase_path(path, root_build_dir) |
| } |
| } else if (defined(new_path)) { |
| # Trim leading //. |
| new_path = rebase_path(new_path, root_build_dir) |
| } |
| |
| if (!defined(name)) { |
| if (defined(package_url)) { |
| name = package_url |
| } else { |
| # We want the test name to be the same regardless of variant. |
| # Path is of the form <toolchain_variant.name>/<basename>, so |
| # removing the left-most appearance should do what we want. |
| name = string_replace(path, toolchain_variant.suffix, "", 1) |
| } |
| } |
| |
| if (!defined(os)) { |
| os = current_os |
| } |
| if (!defined(cpu)) { |
| cpu = current_cpu |
| } |
| if (runtime_deps_file != "") { |
| runtime_deps = rebase_path(runtime_deps_file, root_build_dir) |
| } |
| } |
| environments = [] # Clear from previous iteration. |
| environments = _environments |
| } |
| |
| group(target_name) { |
| forward_variables_from(invoker, |
| [ |
| "visibility", |
| "assert_no_deps", |
| ]) |
| metadata = { |
| if (defined(invoker.metadata)) { |
| forward_variables_from(invoker.metadata, "*") |
| } |
| tests = [ test_spec ] |
| } |
| deps = target_name_deps |
| if (defined(invoker.isolated) && invoker.isolated && |
| # Tests that use product bundles, primarily boot tests, must necessarily |
| # run in isolated mode, so they need not be explicitly included in the |
| # isolated allowlist. |
| !defined(invoker.product_bundle)) { |
| deps += [ "//build/testing/isolated:isolated_test_spec_allowlist" ] |
| } |
| if (defined(invoker.timeout_secs) && |
| # Tests that use product bundles, primarily boot tests, are known to |
| # run slower, so they need not be explicitly included in the allowlist. |
| !defined(invoker.product_bundle)) { |
| dir = string_replace(get_label_info(invoker.target, "dir"), "//", "") |
| split = string_split(dir, "/") |
| if (split[0] == "vendor") { |
| # Use the vendor repo's allowlist. |
| deps += [ "//vendor/" + split[1] + |
| "/build/testing/timeouts:per_test_timeout_allowlist" ] |
| } else { |
| deps += [ "//build/testing/timeouts:per_test_timeout_allowlist" ] |
| } |
| } |
| } |
| |
| # When an unreferenced board_name is used, the allowed_device_types |
| # assignment will have no effect. |
| not_needed([ "allowed_device_types" ]) |
| } |
