@@ -1,218 +1,306 @@
1−# add_qml_test(path component_name [NO_ADD_TEST] [NO_TARGETS]
2−# [TARGETS target1 [target2 [...]]]
3−# [IMPORT_PATHS import_path1 [import_path2 [...]]
4−# [PROPERTIES prop1 value1 [prop2 value2 [...]]])
1+# If you need to override the qmlscene or qmltestrunner executables,
2+# create the corresponding executable target.
3+
4+# These functions respect the global STDOUT_LOGGER and ARTIFACTS_DIR variables.
5+
6+execute_process(
7+ COMMAND gcc -dumpmachine
8+ OUTPUT_VARIABLE ARCH_TRIPLET
9+ OUTPUT_STRIP_TRAILING_WHITESPACE
10+)
11+
12+# You can use those with cmake_parse_arguments
13+# if you need to wrap and mangle arguments.
14+set(QMLTEST_OPTIONS ADD_TEST CACHE INTERNAL "")
15+set(QMLTEST_SINGLE ITERATIONS ARG_PREFIX CACHE INTERNAL "")
16+set(QMLTEST_MULTI ARGS ENVIRONMENT DEPENDS IMPORT_PATHS TARGETS CACHE INTERNAL "")
17+
18+# import_executables(name1 [name2 [...]])
19+#
20+# This will find the named executables and import them
21+# to an imported target of the same name.
22+
23+function(import_executables)
24+ foreach(NAME ${ARGN})
25+ if(NOT TARGET ${NAME})
26+ find_program(${NAME}_exe ${NAME})
27+
28+ if(NOT ${NAME}_exe)
29+ message(FATAL_ERROR "Could not locate ${NAME}.")
30+ endif()
31+
32+ add_executable(${NAME} IMPORTED)
33+ set_target_properties(${NAME} PROPERTIES IMPORTED_LOCATION ${${NAME}_exe})
34+ endif()
35+ endforeach()
36+endfunction()
37+
38+
39+# add_qml_test(path component_name
40+# [...]
41+# )
542#
6−# NO_ADD_TEST will prevent adding the test to the "test" target
7−# NO_TARGETS will prevent adding the test to any targets
8−# TARGETS lists the targets the test should be added to
9−# IMPORT_PATHS will pass those paths to qmltestrunner as "-import" arguments
10−# PROPERTIES will be set on the target and test target. See CMake's set_target_properties()
43+# Add test targets for ${component_name} under ${path}. It's assumed
44+# that the test file is named ${path}/tst_${component_name}.qml.
1145#
12−# Two targets will be created:
13−# - testComponentName - Runs the test with qmltestrunner
14−# - tryComponentName - Runs the test with uqmlscene, for manual interaction
15−# - gdbtestComponentName - Runs the test with qmltestrunner under gdb
46+# This function wraps add_manual_qml_test and add_qml_unittest,
47+# see below for available arguments.
48+
49+function(add_qml_test PATH COMPONENT_NAME)
50+ import_executables(qmltestrunner)
51+ cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "${QMLTEST_MULTI}" ${ARGN})
52+ mangle_arguments()
53+
54+ add_qml_unittest(${ARGV})
55+ add_manual_qml_test(${ARGV})
56+endfunction()
57+
58+
59+# add_manual_qml_test(path component_name
60+# [...]
61+# )
1662#
17−# To change/set a default value for the whole test suite, prior to calling add_qml_test, set:
18−# qmltest_DEFAULT_NO_ADD_TEST (default: FALSE)
19−# qmltest_DEFAULT_TARGETS
20−# qmltest_DEFAULT_IMPORT_PATHS
21−# qmltest_DEFAULT_PROPERTIES
22−
23−find_program(qmltestrunner_exe qmltestrunner)
24−
25−if(NOT qmltestrunner_exe)
26− msg(FATAL_ERROR "Could not locate qmltestrunner.")
27−endif()
28−
29−set(qmlscene_exe ${CMAKE_BINARY_DIR}/tests/uqmlscene/uqmlscene)
30−
31−set(test_env LC_ALL=C UNITY_TESTING=1)
32−
33−macro(add_manual_qml_test SUBPATH COMPONENT_NAME)
34− set(options NO_ADD_TEST NO_TARGETS)
35− set(multi_value_keywords IMPORT_PATHS TARGETS PROPERTIES ENVIRONMENT)
36−
37− cmake_parse_arguments(qmltest "${options}" "" "${multi_value_keywords}" ${ARGN})
38− cmake_parse_arguments(qmltest_default "${options}" "" "${multi_value_keywords}" ${qmltest_DEFAULT_PROPERTIES})
39−
40− set(qmlscene_TARGET try${COMPONENT_NAME})
41− set(qmltest_FILE ${SUBPATH}/tst_${COMPONENT_NAME})
42−
43− set(qmlscene_imports "")
44− if(NOT "${qmltest_IMPORT_PATHS}" STREQUAL "")
45− foreach(IMPORT_PATH ${qmltest_IMPORT_PATHS})
46− list(APPEND qmlscene_imports "-I")
47− list(APPEND qmlscene_imports ${IMPORT_PATH})
48− endforeach(IMPORT_PATH)
49− elseif(NOT "${qmltest_DEFAULT_IMPORT_PATHS}" STREQUAL "")
50− foreach(IMPORT_PATH ${qmltest_DEFAULT_IMPORT_PATHS})
51− list(APPEND qmlscene_imports "-I")
52− list(APPEND qmlscene_imports ${IMPORT_PATH})
53− endforeach(IMPORT_PATH)
54− endif()
63+# Add manual test targets for ${component_name} under ${path}. It's assumed
64+# that the test file is named ${path}/tst_${component_name}.qml.
65+#
66+# This function wraps add_manual_test, see below for available arguments.
67+function(add_qml_unittest PATH COMPONENT_NAME)
68+ import_executables(qmlscene)
5569
56− if("${qmltest_ENVIRONMENT}" STREQUAL "")
57− set(qmltest_ENVIRONMENT "${qmltest_default_ENVIRONMENT}")
58− endif()
70+ add_executable_test(${COMPONENT_NAME} qmltestrunner
71+ ${ARGN}
72+ ARGS -input ${CMAKE_CURRENT_SOURCE_DIR}/${PATH}/tst_${COMPONENT_NAME}.qml ${QMLTEST_ARGS}
73+ )
74+endfunction()
5975
60− set(qmlscene_command
61− env ${test_env} ${qmltest_ENVIRONMENT}
62− ${qmlscene_exe} -qmljsdebugger=port:3768 ${CMAKE_CURRENT_SOURCE_DIR}/${qmltest_FILE}.qml
63− ${qmlscene_imports}
76+
77+# add_manual_qml_test(path component_name
78+# [...]
79+# )
80+#
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.
83+#
84+# This function wraps add_manual_test, see below for available arguments.
85+
86+function(add_manual_qml_test PATH COMPONENT_NAME)
87+ import_executables(qmlscene)
88+ cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "${QMLTEST_MULTI}" ${ARGN})
89+
90+ add_manual_test(${COMPONENT_NAME} qmlscene
91+ ${ARGN}
92+ ARGS ${CMAKE_CURRENT_SOURCE_DIR}/${PATH}/tst_${COMPONENT_NAME}.qml ${QMLTEST_ARGS}
6493 )
65− add_custom_target(${qmlscene_TARGET} ${qmlscene_command})
66−
67−endmacro(add_manual_qml_test)
68−
69−macro(add_qml_benchmark SUBPATH COMPONENT_NAME ITERATIONS)
70− add_qml_test_internal(${SUBPATH} ${COMPONENT_NAME} ${ITERATIONS} ${ARGN})
71−endmacro(add_qml_benchmark)
72−
73−macro(add_qml_test SUBPATH COMPONENT_NAME)
74− add_qml_test_internal(${SUBPATH} ${COMPONENT_NAME} 0 ${ARGN})
75−endmacro(add_qml_test)
76−
77−macro(add_qml_test_internal SUBPATH COMPONENT_NAME ITERATIONS)
78− set(options NO_ADD_TEST NO_TARGETS)
79− set(multi_value_keywords IMPORT_PATHS TARGETS PROPERTIES ENVIRONMENT)
80−
81− cmake_parse_arguments(qmltest "${options}" "" "${multi_value_keywords}" ${ARGN})
82− cmake_parse_arguments(qmltest_default "${options}" "" "${multi_value_keywords}" ${qmltest_DEFAULT_PROPERTIES})
83−
84− set(qmltest_TARGET test${COMPONENT_NAME})
85− set(qmltest_gdb_TARGET gdbtest${COMPONENT_NAME})
86− set(qmltest_xvfb_TARGET xvfbtest${COMPONENT_NAME})
87− set(qmltest_FILE ${SUBPATH}/tst_${COMPONENT_NAME})
88−
89− set(qmltestrunner_imports "")
90− if(NOT "${qmltest_IMPORT_PATHS}" STREQUAL "")
91− foreach(IMPORT_PATH ${qmltest_IMPORT_PATHS})
92− list(APPEND qmltestrunner_imports "-import")
93− list(APPEND qmltestrunner_imports ${IMPORT_PATH})
94− endforeach(IMPORT_PATH)
95− elseif(NOT "${qmltest_DEFAULT_IMPORT_PATHS}" STREQUAL "")
96− foreach(IMPORT_PATH ${qmltest_DEFAULT_IMPORT_PATHS})
97− list(APPEND qmltestrunner_imports "-import")
98− list(APPEND qmltestrunner_imports ${IMPORT_PATH})
99− endforeach(IMPORT_PATH)
94+endfunction()
95+
96+
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+# )
108+#
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.
113+#
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
118+
119+function(add_executable_test COMPONENT_NAME TARGET)
120+ import_executables(gdb xvfb-run)
121+
122+ cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "${QMLTEST_MULTI}" ${ARGN})
123+ mangle_arguments()
124+
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+ set(file_logger -o ${CMAKE_CURRENT_BINARY_DIR}/test${COMPONENT_NAME}.xml,xunitxml)
100131 endif()
101132
133+ bake_arguments("${QMLTEST_ARG_PREFIX}" args ${iterations} ${file_logger} ${STDOUT_LOGGER})
134+
135+ set(qmltest_command
136+ $<TARGET_FILE:${TARGET}>
137+ ${QMLTEST_ARGS}
138+ ${args}
139+ )
140+
141+ add_qmltest_target(test${COMPONENT_NAME} ${TARGET}
142+ COMMAND ${qmltest_command}
143+ ${depends}
144+ ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT}
145+ ${add_test}
146+ ${targets}
147+ )
148+
149+ add_qmltest_target(xvfbtest${COMPONENT_NAME} ${TARGET}
150+ COMMAND $<TARGET_FILE:xvfb-run> --server-args "-screen 0 1024x768x24" --auto-servernum ${qmltest_command}
151+ ${depends}
152+ ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT} LD_PRELOAD=/usr/lib/${ARCH_TRIPLET}/mesa/libGL.so.1
153+ TARGETS ${xvfb_targets}
154+ )
155+
156+ add_qmltest_target(gdbtest${COMPONENT_NAME} ${TARGET}
157+ COMMAND $<TARGET_FILE:gdb> -ex run -args ${qmltest_command}
158+ ${depends}
159+ ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT}
160+ )
161+endfunction()
162+
163+
164+# add_manual_test(target component_name
165+# [DEPENDS target1 [target2 [...]]] # make this test depend on the specified targets
166+# [IMPORT_PATHS import_path1 [import_path2 [...]] # use these QML import paths
167+# # (they're searched first to last)
168+# [ENVIRONMENT var1=value1 [var2=value2 [...]]] # set these environment variables
169+# )
170+#
171+# Two targets will be created:
172+# - try${component_name} - Runs the test for manual interaction
173+# - gdbtry${component_name} - Runs the test under gdb
174+
175+function(add_manual_test COMPONENT_NAME TARGET)
176+ import_executables(gdb)
177+
178+ cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "${QMLTEST_MULTI}" ${ARGN})
179+ mangle_arguments()
180+
181+ bake_arguments("${QMLTEST_ARG_PREFIX}" args -qmljsdebugger=port:3768)
182+
183+ set(qmltry_command
184+ $<TARGET_FILE:${TARGET}>
185+ ${QMLTEST_ARGS}
186+ ${args}
187+ )
188+
189+ add_qmltest_target(try${COMPONENT_NAME} ${TARGET}
190+ COMMAND ${qmltry_command}
191+ ${depends}
192+ ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT}
193+ )
194+
195+ add_qmltest_target(gdbtry${COMPONENT_NAME} ${TARGET}
196+ COMMAND $<TARGET_FILE:gdb> -ex run -args ${qmltry_command}
197+ ${depends}
198+ ENVIRONMENT QML2_IMPORT_PATH=${imports} ${QMLTEST_ENVIRONMENT}
199+ )
200+endfunction()
201+
202+
203+################### INTERNAL ####################
204+
205+# add_qmltest_target(target_name target
206+# COMMAND test_exe [arg1 [...]] # execute this test with arguments
207+# [...] # see above for available arguments:
208+# # ADD_TEST, ENVIRONMENT, DEPENDS and TARGETS
209+# )
210+
211+function(add_qmltest_target TARGET_NAME TARGET)
212+ cmake_parse_arguments(QMLTEST "${QMLTEST_OPTIONS}" "${QMLTEST_SINGLE}" "COMMAND;${QMLTEST_MULTI}" ${ARGN})
213+ mangle_arguments()
214+
215+ # Additional arguments
102216 string(TOLOWER "${CMAKE_GENERATOR}" cmake_generator_lower)
103217 if(cmake_generator_lower STREQUAL "unix makefiles")
104− set(function_ARGS $(FUNCTION))
105− else()
106− set(function_ARGS "")
218+ set(function "$(FUNCTION)")
107219 endif()
108220
109− if (${ITERATIONS} GREATER 0)
110− set(ITERATIONS_STRING "-iterations" ${ITERATIONS})
111− else()
112− set(ITERATIONS_STRING "")
221+ add_custom_target(${TARGET_NAME}
222+ env ${QMLTEST_ENVIRONMENT}
223+ ${QMLTEST_COMMAND} ${function}
224+ DEPENDS ${TARGET} ${QMLTEST_DEPENDS}
225+ )
226+
227+ if(QMLTEST_ADD_TEST)
228+ add_test(
229+ NAME ${TARGET_NAME}
230+ COMMAND ${QMLTEST_COMMAND}
231+ )
232+
233+ foreach(ENV ${QMLTEST_ENVIRONMENT})
234+ set_property(TEST ${TARGET_NAME} APPEND PROPERTY ENVIRONMENT ${ENV})
235+ endforeach()
236+
237+ set_property(TEST ${TARGET_NAME} APPEND PROPERTY DEPENDS ${TARGET})
238+ foreach(DEPEND ${DEPENDS})
239+ set_property(TEST ${TARGET_NAME} APPEND PROPERTY DEPENDS ${DEPEND})
240+ endforeach()
113241 endif()
114242
115− if("${qmltest_ENVIRONMENT}" STREQUAL "")
116− set(qmltest_ENVIRONMENT "${qmltest_default_ENVIRONMENT}")
243+ foreach(UPSTREAM_TARGET ${QMLTEST_TARGETS})
244+ add_dependencies(${UPSTREAM_TARGET} ${TARGET_NAME})
245+ endforeach()
246+endfunction()
247+
248+
249+# mangle_arguments(${ARGN})
250+#
251+# Verify there were no unparsed arguments and
252+# mangle the known ones for further processing.
253+
254+macro(mangle_arguments)
255+ if(QMLTEST_UNPARSED_ARGUMENTS)
256+ message(FATAL_ERROR "Unexpected arguments: ${QMLTEST_UNPARSED_ARGUMENTS}")
117257 endif()
118258
119− set(qmltest_command
120− env ${test_env} ${qmltest_ENVIRONMENT}
121− ${qmltestrunner_exe} -input ${CMAKE_CURRENT_SOURCE_DIR}/${qmltest_FILE}.qml
122− ${qmltestrunner_imports}
123− ${ITERATIONS_STRING}
124− -o ${CMAKE_BINARY_DIR}/${qmltest_TARGET}.xml,xunitxml
125− -o -,txt
126− ${function_ARGS}
127− )
128− find_program(DPKG dpkg-architecture)
129− if(DPKG)
130− exec_program(${DPKG} ARGS "-qDEB_BUILD_MULTIARCH" OUTPUT_VARIABLE ARCH_TRIPLET )
131− set(LD_PRELOAD_PATH "LD_PRELOAD=/usr/lib/${ARCH_TRIPLET}/mesa/libGL.so.1")
259+ if(QMLTEST_ADD_TEST)
260+ set(add_test ADD_TEST)
132261 endif()
133− set(qmltest_xvfb_command
134− env ${test_env} ${qmltest_ENVIRONMENT} ${LD_PRELOAD_PATH}
135− xvfb-run --server-args "-screen 0 1024x768x24" --auto-servernum
136− ${qmltestrunner_exe} -input ${CMAKE_CURRENT_SOURCE_DIR}/${qmltest_FILE}.qml
137− ${qmltestrunner_imports}
138− -o ${CMAKE_BINARY_DIR}/${qmltest_TARGET}.xml,xunitxml
139− -o -,txt
140− ${function_ARGS}
141− )
142262
143− set(qmltest_gdb_command
144− env ${test_env} ${qmltest_ENVIRONMENT} ${LD_PRELOAD_PATH}
145− gdb -e ${qmltestrunner_exe} -ex \"run -input ${CMAKE_CURRENT_SOURCE_DIR}/${qmltest_FILE}.qml ${qmltestrunner_imports} ${ITERATIONS_STRING}\"
146− )
263+ if(QMLTEST_IMPORT_PATHS)
264+ string(REPLACE ";" ":" imports "${QMLTEST_IMPORT_PATHS}")
265+ endif()
147266
148− add_qmltest_target(${qmltest_TARGET} "${qmltest_command}" TRUE ${qmltest_NO_ADD_TEST})
149− add_qmltest_target(${qmltest_xvfb_TARGET} "${qmltest_xvfb_command}" ${qmltest_NO_TARGETS} TRUE)
150− add_qmltest_target(${qmltest_gdb_TARGET} "${qmltest_gdb_command}" TRUE TRUE)
151− add_manual_qml_test(${SUBPATH} ${COMPONENT_NAME} ${ARGN})
152−endmacro(add_qml_test_internal)
153−
154−macro(add_binary_qml_test CLASS_NAME LD_PATH DEPS ENVVAR)
155− set(testCommand
156− ${ENVVAR}
157− LD_LIBRARY_PATH=${LD_PATH}
158− dbus-test-runner
159− -m 300
160− -t ${CMAKE_CURRENT_BINARY_DIR}/${CLASS_NAME}TestExec
161− -p -o -p ${CMAKE_BINARY_DIR}/test${CLASS_NAME}.xml,xunitxml
162− -p -o -p -,txt)
163−
164− add_qmltest_target(test${CLASS_NAME} "${testCommand}" FALSE TRUE)
165− add_dependencies(test${CLASS_NAME} ${CLASS_NAME}TestExec ${DEPS})
166−
167− find_program( HAVE_GCC gcc )
168− if (NOT ${HAVE_GCC} STREQUAL "")
169− exec_program( gcc ARGS "-dumpmachine" OUTPUT_VARIABLE ARCH_TRIPLET )
170− set(LD_PRELOAD_PATH "LD_PRELOAD=/usr/lib/${ARCH_TRIPLET}/mesa/libGL.so.1")
267+ if(QMLTEST_ITERATIONS)
268+ set(iterations -iterations ${QMLTEST_ITERATIONS})
171269 endif()
172− set(xvfbtestCommand
173− ${LD_PRELOAD_PATH}
174− ${ENVVAR}
175− LD_LIBRARY_PATH=${LD_PATH}
176− xvfb-run --server-args "-screen 0 1024x768x24" --auto-servernum
177− dbus-test-runner
178− -m 300
179− -t ${CMAKE_CURRENT_BINARY_DIR}/${CLASS_NAME}TestExec
180− -p -o -p ${CMAKE_BINARY_DIR}/test${CLASS_NAME}.xml,xunitxml
181− -p -o -p -,txt)
182−
183− add_qmltest_target(xvfbtest${CLASS_NAME} "${xvfbtestCommand}" FALSE TRUE)
184− add_dependencies(qmluitests xvfbtest${CLASS_NAME})
185−endmacro(add_binary_qml_test)
186−
187−macro(add_qmltest_target qmltest_TARGET qmltest_command qmltest_NO_TARGETS qmltest_NO_ADD_TEST)
188− add_custom_target(${qmltest_TARGET} ${qmltest_command})
189−
190− if(NOT "${qmltest_PROPERTIES}" STREQUAL "")
191− set_target_properties(${qmltest_TARGET} PROPERTIES ${qmltest_PROPERTIES})
192− elseif(NOT "${qmltest_DEFAULT_PROPERTIES}" STREQUAL "")
193− set_target_properties(${qmltest_TARGET} PROPERTIES ${qmltest_DEFAULT_PROPERTIES})
270+
271+ if(QMLTEST_DEPENDS)
272+ set(depends DEPENDS ${QMLTEST_DEPENDS})
194273 endif()
195274
196− if("${qmltest_NO_ADD_TEST}" STREQUAL FALSE AND NOT "${qmltest_DEFAULT_NO_ADD_TEST}" STREQUAL "TRUE")
197− add_test(${qmltest_TARGET} ${qmltest_command})
275+ if(QMLTEST_TARGETS)
276+ set(targets TARGETS ${QMLTEST_TARGETS})
277+ endif()
198278
199− if(NOT "${qmltest_UNPARSED_ARGUMENTS}" STREQUAL "")
200− set_tests_properties(${qmltest_TARGET} PROPERTIES ${qmltest_PROPERTIES})
201− elseif(NOT "${qmltest_DEFAULT_PROPERTIES}" STREQUAL "")
202− set_tests_properties(${qmltest_TARGET} PROPERTIES ${qmltest_DEFAULT_PROPERTIES})
279+ set(xvfb_targets "")
280+ foreach(target ${QMLTEST_TARGETS})
281+ if(TARGET xvfb${target})
282+ list(APPEND xvfb_targets xvfb${target})
203283 endif()
204− endif("${qmltest_NO_ADD_TEST}" STREQUAL FALSE AND NOT "${qmltest_DEFAULT_NO_ADD_TEST}" STREQUAL "TRUE")
205−
206− if("${qmltest_NO_TARGETS}" STREQUAL "FALSE")
207− if(NOT "${qmltest_TARGETS}" STREQUAL "")
208− foreach(TARGET ${qmltest_TARGETS})
209− add_dependencies(${TARGET} ${qmltest_TARGET})
210− endforeach(TARGET)
211− elseif(NOT "${qmltest_DEFAULT_TARGETS}" STREQUAL "")
212− foreach(TARGET ${qmltest_DEFAULT_TARGETS})
213− add_dependencies(${TARGET} ${qmltest_TARGET})
214− endforeach(TARGET)
215− endif()
216− endif("${qmltest_NO_TARGETS}" STREQUAL "FALSE")
284+ endforeach()
285+ set(xvfb_targets "${xvfb_targets}" PARENT_SCOPE)
286+endmacro()
287+
217288
218−endmacro(add_qmltest_target)
289+# bake_arguments(prefix output
290+# arg1 [arg2 [...]]
291+# )
292+#
293+# If set, add the argument prefix before every passed
294+# argument and store the result in ${OUTPUT} variable.
295+
296+function(bake_arguments PREFIX OUTPUT)
297+ set(args "${ARGN}")
298+ if(PREFIX)
299+ set(args "")
300+ foreach(arg ${ARGN})
301+ list(APPEND args ${PREFIX})
302+ list(APPEND args ${arg})
303+ endforeach()
304+ endif()
305+ set(${OUTPUT} "${args}" PARENT_SCOPE)
306+endfunction()