PageRenderTime 45ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/mk/tests.mk

https://github.com/osaut/rust
Makefile | 712 lines | 496 code | 151 blank | 65 comment | 4 complexity | fcfec07ae92f43f4546b5d1c82965f17 MD5 | raw file
Possible License(s): JSON, Apache-2.0, MIT 
    

  1. # Copyright 2012 The Rust Project Developers. See the COPYRIGHT
    2. 

  2. # file at the top-level directory of this distribution and at
    3. 

  3. # http://rust-lang.org/COPYRIGHT.
    4. 

  4. #
    5. 

  5. # Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
    6. 

  6. # http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
    7. 

  7. # <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
    8. 

  8. # option. This file may not be copied, modified, or distributed
    9. 

  9. # except according to those terms.
    10. 

  10. 

  11. 

  12. ######################################################################
    13. 

  13. # Test variables
    14. 

  14. ######################################################################
    15. 

  15. 

  16. # The names of crates that must be tested
    17. 

  17. TEST_TARGET_CRATES = core std
    18. 

  18. TEST_HOST_CRATES = syntax rustc rustdoc rusti rust rustpkg
    19. 

  19. TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
    20. 

  20. 

  21. # Markdown files under doc/ that should have their code extracted and run
    22. 

  22. DOC_TEST_NAMES = tutorial tutorial-ffi tutorial-macros tutorial-borrowed-ptr tutorial-tasks rust
    23. 

  23. 

  24. ######################################################################
    25. 

  25. # Environment configuration
    26. 

  26. ######################################################################
    27. 

  27. 

  28. # The arguments to all test runners
    29. 

  29. ifdef TESTNAME
    30. 

  30.   TESTARGS += $(TESTNAME)
    31. 

  31. endif
    32. 

  32. 

  33. ifdef CHECK_XFAILS
    34. 

  34.   TESTARGS += --ignored
    35. 

  35. endif
    36. 

  36. 

  37. # Arguments to the cfail/rfail/rpass/bench tests
    38. 

  38. ifdef CFG_VALGRIND
    39. 

  39.   CTEST_RUNTOOL = --runtool "$(CFG_VALGRIND)"
    40. 

  40. endif
    41. 

  41. 

  42. # Arguments to the perf tests
    43. 

  43. ifdef CFG_PERF_TOOL
    44. 

  44.   CTEST_PERF_RUNTOOL = --runtool "$(CFG_PERF_TOOL)"
    45. 

  45. endif
    46. 

  46. 

  47. CTEST_TESTARGS := $(TESTARGS)
    48. 

  48. 

  49. ifdef VERBOSE
    50. 

  50.   CTEST_TESTARGS += --verbose
    51. 

  51. endif
    52. 

  52. 

  53. # If we're running perf then set this environment variable
    54. 

  54. # to put the benchmarks into 'hard mode'
    55. 

  55. ifeq ($(MAKECMDGOALS),perf)
    56. 

  56.   RUST_BENCH=1
    57. 

  57.   export RUST_BENCH
    58. 

  58. endif
    59. 

  59. 

  60. TEST_LOG_FILE=tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).log
    61. 

  61. TEST_OK_FILE=tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).ok
    62. 

  62. 

  63. define DEF_TARGET_COMMANDS
    64. 

  64. 

  65. ifdef CFG_UNIXY_$(1)
    66. 

  66.   CFG_RUN_TEST_$(1)=$$(call CFG_RUN_$(1),,$$(CFG_VALGRIND) $$(1))
    67. 

  67. endif
    68. 

  68. 

  69. ifdef CFG_WINDOWSY_$(1)
    70. 

  70.   CFG_TESTLIB_$(1)=$$(CFG_BUILD_DIR)/$$(2)/$$(strip \
    71. 

  71.    $$(if $$(findstring stage0,$$(1)), \
    72. 

  72.        stage0/$$(CFG_LIBDIR), \
    73. 

  73.       $$(if $$(findstring stage1,$$(1)), \
    74. 

  74.            stage1/$$(CFG_LIBDIR), \
    75. 

  75.           $$(if $$(findstring stage2,$$(1)), \
    76. 

  76.                stage2/$$(CFG_LIBDIR), \
    77. 

  77.                $$(if $$(findstring stage3,$$(1)), \
    78. 

  78.                     stage3/$$(CFG_LIBDIR), \
    79. 

  79.                )))))/rustc/$$(CFG_BUILD_TRIPLE)/$$(CFG_LIBDIR)
    80. 

  80.   CFG_RUN_TEST_$(1)=$$(call CFG_RUN_$(1),$$(call CFG_TESTLIB_$(1),$$(1),$$(3)),$$(1))
    81. 

  81. endif
    82. 

  82. 

  83. # Run the compiletest runner itself under valgrind
    84. 

  84. ifdef CTEST_VALGRIND
    85. 

  85. CFG_RUN_CTEST_$(1)=$$(call CFG_RUN_TEST_$$(CFG_BUILD_TRIPLE),$$(2),$$(3))
    86. 

  86. else
    87. 

  87. CFG_RUN_CTEST_$(1)=$$(call CFG_RUN_$$(CFG_BUILD_TRIPLE),$$(TLIB$$(1)_T_$$(3)_H_$$(3)),$$(2))
    88. 

  88. endif
    89. 

  89. 

  90. endef
    91. 

  91. 

  92. $(foreach target,$(CFG_TARGET_TRIPLES), \
    93. 

  93.   $(eval $(call DEF_TARGET_COMMANDS,$(target))))
    94. 

  94. 

  95. 

  96. ######################################################################
    97. 

  97. # Main test targets
    98. 

  98. ######################################################################
    99. 

  99. 

  100. check: cleantestlibs cleantmptestlogs tidy all check-stage2
    101. 

  101. 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
    102. 

    103. 

  103. check-notidy: cleantestlibs cleantmptestlogs all check-stage2
    104. 

  104. 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
    105. 

    106. 

  106. check-full: cleantestlibs cleantmptestlogs tidy \
    107. 

  107.             all check-stage1 check-stage2 check-stage3
    108. 

  108. 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
    109. 

    110. 

  110. check-test: cleantestlibs cleantmptestlogs all check-stage2-rfail
    111. 

  111. 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
    112. 

    113. 

  113. check-lite: cleantestlibs cleantmptestlogs \
    114. 

  114. 	check-stage2-core check-stage2-std check-stage2-rpass \
    115. 

  115. 	check-stage2-rfail check-stage2-cfail
    116. 

  116. 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
    117. 

    118. 

  118. .PHONY: cleantmptestlogs cleantestlibs
    119. 

    120. 

  120. cleantmptestlogs:
    121. 

  121. 	$(Q)rm -f tmp/*.log
    122. 

    123. 

  123. cleantestlibs:
    124. 

  124. 	$(Q)find $(CFG_BUILD_TRIPLE)/test \
    125. 

  125.          -name '*.[odasS]' -o \
    126. 

  126.          -name '*.so' -o      \
    127. 

  127.          -name '*.dylib' -o   \
    128. 

  128.          -name '*.dll' -o     \
    129. 

  129.          -name '*.def' -o     \
    130. 

  130.          -name '*.bc' -o      \
    131. 

  131.          -name '*.dSYM' -o    \
    132. 

  132.          -name '*.libaux' -o      \
    133. 

  133.          -name '*.out' -o     \
    134. 

  134.          -name '*.err' -o     \
    135. 

  135. 	 -name '*.debugger.script' \
    136. 

  136.          | xargs rm -rf
    137. 

    138. 

    139. 

  139. ######################################################################
    140. 

  140. # Tidy
    141. 

  141. ######################################################################
    142. 

    143. 

  143. ifdef CFG_NOTIDY
    144. 

  144. tidy:
    145. 

  145. else
    146. 

    147. 

  147. ALL_CS := $(wildcard $(S)src/rt/*.cpp \
    148. 

  148.                      $(S)src/rt/*/*.cpp \
    149. 

  149.                      $(S)src/rt/*/*/*.cpp \
    150. 

  150.                      $(S)srcrustllvm/*.cpp)
    151. 

  151. ALL_CS := $(filter-out $(S)src/rt/bigint/bigint_ext.cpp \
    152. 

  152.                        $(S)src/rt/bigint/bigint_int.cpp \
    153. 

  153.                        $(S)src/rt/miniz.cpp \
    154. 

  154.                        $(S)src/rt/linenoise/linenoise.c \
    155. 

  155.                        $(S)src/rt/linenoise/utf8.c \
    156. 

  156. 	,$(ALL_CS))
    157. 

  157. ALL_HS := $(wildcard $(S)src/rt/*.h \
    158. 

  158.                      $(S)src/rt/*/*.h \
    159. 

  159.                      $(S)src/rt/*/*/*.h \
    160. 

  160.                      $(S)srcrustllvm/*.h)
    161. 

  161. ALL_HS := $(filter-out $(S)src/rt/vg/valgrind.h \
    162. 

  162.                        $(S)src/rt/vg/memcheck.h \
    163. 

  163.                        $(S)src/rt/uthash/uthash.h \
    164. 

  164.                        $(S)src/rt/uthash/utlist.h \
    165. 

  165.                        $(S)src/rt/msvc/typeof.h \
    166. 

  166.                        $(S)src/rt/msvc/stdint.h \
    167. 

  167.                        $(S)src/rt/msvc/inttypes.h \
    168. 

  168.                        $(S)src/rt/bigint/bigint.h \
    169. 

  169.                        $(S)src/rt/linenoise/linenoise.h \
    170. 

  170.                        $(S)src/rt/linenoise/utf8.h \
    171. 

  171. 	,$(ALL_HS))
    172. 

    173. 

  173. # Run the tidy script in multiple parts to avoid huge 'echo' commands
    174. 

  174. tidy:
    175. 

  175. 		@$(call E, check: formatting)
    176. 

  176. 		$(Q)find $(S)src -name '*.r[sc]' \
    177. 

  177. 		| grep '^$(S)src/test' -v \
    178. 

  178. 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
    179. 

  179. 		$(Q)find $(S)src/etc -name '*.py' \
    180. 

  180. 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
    181. 

  181. 		$(Q)echo $(ALL_CS) \
    182. 

  182. 	  	| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
    183. 

  183. 		$(Q)echo $(ALL_HS) \
    184. 

  184. 	  	| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
    185. 

    186. 

  186. endif
    187. 

    188. 

    189. 

  189. ######################################################################
    190. 

  190. # Sets of tests
    191. 

  191. ######################################################################
    192. 

    193. 

  193. define DEF_TEST_SETS
    194. 

    195. 

  195. check-stage$(1)-T-$(2)-H-$(3)-exec:     				\
    196. 

  196. 	check-stage$(1)-T-$(2)-H-$(3)-rpass-exec			\
    197. 

  197. 	check-stage$(1)-T-$(2)-H-$(3)-rfail-exec			\
    198. 

  198. 	check-stage$(1)-T-$(2)-H-$(3)-cfail-exec			\
    199. 

  199. 	check-stage$(1)-T-$(2)-H-$(3)-rpass-full-exec			\
    200. 

  200.         check-stage$(1)-T-$(2)-H-$(3)-crates-exec                      \
    201. 

  201. 	check-stage$(1)-T-$(2)-H-$(3)-bench-exec			\
    202. 

  202. 	check-stage$(1)-T-$(2)-H-$(3)-debuginfo-exec \
    203. 

  203. 	check-stage$(1)-T-$(2)-H-$(3)-doc-exec \
    204. 

  204. 	check-stage$(1)-T-$(2)-H-$(3)-pretty-exec
    205. 

    206. 

  206. # Only test the compiler-dependent crates when the target is
    207. 

  207. # able to build a compiler (when the target triple is in the set of host triples)
    208. 

  208. ifneq ($$(findstring $(2),$$(CFG_HOST_TRIPLES)),)
    209. 

    210. 

  210. check-stage$(1)-T-$(2)-H-$(3)-crates-exec: \
    211. 

  211. 	$$(foreach crate,$$(TEST_CRATES), \
    212. 

  212.            check-stage$(1)-T-$(2)-H-$(3)-$$(crate)-exec)
    213. 

    214. 

  214. else
    215. 

    216. 

  216. check-stage$(1)-T-$(2)-H-$(3)-crates-exec: \
    217. 

  217. 	$$(foreach crate,$$(TEST_TARGET_CRATES), \
    218. 

  218.            check-stage$(1)-T-$(2)-H-$(3)-$$(crate)-exec)
    219. 

    220. 

  220. endif
    221. 

    222. 

  222. check-stage$(1)-T-$(2)-H-$(3)-doc-exec: \
    223. 

  223.         $$(foreach docname,$$(DOC_TEST_NAMES), \
    224. 

  224.            check-stage$(1)-T-$(2)-H-$(3)-doc-$$(docname)-exec)
    225. 

    226. 

  226. check-stage$(1)-T-$(2)-H-$(3)-pretty-exec: \
    227. 

  227. 	check-stage$(1)-T-$(2)-H-$(3)-pretty-rpass-exec	\
    228. 

  228. 	check-stage$(1)-T-$(2)-H-$(3)-pretty-rpass-full-exec	\
    229. 

  229. 	check-stage$(1)-T-$(2)-H-$(3)-pretty-rfail-exec	\
    230. 

  230. 	check-stage$(1)-T-$(2)-H-$(3)-pretty-bench-exec	\
    231. 

  231. 	check-stage$(1)-T-$(2)-H-$(3)-pretty-pretty-exec
    232. 

    233. 

  233. endef
    234. 

    235. 

  235. $(foreach host,$(CFG_HOST_TRIPLES), \
    236. 

  236.  $(foreach target,$(CFG_TARGET_TRIPLES), \
    237. 

  237.   $(foreach stage,$(STAGES), \
    238. 

  238.     $(eval $(call DEF_TEST_SETS,$(stage),$(target),$(host))))))
    239. 

    240. 

    241. 

  241. ######################################################################
    242. 

  242. # Crate testing
    243. 

  243. ######################################################################
    244. 

    245. 

  245. define TEST_RUNNER
    246. 

    247. 

  247. # If NO_REBUILD is set then break the dependencies on std so we can
    248. 

  248. # test crates without rebuilding core and std first
    249. 

  249. ifeq ($(NO_REBUILD),)
    250. 

  250. STDTESTDEP_$(1)_$(2)_$(3) = $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB_$(2))
    251. 

  251. else
    252. 

  252. STDTESTDEP_$(1)_$(2)_$(3) =
    253. 

  253. endif
    254. 

    255. 

  255. $(3)/test/coretest.stage$(1)-$(2)$$(X_$(2)):			\
    256. 

  256. 		$$(CORELIB_CRATE) $$(CORELIB_INPUTS)	\
    257. 

  257. 		$$(STDTESTDEP_$(1)_$(2)_$(3))
    258. 

  258. 	@$$(call E, compile_and_link: $$@)
    259. 

  259. 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
    260. 

    261. 

  261. $(3)/test/stdtest.stage$(1)-$(2)$$(X_$(2)):			\
    262. 

  262. 		$$(STDLIB_CRATE) $$(STDLIB_INPUTS)	\
    263. 

  263. 		$$(STDTESTDEP_$(1)_$(2)_$(3))
    264. 

  264. 	@$$(call E, compile_and_link: $$@)
    265. 

  265. 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
    266. 

    267. 

  267. $(3)/test/syntaxtest.stage$(1)-$(2)$$(X_$(2)):			\
    268. 

  268. 		$$(LIBSYNTAX_CRATE) $$(LIBSYNTAX_INPUTS)	\
    269. 

  269. 		$$(STDTESTDEP_$(1)_$(2)_$(3))
    270. 

  270. 	@$$(call E, compile_and_link: $$@)
    271. 

  271. 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
    272. 

    273. 

  273. $(3)/test/rustctest.stage$(1)-$(2)$$(X_$(2)):					\
    274. 

  274. 		$$(COMPILER_CRATE) $$(COMPILER_INPUTS) \
    275. 

  275. 		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUSTLLVM_$(2)) \
    276. 

  276.                 $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBSYNTAX_$(2))
    277. 

  277. 	@$$(call E, compile_and_link: $$@)
    278. 

  278. 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
    279. 

    280. 

  280. $(3)/test/rustpkgtest.stage$(1)-$(2)$$(X_$(2)):					\
    281. 

  281. 		$$(RUSTPKG_LIB) $$(RUSTPKG_INPUTS)		\
    282. 

  282. 		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC_$(2))
    283. 

  283. 	@$$(call E, compile_and_link: $$@)
    284. 

  284. 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
    285. 

    286. 

  286. $(3)/test/rustitest.stage$(1)-$(2)$$(X_$(2)):					\
    287. 

  287. 		$$(RUSTI_LIB) $$(RUSTI_INPUTS)		\
    288. 

  288. 		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC_$(2))
    289. 

  289. 	@$$(call E, compile_and_link: $$@)
    290. 

  290. 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
    291. 

    292. 

  292. $(3)/test/rusttest.stage$(1)-$(2)$$(X_$(2)):					\
    293. 

  293. 		$$(RUST_LIB) $$(RUST_INPUTS)		\
    294. 

  294. 		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC_$(2))
    295. 

  295. 	@$$(call E, compile_and_link: $$@)
    296. 

  296. 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
    297. 

    298. 

  298. $(3)/test/rustdoctest.stage$(1)-$(2)$$(X_$(2)):					\
    299. 

  299. 		$$(RUSTDOC_LIB) $$(RUSTDOC_INPUTS)		\
    300. 

  300. 		$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC_$(2))
    301. 

  301. 	@$$(call E, compile_and_link: $$@)
    302. 

  302. 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test
    303. 

    304. 

  304. endef
    305. 

    306. 

  306. $(foreach host,$(CFG_HOST_TRIPLES), \
    307. 

  307.  $(eval $(foreach target,$(CFG_TARGET_TRIPLES), \
    308. 

  308.   $(eval $(foreach stage,$(STAGES), \
    309. 

  309.    $(eval $(call TEST_RUNNER,$(stage),$(target),$(host))))))))
    310. 

    311. 

  311. define DEF_TEST_CRATE_RULES
    312. 

  312. check-stage$(1)-T-$(2)-H-$(3)-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4))
    313. 

    314. 

  314. $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
    315. 

  315. 		$(3)/test/$(4)test.stage$(1)-$(2)$$(X_$(2))
    316. 

  316. 	@$$(call E, run: $$<)
    317. 

  317. 	$$(Q)$$(call CFG_RUN_TEST_$(2),$$<,$(2),$(3)) $$(TESTARGS)	\
    318. 

  318. 	--logfile $$(call TEST_LOG_FILE,$(1),$(2),$(3),$(4)) \
    319. 

  319. 	&& touch $$@
    320. 

  320. endef
    321. 

    322. 

  322. $(foreach host,$(CFG_HOST_TRIPLES), \
    323. 

  323.  $(foreach target,$(CFG_TARGET_TRIPLES), \
    324. 

  324.   $(foreach stage,$(STAGES), \
    325. 

  325.    $(foreach crate, $(TEST_CRATES), \
    326. 

  326.     $(eval $(call DEF_TEST_CRATE_RULES,$(stage),$(target),$(host),$(crate)))))))
    327. 

    328. 

    329. 

  329. ######################################################################
    330. 

  330. # Rules for the compiletest tests (rpass, rfail, etc.)
    331. 

  331. ######################################################################
    332. 

    333. 

  333. RPASS_RC := $(wildcard $(S)src/test/run-pass/*.rc)
    334. 

  334. RPASS_RS := $(wildcard $(S)src/test/run-pass/*.rs)
    335. 

  335. RPASS_FULL_RC := $(wildcard $(S)src/test/run-pass-fulldeps/*.rc)
    336. 

  336. RPASS_FULL_RS := $(wildcard $(S)src/test/run-pass-fulldeps/*.rs)
    337. 

  337. RFAIL_RC := $(wildcard $(S)src/test/run-fail/*.rc)
    338. 

  338. RFAIL_RS := $(wildcard $(S)src/test/run-fail/*.rs)
    339. 

  339. CFAIL_RC := $(wildcard $(S)src/test/compile-fail/*.rc)
    340. 

  340. CFAIL_RS := $(wildcard $(S)src/test/compile-fail/*.rs)
    341. 

  341. BENCH_RS := $(wildcard $(S)src/test/bench/*.rs)
    342. 

  342. PRETTY_RS := $(wildcard $(S)src/test/pretty/*.rs)
    343. 

  343. DEBUGINFO_RS := $(wildcard $(S)src/test/debug-info/*.rs)
    344. 

    345. 

  345. # perf tests are the same as bench tests only they run under
    346. 

  346. # a performance monitor.
    347. 

  347. PERF_RS := $(wildcard $(S)src/test/bench/*.rs)
    348. 

    349. 

  349. RPASS_TESTS := $(RPASS_RC) $(RPASS_RS)
    350. 

  350. RPASS_FULL_TESTS := $(RPASS_FULL_RC) $(RPASS_FULL_RS)
    351. 

  351. RFAIL_TESTS := $(RFAIL_RC) $(RFAIL_RS)
    352. 

  352. CFAIL_TESTS := $(CFAIL_RC) $(CFAIL_RS)
    353. 

  353. BENCH_TESTS := $(BENCH_RS)
    354. 

  354. PERF_TESTS := $(PERF_RS)
    355. 

  355. PRETTY_TESTS := $(PRETTY_RS)
    356. 

  356. DEBUGINFO_TESTS := $(DEBUGINFO_RS)
    357. 

    358. 

  358. CTEST_SRC_BASE_rpass = run-pass
    359. 

  359. CTEST_BUILD_BASE_rpass = run-pass
    360. 

  360. CTEST_MODE_rpass = run-pass
    361. 

  361. CTEST_RUNTOOL_rpass = $(CTEST_RUNTOOL)
    362. 

    363. 

  363. CTEST_SRC_BASE_rpass-full = run-pass-full
    364. 

  364. CTEST_BUILD_BASE_rpass-full = run-pass-full
    365. 

  365. CTEST_MODE_rpass-full = run-pass
    366. 

  366. CTEST_RUNTOOL_rpass-full = $(CTEST_RUNTOOL)
    367. 

    368. 

  368. CTEST_SRC_BASE_rfail = run-fail
    369. 

  369. CTEST_BUILD_BASE_rfail = run-fail
    370. 

  370. CTEST_MODE_rfail = run-fail
    371. 

  371. CTEST_RUNTOOL_rfail = $(CTEST_RUNTOOL)
    372. 

    373. 

  373. CTEST_SRC_BASE_cfail = compile-fail
    374. 

  374. CTEST_BUILD_BASE_cfail = compile-fail
    375. 

  375. CTEST_MODE_cfail = compile-fail
    376. 

  376. CTEST_RUNTOOL_cfail = $(CTEST_RUNTOOL)
    377. 

    378. 

  378. CTEST_SRC_BASE_bench = bench
    379. 

  379. CTEST_BUILD_BASE_bench = bench
    380. 

  380. CTEST_MODE_bench = run-pass
    381. 

  381. CTEST_RUNTOOL_bench = $(CTEST_RUNTOOL)
    382. 

    383. 

  383. CTEST_SRC_BASE_perf = bench
    384. 

  384. CTEST_BUILD_BASE_perf = perf
    385. 

  385. CTEST_MODE_perf = run-pass
    386. 

  386. CTEST_RUNTOOL_perf = $(CTEST_PERF_RUNTOOL)
    387. 

    388. 

  388. CTEST_SRC_BASE_debuginfo = debug-info
    389. 

  389. CTEST_BUILD_BASE_debuginfo = debug-info
    390. 

  390. CTEST_MODE_debuginfo = debug-info
    391. 

  391. CTEST_RUNTOOL_debuginfo = $(CTEST_RUNTOOL)
    392. 

    393. 

  393. ifeq ($(CFG_GDB),)
    394. 

  394. CTEST_DISABLE_debuginfo = "no gdb found"
    395. 

  395. endif
    396. 

    397. 

  397. ifeq ($(CFG_OSTYPE),apple-darwin)
    398. 

  398. CTEST_DISABLE_debuginfo = "gdb on darwing needs root"
    399. 

  399. endif
    400. 

    401. 

  401. define DEF_CTEST_VARS
    402. 

    403. 

  403. # All the per-stage build rules you might want to call from the
    404. 

  404. # command line.
    405. 

  405. #
    406. 

  406. # $(1) is the stage number
    407. 

  407. # $(2) is the target triple to test
    408. 

  408. # $(3) is the host triple to test
    409. 

    410. 

  410. # Prerequisites for compiletest tests
    411. 

  411. TEST_SREQ$(1)_T_$(2)_H_$(3) = \
    412. 

  412. 	$$(HBIN$(1)_H_$(3))/compiletest$$(X_$(3)) \
    413. 

  413. 	$$(SREQ$(1)_T_$(2)_H_$(3))
    414. 

    415. 

  415. # Rules for the cfail/rfail/rpass/bench/perf test runner
    416. 

    417. 

  417. CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
    418. 

  418. 		--compile-lib-path $$(HLIB$(1)_H_$(3))				\
    419. 

  419.         --run-lib-path $$(TLIB$(1)_T_$(2)_H_$(3))			\
    420. 

  420.         --rustc-path $$(HBIN$(1)_H_$(3))/rustc$$(X_$(3))			\
    421. 

  421.         --aux-base $$(S)src/test/auxiliary/                 \
    422. 

  422.         --stage-id stage$(1)-$(2)							\
    423. 

  423.         --rustcflags "$(RUSTC_FLAGS_$(2)) $$(CFG_RUSTC_FLAGS) --target=$(2)" \
    424. 

  424.         $$(CTEST_TESTARGS)
    425. 

    426. 

  426. CTEST_DEPS_rpass_$(1)-T-$(2)-H-$(3) = $$(RPASS_TESTS)
    427. 

  427. CTEST_DEPS_rpass_full_$(1)-T-$(2)-H-$(3) = $$(RPASS_FULL_TESTS) $$(TLIBRUSTC_DEFAULT$(1)_T_$(2)_H_$(3))
    428. 

  428. CTEST_DEPS_rfail_$(1)-T-$(2)-H-$(3) = $$(RFAIL_TESTS)
    429. 

  429. CTEST_DEPS_cfail_$(1)-T-$(2)-H-$(3) = $$(CFAIL_TESTS)
    430. 

  430. CTEST_DEPS_bench_$(1)-T-$(2)-H-$(3) = $$(BENCH_TESTS)
    431. 

  431. CTEST_DEPS_perf_$(1)-T-$(2)-H-$(3) = $$(PERF_TESTS)
    432. 

  432. CTEST_DEPS_debuginfo_$(1)-T-$(2)-H-$(3) = $$(DEBUGINFO_TESTS)
    433. 

    434. 

  434. endef
    435. 

    436. 

  436. $(foreach host,$(CFG_HOST_TRIPLES), \
    437. 

  437.  $(eval $(foreach target,$(CFG_TARGET_TRIPLES), \
    438. 

  438.   $(eval $(foreach stage,$(STAGES), \
    439. 

  439.    $(eval $(call DEF_CTEST_VARS,$(stage),$(target),$(host))))))))
    440. 

    441. 

  441. define DEF_RUN_COMPILETEST
    442. 

    443. 

  443. CTEST_ARGS$(1)-T-$(2)-H-$(3)-$(4) := \
    444. 

  444.         $$(CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3))	\
    445. 

  445.         --src-base $$(S)src/test/$$(CTEST_SRC_BASE_$(4))/ \
    446. 

  446.         --build-base $(3)/test/$$(CTEST_BUILD_BASE_$(4))/ \
    447. 

  447.         --mode $$(CTEST_MODE_$(4)) \
    448. 

  448. 	$$(CTEST_RUNTOOL_$(4))
    449. 

    450. 

  450. check-stage$(1)-T-$(2)-H-$(3)-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4))
    451. 

    452. 

  452. ifeq ($$(CTEST_DISABLE_$(4)),)
    453. 

    454. 

  454. $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
    455. 

  455. 		$$(TEST_SREQ$(1)_T_$(2)_H_$(3)) \
    456. 

  456.                 $$(CTEST_DEPS_$(4)_$(1)-T-$(2)-H-$(3))
    457. 

  457. 	@$$(call E, run $(4): $$<)
    458. 

  458. 	$$(Q)$$(call CFG_RUN_CTEST_$(2),$(1),$$<,$(3)) \
    459. 

  459. 		$$(CTEST_ARGS$(1)-T-$(2)-H-$(3)-$(4)) \
    460. 

  460. 		--logfile $$(call TEST_LOG_FILE,$(1),$(2),$(3),$(4)) \
    461. 

  461.                 && touch $$@
    462. 

    463. 

  463. else
    464. 

    465. 

  465. $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
    466. 

  466. 		$$(TEST_SREQ$(1)_T_$(2)_H_$(3)) \
    467. 

  467.                 $$(CTEST_DEPS_$(4)_$(1)-T-$(2)-H-$(3))
    468. 

  468. 	@$$(call E, run $(4): $$<)
    469. 

  469. 	@$$(call E, warning: tests disabled: $$(CTEST_DISABLE_$(4)))
    470. 

  470. 	touch $$@
    471. 

    472. 

  472. endif
    473. 

    474. 

  474. endef
    475. 

    476. 

  476. CTEST_NAMES = rpass rpass-full rfail cfail bench perf debuginfo
    477. 

    478. 

  478. $(foreach host,$(CFG_HOST_TRIPLES), \
    479. 

  479.  $(eval $(foreach target,$(CFG_TARGET_TRIPLES), \
    480. 

  480.   $(eval $(foreach stage,$(STAGES), \
    481. 

  481.    $(eval $(foreach name,$(CTEST_NAMES), \
    482. 

  482.    $(eval $(call DEF_RUN_COMPILETEST,$(stage),$(target),$(host),$(name))))))))))
    483. 

    484. 

  484. PRETTY_NAMES = pretty-rpass pretty-rpass-full pretty-rfail pretty-bench pretty-pretty
    485. 

  485. PRETTY_DEPS_pretty-rpass = $(RPASS_TESTS)
    486. 

  486. PRETTY_DEPS_pretty-rpass-full = $(RPASS_FULL_TESTS)
    487. 

  487. PRETTY_DEPS_pretty-rfail = $(RFAIL_TESTS)
    488. 

  488. PRETTY_DEPS_pretty-bench = $(BENCH_TESTS)
    489. 

  489. PRETTY_DEPS_pretty-pretty = $(PRETTY_TESTS)
    490. 

  490. PRETTY_DIRNAME_pretty-rpass = run-pass
    491. 

  491. PRETTY_DIRNAME_pretty-rpass-full = run-pass-full
    492. 

  492. PRETTY_DIRNAME_pretty-rfail = run-fail
    493. 

  493. PRETTY_DIRNAME_pretty-bench = bench
    494. 

  494. PRETTY_DIRNAME_pretty-pretty = pretty
    495. 

    496. 

  496. define DEF_RUN_PRETTY_TEST
    497. 

    498. 

  498. PRETTY_ARGS$(1)-T-$(2)-H-$(3)-$(4) :=			\
    499. 

  499. 		$$(CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3))	\
    500. 

  500.         --src-base $$(S)src/test/$$(PRETTY_DIRNAME_$(4))/ \
    501. 

  501.         --build-base $(3)/test/$$(PRETTY_DIRNAME_$(4))/ \
    502. 

  502.         --mode pretty
    503. 

    504. 

  504. check-stage$(1)-T-$(2)-H-$(3)-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4))
    505. 

    506. 

  506. $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
    507. 

  507. 	        $$(TEST_SREQ$(1)_T_$(2)_H_$(3))		\
    508. 

  508. 	        $$(PRETTY_DEPS_$(4))
    509. 

  509. 	@$$(call E, run pretty-rpass: $$<)
    510. 

  510. 	$$(Q)$$(call CFG_RUN_CTEST_$(2),$(1),$$<,$(3)) \
    511. 

  511. 		$$(PRETTY_ARGS$(1)-T-$(2)-H-$(3)-$(4)) \
    512. 

  512. 		--logfile $$(call TEST_LOG_FILE,$(1),$(2),$(3),$(4)) \
    513. 

  513.                 && touch $$@
    514. 

    515. 

  515. endef
    516. 

    517. 

  517. $(foreach host,$(CFG_HOST_TRIPLES), \
    518. 

  518.  $(foreach target,$(CFG_TARGET_TRIPLES), \
    519. 

  519.   $(foreach stage,$(STAGES), \
    520. 

  520.    $(foreach pretty-name,$(PRETTY_NAMES), \
    521. 

  521.     $(eval $(call DEF_RUN_PRETTY_TEST,$(stage),$(target),$(host),$(pretty-name)))))))
    522. 

    523. 

  523. define DEF_RUN_DOC_TEST
    524. 

    525. 

  525. DOC_TEST_ARGS$(1)-T-$(2)-H-$(3)-doc-$(4) := \
    526. 

  526.         $$(CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3))	\
    527. 

  527.         --src-base $(3)/test/doc-$(4)/	\
    528. 

  528.         --build-base $(3)/test/doc-$(4)/	\
    529. 

  529.         --mode run-pass
    530. 

    531. 

  531. check-stage$(1)-T-$(2)-H-$(3)-doc-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3),doc-$(4))
    532. 

    533. 

  533. $$(call TEST_OK_FILE,$(1),$(2),$(3),doc-$(4)): \
    534. 

  534. 	        $$(TEST_SREQ$(1)_T_$(2)_H_$(3))		\
    535. 

  535.                 doc-$(4)-extract$(3)
    536. 

  536. 	@$$(call E, run doc-$(4): $$<)
    537. 

  537. 	$$(Q)$$(call CFG_RUN_CTEST_$(2),$(1),$$<,$(3)) \
    538. 

  538.                 $$(DOC_TEST_ARGS$(1)-T-$(2)-H-$(3)-doc-$(4)) \
    539. 

  539. 		--logfile $$(call TEST_LOG_FILE,$(1),$(2),$(3),doc-$(4)) \
    540. 

  540.                 && touch $$@
    541. 

    542. 

  542. endef
    543. 

    544. 

  544. $(foreach host,$(CFG_HOST_TRIPLES), \
    545. 

  545.  $(foreach target,$(CFG_TARGET_TRIPLES), \
    546. 

  546.   $(foreach stage,$(STAGES), \
    547. 

  547.    $(foreach docname,$(DOC_TEST_NAMES), \
    548. 

  548.     $(eval $(call DEF_RUN_DOC_TEST,$(stage),$(target),$(host),$(docname)))))))
    549. 

    550. 

    551. 

  551. ######################################################################
    552. 

  552. # Extracting tests for docs
    553. 

  553. ######################################################################
    554. 

    555. 

  555. EXTRACT_TESTS := "$(CFG_PYTHON)" $(S)src/etc/extract-tests.py
    556. 

    557. 

  557. define DEF_DOC_TEST_HOST
    558. 

    559. 

  559. doc-$(2)-extract$(1):
    560. 

  560. 	@$$(call E, extract: $(2) tests)
    561. 

  561. 	$$(Q)rm -f $(1)/test/doc-$(2)/*.rs
    562. 

  562. 	$$(Q)$$(EXTRACT_TESTS) $$(S)doc/$(2).md $(1)/test/doc-$(2)
    563. 

    564. 

  564. endef
    565. 

    566. 

  566. $(foreach host,$(CFG_HOST_TRIPLES), \
    567. 

  567.  $(foreach docname,$(DOC_TEST_NAMES), \
    568. 

  568.   $(eval $(call DEF_DOC_TEST_HOST,$(host),$(docname)))))
    569. 

    570. 

    571. 

  571. ######################################################################
    572. 

  572. # Shortcut rules
    573. 

  573. ######################################################################
    574. 

    575. 

  575. TEST_GROUPS = \
    576. 

  576. 	crates \
    577. 

  577. 	$(foreach crate,$(TEST_CRATES),$(crate)) \
    578. 

  578. 	rpass \
    579. 

  579. 	rpass-full \
    580. 

  580. 	rfail \
    581. 

  581. 	cfail \
    582. 

  582. 	bench \
    583. 

  583. 	perf \
    584. 

  584. 	debuginfo \
    585. 

  585. 	doc \
    586. 

  586. 	$(foreach docname,$(DOC_TEST_NAMES),$(docname)) \
    587. 

  587. 	pretty \
    588. 

  588. 	pretty-rpass \
    589. 

  589. 	pretty-rpass-full \
    590. 

  590. 	pretty-rfail \
    591. 

  591. 	pretty-bench \
    592. 

  592. 	pretty-pretty \
    593. 

  593. 	$(NULL)
    594. 

    595. 

  595. define DEF_CHECK_FOR_STAGE_AND_TARGET_AND_HOST
    596. 

  596. check-stage$(1)-T-$(2)-H-$(3): check-stage$(1)-T-$(2)-H-$(3)-exec
    597. 

  597. endef
    598. 

    599. 

  599. $(foreach stage,$(STAGES), \
    600. 

  600.  $(foreach target,$(CFG_TARGET_TRIPLES), \
    601. 

  601.   $(foreach host,$(CFG_HOST_TRIPLES), \
    602. 

  602.    $(eval $(call DEF_CHECK_FOR_STAGE_AND_TARGET_AND_HOST,$(stage),$(target),$(host))))))
    603. 

    604. 

  604. define DEF_CHECK_FOR_STAGE_AND_TARGET_AND_HOST_AND_GROUP
    605. 

  605. check-stage$(1)-T-$(2)-H-$(3)-$(4): check-stage$(1)-T-$(2)-H-$(3)-$(4)-exec
    606. 

  606. endef
    607. 

    608. 

  608. $(foreach stage,$(STAGES), \
    609. 

  609.  $(foreach target,$(CFG_TARGET_TRIPLES), \
    610. 

  610.   $(foreach host,$(CFG_HOST_TRIPLES), \
    611. 

  611.    $(foreach group,$(TEST_GROUPS), \
    612. 

  612.     $(eval $(call DEF_CHECK_FOR_STAGE_AND_TARGET_AND_HOST_AND_GROUP,$(stage),$(target),$(host),$(group)))))))
    613. 

    614. 

  614. define DEF_CHECK_FOR_STAGE
    615. 

  615. check-stage$(1): check-stage$(1)-H-$$(CFG_BUILD_TRIPLE)
    616. 

  616. check-stage$(1)-H-all: $$(foreach target,$$(CFG_TARGET_TRIPLES), \
    617. 

  617.                            check-stage$(1)-H-$$(target))
    618. 

  618. endef
    619. 

    620. 

  620. $(foreach stage,$(STAGES), \
    621. 

  621.  $(eval $(call DEF_CHECK_FOR_STAGE,$(stage))))
    622. 

    623. 

  623. define DEF_CHECK_FOR_STAGE_AND_GROUP
    624. 

  624. check-stage$(1)-$(2): check-stage$(1)-H-$$(CFG_BUILD_TRIPLE)-$(2)
    625. 

  625. check-stage$(1)-H-all-$(2): $$(foreach target,$$(CFG_TARGET_TRIPLES), \
    626. 

  626.                                check-stage$(1)-H-$$(target)-$(2))
    627. 

  627. endef
    628. 

    629. 

  629. $(foreach stage,$(STAGES), \
    630. 

  630.  $(foreach group,$(TEST_GROUPS), \
    631. 

  631.   $(eval $(call DEF_CHECK_FOR_STAGE_AND_GROUP,$(stage),$(group)))))
    632. 

    633. 

    634. 

  634. define DEF_CHECK_FOR_STAGE_AND_HOSTS
    635. 

  635. check-stage$(1)-H-$(2): $$(foreach target,$$(CFG_TARGET_TRIPLES), \
    636. 

  636.                            check-stage$(1)-T-$$(target)-H-$(2))
    637. 

  637. endef
    638. 

    639. 

  639. $(foreach stage,$(STAGES), \
    640. 

  640.  $(foreach host,$(CFG_HOST_TRIPLES), \
    641. 

  641.   $(eval $(call DEF_CHECK_FOR_STAGE_AND_HOSTS,$(stage),$(host)))))
    642. 

    643. 

  643. define DEF_CHECK_FOR_STAGE_AND_HOSTS_AND_GROUP
    644. 

  644. check-stage$(1)-H-$(2)-$(3): $$(foreach target,$$(CFG_TARGET_TRIPLES), \
    645. 

  645.                                 check-stage$(1)-T-$$(target)-H-$(2)-$(3))
    646. 

  646. endef
    647. 

    648. 

  648. $(foreach stage,$(STAGES), \
    649. 

  649.  $(foreach host,$(CFG_HOST_TRIPLES), \
    650. 

  650.   $(foreach group,$(TEST_GROUPS), \
    651. 

  651.    $(eval $(call DEF_CHECK_FOR_STAGE_AND_HOSTS_AND_GROUP,$(stage),$(host),$(group))))))
    652. 

    653. 

  653. ######################################################################
    654. 

  654. # check-fast rules
    655. 

  655. ######################################################################
    656. 

    657. 

  657. FT := run_pass_stage2
    658. 

  658. FT_LIB := $(call CFG_LIB_NAME_$(CFG_BUILD_TRIPLE),$(FT))
    659. 

  659. FT_DRIVER := $(FT)_driver
    660. 

    661. 

  661. GENERATED += tmp/$(FT).rc tmp/$(FT_DRIVER).rs
    662. 

    663. 

  663. tmp/$(FT).rc tmp/$(FT_DRIVER).rs: \
    664. 

  664. 		$(RPASS_TESTS) \
    665. 

  665. 		$(S)src/etc/combine-tests.py
    666. 

  666. 	@$(call E, check: building combined stage2 test runner)
    667. 

  667. 	$(Q)$(CFG_PYTHON) $(S)src/etc/combine-tests.py
    668. 

    669. 

  669. define DEF_CHECK_FAST_FOR_T_H
    670. 

  670. # $(1) unused
    671. 

  671. # $(2) target triple
    672. 

  672. # $(3) host triple
    673. 

    674. 

  674. $$(TLIB2_T_$(2)_H_$(3))/$$(FT_LIB): \
    675. 

  675. 		tmp/$$(FT).rc \
    676. 

  676. 		$$(SREQ2_T_$(2)_H_$(3))
    677. 

  677. 	@$$(call E, compile_and_link: $$@)
    678. 

  678. 	$$(STAGE2_T_$(2)_H_$(3)) --lib -o $$@ $$<
    679. 

    680. 

  680. $(3)/test/$$(FT_DRIVER)-$(2)$$(X_$(2)): \
    681. 

  681. 		tmp/$$(FT_DRIVER).rs \
    682. 

  682. 		$$(TLIB2_T_$(2)_H_$(3))/$$(FT_LIB) \
    683. 

  683. 		$$(SREQ2_T_$(2)_H_$(3))
    684. 

  684. 	@$$(call E, compile_and_link: $$@ $$<)
    685. 

  685. 	$$(STAGE2_T_$(2)_H_$(3)) -o $$@ $$<
    686. 

    687. 

  687. $(3)/test/$$(FT_DRIVER)-$(2).out: \
    688. 

  688. 		$(3)/test/$$(FT_DRIVER)-$(2)$$(X_$(2)) \
    689. 

  689. 		$$(SREQ2_T_$(2)_H_$(3))
    690. 

  690. 	$$(Q)$$(call CFG_RUN_TEST_$(2),$$<,$(2),$(3)) \
    691. 

  691. 	--logfile tmp/$$(FT_DRIVER)-$(2).log
    692. 

    693. 

  693. check-fast-T-$(2)-H-$(3):     			\
    694. 

  694. 	$(3)/test/$$(FT_DRIVER)-$(2).out
    695. 

    696. 

  696. endef
    697. 

    698. 

  698. $(foreach host,$(CFG_HOST_TRIPLES), \
    699. 

  699.  $(eval $(foreach target,$(CFG_TARGET_TRIPLES), \
    700. 

  700.    $(eval $(call DEF_CHECK_FAST_FOR_T_H,,$(target),$(host))))))
    701. 

    702. 

  702. check-fast: tidy check-fast-H-$(CFG_BUILD_TRIPLE)
    703. 

    704. 

  704. define DEF_CHECK_FAST_FOR_H
    705. 

    706. 

  706. check-fast-H-$(1): 		check-fast-T-$(1)-H-$(1)
    707. 

    708. 

  708. endef
    709. 

    710. 

  710. $(foreach host,$(CFG_HOST_TRIPLES),			\
    711. 

  711.  $(eval $(call DEF_CHECK_FAST_FOR_H,$(host))))
    712. 

    713. 

    714.