test/Android.run-test.mk

   1 # Copyright (C) 2011 The Android Open Source Project
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14 #
  15
  16 LOCAL_PATH := $(call my-dir)
  17
  18 include art/build/Android.common_test.mk
  19
  20 # List of all tests of the form 003-omnibus-opcodes.
  21 TEST_ART_RUN_TESTS := $(wildcard $(LOCAL_PATH)/[0-9]*)
  22 TEST_ART_RUN_TESTS := $(subst $(LOCAL_PATH)/,, $(TEST_ART_RUN_TESTS))
  23
  24 ########################################################################
  25 # The art-run-tests module, used to build all run-tests into an image.
  26
  27 # The path where build only targets will be output, e.g.
  28 # out/target/product/generic_x86_64/obj/PACKAGING/art-run-tests_intermediates/DATA
  29 art_run_tests_build_dir := $(call intermediates-dir-for,JAVA_LIBRARIES,art-run-tests)/DATA
  30 art_run_tests_install_dir := $(call intermediates-dir-for,PACKAGING,art-run-tests)/DATA
  31
  32 # A generated list of prerequisites that call 'run-test --build-only', the actual prerequisite is
  33 # an empty file touched in the intermediate directory.
  34 TEST_ART_RUN_TEST_BUILD_RULES :=
  35
  36 # Dependencies for actually running a run-test.
  37 TEST_ART_RUN_TEST_DEPENDENCIES := \
  38   $(DX) \
  39   $(HOST_OUT_EXECUTABLES)/jasmin \
  40   $(HOST_OUT_EXECUTABLES)/smali \
  41   $(HOST_OUT_EXECUTABLES)/dexmerger \
  42   $(JACK)
  43
  44 TEST_ART_RUN_TEST_ORDERONLY_DEPENDENCIES := setup-jack-server
  45
  46 ifeq ($(ART_TEST_DEBUG_GC),true)
  47   ART_TEST_WITH_STRACE := true
  48 endif
  49
  50 ifeq ($(ART_TEST_BISECTION),true)
  51   # Need to keep rebuilding the test to bisection search it.
  52   ART_TEST_RUN_TEST_NO_PREBUILD := true
  53   ART_TEST_RUN_TEST_PREBUILD := false
  54   # Bisection search writes to standard output.
  55   ART_TEST_QUIET := false
  56 endif
  57
  58 # Helper to create individual build targets for tests. Must be called with $(eval).
  59 # $(1): the test number
  60 define define-build-art-run-test
  61   dmart_target := $(art_run_tests_build_dir)/art-run-tests/$(1)/touch
  62   dmart_install_target := $(art_run_tests_install_dir)/art-run-tests/$(1)/touch
  63   run_test_options = --build-only
  64   ifeq ($(ART_TEST_QUIET),true)
  65     run_test_options += --quiet
  66   endif
  67 $$(dmart_target): PRIVATE_RUN_TEST_OPTIONS := $$(run_test_options)
  68 $$(dmart_target): $(TEST_ART_RUN_TEST_DEPENDENCIES) $(TARGET_JACK_CLASSPATH_DEPENDENCIES) | $(TEST_ART_RUN_TEST_ORDERONLY_DEPENDENCIES)
  69         $(hide) rm -rf $$(dir $$@) && mkdir -p $$(dir $$@)
  70         $(hide) DX=$(abspath $(DX)) JASMIN=$(abspath $(HOST_OUT_EXECUTABLES)/jasmin) \
  71           SMALI=$(abspath $(HOST_OUT_EXECUTABLES)/smali) \
  72           DXMERGER=$(abspath $(HOST_OUT_EXECUTABLES)/dexmerger) \
  73           JACK_VERSION=$(JACK_DEFAULT_VERSION) \
  74           JACK=$(abspath $(JACK)) \
  75           JACK_VERSION=$(JACK_DEFAULT_VERSION) \
  76           JACK_CLASSPATH=$(TARGET_JACK_CLASSPATH) \
  77           $(LOCAL_PATH)/run-test $$(PRIVATE_RUN_TEST_OPTIONS) --output-path $$(abspath $$(dir $$@)) $(1)
  78         $(hide) touch $$@
  79
  80 $$(dmart_install_target): $$(dmart_target)
  81         $(hide) rm -rf $$(dir $$@) && mkdir -p $$(dir $$@)
  82         $(hide) cp $$(dir $$<)/* $$(dir $$@)/
  83
  84   TEST_ART_RUN_TEST_BUILD_RULES += $$(dmart_install_target)
  85   dmart_target :=
  86   dmart_install_target :=
  87   run_test_options :=
  88 endef
  89 $(foreach test, $(TEST_ART_RUN_TESTS), $(eval $(call define-build-art-run-test,$(test))))
  90
  91 include $(CLEAR_VARS)
  92 LOCAL_MODULE_TAGS := tests
  93 LOCAL_MODULE := art-run-tests
  94 LOCAL_ADDITIONAL_DEPENDENCIES := $(TEST_ART_RUN_TEST_BUILD_RULES)
  95 # The build system use this flag to pick up files generated by declare-make-art-run-test.
  96 LOCAL_PICKUP_FILES := $(art_run_tests_install_dir)
  97
  98 include $(BUILD_PHONY_PACKAGE)
  99
 100 # Clear temp vars.
 101 art_run_tests_build_dir :=
 102 art_run_tests_install_dir :=
 103 define-build-art-run-test :=
 104 TEST_ART_RUN_TEST_BUILD_RULES :=
 105
 106 ########################################################################
 107 # General rules to build and run a run-test.
 108
 109 TARGET_TYPES := host target
 110 PREBUILD_TYPES :=
 111 ifeq ($(ART_TEST_RUN_TEST_PREBUILD),true)
 112   PREBUILD_TYPES += prebuild
 113 endif
 114 ifeq ($(ART_TEST_RUN_TEST_NO_PREBUILD),true)
 115   PREBUILD_TYPES += no-prebuild
 116 endif
 117 ifeq ($(ART_TEST_RUN_TEST_NO_DEX2OAT),true)
 118   PREBUILD_TYPES += no-dex2oat
 119 endif
 120 COMPILER_TYPES :=
 121 ifeq ($(ART_TEST_INTERPRETER_ACCESS_CHECKS),true)
 122   COMPILER_TYPES += interp-ac
 123 endif
 124 ifeq ($(ART_TEST_INTERPRETER),true)
 125   COMPILER_TYPES += interpreter
 126 endif
 127 ifeq ($(ART_TEST_JIT),true)
 128   COMPILER_TYPES += jit
 129 endif
 130 OPTIMIZING_COMPILER_TYPES :=
 131 ifeq ($(ART_TEST_OPTIMIZING),true)
 132   COMPILER_TYPES += optimizing
 133   OPTIMIZING_COMPILER_TYPES += optimizing
 134 endif
 135 ifeq ($(ART_TEST_OPTIMIZING_GRAPH_COLOR),true)
 136   COMPILER_TYPES += regalloc_gc
 137   OPTIMIZING_COMPILER_TYPES += regalloc_gc
 138 endif
 139 RELOCATE_TYPES := no-relocate
 140 ifeq ($(ART_TEST_RUN_TEST_RELOCATE),true)
 141   RELOCATE_TYPES += relocate
 142 endif
 143 ifeq ($(ART_TEST_RUN_TEST_RELOCATE_NO_PATCHOAT),true)
 144   RELOCATE_TYPES += relocate-npatchoat
 145 endif
 146 TRACE_TYPES := ntrace
 147 ifeq ($(ART_TEST_TRACE),true)
 148   TRACE_TYPES += trace
 149 endif
 150 ifeq ($(ART_TEST_TRACE_STREAM),true)
 151   TRACE_TYPES += stream
 152 endif
 153 GC_TYPES := cms
 154 ifeq ($(ART_TEST_GC_STRESS),true)
 155   GC_TYPES += gcstress
 156 endif
 157 ifeq ($(ART_TEST_GC_VERIFY),true)
 158   GC_TYPES += gcverify
 159 endif
 160 JNI_TYPES := checkjni
 161 ifeq ($(ART_TEST_JNI_FORCECOPY),true)
 162   JNI_TYPES += forcecopy
 163 endif
 164 ifeq ($(ART_TEST_RUN_TEST_IMAGE),true)
 165 IMAGE_TYPES := picimage
 166 endif
 167 ifeq ($(ART_TEST_RUN_TEST_NO_IMAGE),true)
 168   IMAGE_TYPES += no-image
 169 endif
 170 ifeq ($(ART_TEST_RUN_TEST_MULTI_IMAGE),true)
 171   IMAGE_TYPES := multipicimage
 172 endif
 173 PICTEST_TYPES := npictest
 174 ifeq ($(ART_TEST_PIC_TEST),true)
 175   PICTEST_TYPES += pictest
 176 endif
 177 RUN_TYPES :=
 178 ifeq ($(ART_TEST_RUN_TEST_DEBUG),true)
 179   RUN_TYPES += debug
 180 endif
 181 ifeq ($(ART_TEST_RUN_TEST_NDEBUG),true)
 182   RUN_TYPES += ndebug
 183 endif
 184 DEBUGGABLE_TYPES := ndebuggable
 185 ifeq ($(ART_TEST_RUN_TEST_DEBUGGABLE),true)
 186 DEBUGGABLE_TYPES += debuggable
 187 endif
 188 ADDRESS_SIZES_TARGET := $(ART_PHONY_TEST_TARGET_SUFFIX)
 189 ADDRESS_SIZES_HOST := $(ART_PHONY_TEST_HOST_SUFFIX)
 190 ifeq ($(ART_TEST_RUN_TEST_2ND_ARCH),true)
 191   ADDRESS_SIZES_TARGET += $(2ND_ART_PHONY_TEST_TARGET_SUFFIX)
 192   ADDRESS_SIZES_HOST += $(2ND_ART_PHONY_TEST_HOST_SUFFIX)
 193 endif
 194 ALL_ADDRESS_SIZES := 64 32
 195
 196 # List all run test names with number arguments agreeing with the comment above.
 197 define all-run-test-names
 198   $(foreach target, $(1), \
 199     $(foreach run-type, $(2), \
 200       $(foreach prebuild, $(3), \
 201         $(foreach compiler, $(4), \
 202           $(foreach relocate, $(5), \
 203             $(foreach trace, $(6), \
 204               $(foreach gc, $(7), \
 205                 $(foreach jni, $(8), \
 206                   $(foreach image, $(9), \
 207                     $(foreach pictest, $(10), \
 208                       $(foreach debuggable, $(11), \
 209                         $(foreach test, $(12), \
 210                           $(foreach address_size, $(13), \
 211                             test-art-$(target)-run-test-$(run-type)-$(prebuild)-$(compiler)-$(relocate)-$(trace)-$(gc)-$(jni)-$(image)-$(pictest)-$(debuggable)-$(test)$(address_size) \
 212                     )))))))))))))
 213 endef  # all-run-test-names
 214
 215 # To generate a full list or tests:
 216 # $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES),$(COMPILER_TYPES), \
 217 #        $(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES), \
 218 #        $(PICTEST_TYPES),$(DEBUGGABLE_TYPES),$(TEST_ART_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 219
 220 # Convert's a rule name to the form used in variables, e.g. no-relocate to NO_RELOCATE
 221 define name-to-var
 222 $(shell echo $(1) | tr '[:lower:]' '[:upper:]' | tr '-' '_')
 223 endef  # name-to-var
 224
 225 # Disable 115-native-bridge, it fails when run through make b/35984597.
 226 # Disable 153-reference-stress temporarily until a fix arrives. b/33389022.
 227 # Disable 080-oom-fragmentation due to flakes. b/33795328
 228 # Disable 497-inlining-and-class-loader and 542-unresolved-access-check until
 229 #     they are rewritten. These tests use a broken class loader that tries to
 230 #     register a dex file that's already registered with a different loader.
 231 #     b/34193123
 232 ART_TEST_RUN_TEST_SKIP += \
 233   115-native-bridge \
 234   153-reference-stress \
 235   080-oom-fragmentation \
 236   497-inlining-and-class-loader \
 237   542-unresolved-access-check
 238
 239 ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 240         $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 241         $(IMAGE_TYPES), $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(ART_TEST_RUN_TEST_SKIP), $(ALL_ADDRESS_SIZES))
 242
 243
 244 # Disable 149-suspend-all-stress, its output is flaky (b/28988206).
 245 TEST_ART_BROKEN_ALL_TARGET_TESTS := \
 246   149-suspend-all-stress \
 247
 248 ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 249     $(COMPILER_TYPES), $(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 250     $(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_ALL_TARGET_TESTS), \
 251     $(ALL_ADDRESS_SIZES))
 252
 253 TEST_ART_BROKEN_ALL_TARGET_TESTS :=
 254
 255 # Tests that are timing sensitive and flaky on heavily loaded systems.
 256 TEST_ART_TIMING_SENSITIVE_RUN_TESTS := \
 257   002-sleep \
 258   053-wait-some \
 259   055-enum-performance \
 260   133-static-invoke-super
 261
 262 # disable timing sensitive tests on "dist" builds.
 263 ifdef dist_goal
 264   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 265         $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 266         $(IMAGE_TYPES), $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_TIMING_SENSITIVE_RUN_TESTS), $(ALL_ADDRESS_SIZES))
 267 endif
 268
 269 # 147-stripped-dex-fallback isn't supported on device because --strip-dex
 270 # requires the zip command.
 271 # 569-checker-pattern-replacement tests behaviour present only on host.
 272 TEST_ART_BROKEN_TARGET_TESTS := \
 273   147-stripped-dex-fallback \
 274   569-checker-pattern-replacement
 275
 276 ifneq (,$(filter target,$(TARGET_TYPES)))
 277   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,target,$(RUN_TYPES),$(PREBUILD_TYPES), \
 278       $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 279       $(IMAGE_TYPES), $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_TARGET_TESTS), $(ALL_ADDRESS_SIZES))
 280 endif
 281
 282 TEST_ART_BROKEN_TARGET_TESTS :=
 283
 284 # Tests that require python3.
 285 TEST_ART_PYTHON3_DEPENDENCY_RUN_TESTS := \
 286   960-default-smali \
 287   961-default-iface-resolution-gen \
 288   964-default-iface-init-gen \
 289   968-default-partial-compile-gen \
 290   969-iface-super \
 291   970-iface-super-resolution-gen \
 292   971-iface-super
 293
 294 # Check if we have python3 to run our tests.
 295 ifeq ($(wildcard /usr/bin/python3),)
 296   $(warning "No python3 found. Disabling tests: $(TEST_ART_PYTHON3_DEPENDENCY_RUN_TESTS)")
 297
 298   # Currently disable tests requiring python3 when it is not installed.
 299   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 300         $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 301         $(IMAGE_TYPES), $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_PYTHON3_DEPENDENCY_RUN_TESTS), $(ALL_ADDRESS_SIZES))
 302 endif
 303
 304 TEST_ART_TIMING_SENSITIVE_RUN_TESTS :=
 305
 306 # Note 116-nodex2oat is not broken per-se it just doesn't (and isn't meant to) work with --prebuild.
 307 TEST_ART_BROKEN_PREBUILD_RUN_TESTS := \
 308   116-nodex2oat \
 309   118-noimage-dex2oat \
 310   134-nodex2oat-nofallback
 311
 312 ifneq (,$(filter prebuild,$(PREBUILD_TYPES)))
 313   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),prebuild, \
 314       $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 315       $(IMAGE_TYPES), $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_PREBUILD_RUN_TESTS), $(ALL_ADDRESS_SIZES))
 316 endif
 317
 318 TEST_ART_BROKEN_PREBUILD_RUN_TESTS :=
 319
 320 # 554-jit-profile-file is disabled because it needs a primary oat file to know what it should save.
 321 # 529 and 555: b/27784033
 322 TEST_ART_BROKEN_NO_PREBUILD_TESTS := \
 323   117-nopatchoat \
 324   147-stripped-dex-fallback \
 325   554-jit-profile-file \
 326   529-checker-unresolved \
 327   555-checker-regression-x86const \
 328   608-checker-unresolved-lse
 329
 330 ifneq (,$(filter no-prebuild,$(PREBUILD_TYPES)))
 331   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),no-prebuild, \
 332       $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 333       $(IMAGE_TYPES), $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_NO_PREBUILD_TESTS), $(ALL_ADDRESS_SIZES))
 334 endif
 335
 336 TEST_ART_BROKEN_NO_PREBUILD_TESTS :=
 337
 338 # Note 117-nopatchoat is not broken per-se it just doesn't work (and isn't meant to) without
 339 # --prebuild --relocate
 340 TEST_ART_BROKEN_NO_RELOCATE_TESTS := \
 341   117-nopatchoat \
 342   118-noimage-dex2oat \
 343   119-noimage-patchoat \
 344   554-jit-profile-file
 345
 346 ifneq (,$(filter no-relocate,$(RELOCATE_TYPES)))
 347   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 348       $(COMPILER_TYPES), no-relocate,$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 349       $(IMAGE_TYPES), $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_NO_RELOCATE_TESTS), $(ALL_ADDRESS_SIZES))
 350 endif
 351
 352 TEST_ART_BROKEN_NO_RELOCATE_TESTS :=
 353
 354 # Temporarily disable some broken tests when forcing access checks in interpreter b/22414682
 355 # 629 requires compilation.
 356 TEST_ART_BROKEN_INTERPRETER_ACCESS_CHECK_TESTS := \
 357   137-cfi \
 358   629-vdex-speed
 359
 360 ifneq (,$(filter interp-ac,$(COMPILER_TYPES)))
 361   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 362       interp-ac,$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 363       $(IMAGE_TYPES), $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_INTERPRETER_ACCESS_CHECK_TESTS), $(ALL_ADDRESS_SIZES))
 364 endif
 365
 366 TEST_ART_BROKEN_INTERPRETER_ACCESS_CHECK_TESTS :=
 367
 368 # Tests that are broken with GC stress.
 369 # * 137-cfi needs to unwind a second forked process. We're using a primitive sleep to wait till we
 370 #   hope the second process got into the expected state. The slowness of gcstress makes this bad.
 371 # * 152-dead-large-object requires a heap larger than what gcstress uses.
 372 # * 908-gc-start-finish expects GCs only to be run at clear points. The reduced heap size makes
 373 #   this non-deterministic. Same for 913.
 374 # * 961-default-iface-resolution-gen and 964-default-iface-init-genare very long tests that often
 375 #   will take more than the timeout to run when gcstress is enabled. This is because gcstress
 376 #   slows down allocations significantly which these tests do a lot.
 377 TEST_ART_BROKEN_GCSTRESS_RUN_TESTS := \
 378   137-cfi \
 379   152-dead-large-object \
 380   154-gc-loop \
 381   908-gc-start-finish \
 382   913-heaps \
 383   961-default-iface-resolution-gen \
 384   964-default-iface-init-gen \
 385
 386 ifneq (,$(filter gcstress,$(GC_TYPES)))
 387   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 388       $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),gcstress,$(JNI_TYPES), \
 389       $(IMAGE_TYPES), $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_GCSTRESS_RUN_TESTS), $(ALL_ADDRESS_SIZES))
 390 endif
 391
 392 TEST_ART_BROKEN_GCSTRESS_RUN_TESTS :=
 393
 394 # 115-native-bridge setup is complicated. Need to implement it correctly for the target.
 395 ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,target,$(RUN_TYPES),$(PREBUILD_TYPES),$(COMPILER_TYPES), \
 396     $(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), 115-native-bridge, \
 397     $(ALL_ADDRESS_SIZES))
 398
 399 # 130-hprof dumps the heap and runs hprof-conv to check whether the file is somewhat readable. This
 400 # is only possible on the host.
 401 # TODO: Turn off all the other combinations, this is more about testing actual ART code. A gtest is
 402 #       very hard to write here, as (for a complete test) JDWP must be set up.
 403 ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,target,$(RUN_TYPES),$(PREBUILD_TYPES), \
 404     $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES), \
 405     $(PICTEST_TYPES),$(DEBUGGABLE_TYPES),130-hprof,$(ALL_ADDRESS_SIZES))
 406
 407 # 131 is an old test. The functionality has been implemented at an earlier stage and is checked
 408 # in tests 138. Blacklisted for debug builds since these builds have duplicate classes checks which
 409 # punt to interpreter.
 410 ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),debug,$(PREBUILD_TYPES), \
 411     $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES), \
 412     $(PICTEST_TYPES),$(DEBUGGABLE_TYPES),131-structural-change,$(ALL_ADDRESS_SIZES))
 413
 414 # 138-duplicate-classes-check. Turned on for debug builds since debug builds have duplicate classes
 415 # checks enabled, b/2133391.
 416 ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),ndebug,$(PREBUILD_TYPES), \
 417     $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES), \
 418     $(PICTEST_TYPES),$(DEBUGGABLE_TYPES),138-duplicate-classes-check,$(ALL_ADDRESS_SIZES))
 419
 420 # All these tests check that we have sane behavior if we don't have a patchoat or dex2oat.
 421 # Therefore we shouldn't run them in situations where we actually don't have these since they
 422 # explicitly test for them. These all also assume we have an image.
 423 # 147-stripped-dex-fallback is disabled because it requires --prebuild.
 424 # 554-jit-profile-file is disabled because it needs a primary oat file to know what it should save.
 425 # 629-vdex-speed requires compiled code.
 426 TEST_ART_BROKEN_FALLBACK_RUN_TESTS := \
 427   116-nodex2oat \
 428   117-nopatchoat \
 429   118-noimage-dex2oat \
 430   119-noimage-patchoat \
 431   137-cfi \
 432   138-duplicate-classes-check2 \
 433   147-stripped-dex-fallback \
 434   554-jit-profile-file \
 435   616-cha \
 436   616-cha-abstract \
 437   912-classes \
 438   629-vdex-speed
 439
 440 # This test fails without an image.
 441 # 018, 961, 964, 968 often time out. b/34369284
 442 TEST_ART_BROKEN_NO_IMAGE_RUN_TESTS := \
 443   137-cfi \
 444   138-duplicate-classes-check \
 445   018-stack-overflow \
 446   476-clinit-inline-static-invoke \
 447   496-checker-inlining-class-loader \
 448   637-checker-throw-inline \
 449   616-cha \
 450   616-cha-abstract \
 451   912-classes \
 452   961-default-iface-resolution-gen \
 453   964-default-iface-init \
 454   968-default-partial-compile-gen \
 455
 456 ifneq (,$(filter no-dex2oat,$(PREBUILD_TYPES)))
 457   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),no-dex2oat, \
 458       $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES), \
 459       $(PICTEST_TYPES),$(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_FALLBACK_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 460 endif
 461
 462
 463 ifneq (,$(filter no-image,$(IMAGE_TYPES)))
 464   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 465       $(COMPILER_TYPES), $(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES),no-image, \
 466       $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_FALLBACK_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 467   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 468       $(COMPILER_TYPES), $(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES),no-image, \
 469       $(PICTEST_TYPES), $(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_NO_IMAGE_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 470 endif
 471
 472 ifneq (,$(filter relocate-npatchoat,$(RELOCATE_TYPES)))
 473   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 474       $(COMPILER_TYPES), relocate-npatchoat,$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 475       $(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_FALLBACK_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 476 endif
 477
 478 TEST_ART_BROKEN_FALLBACK_RUN_TESTS :=
 479
 480 # 137:
 481 # This test unrolls and expects managed frames, but tracing means we run the interpreter.
 482 # 802 and 570-checker-osr:
 483 # This test dynamically enables tracing to force a deoptimization. This makes the test meaningless
 484 # when already tracing, and writes an error message that we do not want to check for.
 485 # 130 occasional timeout b/32383962.
 486 # 629 requires compilation.
 487 TEST_ART_BROKEN_TRACING_RUN_TESTS := \
 488   087-gc-after-link \
 489   130-hprof \
 490   137-cfi \
 491   141-class-unload \
 492   570-checker-osr \
 493   629-vdex-speed \
 494   802-deoptimization
 495
 496 ifneq (,$(filter trace stream,$(TRACE_TYPES)))
 497   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 498       $(COMPILER_TYPES),$(RELOCATE_TYPES),trace stream,$(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES), \
 499       $(PICTEST_TYPES),$(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_TRACING_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 500 endif
 501
 502 TEST_ART_BROKEN_TRACING_RUN_TESTS :=
 503
 504 # These tests expect JIT compilation, which is suppressed when tracing.
 505 TEST_ART_BROKEN_JIT_TRACING_RUN_TESTS := \
 506   604-hot-static-interface \
 507   612-jit-dex-cache \
 508   613-inlining-dex-cache \
 509   616-cha \
 510   626-set-resolved-string \
 511
 512 ifneq (,$(filter trace stream,$(TRACE_TYPES)))
 513   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 514       jit,$(RELOCATE_TYPES),trace stream,$(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES), \
 515       $(PICTEST_TYPES),$(DEBUGGABLE_TYPES), $(TEST_ART_BROKEN_JIT_TRACING_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 516 endif
 517
 518 TEST_ART_BROKEN_JIT_TRACING_RUN_TESTS :=
 519
 520 # Known broken tests for the interpreter.
 521 # CFI unwinding expects managed frames.
 522 # 629 requires compilation.
 523 TEST_ART_BROKEN_INTERPRETER_RUN_TESTS := \
 524   137-cfi \
 525   554-jit-profile-file \
 526   629-vdex-speed
 527
 528 ifneq (,$(filter interpreter,$(COMPILER_TYPES)))
 529   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 530       interpreter,$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 531       $(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES),$(TEST_ART_BROKEN_INTERPRETER_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 532 endif
 533
 534 TEST_ART_BROKEN_INTERPRETER_RUN_TESTS :=
 535
 536 # Known broken tests for the JIT.
 537 # CFI unwinding expects managed frames, and the test does not iterate enough to even compile. JIT
 538 # also uses Generic JNI instead of the JNI compiler.
 539 # 154-gc-loop requires more deterministic GC behavior than what JIT does.
 540 # Test 906 iterates the heap filtering with different options. No instances should be created
 541 # between those runs to be able to have precise checks.
 542 # Test 629 requires compilation.
 543 # 912: b/34655682
 544 TEST_ART_BROKEN_JIT_RUN_TESTS := \
 545   137-cfi \
 546   154-gc-loop \
 547   629-vdex-speed \
 548   904-object-allocation \
 549   906-iterate-heap \
 550
 551 ifneq (,$(filter jit,$(COMPILER_TYPES)))
 552   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 553       jit,$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 554       $(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES),$(TEST_ART_BROKEN_JIT_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 555 endif
 556
 557 TEST_ART_BROKEN_JIT_RUN_TESTS :=
 558
 559 # Known broken tests for the graph coloring register allocator.
 560 # These tests were based on the linear scan allocator, which makes different decisions than
 561 # the graph coloring allocator. (These attempt to test for code quality, not correctness.)
 562 TEST_ART_BROKEN_OPTIMIZING_GRAPH_COLOR := \
 563   570-checker-select \
 564   484-checker-register-hints
 565
 566 ifneq (,$(filter regalloc_gc,$(COMPILER_TYPES)))
 567   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 568       regalloc_gc,$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 569       $(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 570       $(TEST_ART_BROKEN_OPTIMIZING_GRAPH_COLOR),$(ALL_ADDRESS_SIZES))
 571 endif
 572
 573 # Known broken tests for the mips32 optimizing compiler backend.
 574 TEST_ART_BROKEN_OPTIMIZING_MIPS_RUN_TESTS := \
 575
 576 ifeq (mips,$(TARGET_ARCH))
 577   ifneq (,$(filter $(OPTIMIZING_COMPILER_TYPES),$(COMPILER_TYPES)))
 578     ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,target,$(RUN_TYPES),$(PREBUILD_TYPES), \
 579         $(OPTIMIZING_COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 580         $(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 581         $(TEST_ART_BROKEN_OPTIMIZING_MIPS_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 582   endif
 583 endif
 584
 585 TEST_ART_BROKEN_OPTIMIZING_MIPS_RUN_TESTS :=
 586
 587 # Known broken tests for the mips64 optimizing compiler backend.
 588 TEST_ART_BROKEN_OPTIMIZING_MIPS64_RUN_TESTS := \
 589
 590 ifeq (mips64,$(TARGET_ARCH))
 591   ifneq (,$(filter $(OPTIMIZING_COMPILER_TYPES),$(COMPILER_TYPES)))
 592     ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,target,$(RUN_TYPES),$(PREBUILD_TYPES), \
 593         $(OPTIMIZING_COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 594         $(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 595         $(TEST_ART_BROKEN_OPTIMIZING_MIPS64_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 596   endif
 597 endif
 598
 599 TEST_ART_BROKEN_OPTIMIZING_MIPS64_RUN_TESTS :=
 600
 601 # Tests that should fail when the optimizing compiler compiles them non-debuggable.
 602 TEST_ART_BROKEN_OPTIMIZING_NONDEBUGGABLE_RUN_TESTS := \
 603   454-get-vreg \
 604   457-regs \
 605   602-deoptimizeable
 606
 607 ifneq (,$(filter $(OPTIMIZING_COMPILER_TYPES),$(COMPILER_TYPES)))
 608   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 609       $(OPTIMIZING_COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 610       $(IMAGE_TYPES),$(PICTEST_TYPES),ndebuggable,$(TEST_ART_BROKEN_OPTIMIZING_NONDEBUGGABLE_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 611 endif
 612
 613 TEST_ART_BROKEN_OPTIMIZING_NONDEBUGGABLE_RUN_TESTS :=
 614
 615 # Tests that should fail when the optimizing compiler compiles them debuggable.
 616 TEST_ART_BROKEN_OPTIMIZING_DEBUGGABLE_RUN_TESTS := \
 617
 618 ifneq (,$(filter $(OPTIMIZING_COMPILER_TYPES),$(COMPILER_TYPES)))
 619   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 620       $(OPTIMIZING_COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 621       $(IMAGE_TYPES),$(PICTEST_TYPES),debuggable,$(TEST_ART_BROKEN_OPTIMIZING_DEBUGGABLE_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 622 endif
 623
 624 TEST_ART_BROKEN_OPTIMIZING_DEBUGGABLE_RUN_TESTS :=
 625
 626 # Tests that should fail in the read barrier configuration with the interpreter.
 627 TEST_ART_BROKEN_INTERPRETER_READ_BARRIER_RUN_TESTS :=
 628
 629 # Tests that should fail in the read barrier configuration with the Optimizing compiler (AOT).
 630 TEST_ART_BROKEN_OPTIMIZING_READ_BARRIER_RUN_TESTS :=
 631
 632 # Tests that should fail in the read barrier configuration with JIT (Optimizing compiler).
 633 TEST_ART_BROKEN_JIT_READ_BARRIER_RUN_TESTS :=
 634
 635 # Tests failing in non-Baker read barrier configurations with the Optimizing compiler (AOT).
 636 # 537 and 641: Expect an array copy to be intrinsified, but calling-on-slowpath intrinsics are not yet
 637 #      handled in non-Baker read barrier configurations.
 638 TEST_ART_BROKEN_OPTIMIZING_NON_BAKER_READ_BARRIER_RUN_TESTS := \
 639   537-checker-arraycopy \
 640   641-checker-arraycopy
 641
 642 # Tests failing in non-Baker read barrier configurations with JIT (Optimizing compiler).
 643 # 537 and 641: Expect an array copy to be intrinsified, but calling-on-slowpath intrinsics are not yet
 644 #      handled in non-Baker read barrier configurations.
 645 TEST_ART_BROKEN_JIT_NON_BAKER_READ_BARRIER_RUN_TESTS := \
 646   537-checker-arraycopy \
 647   641-checker-arraycopy
 648
 649 ifeq ($(ART_USE_READ_BARRIER),true)
 650   ifneq (,$(filter interpreter,$(COMPILER_TYPES)))
 651     ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES), \
 652         $(PREBUILD_TYPES),interpreter,$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES), \
 653         $(JNI_TYPES),$(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 654         $(TEST_ART_BROKEN_INTERPRETER_READ_BARRIER_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 655   endif
 656
 657   ifneq (,$(filter $(OPTIMIZING_COMPILER_TYPES),$(COMPILER_TYPES)))
 658     ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES), \
 659         $(PREBUILD_TYPES),$(OPTIMIZING_COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES), \
 660         $(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 661         $(TEST_ART_BROKEN_OPTIMIZING_READ_BARRIER_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 662     ifneq ($(ART_READ_BARRIER_TYPE),BAKER)
 663       ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES), \
 664           $(PREBUILD_TYPES),$(OPTIMIZING_COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES), \
 665           $(GC_TYPES),$(JNI_TYPES),$(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 666           $(TEST_ART_BROKEN_OPTIMIZING_NON_BAKER_READ_BARRIER_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 667     endif
 668   endif
 669
 670   ifneq (,$(filter jit,$(COMPILER_TYPES)))
 671     ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES), \
 672         $(PREBUILD_TYPES),jit,$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES), \
 673         $(JNI_TYPES),$(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 674         $(TEST_ART_BROKEN_JIT_READ_BARRIER_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 675     ifneq ($(ART_READ_BARRIER_TYPE),BAKER)
 676       ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES), \
 677           $(PREBUILD_TYPES),jit,$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES), \
 678           $(JNI_TYPES),$(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 679           $(TEST_ART_BROKEN_JIT_NON_BAKER_READ_BARRIER_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 680     endif
 681   endif
 682 endif
 683
 684 TEST_ART_BROKEN_OPTIMIZING_READ_BARRIER_RUN_TESTS :=
 685 TEST_ART_BROKEN_JIT_READ_BARRIER_RUN_TESTS :=
 686
 687 TEST_ART_BROKEN_NPIC_RUN_TESTS := 596-app-images
 688 ifneq (,$(filter npictest,$(PICTEST_TYPES)))
 689   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 690       ${COMPILER_TYPES},$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 691       $(IMAGE_TYPES),npictest,$(DEBUGGABLE_TYPES),$(TEST_ART_BROKEN_NPIC_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 692 endif
 693
 694 # Tests that should fail in the heap poisoning configuration with the Optimizing compiler.
 695 # 055: Exceeds run time limits due to heap poisoning instrumentation (on ARM and ARM64 devices).
 696 TEST_ART_BROKEN_OPTIMIZING_HEAP_POISONING_RUN_TESTS := \
 697   055-enum-performance
 698
 699 ifeq ($(ART_HEAP_POISONING),true)
 700   ifneq (,$(filter $(OPTIMIZING_COMPILER_TYPES),$(COMPILER_TYPES)))
 701     ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES), \
 702         $(PREBUILD_TYPES),$(OPTIMIZING_COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 703         $(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 704         $(TEST_ART_BROKEN_OPTIMIZING_HEAP_POISONING_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 705   endif
 706 endif
 707
 708 TEST_ART_BROKEN_OPTIMIZING_HEAP_POISONING_RUN_TESTS :=
 709
 710 # 909: Tests that check semantics for a non-debuggable app.
 711 # 137: relies on AOT code and debuggable makes us JIT always.
 712 TEST_ART_BROKEN_DEBUGGABLE_RUN_TESTS := \
 713   137-cfi \
 714   909-attach-agent \
 715
 716 ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
 717     $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 718     $(IMAGE_TYPES),$(PICTEST_TYPES),debuggable,$(TEST_ART_BROKEN_DEBUGGABLE_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 719
 720 TEST_ART_BROKEN_DEBUGGABLE_RUN_TESTS :=
 721
 722 # Tests incompatible with bisection bug search. Sorted by incompatibility reason.
 723 # 000 through 595 do not compile anything. 089 tests a build failure. 018 through 137
 724 # run dalvikvm more than once. 115 and 088 assume they are always compiled.
 725 # 055 tests performance which is degraded during bisecting.
 726 TEST_ART_INCOMPATIBLE_BISECTION_SEARCH_RUN_TESTS := \
 727   000-nop \
 728   134-nodex2oat-nofallback \
 729   147-stripped-dex-fallback \
 730   595-profile-saving \
 731   \
 732   089-many-methods \
 733   \
 734   018-stack-overflow \
 735   116-nodex2oat \
 736   117-nopatchoat \
 737   118-noimage-dex2oat \
 738   119-noimage-patchoat \
 739   126-miranda-multidex \
 740   137-cfi \
 741   \
 742   115-native-bridge \
 743   088-monitor-verification \
 744   \
 745   055-enum-performance
 746
 747 ifeq ($(ART_TEST_BISECTION),true)
 748   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES), \
 749       $(PREBUILD_TYPES),$(OPTIMIZING_COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \
 750       $(IMAGE_TYPES),$(PICTEST_TYPES),$(DEBUGGABLE_TYPES), \
 751       $(TEST_ART_INCOMPATIBLE_BISECTION_SEARCH_RUN_TESTS),$(ALL_ADDRESS_SIZES))
 752 endif
 753
 754 # Clear variables ahead of appending to them when defining tests.
 755 $(foreach target, $(TARGET_TYPES), $(eval ART_RUN_TEST_$(call name-to-var,$(target))_RULES :=))
 756 $(foreach target, $(TARGET_TYPES), \
 757   $(foreach prebuild, $(PREBUILD_TYPES), \
 758     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(prebuild))_RULES :=)))
 759 $(foreach target, $(TARGET_TYPES), \
 760   $(foreach compiler, $(COMPILER_TYPES), \
 761     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(compiler))_RULES :=)))
 762 $(foreach target, $(TARGET_TYPES), \
 763   $(foreach relocate, $(RELOCATE_TYPES), \
 764     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(relocate))_RULES :=)))
 765 $(foreach target, $(TARGET_TYPES), \
 766   $(foreach trace, $(TRACE_TYPES), \
 767     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(trace))_RULES :=)))
 768 $(foreach target, $(TARGET_TYPES), \
 769   $(foreach gc, $(GC_TYPES), \
 770     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(gc))_RULES :=)))
 771 $(foreach target, $(TARGET_TYPES), \
 772   $(foreach jni, $(JNI_TYPES), \
 773     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(jni))_RULES :=)))
 774 $(foreach target, $(TARGET_TYPES), \
 775   $(foreach image, $(IMAGE_TYPES), \
 776     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(image))_RULES :=)))
 777 $(foreach target, $(TARGET_TYPES), \
 778   $(foreach test, $(TEST_ART_RUN_TESTS), \
 779     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(test))_RULES :=)))
 780 $(foreach target, $(TARGET_TYPES), \
 781   $(foreach address_size, $(ALL_ADDRESS_SIZES), \
 782     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(address_size))_RULES :=)))
 783 $(foreach target, $(TARGET_TYPES), \
 784   $(foreach run_type, $(RUN_TYPES), \
 785     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(run_type))_RULES :=)))
 786 $(foreach target, $(TARGET_TYPES), \
 787   $(foreach debuggable_type, $(DEBUGGABLE_TYPES), \
 788     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(debuggable_type))_RULES :=)))
 789
 790 # We need dex2oat and dalvikvm on the target as well as the core images (all images as we sync
 791 # only once).
 792 TEST_ART_TARGET_SYNC_DEPS += $(ART_TARGET_EXECUTABLES) $(TARGET_CORE_IMG_OUTS)
 793
 794 # Also need libartagent.
 795 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_ARCH)_libartagent)
 796 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_ARCH)_libartagentd)
 797 ifdef TARGET_2ND_ARCH
 798 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_2ND_ARCH)_libartagent)
 799 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_2ND_ARCH)_libartagentd)
 800 endif
 801
 802 # Also need libtiagent.
 803 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_ARCH)_libtiagent)
 804 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_ARCH)_libtiagentd)
 805 ifdef TARGET_2ND_ARCH
 806 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_2ND_ARCH)_libtiagent)
 807 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_2ND_ARCH)_libtiagentd)
 808 endif
 809
 810 # Also need libarttest.
 811 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_ARCH)_libarttest)
 812 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_ARCH)_libarttestd)
 813 ifdef TARGET_2ND_ARCH
 814 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_2ND_ARCH)_libarttest)
 815 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_2ND_ARCH)_libarttestd)
 816 endif
 817
 818 # Also need libnativebridgetest.
 819 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_ARCH)_libnativebridgetest)
 820 ifdef TARGET_2ND_ARCH
 821 TEST_ART_TARGET_SYNC_DEPS += $(OUT_DIR)/$(ART_TEST_LIST_device_$(TARGET_2ND_ARCH)_libnativebridgetest)
 822 endif
 823
 824 # Also need libopenjdkjvmti.
 825 TEST_ART_TARGET_SYNC_DEPS += libopenjdkjvmti
 826 TEST_ART_TARGET_SYNC_DEPS += libopenjdkjvmtid
 827
 828 TEST_ART_TARGET_SYNC_DEPS += $(TARGET_OUT_JAVA_LIBRARIES)/core-libart-testdex.jar
 829 TEST_ART_TARGET_SYNC_DEPS += $(TARGET_OUT_JAVA_LIBRARIES)/core-oj-testdex.jar
 830 TEST_ART_TARGET_SYNC_DEPS += $(TARGET_OUT_JAVA_LIBRARIES)/okhttp-testdex.jar
 831 TEST_ART_TARGET_SYNC_DEPS += $(TARGET_OUT_JAVA_LIBRARIES)/bouncycastle-testdex.jar
 832 TEST_ART_TARGET_SYNC_DEPS += $(TARGET_OUT_JAVA_LIBRARIES)/conscrypt-testdex.jar
 833
 834 # All tests require the host executables. The tests also depend on the core images, but on
 835 # specific version depending on the compiler.
 836 ART_TEST_HOST_RUN_TEST_DEPENDENCIES := \
 837   $(ART_HOST_EXECUTABLES) \
 838   $(OUT_DIR)/$(ART_TEST_LIST_host_$(ART_HOST_ARCH)_libtiagent) \
 839   $(OUT_DIR)/$(ART_TEST_LIST_host_$(ART_HOST_ARCH)_libtiagentd) \
 840   $(OUT_DIR)/$(ART_TEST_LIST_host_$(ART_HOST_ARCH)_libartagent) \
 841   $(OUT_DIR)/$(ART_TEST_LIST_host_$(ART_HOST_ARCH)_libartagentd) \
 842   $(OUT_DIR)/$(ART_TEST_LIST_host_$(ART_HOST_ARCH)_libarttest) \
 843   $(OUT_DIR)/$(ART_TEST_LIST_host_$(ART_HOST_ARCH)_libarttestd) \
 844   $(OUT_DIR)/$(ART_TEST_LIST_host_$(ART_HOST_ARCH)_libnativebridgetest) \
 845   $(ART_HOST_OUT_SHARED_LIBRARIES)/libjavacore$(ART_HOST_SHLIB_EXTENSION) \
 846   $(ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdk$(ART_HOST_SHLIB_EXTENSION) \
 847   $(ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdkd$(ART_HOST_SHLIB_EXTENSION) \
 848   $(ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdkjvmti$(ART_HOST_SHLIB_EXTENSION) \
 849   $(ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdkjvmtid$(ART_HOST_SHLIB_EXTENSION) \
 850
 851 ifneq ($(HOST_PREFER_32_BIT),true)
 852 ART_TEST_HOST_RUN_TEST_DEPENDENCIES += \
 853   $(OUT_DIR)/$(ART_TEST_LIST_host_$(2ND_ART_HOST_ARCH)_libtiagent) \
 854   $(OUT_DIR)/$(ART_TEST_LIST_host_$(2ND_ART_HOST_ARCH)_libtiagentd) \
 855   $(OUT_DIR)/$(ART_TEST_LIST_host_$(2ND_ART_HOST_ARCH)_libartagent) \
 856   $(OUT_DIR)/$(ART_TEST_LIST_host_$(2ND_ART_HOST_ARCH)_libartagentd) \
 857   $(OUT_DIR)/$(ART_TEST_LIST_host_$(2ND_ART_HOST_ARCH)_libarttest) \
 858   $(OUT_DIR)/$(ART_TEST_LIST_host_$(2ND_ART_HOST_ARCH)_libarttestd) \
 859   $(OUT_DIR)/$(ART_TEST_LIST_host_$(2ND_ART_HOST_ARCH)_libnativebridgetest) \
 860   $(2ND_ART_HOST_OUT_SHARED_LIBRARIES)/libjavacore$(ART_HOST_SHLIB_EXTENSION) \
 861   $(2ND_ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdk$(ART_HOST_SHLIB_EXTENSION) \
 862   $(2ND_ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdkd$(ART_HOST_SHLIB_EXTENSION) \
 863   $(2ND_ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdkjvmti$(ART_HOST_SHLIB_EXTENSION) \
 864   $(2ND_ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdkjvmtid$(ART_HOST_SHLIB_EXTENSION) \
 865
 866 endif
 867
 868 # Host executables.
 869 host_prereq_rules := $(ART_TEST_HOST_RUN_TEST_DEPENDENCIES)
 870
 871 # Classpath for Jack compilation for host.
 872 host_prereq_rules += $(HOST_JACK_CLASSPATH_DEPENDENCIES)
 873
 874 # Required for dx, jasmin, smali, dexmerger, jack.
 875 host_prereq_rules += $(TEST_ART_RUN_TEST_DEPENDENCIES)
 876
 877 host_prereq_rules += $(HOST_OUT_EXECUTABLES)/hprof-conv
 878
 879 # Classpath for Jack compilation for target.
 880 target_prereq_rules := $(TARGET_JACK_CLASSPATH_DEPENDENCIES)
 881
 882 # Sync test files to the target, depends upon all things that must be pushed
 883 #to the target.
 884 target_prereq_rules += test-art-target-sync
 885
 886 define core-image-dependencies
 887   image_suffix := $(3)
 888   ifeq ($(3),regalloc_gc)
 889     image_suffix:=optimizing
 890   else
 891     ifeq ($(3),jit)
 892       image_suffix:=interpreter
 893     endif
 894   endif
 895   ifeq ($(2),no-image)
 896     $(1)_prereq_rules += $$($(call name-to-var,$(1))_CORE_IMAGE_$$(image_suffix)_$(4))
 897   else
 898     ifeq ($(2),picimage)
 899       $(1)_prereq_rules += $$($(call name-to-var,$(1))_CORE_IMAGE_$$(image_suffix)_$(4))
 900     else
 901       ifeq ($(2),multipicimage)
 902         $(1)_prereq_rules += $$($(call name-to-var,$(1))_CORE_IMAGE_$$(image_suffix)_multi_$(4))
 903       endif
 904     endif
 905   endif
 906 endef
 907
 908 COMPILER_TYPES_2 := optimizing
 909 COMPILER_TYPES_2 += interpreter
 910 COMPILER_TYPES_2 += jit
 911 COMPILER_TYPES_2 += regalloc_gc
 912 COMPILER_TYPES_2 += interp-ac
 913 ALL_ADDRESS_SIZES_2 := 32 64
 914 IMAGE_TYPES_2 := picimage
 915 IMAGE_TYPES_2 += no-image
 916 IMAGE_TYPES_2 += npicimage
 917 IMAGE_TYPES_2 += multinpicimage
 918 IMAGE_TYPES_2 += multipicimage
 919
 920 # Add core image dependencies required for given target - HOST or TARGET,
 921 # IMAGE_TYPE, COMPILER_TYPE and ADDRESS_SIZE to the prereq_rules.
 922 $(foreach target, $(TARGET_TYPES), \
 923   $(foreach image, $(IMAGE_TYPES_2), \
 924     $(foreach compiler, $(COMPILER_TYPES_2), \
 925       $(foreach address_size, $(ALL_ADDRESS_SIZES_2), $(eval \
 926         $(call core-image-dependencies,$(target),$(image),$(compiler),$(address_size)))))))
 927
 928 test-art-host-run-test-dependencies : $(host_prereq_rules)
 929 test-art-target-run-test-dependencies : $(target_prereq_rules)
 930 test-art-run-test-dependencies : test-art-host-run-test-dependencies test-art-target-run-test-dependencies
 931
 932 host_prereq_rules :=
 933 target_prereq_rules :=
 934
 935 # Create a rule to build and run a tests following the form:
 936 # test-art-{1: host or target}-run-test-{2: debug ndebug}-{3: prebuild no-prebuild no-dex2oat}-
 937 #    {4: interpreter optimizing jit interp-ac}-
 938 #    {5: relocate nrelocate relocate-npatchoat}-
 939 #    {6: trace or ntrace}-{7: gcstress gcverify cms}-{8: forcecopy checkjni jni}-
 940 #    {9: no-image image picimage}-{10: pictest npictest}-
 941 #    {11: ndebuggable debuggable}-{12: test name}{13: 32 or 64}
 942 define define-test-art-run-test
 943   run_test_options :=
 944   prereq_rule :=
 945   test_groups :=
 946   uc_host_or_target :=
 947   jack_classpath :=
 948   ifeq ($(ART_TEST_WITH_STRACE),true)
 949     run_test_options += --strace
 950   endif
 951   ifeq ($(ART_TEST_RUN_TEST_ALWAYS_CLEAN),true)
 952     run_test_options += --always-clean
 953   endif
 954   ifeq ($(ART_TEST_BISECTION),true)
 955     run_test_options += --bisection-search
 956   endif
 957   ifeq ($(1),host)
 958     uc_host_or_target := HOST
 959     test_groups := ART_RUN_TEST_HOST_RULES
 960     run_test_options += --host
 961     prereq_rule := $(ART_TEST_HOST_RUN_TEST_DEPENDENCIES) $(HOST_JACK_CLASSPATH_DEPENDENCIES)
 962     jack_classpath := $(HOST_JACK_CLASSPATH)
 963   else
 964     ifeq ($(1),target)
 965       uc_host_or_target := TARGET
 966       test_groups := ART_RUN_TEST_TARGET_RULES
 967       prereq_rule := test-art-target-sync $(TARGET_JACK_CLASSPATH_DEPENDENCIES)
 968       jack_classpath := $(TARGET_JACK_CLASSPATH)
 969     else
 970       $$(error found $(1) expected $(TARGET_TYPES))
 971     endif
 972   endif
 973   ifeq ($(2),debug)
 974     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_DEBUG_RULES
 975   else
 976     ifeq ($(2),ndebug)
 977       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_RELEASE_RULES
 978       run_test_options += -O
 979     else
 980       $$(error found $(2) expected $(RUN_TYPES))
 981     endif
 982   endif
 983   ifeq ($(3),prebuild)
 984     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_PREBUILD_RULES
 985     run_test_options += --prebuild
 986   else
 987     ifeq ($(3),no-prebuild)
 988       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_NO_PREBUILD_RULES
 989       run_test_options += --no-prebuild
 990     else
 991       ifeq ($(3),no-dex2oat)
 992         test_groups += ART_RUN_TEST_$$(uc_host_or_target)_NO_DEX2OAT_RULES
 993         run_test_options += --no-prebuild --no-dex2oat
 994       else
 995         $$(error found $(3) expected $(PREBUILD_TYPES))
 996       endif
 997     endif
 998   endif
 999   ifeq ($(4),optimizing)
1000     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_OPTIMIZING_RULES
1001     run_test_options += --optimizing
1002   else ifeq ($(4),regalloc_gc)
1003     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_OPTIMIZING_GRAPH_COLOR_RULES
1004     run_test_options += --optimizing -Xcompiler-option --register-allocation-strategy=graph-color
1005   else
1006     ifeq ($(4),interpreter)
1007       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_INTERPRETER_RULES
1008       run_test_options += --interpreter
1009     else ifeq ($(4),interp-ac)
1010       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_INTERPRETER_ACCESS_CHECKS_RULES
1011       run_test_options += --interpreter --verify-soft-fail
1012     else
1013       ifeq ($(4),jit)
1014         test_groups += ART_RUN_TEST_$$(uc_host_or_target)_JIT_RULES
1015         run_test_options += --jit
1016       else
1017         $$(error found $(4) expected $(COMPILER_TYPES))
1018       endif
1019     endif
1020   endif
1021
1022   ifeq ($(5),relocate)
1023     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_RELOCATE_RULES
1024     run_test_options += --relocate
1025   else
1026     ifeq ($(5),no-relocate)
1027       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_NO_RELOCATE_RULES
1028       run_test_options += --no-relocate
1029     else
1030       ifeq ($(5),relocate-npatchoat)
1031         test_groups += ART_RUN_TEST_$$(uc_host_or_target)_RELOCATE_NO_PATCHOAT_RULES
1032         run_test_options += --relocate --no-patchoat
1033       else
1034         $$(error found $(5) expected $(RELOCATE_TYPES))
1035       endif
1036     endif
1037   endif
1038   ifeq ($(6),trace)
1039     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_TRACE_RULES
1040     run_test_options += --trace
1041   else
1042     ifeq ($(6),ntrace)
1043       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_NO_TRACE_RULES
1044     else
1045       ifeq ($(6),stream)
1046         # Group streaming under normal tracing rules.
1047         test_groups += ART_RUN_TEST_$$(uc_host_or_target)_TRACE_RULES
1048         run_test_options += --trace --stream
1049       else
1050         $$(error found $(6) expected $(TRACE_TYPES))
1051       endif
1052     endif
1053   endif
1054   ifeq ($(7),gcverify)
1055     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_GCVERIFY_RULES
1056     run_test_options += --gcverify
1057   else
1058     ifeq ($(7),gcstress)
1059       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_GCSTRESS_RULES
1060       run_test_options += --gcstress
1061     else
1062       ifeq ($(7),cms)
1063         test_groups += ART_RUN_TEST_$$(uc_host_or_target)_CMS_RULES
1064       else
1065         $$(error found $(7) expected $(GC_TYPES))
1066       endif
1067     endif
1068   endif
1069   ifeq ($(8),forcecopy)
1070     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_FORCECOPY_RULES
1071     run_test_options += --runtime-option -Xjniopts:forcecopy
1072     ifneq ($$(ART_TEST_JNI_FORCECOPY),true)
1073       skip_test := true
1074     endif
1075   else
1076     ifeq ($(8),checkjni)
1077       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_CHECKJNI_RULES
1078       run_test_options += --runtime-option -Xcheck:jni
1079     else
1080       ifeq ($(8),jni)
1081         test_groups += ART_RUN_TEST_$$(uc_host_or_target)_JNI_RULES
1082       else
1083         $$(error found $(8) expected $(JNI_TYPES))
1084       endif
1085     endif
1086   endif
1087   image_suffix := $(4)
1088   ifeq ($(4),regalloc_gc)
1089     # Graph coloring tests share the image_suffix with optimizing tests.
1090     image_suffix := optimizing
1091   else
1092     ifeq ($(4),jit)
1093       # JIT tests share the image_suffix with interpreter tests.
1094       image_suffix := interpreter
1095     endif
1096   endif
1097   ifeq ($(9),no-image)
1098     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_NO_IMAGE_RULES
1099     run_test_options += --no-image
1100     # Add the core dependency. This is required for pre-building.
1101     # Use the PIC image, as it is the default in run-test, to match dependencies.
1102     ifeq ($(1),host)
1103       prereq_rule += $$(HOST_CORE_IMAGE_$$(image_suffix)_$(13))
1104     else
1105       prereq_rule += $$(TARGET_CORE_IMAGE_$$(image_suffix)_$(13))
1106     endif
1107   else
1108     ifeq ($(9),picimage)
1109       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_PICIMAGE_RULES
1110       ifeq ($(1),host)
1111         prereq_rule += $$(HOST_CORE_IMAGE_$$(image_suffix)_$(13))
1112       else
1113         prereq_rule += $$(TARGET_CORE_IMAGE_$$(image_suffix)_$(13))
1114       endif
1115     else
1116       ifeq ($(9),multipicimage)
1117         test_groups += ART_RUN_TEST_$$(uc_host_or_target)_PICIMAGE_RULES
1118         run_test_options += --multi-image
1119         ifeq ($(1),host)
1120           prereq_rule += $$(HOST_CORE_IMAGE_$$(image_suffix)_multi_$(13))
1121         else
1122           prereq_rule += $$(TARGET_CORE_IMAGE_$$(image_suffix)_multi_$(13))
1123         endif
1124       else
1125         $$(error found $(9) expected $(IMAGE_TYPES))
1126       endif
1127     endif
1128   endif
1129   ifeq ($(10),pictest)
1130     run_test_options += --pic-test
1131   else
1132     ifeq ($(10),npictest)
1133       # Nothing to be done.
1134     else
1135       $$(error found $(10) expected $(PICTEST_TYPES))
1136     endif
1137   endif
1138   ifeq ($(11),debuggable)
1139     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_DEBUGGABLE_RULES
1140     run_test_options += --debuggable
1141   else
1142     ifeq ($(11),ndebuggable)
1143     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_NONDEBUGGABLE_RULES
1144       # Nothing to be done.
1145     else
1146       $$(error found $(11) expected $(DEBUGGABLE_TYPES))
1147     endif
1148   endif
1149   # $(12) is the test name.
1150   test_groups += ART_RUN_TEST_$$(uc_host_or_target)_$(call name-to-var,$(12))_RULES
1151   ifeq ($(13),64)
1152     test_groups += ART_RUN_TEST_$$(uc_host_or_target)_64_RULES
1153     run_test_options += --64
1154   else
1155     ifeq ($(13),32)
1156       test_groups += ART_RUN_TEST_$$(uc_host_or_target)_32_RULES
1157     else
1158       $$(error found $(13) expected $(ALL_ADDRESS_SIZES))
1159     endif
1160   endif
1161   # Override of host instruction-set-features. Required to test advanced x86 intrinsics. The
1162   # conditionals aren't really correct, they will fail to do the right thing on a 32-bit only
1163   # host. However, this isn't common enough to worry here and make the conditions complicated.
1164   ifneq ($(DEX2OAT_HOST_INSTRUCTION_SET_FEATURES),)
1165     ifeq ($(13),64)
1166       run_test_options += --instruction-set-features $(DEX2OAT_HOST_INSTRUCTION_SET_FEATURES)
1167     endif
1168   endif
1169   ifneq ($($(HOST_2ND_ARCH_VAR_PREFIX)DEX2OAT_HOST_INSTRUCTION_SET_FEATURES),)
1170     ifeq ($(13),32)
1171       run_test_options += --instruction-set-features $($(HOST_2ND_ARCH_VAR_PREFIX)DEX2OAT_HOST_INSTRUCTION_SET_FEATURES)
1172     endif
1173   endif
1174   run_test_rule_name := test-art-$(1)-run-test-$(2)-$(3)-$(4)-$(5)-$(6)-$(7)-$(8)-$(9)-$(10)-$(11)-$(12)$(13)
1175   run_test_options := --output-path $(ART_HOST_TEST_DIR)/run-test-output/$$(run_test_rule_name) \
1176       $$(run_test_options)
1177   ifneq ($(ART_TEST_ANDROID_ROOT),)
1178     run_test_options := --android-root $(ART_TEST_ANDROID_ROOT) $$(run_test_options)
1179   endif
1180   ifeq ($(ART_TEST_QUIET),true)
1181     run_test_options += --quiet
1182   endif
1183 $$(run_test_rule_name): PRIVATE_RUN_TEST_OPTIONS := $$(run_test_options)
1184 $$(run_test_rule_name): PRIVATE_JACK_CLASSPATH := $$(jack_classpath)
1185 .PHONY: $$(run_test_rule_name)
1186 $$(run_test_rule_name): $(TEST_ART_RUN_TEST_DEPENDENCIES) $(HOST_OUT_EXECUTABLES)/hprof-conv $$(prereq_rule) | $(TEST_ART_RUN_TEST_ORDERONLY_DEPENDENCIES)
1187         $(hide) $$(call ART_TEST_SKIP,$$@) && \
1188           DX=$(abspath $(DX)) \
1189             JASMIN=$(abspath $(HOST_OUT_EXECUTABLES)/jasmin) \
1190             SMALI=$(abspath $(HOST_OUT_EXECUTABLES)/smali) \
1191             DXMERGER=$(abspath $(HOST_OUT_EXECUTABLES)/dexmerger) \
1192             JACK_VERSION=$(JACK_DEFAULT_VERSION) \
1193             JACK=$(abspath $(JACK)) \
1194             JACK_VERSION=$(JACK_DEFAULT_VERSION) \
1195             JACK_CLASSPATH=$$(PRIVATE_JACK_CLASSPATH) \
1196             art/test/run-test $$(PRIVATE_RUN_TEST_OPTIONS) $(12) \
1197               && $$(call ART_TEST_PASSED,$$@) || $$(call ART_TEST_FAILED,$$@)
1198         $$(hide) (echo $(MAKECMDGOALS) | grep -q $$@ && \
1199           echo "run-test run as top-level target, removing test directory $(ART_HOST_TEST_DIR)" && \
1200           rm -r $(ART_HOST_TEST_DIR)) || true
1201
1202   $$(foreach test_group,$$(test_groups), $$(eval $$(value test_group) += $$(run_test_rule_name)))
1203
1204   # Clear locally defined variables.
1205   uc_host_or_target :=
1206   test_groups :=
1207   run_test_options :=
1208   run_test_rule_name :=
1209   prereq_rule :=
1210   jack_classpath :=
1211 endef  # define-test-art-run-test
1212
1213 $(foreach target, $(TARGET_TYPES), \
1214   $(foreach test, $(TEST_ART_RUN_TESTS), \
1215     $(foreach run_type, $(RUN_TYPES), \
1216       $(foreach address_size, $(ADDRESS_SIZES_$(call name-to-var,$(target))), \
1217         $(foreach prebuild, $(PREBUILD_TYPES), \
1218           $(foreach compiler, $(COMPILER_TYPES), \
1219             $(foreach relocate, $(RELOCATE_TYPES), \
1220               $(foreach trace, $(TRACE_TYPES), \
1221                 $(foreach gc, $(GC_TYPES), \
1222                   $(foreach jni, $(JNI_TYPES), \
1223                     $(foreach image, $(IMAGE_TYPES), \
1224                       $(foreach pictest, $(PICTEST_TYPES), \
1225                         $(foreach debuggable, $(DEBUGGABLE_TYPES), \
1226                           $(eval $(call define-test-art-run-test,$(target),$(run_type),$(prebuild),$(compiler),$(relocate),$(trace),$(gc),$(jni),$(image),$(pictest),$(debuggable),$(test),$(address_size))) \
1227                   )))))))))))))
1228 define-test-art-run-test :=
1229
1230 # Define a phony rule whose purpose is to test its prerequisites.
1231 # $(1): host or target
1232 # $(2): list of prerequisites
1233 define define-test-art-run-test-group
1234 .PHONY: $(1)
1235 $(1): $(2)
1236         $(hide) $$(call ART_TEST_PREREQ_FINISHED,$$@)
1237
1238 endef  # define-test-art-run-test-group
1239
1240
1241 $(foreach target, $(TARGET_TYPES), $(eval \
1242   $(call define-test-art-run-test-group,test-art-$(target)-run-test,$(ART_RUN_TEST_$(call name-to-var,$(target))_RULES))))
1243 $(foreach target, $(TARGET_TYPES), \
1244   $(foreach prebuild, $(PREBUILD_TYPES), $(eval \
1245     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(prebuild),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(prebuild))_RULES)))))
1246 $(foreach target, $(TARGET_TYPES), \
1247   $(foreach run-type, $(RUN_TYPES), $(eval \
1248     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(run-type),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(run-type))_RULES)))))
1249 $(foreach target, $(TARGET_TYPES), \
1250   $(foreach compiler, $(COMPILER_TYPES), $(eval \
1251     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(compiler),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(compiler))_RULES)))))
1252 $(foreach target, $(TARGET_TYPES), \
1253   $(foreach relocate, $(RELOCATE_TYPES), $(eval \
1254     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(relocate),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(relocate))_RULES)))))
1255 $(foreach target, $(TARGET_TYPES), \
1256   $(foreach trace, $(TRACE_TYPES), $(eval \
1257     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(trace),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(trace))_RULES)))))
1258 $(foreach target, $(TARGET_TYPES), \
1259   $(foreach gc, $(GC_TYPES), $(eval \
1260     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(gc),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(gc))_RULES)))))
1261 $(foreach target, $(TARGET_TYPES), \
1262   $(foreach jni, $(JNI_TYPES), $(eval \
1263     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(jni),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(jni))_RULES)))))
1264 $(foreach target, $(TARGET_TYPES), \
1265   $(foreach debuggable, $(DEBUGGABLE_TYPES), $(eval \
1266     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(debuggable),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(debuggable))_RULES)))))
1267 $(foreach target, $(TARGET_TYPES), \
1268   $(foreach image, $(IMAGE_TYPES), $(eval \
1269     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(image),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(image))_RULES)))))
1270 $(foreach target, $(TARGET_TYPES), \
1271   $(foreach test, $(TEST_ART_RUN_TESTS), $(eval \
1272     $(call define-test-art-run-test-group,test-art-$(target)-run-test-$(test),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(test))_RULES)))))
1273 $(foreach target, $(TARGET_TYPES), \
1274   $(foreach address_size, $(ADDRESS_SIZES_$(call name-to-var,$(target))), $(eval \
1275     $(call define-test-art-run-test-group,test-art-$(target)-run-test$(address_size),$(ART_RUN_TEST_$(call name-to-var,$(target))_$(address_size)_RULES)))))
1276
1277 # Clear variables now we're finished with them.
1278 $(foreach target, $(TARGET_TYPES), $(eval ART_RUN_TEST_$(call name-to-var,$(target))_RULES :=))
1279 $(foreach target, $(TARGET_TYPES), \
1280   $(foreach prebuild, $(PREBUILD_TYPES), \
1281     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(prebuild))_RULES :=)))
1282 $(foreach target, $(TARGET_TYPES), \
1283   $(foreach compiler, $(COMPILER_TYPES), \
1284     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(compiler))_RULES :=)))
1285 $(foreach target, $(TARGET_TYPES), \
1286   $(foreach relocate, $(RELOCATE_TYPES), \
1287     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(relocate))_RULES :=)))
1288 $(foreach target, $(TARGET_TYPES), \
1289   $(foreach trace, $(TRACE_TYPES), \
1290     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(trace))_RULES :=)))
1291 $(foreach target, $(TARGET_TYPES), \
1292   $(foreach gc, $(GC_TYPES), \
1293     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(gc))_RULES :=)))
1294 $(foreach target, $(TARGET_TYPES), \
1295   $(foreach jni, $(JNI_TYPES), \
1296     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(jni))_RULES :=)))
1297 $(foreach target, $(TARGET_TYPES), \
1298   $(foreach debuggable, $(DEBUGGABLE_TYPES), \
1299     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(debuggable))_RULES :=)))
1300 $(foreach target, $(TARGET_TYPES), \
1301   $(foreach image, $(IMAGE_TYPES), \
1302     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(image))_RULES :=)))
1303 $(foreach target, $(TARGET_TYPES), \
1304   $(foreach test, $(TEST_ART_RUN_TESTS), \
1305     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(test))_RULES :=)))
1306 $(foreach target, $(TARGET_TYPES), \
1307   $(foreach address_size, $(ALL_ADDRESS_SIZES), \
1308     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(address_size))_RULES :=)))
1309 $(foreach target, $(TARGET_TYPES), \
1310   $(foreach run_type, $(RUN_TYPES), \
1311     $(eval ART_RUN_TEST_$(call name-to-var,$(target))_$(call name-to-var,$(run_type))_RULES :=)))
1312 define-test-art-run-test-group :=
1313 TARGET_TYPES :=
1314 PREBUILD_TYPES :=
1315 COMPILER_TYPES :=
1316 RELOCATE_TYPES :=
1317 TRACE_TYPES :=
1318 GC_TYPES :=
1319 JNI_TYPES :=
1320 IMAGE_TYPES :=
1321 ADDRESS_SIZES_TARGET :=
1322 ADDRESS_SIZES_HOST :=
1323 ALL_ADDRESS_SIZES :=
1324 RUN_TYPES :=
1325 DEBUGGABLE_TYPES :=
1326
1327 LOCAL_PATH :=