forked from flutter/engine
-
Notifications
You must be signed in to change notification settings - Fork 0
/
testing.gni
299 lines (247 loc) · 8.86 KB
/
testing.gni
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
# 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")
is_aot_test =
flutter_runtime_mode == "profile" || flutter_runtime_mode == "release"
# Unit tests targets are only enabled for host machines and Fuchsia right now
declare_args() {
enable_unittests = current_toolchain == host_toolchain || is_fuchsia
}
# 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)
# 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* GetFixturesPath() {return \"$location_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 ]
}
}
# 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")
dart_action(target_name) {
testonly = true
deps = [
# This generates the Frontend server snapshot used in this Dart action as
# well as the patched SDK.
"//third_party/dart/utils/kernel-service:frontend_server",
]
if (is_aot_test) {
deps += [ "//flutter/lib/snapshot:strong_platform" ]
}
script = "$root_out_dir/frontend_server.dart.snapshot"
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"
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 = [
"--lazy_async_stacks",
"--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.
template("copy_fixtures") {
testonly = true
assert(defined(invoker.fixtures), "The test fixtures must be specified.")
has_fixtures = false
foreach(fixture, invoker.fixtures) {
has_fixtures = true
}
if (has_fixtures) {
copy(target_name) {
sources = invoker.fixtures
outputs = [ "$target_gen_dir/assets/{{source_file_part}}" ]
}
} 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.
template("test_fixtures") {
# 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 = "$target_gen_dir/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
}
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
}
}