git.iko.soy/unity8
on 6ca9421 help sign in
unity8/cmake/modules/QmlTest.cmake
313 lines 11 kB history raw
1# If you need to override the qmlscene or qmltestrunner executables,
2# create the corresponding executable target.
4# These functions respect the global STDOUT_LOGGER and ARTIFACTS_DIR variables.
6# You can use those with cmake_parse_arguments
7# if you need to wrap and mangle arguments.
8set(QMLTEST_OPTIONS ADD_TEST CACHE INTERNAL "")
9set(QMLTEST_SINGLE ITERATIONS ARG_PREFIX CACHE INTERNAL "")
10set(QMLTEST_MULTI ARGS ENVIRONMENT DEPENDS IMPORT_PATHS TARGETS CACHE INTERNAL "")
12# import_executables(name1 [name2 [...]]
13# [OPTIONAL] # continue when not found
14# )
16# This will find the named executables and import them
17# to an imported target of the same name.
19function(import_executables)
20 cmake_parse_arguments(QMLTEST "OPTIONAL" "" "" ${ARGN})
22 foreach(NAME ${QMLTEST_UNPARSED_ARGUMENTS})
23 if(NOT TARGET ${NAME})
24 add_executable(${NAME} IMPORTED GLOBAL)
25 find_program(${NAME}_exe ${NAME})
27 if(NOT QMLTEST_OPTIONAL AND NOT ${NAME}_exe)
28 message(FATAL_ERROR "Could not locate ${NAME}.")
29 elseif(NOT ${NAME}_exe)
30 message(STATUS "Could not locate ${NAME}, skipping.")
31 else()
32 set_target_properties(${NAME} PROPERTIES IMPORTED_LOCATION ${${NAME}_exe})
33 endif()
34 endif()
35 endforeach()
36endfunction()
39# add_qml_test(path component_name
40# [...]
41# )
43# Add test targets for ${component_name} under ${path}. It's assumed
44# that the test file is named ${path}/tst_${component_name}.qml.
46# This function wraps add_manual_qml_test and add_qml_unittest,
47# see below for available arguments.
49function(add_qml_test PATH COMPONENT_NAME)
50 cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "${QMLTEST_MULTI}" ${ARGN})
51 mangle_arguments()
53 add_qml_unittest(${ARGV})
54 add_manual_qml_test(${ARGV})
55endfunction()
58# add_qml_unittest(path component_name
59# [...]
60# )
62# Add test targets for ${component_name} under ${path}. It's assumed
63# that the test file is named ${path}/tst_${component_name}.qml.
65# This function wraps add_executable_test, see below for available arguments.
67function(add_qml_unittest PATH COMPONENT_NAME)
68 import_executables(qmltestrunner)
70 add_executable_test(${COMPONENT_NAME} qmltestrunner
71 ${ARGN}
72 ARGS -input ${CMAKE_CURRENT_SOURCE_DIR}/${PATH}/tst_${COMPONENT_NAME}.qml ${QMLTEST_ARGS}
73 )
74endfunction()
77# add_manual_qml_test(path component_name
78# [...]
79# )
81# Add manual test targets for ${component_name} under ${path}. It's assumed
82# that the test file is named ${path}/tst_${component_name}.qml.
84# This function wraps add_manual_test, see below for available arguments.
86function(add_manual_qml_test PATH COMPONENT_NAME)
87 import_executables(qmlscene)
88 cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "${QMLTEST_MULTI}" ${ARGN})
90 add_manual_test(${COMPONENT_NAME} qmlscene
91 ${ARGN}
92 ARGS ${CMAKE_CURRENT_SOURCE_DIR}/${PATH}/tst_${COMPONENT_NAME}.qml ${QMLTEST_ARGS}
93 )
94endfunction()
97# add_executable_test(target component_name
98# [...] # see doc for add_manual_qml_test for common arguments
99# [ADD_TEST] # whether to add to the "test" target
100# [ARG_PREFIX arg_prefix] # prefix logging arguments with this string
101# [ARGS] arg1 [arg2 [...]] # pass these arguments to the test executable
102# [TARGETS target1 [target2 [...]]] # make the listed targets depend on this test
103# # if a corresponding xvfbtarget1, xvfbtarget2 etc. exists,
104# # this test running under xvfb will be added as a dependency
105# # of those targets
106# [ITERATIONS count] # run this test as a benchmark for ${count} iterations
107# )
109# Logging options in the standard form of "-o filename,format"
110# will be appended to the arguments list, prefixed with ARG_PREFIX.
111# XUnitXML files will be stored in current binary dir or under
112# ARTIFACTS_DIR, if set.
114# Three targets will be created:
115# - test${component_name} - Runs the test
116# - xvfbtest${component_name} - Runs the test under xvfb
117# - gdbtest${component_name} - Runs the test under gdb
119function(add_executable_test COMPONENT_NAME TARGET)
120 import_executables(gdb xvfb-run OPTIONAL)
122 cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "${QMLTEST_MULTI}" ${ARGN})
123 mangle_arguments()
125 if(ARTIFACTS_DIR)
126 file(RELATIVE_PATH path ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
127 file(MAKE_DIRECTORY ${ARTIFACTS_DIR}/${path})
128 set(file_logger -o ${ARTIFACTS_DIR}/${path}/test${COMPONENT_NAME}.xml,xunitxml)
129 else()
130 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
131 set(file_logger -o ${CMAKE_CURRENT_BINARY_DIR}/test${COMPONENT_NAME}.xml,xunitxml)
132 endif()
134 bake_arguments("${QMLTEST_ARG_PREFIX}" args ${iterations} ${file_logger} ${STDOUT_LOGGER})
136 set(qmltest_command
137 $<TARGET_FILE:${TARGET}>
138 ${QMLTEST_ARGS}
139 ${args}
140 )
142 add_qmltest_target(test${COMPONENT_NAME} ${TARGET}
143 COMMAND ${qmltest_command}
144 ${depends}
145 ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT}
146 ${add_test}
147 ${targets}
148 )
150 if(TARGET xvfb-run)
151 add_qmltest_target(xvfbtest${COMPONENT_NAME} ${TARGET}
152 COMMAND $<TARGET_FILE:xvfb-run> --server-args "-screen 0 1024x768x24" --auto-servernum ${qmltest_command}
153 ${depends}
154 ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT} LD_PRELOAD=/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/mesa/libGL.so.1
155 TARGETS ${xvfb_targets}
156 )
157 endif()
159 if(TARGET gdb)
160 add_qmltest_target(gdbtest${COMPONENT_NAME} ${TARGET}
161 COMMAND $<TARGET_FILE:gdb> -ex run -args ${qmltest_command}
162 ${depends}
163 ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT}
164 )
165 endif()
166endfunction()
169# add_manual_test(target component_name
170# [DEPENDS target1 [target2 [...]]] # make this test depend on the specified targets
171# [IMPORT_PATHS import_path1 [import_path2 [...]] # use these QML import paths
172# # (they're searched first to last)
173# [ENVIRONMENT var1=value1 [var2=value2 [...]]] # set these environment variables
174# )
176# Two targets will be created:
177# - try${component_name} - Runs the test for manual interaction
178# - gdbtry${component_name} - Runs the test under gdb
180function(add_manual_test COMPONENT_NAME TARGET)
181 import_executables(gdb OPTIONAL)
183 cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "${QMLTEST_MULTI}" ${ARGN})
184 mangle_arguments()
186 bake_arguments("${QMLTEST_ARG_PREFIX}" args -qmljsdebugger=port:3768)
188 set(qmltry_command
189 $<TARGET_FILE:${TARGET}>
190 ${QMLTEST_ARGS}
191 ${args}
192 )
194 add_qmltest_target(try${COMPONENT_NAME} ${TARGET}
195 COMMAND ${qmltry_command}
196 ${depends}
197 ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT}
198 )
200 if(TARGET gdb)
201 add_qmltest_target(gdbtry${COMPONENT_NAME} ${TARGET}
202 COMMAND $<TARGET_FILE:gdb> -ex run -args ${qmltry_command}
203 ${depends}
204 ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT}
205 )
206 endif()
207endfunction()
210################### INTERNAL ####################
212# add_qmltest_target(target_name target
213# COMMAND test_exe [arg1 [...]] # execute this test with arguments
214# [...] # see above for available arguments:
215# # ADD_TEST, ENVIRONMENT, DEPENDS and TARGETS
216# )
218function(add_qmltest_target TARGET_NAME TARGET)
219 cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "COMMAND;${QMLTEST_MULTI}" ${ARGN})
220 mangle_arguments()
222 # Additional arguments
223 string(TOLOWER "${CMAKE_GENERATOR}" cmake_generator_lower)
224 if(cmake_generator_lower STREQUAL "unix makefiles")
225 set(function "$(FUNCTION)")
226 endif()
228 add_custom_target(${TARGET_NAME}
229 env ${QMLTEST_ENVIRONMENT}
230 ${QMLTEST_COMMAND} ${function}
231 DEPENDS ${TARGET} ${QMLTEST_DEPENDS}
232 )
234 if(QMLTEST_ADD_TEST)
235 add_test(
236 NAME ${TARGET_NAME}
237 COMMAND ${QMLTEST_COMMAND}
238 )
240 foreach(ENV ${QMLTEST_ENVIRONMENT})
241 set_property(TEST ${TARGET_NAME} APPEND PROPERTY ENVIRONMENT ${ENV})
242 endforeach()
244 set_property(TEST ${TARGET_NAME} APPEND PROPERTY DEPENDS ${TARGET})
245 foreach(DEPEND ${DEPENDS})
246 set_property(TEST ${TARGET_NAME} APPEND PROPERTY DEPENDS ${DEPEND})
247 endforeach()
248 endif()
250 foreach(UPSTREAM_TARGET ${QMLTEST_TARGETS})
251 add_dependencies(${UPSTREAM_TARGET} ${TARGET_NAME})
252 endforeach()
253endfunction()
256# mangle_arguments(${ARGN})
258# Verify there were no unparsed arguments and
259# mangle the known ones for further processing.
261macro(mangle_arguments)
262 if(QMLTEST_UNPARSED_ARGUMENTS)
263 message(FATAL_ERROR "Unexpected arguments: ${QMLTEST_UNPARSED_ARGUMENTS}")
264 endif()
266 if(QMLTEST_ADD_TEST)
267 set(add_test ADD_TEST)
268 endif()
270 if(QMLTEST_IMPORT_PATHS)
271 string(REPLACE ";" ":" imports "${QMLTEST_IMPORT_PATHS}")
272 endif()
274 if(QMLTEST_ITERATIONS)
275 set(iterations -iterations ${QMLTEST_ITERATIONS})
276 endif()
278 if(QMLTEST_DEPENDS)
279 set(depends DEPENDS ${QMLTEST_DEPENDS})
280 endif()
282 if(QMLTEST_TARGETS)
283 set(targets TARGETS ${QMLTEST_TARGETS})
284 endif()
286 set(xvfb_targets "")
287 foreach(target ${QMLTEST_TARGETS})
288 if(TARGET xvfb${target})
289 list(APPEND xvfb_targets xvfb${target})
290 endif()
291 endforeach()
292 set(xvfb_targets "${xvfb_targets}" PARENT_SCOPE)
293endmacro()
296# bake_arguments(prefix output
297# arg1 [arg2 [...]]
298# )
300# If set, add the argument prefix before every passed
301# argument and store the result in ${OUTPUT} variable.
303function(bake_arguments PREFIX OUTPUT)
304 set(args "${ARGN}")
305 if(PREFIX)
306 set(args "")
307 foreach(arg ${ARGN})
308 list(APPEND args ${PREFIX})
309 list(APPEND args ${arg})
310 endforeach()
311 endif()
312 set(${OUTPUT} "${args}" PARENT_SCOPE)
313endfunction()