mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
212da506a4
Whether we're building an x64 or arm64 macOS host build, always build unit tests. Issue: https://github.com/flutter/flutter/issues/124840
370 lines
11 KiB
Plaintext
370 lines
11 KiB
Plaintext
# Copyright 2013 The Flutter 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/compiled_action.gni")
|
|
import("//flutter/common/config.gni")
|
|
import("//third_party/dart/build/dart/dart_action.gni")
|
|
import("//third_party/dart/sdk_args.gni")
|
|
|
|
is_aot_test =
|
|
flutter_runtime_mode == "profile" || flutter_runtime_mode == "release"
|
|
|
|
# Build unit tests when any of the following are true:
|
|
# * host_toolchain: non-cross-compile, so we can run tests on the host.
|
|
# * is_mac: arm64 builds can run x64 binaries.
|
|
# * is_fuchsia: build unittests for testing on device.
|
|
declare_args() {
|
|
enable_unittests = current_toolchain == host_toolchain || is_fuchsia || is_mac
|
|
}
|
|
|
|
# Creates a translation unit that defines the flutter::testing::GetFixturesPath
|
|
# method that tests can use to locate their fixtures.
|
|
#
|
|
# Arguments
|
|
# assets_dir (required): The assets directory
|
|
template("fixtures_location") {
|
|
testonly = true
|
|
|
|
assert(defined(invoker.assets_dir), "The assets directory.")
|
|
|
|
location_path = rebase_path(invoker.assets_dir)
|
|
testing_assets_path = rebase_path("$root_out_dir/gen/flutter/testing/assets")
|
|
source_path = rebase_path("//")
|
|
|
|
# Array of source lines. We use a list to ensure a trailing newline is
|
|
# emitted by write_file() to comply with -Wnewline-eof.
|
|
location_source = [
|
|
"namespace flutter { namespace testing { ",
|
|
"const char* GetSourcePath() {return \"$source_path\";} ",
|
|
"const char* GetFixturesPath() {return \"$location_path\";} ",
|
|
"const char* GetTestingAssetsPath() {return \"$testing_assets_path\";} ",
|
|
"}}",
|
|
]
|
|
location_source_path = "$target_gen_dir/_fl_$target_name.cc"
|
|
|
|
write_file(location_source_path, location_source)
|
|
|
|
source_set(target_name) {
|
|
public = []
|
|
sources = [ location_source_path ]
|
|
}
|
|
}
|
|
|
|
# Invokes the frontend server using the built Dart SDK or the prebuilt Dart SDK
|
|
# as appropriate.
|
|
#
|
|
# Parameters:
|
|
# The parameters testonly, deps, inputs, outputs, depfile, and args are
|
|
# forwarded from the invoker either to an 'action' target or a 'dart_action'
|
|
# target depending on whether a prebuilt Dart SDK is used or not,
|
|
# respectively.
|
|
template("_frontend_server") {
|
|
if (flutter_prebuilt_dart_sdk) {
|
|
action(target_name) {
|
|
testonly = invoker.testonly
|
|
deps = invoker.deps
|
|
script = "//build/gn_run_binary.py"
|
|
inputs = invoker.inputs
|
|
outputs = invoker.outputs
|
|
depfile = invoker.depfile
|
|
pool = "//flutter/build/dart:dart_pool"
|
|
|
|
ext = ""
|
|
if (is_win) {
|
|
ext = ".exe"
|
|
}
|
|
dart = rebase_path("$host_prebuilt_dart_sdk/bin/dart$ext", root_out_dir)
|
|
frontend_server = rebase_path(
|
|
"$host_prebuilt_dart_sdk/bin/snapshots/frontend_server.dart.snapshot")
|
|
|
|
args = [
|
|
dart,
|
|
frontend_server,
|
|
] + invoker.args
|
|
}
|
|
} else {
|
|
dart_action(target_name) {
|
|
forward_variables_from(invoker, "*")
|
|
deps += [ "//third_party/dart/utils/kernel-service:frontend_server" ]
|
|
script = "$root_out_dir/frontend_server.dart.snapshot"
|
|
pool = "//flutter/build/dart:dart_pool"
|
|
}
|
|
}
|
|
}
|
|
|
|
# Generates the Dart kernel snapshot.
|
|
#
|
|
# Arguments
|
|
# dart_main (required): The Main Dart file.
|
|
#
|
|
# dart_kernel (required): The path to the output kernel snapshot in the out
|
|
# directory.
|
|
template("dart_snapshot_kernel") {
|
|
testonly = true
|
|
|
|
assert(defined(invoker.dart_main), "The Dart Main file must be specified")
|
|
assert(defined(invoker.dart_kernel),
|
|
"The Dart Kernel file location must be specified")
|
|
|
|
_frontend_server(target_name) {
|
|
testonly = true
|
|
|
|
deps = [ "//flutter/lib/snapshot:strong_platform" ]
|
|
|
|
inputs = [ invoker.dart_main ]
|
|
|
|
outputs = [ invoker.dart_kernel ]
|
|
|
|
snapshot_depfile = "$target_gen_dir/snapshot_$target_name.depfile.d"
|
|
depfile = snapshot_depfile
|
|
|
|
args = [
|
|
"--sdk-root",
|
|
rebase_path("$root_out_dir/flutter_patched_sdk"),
|
|
"--target",
|
|
"flutter",
|
|
"--sound-null-safety",
|
|
"--output-dill",
|
|
rebase_path(invoker.dart_kernel, root_out_dir),
|
|
"--depfile",
|
|
rebase_path(snapshot_depfile),
|
|
]
|
|
|
|
if (flutter_runtime_mode == "release" ||
|
|
flutter_runtime_mode == "jit_release") {
|
|
args += [ "-Ddart.vm.product=true" ]
|
|
}
|
|
|
|
if (is_aot_test) {
|
|
args += [
|
|
"--aot",
|
|
|
|
# type flow analysis
|
|
"--tfa",
|
|
]
|
|
}
|
|
|
|
args += [ rebase_path(invoker.dart_main) ]
|
|
}
|
|
}
|
|
|
|
# Generates an AOT snapshot from a kernel snapshot.
|
|
#
|
|
# Arguments:
|
|
#
|
|
# dart_kernel (required): The path to the kernel snapshot.
|
|
#
|
|
# dart_elf_filename (required): The filename of the AOT ELF snapshot.
|
|
template("dart_snapshot_aot") {
|
|
testonly = true
|
|
|
|
assert(defined(invoker.dart_kernel),
|
|
"The Dart Kernel file location must be specified")
|
|
|
|
assert(defined(invoker.dart_elf_filename),
|
|
"The main Dart ELF filename must be specified.")
|
|
|
|
compiled_action(target_name) {
|
|
testonly = true
|
|
|
|
tool = "//third_party/dart/runtime/bin:gen_snapshot"
|
|
|
|
pool = "//flutter/build/dart:dart_pool"
|
|
|
|
inputs = [ invoker.dart_kernel ]
|
|
|
|
# Custom ELF loader is used for Mac and Windows.
|
|
elf_object = "$target_gen_dir/assets/${invoker.dart_elf_filename}"
|
|
|
|
loading_unit_manifest = "$target_gen_dir/assets/loading_unit_manifest.json"
|
|
|
|
outputs = [ elf_object ]
|
|
|
|
args = [
|
|
"--deterministic",
|
|
"--snapshot_kind=app-aot-elf",
|
|
"--loading_unit_manifest=" + rebase_path(loading_unit_manifest),
|
|
"--elf=" + rebase_path(elf_object),
|
|
rebase_path(invoker.dart_kernel),
|
|
]
|
|
|
|
forward_variables_from(invoker, [ "deps" ])
|
|
}
|
|
}
|
|
|
|
# Generates a kernel or AOT snapshot as necessary from the main Dart file.
|
|
# Other Dart dependencies referenced by that main Dart file will be tracked.
|
|
#
|
|
# Arguments:
|
|
#
|
|
# dart_main (required): The path to the main Dart file.
|
|
#
|
|
# dart_kernel_filename (required): The filename of the kernel blob.
|
|
#
|
|
# dart_elf_filename (required): The filename of the AOT ELF snapshot only if is_aot_test is true.
|
|
template("dart_snapshot") {
|
|
assert(defined(invoker.dart_main), "The main Dart file must be specified.")
|
|
assert(defined(invoker.dart_kernel_filename),
|
|
"The main Dart kernel filename must be specified.")
|
|
|
|
testonly = true
|
|
|
|
dart_snapshot_kernel_target_name = "_dsk_$target_name"
|
|
|
|
dart_snapshot_kernel_path =
|
|
"$target_gen_dir/assets/${invoker.dart_kernel_filename}"
|
|
|
|
dart_snapshot_kernel(dart_snapshot_kernel_target_name) {
|
|
dart_main = invoker.dart_main
|
|
dart_kernel = dart_snapshot_kernel_path
|
|
}
|
|
|
|
snapshot_deps = []
|
|
snapshot_public_deps = [ ":$dart_snapshot_kernel_target_name" ]
|
|
|
|
if (is_aot_test) {
|
|
assert(defined(invoker.dart_elf_filename),
|
|
"The main Dart ELF filename must be specified.")
|
|
|
|
dart_snapshot_aot_target_name = "_dsa_$target_name"
|
|
dart_snapshot_aot(dart_snapshot_aot_target_name) {
|
|
dart_kernel = dart_snapshot_kernel_path
|
|
dart_elf_filename = invoker.dart_elf_filename
|
|
deps = [ ":$dart_snapshot_kernel_target_name" ]
|
|
}
|
|
snapshot_deps += [ ":$dart_snapshot_aot_target_name" ]
|
|
}
|
|
|
|
group(target_name) {
|
|
testonly = true
|
|
deps = snapshot_deps
|
|
public_deps = snapshot_public_deps
|
|
}
|
|
}
|
|
|
|
# Copies a (potentially empty) list of fixtures to the fixtures directory for
|
|
# the unit test.
|
|
#
|
|
# Arguments:
|
|
#
|
|
# fixtures (required): The list of fixtures to copy.
|
|
#
|
|
# dest (optional): When specified, the fixtures are placed under an
|
|
# 'assets' subdirectory of this path rather than an
|
|
# 'assets' subdirectory of target_gen_dir.
|
|
template("copy_fixtures") {
|
|
testonly = true
|
|
|
|
assert(defined(invoker.fixtures), "The test fixtures must be specified.")
|
|
|
|
dest = target_gen_dir
|
|
if (defined(invoker.dest)) {
|
|
dest = invoker.dest
|
|
}
|
|
|
|
has_fixtures = false
|
|
foreach(fixture, invoker.fixtures) {
|
|
has_fixtures = true
|
|
}
|
|
|
|
if (has_fixtures) {
|
|
copy(target_name) {
|
|
sources = invoker.fixtures
|
|
outputs = [ "$dest/assets/{{source_file_part}}" ]
|
|
forward_variables_from(invoker, [ "deps" ])
|
|
}
|
|
} else {
|
|
group(target_name) {
|
|
# The copy target cannot accept an empty list.
|
|
}
|
|
}
|
|
}
|
|
|
|
# Specifies the fixtures to copy to a location known by the specific unit test.
|
|
# Test executable can only depend on one such target. You can use either one of
|
|
# both arguments to expand this template. If you have none, then you'll see the
|
|
# unused invoker scope error. In such cases specify the fixtures using an empty
|
|
# array.
|
|
#
|
|
# The targets which generate the outputs from these test fixtures (e.g. the
|
|
# Dart kernel snapshot) are exposed as public dependencies of the test fixture
|
|
# target. This is so that users can depend on the test fixture target directly
|
|
# and be able to access the generated outputs without needing to know about the
|
|
# internal dependency structure generated by this template.
|
|
#
|
|
# Arguments:
|
|
#
|
|
# fixtures (optional): The list of test fixtures. An empty list may be
|
|
# specified.
|
|
#
|
|
# dart_main (optional): The path to the main Dart file. If specified, it is
|
|
# snapshotted.
|
|
#
|
|
# use_target_as_artifact_prefix(optional): If true, adds the target name as
|
|
# prefix of the kernel and AOT ELF snapshot filename.
|
|
#
|
|
# dest (optional): When specified, the fixtures are placed under an
|
|
# 'assets' subdirectory of this path rather than an
|
|
# 'assets' subdirectory of target_gen_dir.
|
|
template("test_fixtures") {
|
|
dest = target_gen_dir
|
|
if (defined(invoker.dest)) {
|
|
dest = invoker.dest
|
|
}
|
|
|
|
# Not all paths use 'dest'
|
|
not_needed([ "dest" ])
|
|
|
|
# Even if no fixtures are present, the location of the fixtures directory
|
|
# must always be known to tests.
|
|
fixtures_location_target_name = "_fl_$target_name"
|
|
fixtures_location(fixtures_location_target_name) {
|
|
if (is_fuchsia) {
|
|
assets_dir = "/pkg/data/assets"
|
|
} else {
|
|
assets_dir = "$dest/assets"
|
|
}
|
|
}
|
|
test_deps = [ ":$fixtures_location_target_name" ]
|
|
test_public_deps = []
|
|
|
|
# If the fixtures are specified, copy them to the assets directory.
|
|
if (defined(invoker.fixtures)) {
|
|
copy_fixtures_target_name = "_cf_$target_name"
|
|
copy_fixtures(copy_fixtures_target_name) {
|
|
fixtures = invoker.fixtures
|
|
dest = dest
|
|
forward_variables_from(invoker, [ "deps" ])
|
|
}
|
|
test_public_deps += [ ":$copy_fixtures_target_name" ]
|
|
}
|
|
|
|
# If a Dart file is specified, snapshot it and place it in the generated
|
|
# assets directory.
|
|
if (defined(invoker.dart_main)) {
|
|
if (defined(invoker.use_target_as_artifact_prefix) &&
|
|
invoker.use_target_as_artifact_prefix) {
|
|
artifact_prefix = "${target_name}_"
|
|
} else {
|
|
artifact_prefix = ""
|
|
}
|
|
dart_snapshot_target_name = "_ds_$target_name"
|
|
dart_snapshot(dart_snapshot_target_name) {
|
|
dart_main = invoker.dart_main
|
|
dart_kernel_filename = "${artifact_prefix}kernel_blob.bin"
|
|
if (is_aot_test) {
|
|
dart_elf_filename = "${artifact_prefix}app_elf_snapshot.so"
|
|
}
|
|
}
|
|
|
|
test_public_deps += [ ":$dart_snapshot_target_name" ]
|
|
}
|
|
|
|
group(target_name) {
|
|
testonly = true
|
|
deps = test_deps
|
|
public_deps = test_public_deps
|
|
}
|
|
}
|