| cmake_minimum_required(VERSION 3.10) | |
| include(RunCMake) | |
| cmake_policy(SET CMP0140 NEW) | |
| function(version_json_check_python v is_json_ready) | |
| if(RunCMake_TEST_FAILED OR NOT Python_EXECUTABLE OR NOT CMake_TEST_JSON_SCHEMA) | |
| return() | |
| endif() | |
| set(json_file "${RunCMake_TEST_BINARY_DIR}/version-v${v}.json") | |
| if (NOT is_json_ready) | |
| file(WRITE "${json_file}" "${actual_stdout}") | |
| set(actual_stdout "" PARENT_SCOPE) | |
| endif() | |
| execute_process( | |
| COMMAND ${Python_EXECUTABLE} "${RunCMake_SOURCE_DIR}/version_json_validate_schema.py" "${json_file}" | |
| RESULT_VARIABLE result | |
| OUTPUT_VARIABLE output | |
| ERROR_VARIABLE output | |
| ) | |
| if(NOT result STREQUAL 0) | |
| string(REPLACE "\n" "\n " output "${output}") | |
| string(APPEND RunCMake_TEST_FAILED "Failed to validate version ${v} JSON schema for file: ${json_file}\nOutput:\n${output}\n") | |
| endif() | |
| return(PROPAGATE RunCMake_TEST_FAILED) | |
| endfunction() | |
| run_cmake_command(versionSingleDash ${CMAKE_COMMAND} -version version.txt) | |
| run_cmake_command(versionSingleDashJson ${CMAKE_COMMAND} -version=json-v1 version-v1.json) | |
| run_cmake_command(versionDoubleDash ${CMAKE_COMMAND} --version version.txt) | |
| run_cmake_command(versionDoubleDashJson ${CMAKE_COMMAND} --version=json-v1 version-v1.json) | |
| run_cmake_command(versionSlash ${CMAKE_COMMAND} /version version.txt) | |
| run_cmake_command(versionSlashJson ${CMAKE_COMMAND} /version=json-v1 version-v1.json) | |
| run_cmake_command(versionV ${CMAKE_COMMAND} /V version.txt) | |
| run_cmake_command(versionVJson ${CMAKE_COMMAND} /V=json-v1 version-v1.json) | |
| run_cmake_command(versionSingleDashNoArg ${CMAKE_COMMAND} -version) | |
| run_cmake_command(versionSingleDashJsonNoArg ${CMAKE_COMMAND} -version=json-v1) | |
| run_cmake_command(versionDoubleDashNoArg ${CMAKE_COMMAND} --version) | |
| run_cmake_command(versionDoubleDashJsonNoArg ${CMAKE_COMMAND} --version=json-v1) | |
| run_cmake_command(versionSlashNoArg ${CMAKE_COMMAND} /version) | |
| run_cmake_command(versionSlashJsonNoArg ${CMAKE_COMMAND} /version=json-v1) | |
| run_cmake_command(versionVNoArg ${CMAKE_COMMAND} /V) | |
| run_cmake_command(versionVJsonNoArg ${CMAKE_COMMAND} /V=json-v1) | |
| run_cmake_command(NoArgs ${CMAKE_COMMAND}) | |
| run_cmake_command(InvalidArg1 ${CMAKE_COMMAND} -invalid) | |
| run_cmake_command(InvalidArg2 ${CMAKE_COMMAND} --invalid) | |
| run_cmake_command(Wizard ${CMAKE_COMMAND} -i) | |
| run_cmake_command(C-no-arg ${CMAKE_COMMAND} -B DummyBuildDir -C) | |
| run_cmake_command(C-no-arg2 ${CMAKE_COMMAND} -B DummyBuildDir -C -T) | |
| set(RunCMake_TEST_RAW_ARGS [[-C ""]]) | |
| run_cmake_command(C-no-arg3 ${CMAKE_COMMAND} -B DummyBuildDir) | |
| unset(RunCMake_TEST_RAW_ARGS) | |
| run_cmake_command(C-no-file ${CMAKE_COMMAND} -B DummyBuildDir -C nosuchcachefile.txt) | |
| run_cmake_command(Cno-file ${CMAKE_COMMAND} -B DummyBuildDir -Cnosuchcachefile.txt) | |
| run_cmake_command(cache-no-file ${CMAKE_COMMAND} nosuchsubdir/CMakeCache.txt) | |
| run_cmake_command(lists-no-file ${CMAKE_COMMAND} nosuchsubdir/CMakeLists.txt) | |
| run_cmake_command(D-no-arg ${CMAKE_COMMAND} -B DummyBuildDir -D) | |
| run_cmake_command(D-no-src ${CMAKE_COMMAND} -B DummyBuildDir -D VAR=VALUE) | |
| run_cmake_command(Dno-src ${CMAKE_COMMAND} -B DummyBuildDir -DVAR=VALUE) | |
| run_cmake_script(D-tilde -DTILDE=~ -DTILDE_PATH:PATH=~ -DTILDE_SLASH=~/InHome -DTILDE_SLASH_PATH:PATH=~/InHome) | |
| run_cmake_command(U-no-arg ${CMAKE_COMMAND} -B DummyBuildDir -U) | |
| run_cmake_command(U-no-src ${CMAKE_COMMAND} -B DummyBuildDir -U VAR) | |
| run_cmake_command(Uno-src ${CMAKE_COMMAND} -B DummyBuildDir -UVAR) | |
| run_cmake_command(E-no-arg ${CMAKE_COMMAND} -E) | |
| run_cmake_command(E_capabilities ${CMAKE_COMMAND} -E capabilities) | |
| run_cmake_command(E_capabilities-arg ${CMAKE_COMMAND} -E capabilities --extra-arg) | |
| run_cmake_command(E_compare_files-different-eol ${CMAKE_COMMAND} -E compare_files ${RunCMake_SOURCE_DIR}/compare_files/lf ${RunCMake_SOURCE_DIR}/compare_files/crlf) | |
| run_cmake_command(E_compare_files-ignore-eol-same ${CMAKE_COMMAND} -E compare_files --ignore-eol ${RunCMake_SOURCE_DIR}/compare_files/lf ${RunCMake_SOURCE_DIR}/compare_files/crlf) | |
| run_cmake_command(E_compare_files-ignore-eol-empty ${CMAKE_COMMAND} -E compare_files --ignore-eol ${RunCMake_SOURCE_DIR}/compare_files/empty1 ${RunCMake_SOURCE_DIR}/compare_files/empty2) | |
| run_cmake_command(E_compare_files-ignore-eol-nonexistent ${CMAKE_COMMAND} -E compare_files --ignore-eol nonexistent_a nonexistent_b) | |
| run_cmake_command(E_compare_files-invalid-arguments ${CMAKE_COMMAND} -E compare_files file1.txt file2.txt file3.txt) | |
| run_cmake_command(E_echo_append ${CMAKE_COMMAND} -E echo_append) | |
| run_cmake_command(E_rename-no-arg ${CMAKE_COMMAND} -E rename) | |
| run_cmake_command(E_server ${CMAKE_COMMAND} -E server) | |
| run_cmake_command(E_true ${CMAKE_COMMAND} -E true) | |
| run_cmake_command(E_true-extraargs ${CMAKE_COMMAND} -E true ignored) | |
| run_cmake_command(E_false ${CMAKE_COMMAND} -E false) | |
| run_cmake_command(E_false-extraargs ${CMAKE_COMMAND} -E false ignored) | |
| run_cmake_command(E_touch_nocreate-no-arg ${CMAKE_COMMAND} -E touch_nocreate) | |
| run_cmake_command(E_touch-nonexistent-dir ${CMAKE_COMMAND} -E touch "${RunCMake_BINARY_DIR}/touch-nonexistent-dir/foo") | |
| run_cmake_command(E_time ${CMAKE_COMMAND} -E time ${CMAKE_COMMAND} -E echo "hello world") | |
| run_cmake_command(E_time-no-arg ${CMAKE_COMMAND} -E time) | |
| run_cmake_command(E___run_co_compile-no-iwyu ${CMAKE_COMMAND} -E __run_co_compile -- command-does-not-exist) | |
| run_cmake_command(E___run_co_compile-bad-iwyu ${CMAKE_COMMAND} -E __run_co_compile --iwyu=iwyu-does-not-exist -- command-does-not-exist) | |
| run_cmake_command(E___run_co_compile-no--- ${CMAKE_COMMAND} -E __run_co_compile --iwyu=iwyu-does-not-exist command-does-not-exist) | |
| run_cmake_command(E___run_co_compile-no-cc ${CMAKE_COMMAND} -E __run_co_compile --iwyu=iwyu-does-not-exist --) | |
| run_cmake_command(E___run_co_compile-tidy-remove-fixes ${CMAKE_COMMAND} -E __run_co_compile "--tidy=${CMAKE_COMMAND}\\;-E\\;true\\;--export-fixes=${RunCMake_BINARY_DIR}/tidy-fixes.yaml" -- ${CMAKE_COMMAND} -E true) | |
| block() | |
| set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/list-cache-build) | |
| run_cmake(list-cache) | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| run_cmake_command(list-cache-LR ${CMAKE_COMMAND} . -LR MIDDLE) | |
| run_cmake_command(list-cache-LRA ${CMAKE_COMMAND} . -LRA MIDDLE) | |
| run_cmake_command(list-cache-LRH ${CMAKE_COMMAND} . -LRH MIDDLE) | |
| run_cmake_command(list-cache-LRAH ${CMAKE_COMMAND} . -LRAH MIDDLE) | |
| endblock() | |
| run_cmake_command(G_no-arg ${CMAKE_COMMAND} -B DummyBuildDir -G) | |
| run_cmake_command(G_bad-arg ${CMAKE_COMMAND} -B DummyBuildDir -G NoSuchGenerator) | |
| run_cmake_command(P_no-arg ${CMAKE_COMMAND} -P) | |
| run_cmake_command(P_no-file ${CMAKE_COMMAND} -P nosuchscriptfile.cmake) | |
| run_cmake_command(P_args ${CMAKE_COMMAND} -P "${RunCMake_SOURCE_DIR}/P_args.cmake" relative/path "${RunCMake_SOURCE_DIR}") | |
| run_cmake_command(P_arbitrary_args ${CMAKE_COMMAND} -P "${RunCMake_SOURCE_DIR}/P_arbitrary_args.cmake" -- -DFOO -S -B --fresh --version) | |
| run_cmake_command(P_P_in_arbitrary_args ${CMAKE_COMMAND} -P "${RunCMake_SOURCE_DIR}/P_arbitrary_args.cmake" -- -P "${RunCMake_SOURCE_DIR}/non_existing.cmake") | |
| run_cmake_command(P_P_in_arbitrary_args_2 ${CMAKE_COMMAND} -P "${RunCMake_SOURCE_DIR}/P_arbitrary_args.cmake" -- -P -o) | |
| run_cmake_command(P_fresh ${CMAKE_COMMAND} -P "${RunCMake_SOURCE_DIR}/P_fresh.cmake" --fresh) | |
| if(CMAKE_HOST_WIN32) | |
| run_cmake_command(P_PathOnDisk ${CMAKE_COMMAND} -P "${RunCMake_SOURCE_DIR}/../CommandLine/P_pathondisk.cmake") | |
| else() | |
| run_cmake_command(P_PathOnDisk ${CMAKE_COMMAND} -P "${RunCMake_SOURCE_DIR}/../CommandLine/P_PathOnDisk.cmake") | |
| endif() | |
| run_cmake_command(build-no-dir | |
| ${CMAKE_COMMAND} --build) | |
| run_cmake_command(build-no-dir2 | |
| ${CMAKE_COMMAND} --build --target=invalid) | |
| run_cmake_command(build-no-cache | |
| ${CMAKE_COMMAND} --build ${RunCMake_SOURCE_DIR}) | |
| run_cmake_command(build-unknown-command-short | |
| ${CMAKE_COMMAND} --build ${RunCMake_SOURCE_DIR} -invalid-command) | |
| run_cmake_command(build-unknown-command-long | |
| ${CMAKE_COMMAND} --build ${RunCMake_SOURCE_DIR} --invalid-command) | |
| run_cmake_command(build-unknown-command-partial-match | |
| ${CMAKE_COMMAND} --build ${RunCMake_SOURCE_DIR} --targetinvalid) | |
| run_cmake_command(build-invalid-target-syntax | |
| ${CMAKE_COMMAND} --build ${RunCMake_SOURCE_DIR} --target=invalid) | |
| run_cmake_command(build-no-generator | |
| ${CMAKE_COMMAND} --build ${RunCMake_SOURCE_DIR}/cache-no-generator) | |
| run_cmake_command(build-bad-dir | |
| ${CMAKE_COMMAND} --build dir-does-not-exist) | |
| run_cmake_command(build-bad-generator | |
| ${CMAKE_COMMAND} --build ${RunCMake_SOURCE_DIR}/cache-bad-generator) | |
| run_cmake_command(install-prefix-no-arg ${CMAKE_COMMAND} -B DummyBuildDir --install-prefix) | |
| run_cmake_command(install-no-dir | |
| ${CMAKE_COMMAND} --install) | |
| run_cmake_command(install-bad-dir | |
| ${CMAKE_COMMAND} --install dir-does-not-exist) | |
| run_cmake_command(install-unknown-command-short | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR} -invalid-command) | |
| run_cmake_command(install-unknown-command-long | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR} --invalid-command) | |
| run_cmake_command(install-options-to-vars | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-install-options-to-vars | |
| --strip --prefix /var/test --config sample --component pack) | |
| run_cmake_command(install-default-dir-permissions-all | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-permissions-install-options-to-vars | |
| --default-directory-permissions u=rwx,g=rx,o=rx) | |
| run_cmake_command(install-default-dir-permissions-afew | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-permissions-install-options-to-vars | |
| --default-directory-permissions u=rwx,g=rx) | |
| run_cmake_command(install-default-dir-permissions-none | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-permissions-install-options-to-vars) | |
| run_cmake_command(install-default-dir-permissions-invalid-comma1 | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-permissions-install-options-to-vars | |
| --default-directory-permissions u=rwxg=,x) | |
| run_cmake_command(install-default-dir-permissions-invalid-comma2 | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-permissions-install-options-to-vars | |
| --default-directory-permissions u=rwxg,=x) | |
| run_cmake_command(install-default-dir-permissions-comma-at-the-end | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-permissions-install-options-to-vars | |
| --default-directory-permissions u=rwx,) | |
| run_cmake_command(install-default-dir-permissions-invalid-assignment | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-permissions-install-options-to-vars | |
| --default-directory-permissions u=rwx,=x) | |
| run_cmake_command(install-default-dir-permissions-assignment-at-the-end | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-permissions-install-options-to-vars | |
| --default-directory-permissions u=rwx,g=) | |
| run_cmake_command(install-default-dir-permissions-assignment-at-the-beginning | |
| ${CMAKE_COMMAND} --install ${RunCMake_SOURCE_DIR}/dir-permissions-install-options-to-vars | |
| --default-directory-permissions =u=rwx,g=rx) | |
| run_cmake_command(cache-bad-entry | |
| ${CMAKE_COMMAND} --build ${RunCMake_SOURCE_DIR}/cache-bad-entry/) | |
| run_cmake_command(cache-empty-entry | |
| ${CMAKE_COMMAND} --build ${RunCMake_SOURCE_DIR}/cache-empty-entry/) | |
| run_cmake_command(DebuggerCapabilityInspect ${CMAKE_COMMAND} -E capabilities) | |
| get_property(CMake_ENABLE_DEBUGGER DIRECTORY PROPERTY CMake_ENABLE_DEBUGGER) | |
| if(CMake_ENABLE_DEBUGGER) | |
| run_cmake_with_options(DebuggerArgMissingPipe --debugger-pipe) | |
| run_cmake_with_options(DebuggerArgMissingDapLog --debugger-dap-log) | |
| else() | |
| run_cmake_with_options(DebuggerNotSupported --debugger) | |
| run_cmake_with_options(DebuggerNotSupportedPipe --debugger-pipe pipe) | |
| run_cmake_with_options(DebuggerNotSupportedDapLog --debugger-dap-log dap-log) | |
| endif() | |
| function(run_ExplicitDirs) | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| set(RunCMake_TEST_NO_SOURCE_DIR 1) | |
| set(source_dir ${RunCMake_BINARY_DIR}/ExplicitDirsMissing) | |
| file(REMOVE_RECURSE "${source_dir}") | |
| file(MAKE_DIRECTORY "${source_dir}") | |
| file(WRITE ${source_dir}/CMakeLists.txt [=[ | |
| cmake_minimum_required(VERSION 3.13) | |
| project(ExplicitDirsMissing LANGUAGES NONE) | |
| ]=]) | |
| set(RunCMake_TEST_SOURCE_DIR "${source_dir}") | |
| set(RunCMake_TEST_BINARY_DIR "${source_dir}") | |
| run_cmake_with_options(ExplicitDirs-no-S-B -DFOO=BAR) | |
| file(WRITE ${source_dir}/CMakeLists.txt [=[ | |
| cmake_minimum_required(VERSION 3.13) | |
| project(ExplicitDirsMissing LANGUAGES NONE) | |
| if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR) | |
| message(FATAL_ERROR "CWD used as binary dir") | |
| endif() | |
| message(STATUS "CMAKE_SOURCE_DIR='${CMAKE_SOURCE_DIR}'") | |
| message(STATUS "CMAKE_BINARY_DIR='${CMAKE_BINARY_DIR}'") | |
| ]=]) | |
| file(REMOVE_RECURSE "${source_dir}/build") | |
| # Test with a setup where binary_dir won't be created by `run_cmake_with_options` | |
| run_cmake_with_options(ExplicitDirs-S-arg-build-dir-not-created -S ${source_dir} build/) | |
| run_cmake_with_options(ExplicitDirs-S-arg-reverse-build-dir-not-created build/ -S${source_dir} ) | |
| file(REMOVE_RECURSE "${source_dir}/build") | |
| file(MAKE_DIRECTORY "${source_dir}/build") | |
| run_cmake_with_options(ExplicitDirs-S-arg-build-dir-empty -S ${source_dir} build/) | |
| set(source_dir ${RunCMake_SOURCE_DIR}/ExplicitDirs) | |
| set(binary_dir ${RunCMake_BINARY_DIR}/ExplicitDirs-build) | |
| set(working_dir ${RunCMake_BINARY_DIR}/ExplicitDirs-cwd) | |
| set(RunCMake_TEST_SOURCE_DIR "${source_dir}") | |
| set(RunCMake_TEST_BINARY_DIR "${binary_dir}") | |
| file(MAKE_DIRECTORY "${working_dir}") | |
| set(RunCMake_TEST_COMMAND_WORKING_DIRECTORY "${working_dir}") | |
| file(REMOVE_RECURSE "${binary_dir}") | |
| run_cmake_with_options(ExplicitDirs-S-arg -S ${source_dir} ${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-S-arg-reverse-order ${binary_dir} -S${source_dir} ) | |
| run_cmake_with_options(ExplicitDirs-S-no-arg -S ) | |
| run_cmake_with_options(ExplicitDirs-S-no-arg2 -S -T) | |
| run_cmake_with_raw_args(ExplicitDirs-S-no-arg3 [[-S ""]]) | |
| run_cmake_with_options(ExplicitDirs-S-B -S ${source_dir} -B ${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-S-B-extra-path -S ${source_dir} -B ${binary_dir} /extra/path/) | |
| run_cmake_with_raw_args(ExplicitDirs-S-B-non-path "-S \"${source_dir}\" -B \"${binary_dir}\" \"\"") | |
| run_cmake_with_raw_args(ExplicitDirs-S-B-non-path2 "-S \"${source_dir}\" \"\" -B \"${binary_dir}\"") | |
| file(REMOVE_RECURSE "${binary_dir}/other_dir") | |
| file(MAKE_DIRECTORY "${binary_dir}/other_dir") | |
| file(WRITE "${binary_dir}/other_dir/CMakeLists.txt" [=[ ]=]) | |
| run_cmake_with_options(ExplicitDirs-S-S-same -S ${source_dir} -S ${source_dir} -B ${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-S-S-differs -S ${binary_dir}/other_dir -S ${source_dir} -B ${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-S-implicit-same -S ${source_dir} ${source_dir} -B ${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-S-implicit-differs -S ${binary_dir}/other_dir ${source_dir} -B ${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-S-implicit-differs2 ${binary_dir}/other_dir -S ${source_dir} -B ${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-S-implicit-differs3 ${binary_dir}/other_dir ${source_dir} -B ${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-S-S-Sdiffers -S ${binary_dir}/other_dir1 -S ${binary_dir}/other_dir2 -S ${source_dir} -B ${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-S-S-Simplicit ${binary_dir}/other_dir1 ${binary_dir}/other_dir2 ${source_dir} -B ${binary_dir}) | |
| # make sure that -B can explicitly construct build directories | |
| file(REMOVE_RECURSE "${binary_dir}") | |
| run_cmake_with_options(ExplicitDirs-B-arg -B ${binary_dir} ${source_dir}) | |
| file(REMOVE_RECURSE "${binary_dir}") | |
| run_cmake_with_options(ExplicitDirs-B-arg-reverse-order ${source_dir} -B${binary_dir}) | |
| run_cmake_with_options(ExplicitDirs-B-no-arg -B ) | |
| run_cmake_with_options(ExplicitDirs-B-no-arg2 -B -T) | |
| run_cmake_with_raw_args(ExplicitDirs-B-no-arg3 [[-B ""]]) | |
| file(REMOVE_RECURSE "${binary_dir}") | |
| run_cmake_with_options(ExplicitDirs-B-S -B${binary_dir} -S${source_dir}) | |
| run_cmake_with_options(ExplicitDirs-B-S-extra-path -B${binary_dir} -S${source_dir} /extra/path/) | |
| unset(RunCMake_TEST_COMMAND_WORKING_DIRECTORY) | |
| message("copied to ${RunCMake_TEST_BINARY_DIR}/initial-cache.txt") | |
| file(COPY ${RunCMake_SOURCE_DIR}/C_buildsrcdir/initial-cache.txt DESTINATION ${RunCMake_TEST_BINARY_DIR}) | |
| # CMAKE_BINARY_DIR should be determined by -B if specified, and CMAKE_SOURCE_DIR determined by -S if specified. | |
| # Path to initial-cache.txt is relative to the $PWD, which is normally set to ${RunCMake_TEST_BINARY_DIR}. | |
| run_cmake_with_options(ExplicitDirs-C_buildsrcdir -B DummyBuildDir -S ${RunCMake_SOURCE_DIR}/C_buildsrcdir/src -C initial-cache.txt) | |
| # Test that full path works, too. | |
| run_cmake_with_options(ExplicitDirs-C_buildsrcdir -B DummyBuildDir -S ${RunCMake_SOURCE_DIR}/C_buildsrcdir/src -C ${RunCMake_TEST_BINARY_DIR}/initial-cache.txt) | |
| run_cmake_with_options(ExplicitDirs-C_buildsrcdir -B DummyBuildDir ${RunCMake_SOURCE_DIR}/C_buildsrcdir/src -C ${RunCMake_TEST_BINARY_DIR}/initial-cache.txt) | |
| endfunction() | |
| run_ExplicitDirs() | |
| function(run_Fresh) | |
| set(RunCMake_TEST_BINARY_DIR "${RunCMake_BINARY_DIR}/Fresh-build") | |
| set(RunCMake_TEST_VARIANT_DESCRIPTION "-empty") | |
| run_cmake_with_options(Fresh --fresh -DFIRST=ON) | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| set(RunCMake_TEST_VARIANT_DESCRIPTION "-reconfig") | |
| run_cmake_with_options(Fresh --fresh) | |
| set(RunCMake_TEST_VARIANT_DESCRIPTION "-src-from-cache") | |
| set(RunCMake_TEST_NO_SOURCE_DIR 1) | |
| run_cmake_with_options(Fresh --fresh "${RunCMake_TEST_BINARY_DIR}") | |
| endfunction() | |
| run_Fresh() | |
| function(run_Toolchain) | |
| set(RunCMake_TEST_NO_SOURCE_DIR 1) | |
| set(source_dir ${RunCMake_SOURCE_DIR}/Toolchain) | |
| run_cmake_with_options(toolchain-no-arg -S ${source_dir} --toolchain=) | |
| run_cmake_with_options(toolchain-valid-abs-path -S ${source_dir} --toolchain "${source_dir}/toolchain.cmake") | |
| run_cmake_with_options(toolchain-valid-rel-src-path -S ${source_dir} --toolchain=toolchain.cmake) | |
| run_cmake_with_options(toolchain-D-abs-path -S ${source_dir} -DCMAKE_TOOLCHAIN_FILE=${source_dir}/toolchain.cmake) | |
| if(CMAKE_HOST_UNIX AND NOT CMAKE_SYSTEM_NAME STREQUAL "CYGWIN" AND NOT CMAKE_SYSTEM_NAME STREQUAL "MSYS") | |
| run_cmake_with_options(toolchain-D-slash-abs-path -S ${source_dir} -DCMAKE_TOOLCHAIN_FILE=/${source_dir}/toolchain.cmake) | |
| endif() | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| set(binary_dir ${RunCMake_BINARY_DIR}/Toolchain-build) | |
| set(RunCMake_TEST_BINARY_DIR "${binary_dir}") | |
| file(REMOVE_RECURSE "${binary_dir}") | |
| # Test that we both search the binary dir for toolchain files, and it takes | |
| # precedence over source dir | |
| file(WRITE ${binary_dir}/toolchain.cmake [=[ | |
| set(CMAKE_SYSTEM_NAME Linux) | |
| ]=]) | |
| run_cmake_with_options(toolchain-valid-rel-build-path -S ${source_dir} -B ${binary_dir} --toolchain toolchain.cmake) | |
| endfunction() | |
| run_Toolchain() | |
| function(run_BuildDir) | |
| # Use a single build tree for a few tests without cleaning. | |
| set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/BuildDir-build) | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") | |
| file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") | |
| run_cmake(BuildDir) | |
| run_cmake_command(BuildDir--build ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --target CustomTarget) | |
| run_cmake_command(BuildDir--build-multiple-targets ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -t CustomTarget2 --target CustomTarget3) | |
| run_cmake_command(BuildDir--build-multiple-targets-fail ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -t CustomTargetFail --target CustomTarget3) | |
| run_cmake_command(BuildDir--build-multiple-targets-jobs ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --target CustomTarget CustomTarget2 -j2 --target CustomTarget3) | |
| run_cmake_command(BuildDir--build-multiple-targets-with-clean-first ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --target clean CustomTarget) | |
| run_cmake_command(BuildDir--build-multiple-targets-with-clean-second ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --target CustomTarget clean) | |
| run_cmake_command(BuildDir--build-jobs-bad-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j 12ab) | |
| run_cmake_command(BuildDir--build-jobs-good-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j 2) | |
| run_cmake_command(BuildDir--build-jobs-good-number-trailing--target ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j 2 --target CustomTarget) | |
| run_cmake_command(BuildDir--build--parallel-bad-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel 12ab) | |
| run_cmake_command(BuildDir--build--parallel-good-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel 2) | |
| run_cmake_command(BuildDir--build--parallel-good-number-trailing--target ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel 2 --target CustomTarget) | |
| run_cmake_command(BuildDir--build-jobs-no-space-bad-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j12ab) | |
| run_cmake_command(BuildDir--build-jobs-no-space-good-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j2) | |
| run_cmake_command(BuildDir--build-jobs-no-space-good-number-trailing--target ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j2 --target CustomTarget) | |
| run_cmake_command(BuildDir--build--parallel-no-space-bad-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel12ab) | |
| run_cmake_command(BuildDir--build--parallel-no-space-good-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel2) | |
| run_cmake_command(BuildDir--build--parallel-no-space-good-number-trailing--target ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel2 --target CustomTarget) | |
| run_cmake_command(BuildDir--build-jobs-zero ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j 0) | |
| run_cmake_command(BuildDir--build--parallel-zero ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel 0) | |
| run_cmake_command(BuildDir--build-jobs-large ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j 4294967293) | |
| run_cmake_command(BuildDir--build--parallel-large ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel 4294967293) | |
| # No default jobs for FreeBSD build command | |
| if(NOT CMAKE_SYSTEM_NAME MATCHES "FreeBSD") | |
| run_cmake_command(BuildDir--build-jobs-no-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j) | |
| run_cmake_command(BuildDir--build-jobs-no-number-trailing--target ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j --target CustomTarget) | |
| if(RunCMake_GENERATOR MATCHES "Unix Makefiles" OR RunCMake_GENERATOR MATCHES "Ninja") | |
| set(_backup_lang "$ENV{LANG}") | |
| set(_backup_lc_messages "$ENV{LC_MESSAGES}") | |
| set(ENV{LANG} "C") | |
| set(ENV{LC_MESSAGES} "C") | |
| run_cmake_command(BuildDir--build-jobs-no-number-trailing--invalid-target ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build -j --target invalid-target) | |
| set(ENV{LANG} "${_backup_lang}") | |
| set(ENV{LC_MESSAGES} "${_backup_lc_messages}") | |
| endif() | |
| run_cmake_command(BuildDir--build--parallel-no-number ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel) | |
| run_cmake_command(BuildDir--build--parallel-no-number-trailing--target ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build BuildDir-build --parallel --target CustomTarget) | |
| endif() | |
| endfunction() | |
| run_BuildDir() | |
| function(run_EnvironmentGenerator) | |
| set(source_dir ${RunCMake_SOURCE_DIR}/EnvGenerator) | |
| set(ENV{CMAKE_GENERATOR_INSTANCE} "instance") | |
| set(ENV{CMAKE_GENERATOR_PLATFORM} "platform") | |
| set(ENV{CMAKE_GENERATOR_TOOLSET} "toolset") | |
| run_cmake_command(Envgen-warnings ${CMAKE_COMMAND} -G) | |
| unset(ENV{CMAKE_GENERATOR_INSTANCE}) | |
| unset(ENV{CMAKE_GENERATOR_PLATFORM}) | |
| unset(ENV{CMAKE_GENERATOR_TOOLSET}) | |
| # Test CMAKE_GENERATOR without actual configuring | |
| run_cmake_command(Envgen-unset ${CMAKE_COMMAND} -G) | |
| set(ENV{CMAKE_GENERATOR} "Ninja") | |
| run_cmake_command(Envgen-ninja ${CMAKE_COMMAND} -G) | |
| set(ENV{CMAKE_GENERATOR} "NoSuchGenerator") | |
| run_cmake_command(Envgen-bad ${CMAKE_COMMAND} -G) | |
| unset(ENV{CMAKE_GENERATOR}) | |
| # Honor CMAKE_GENERATOR env var in --help output | |
| set(ENV{CMAKE_GENERATOR} "Ninja Multi-Config") | |
| run_cmake_command(Envgen-ninja-multi-help ${CMAKE_COMMAND} --help) | |
| set(ENV{CMAKE_GENERATOR} "NoSuchGenerator") | |
| run_cmake_command(Envgen-bad-help ${CMAKE_COMMAND} --help) | |
| unset(ENV{CMAKE_GENERATOR}) | |
| if(RunCMake_GENERATOR MATCHES "Visual Studio") | |
| set(ENV{CMAKE_GENERATOR} "${RunCMake_GENERATOR}") | |
| run_cmake_command(Envgen ${CMAKE_COMMAND} ${source_dir}) | |
| set(ENV{CMAKE_GENERATOR_TOOLSET} "invalid") | |
| # Envvar shouldn't affect existing build tree | |
| run_cmake_command(Envgen-toolset-existing ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build Envgen-build) | |
| run_cmake_command(Envgen-toolset-invalid ${CMAKE_COMMAND} ${source_dir}) | |
| # Command line -G implies -T"" | |
| run_cmake_command(Envgen-G-implicit-toolset ${CMAKE_COMMAND} -G "${RunCMake_GENERATOR}" ${source_dir}) | |
| run_cmake_command(Envgen-T-toolset ${CMAKE_COMMAND} -T "fromcli" ${source_dir}) | |
| unset(ENV{CMAKE_GENERATOR_TOOLSET}) | |
| # Platform can be set only if not in generator name. | |
| if(RunCMake_GENERATOR MATCHES "^Visual Studio [0-9]+ [0-9]+$") | |
| set(ENV{CMAKE_GENERATOR_PLATFORM} "invalid") | |
| # Envvar shouldn't affect existing build tree | |
| run_cmake_command(Envgen-platform-existing ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build Envgen-build) | |
| run_cmake_command(Envgen-platform-invalid ${CMAKE_COMMAND} ${source_dir}) | |
| unset(RunCMake-stderr-file) | |
| # Command line -G implies -A"" | |
| run_cmake_command(Envgen-G-implicit-platform ${CMAKE_COMMAND} -G "${RunCMake_GENERATOR}" ${source_dir}) | |
| run_cmake_command(Envgen-A-platform ${CMAKE_COMMAND} -A "fromcli" ${source_dir}) | |
| unset(RunCMake-stderr-file) | |
| unset(ENV{CMAKE_GENERATOR_PLATFORM}) | |
| endif() | |
| # Instance is available since VS 2017. | |
| if(RunCMake_GENERATOR MATCHES "Visual Studio 1[5678].*") | |
| set(ENV{CMAKE_GENERATOR_INSTANCE} "invalid") | |
| # Envvar shouldn't affect existing build tree | |
| run_cmake_command(Envgen-instance-existing ${CMAKE_COMMAND} -E chdir .. | |
| ${CMAKE_COMMAND} --build Envgen-build) | |
| run_cmake_command(Envgen-instance-invalid ${CMAKE_COMMAND} ${source_dir}) | |
| unset(ENV{CMAKE_GENERATOR_INSTANCE}) | |
| endif() | |
| unset(ENV{CMAKE_GENERATOR}) | |
| endif() | |
| endfunction() | |
| run_EnvironmentGenerator() | |
| function(run_EnvironmentExportCompileCommands) | |
| set(RunCMake_TEST_SOURCE_DIR ${RunCMake_SOURCE_DIR}/env-export-compile-commands) | |
| run_cmake(env-export-compile-commands-unset) | |
| set(ENV{CMAKE_EXPORT_COMPILE_COMMANDS} ON) | |
| run_cmake(env-export-compile-commands-set) | |
| set(RunCMake_TEST_OPTIONS -DCMAKE_EXPORT_COMPILE_COMMANDS=OFF) | |
| run_cmake(env-export-compile-commands-override) | |
| unset(ENV{CMAKE_EXPORT_COMPILE_COMMANDS}) | |
| endfunction() | |
| if(RunCMake_GENERATOR MATCHES "Unix Makefiles" OR RunCMake_GENERATOR MATCHES "Ninja") | |
| run_EnvironmentExportCompileCommands() | |
| endif() | |
| function(run_EnvironmentBuildType) | |
| set(ENV{CMAKE_BUILD_TYPE} "BuildTypeEnv") | |
| run_cmake(EnvBuildType) | |
| run_cmake_with_options(EnvBuildTypeIgnore -DCMAKE_BUILD_TYPE=BuildTypeOpt) | |
| unset(ENV{CMAKE_BUILD_TYPE}) | |
| endfunction() | |
| function(run_EnvironmentConfigTypes) | |
| set(ENV{CMAKE_CONFIGURATION_TYPES} "ConfigTypesEnv") | |
| run_cmake(EnvConfigTypes) | |
| run_cmake_with_options(EnvConfigTypesIgnore -DCMAKE_CONFIGURATION_TYPES=ConfigTypesOpt) | |
| unset(ENV{CMAKE_CONFIGURATION_TYPES}) | |
| endfunction() | |
| if(RunCMake_GENERATOR MATCHES "Make|^Ninja$") | |
| run_EnvironmentBuildType() | |
| elseif(RunCMake_GENERATOR MATCHES "Ninja Multi-Config|Visual Studio|Xcode") | |
| run_EnvironmentConfigTypes() | |
| endif() | |
| function(run_EnvironmentInstallPrefix) | |
| set(ENV{CMAKE_INSTALL_PREFIX} "${RunCMake_BINARY_DIR}/install_prefix_set_via_env_var") | |
| run_cmake(EnvInstallPrefix) | |
| run_cmake_with_options(EnvInstallPrefixOverrideWithVar -DCMAKE_INSTALL_PREFIX=${RunCMake_BINARY_DIR}/install_prefix_set_via_var) | |
| run_cmake_with_options(EnvInstallPrefixOverrideWithCmdLineOpt --install-prefix ${RunCMake_BINARY_DIR}/install_prefix_set_cmd_line_opt) | |
| unset(ENV{CMAKE_INSTALL_PREFIX}) | |
| endfunction() | |
| run_EnvironmentInstallPrefix() | |
| function(run_EnvironmentToolchain) | |
| set(ENV{CMAKE_TOOLCHAIN_FILE} "${RunCMake_SOURCE_DIR}/EnvToolchain-toolchain.cmake") | |
| run_cmake(EnvToolchainAbsolute) | |
| run_cmake_with_options(EnvToolchainIgnore -DCMAKE_TOOLCHAIN_FILE=) | |
| unset(ENV{CMAKE_TOOLCHAIN_FILE}) | |
| set(ENV{CMAKE_TOOLCHAIN_FILE} "EnvToolchain-toolchain.cmake") | |
| set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/EnvToolchainRelative-build) | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") | |
| file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") | |
| configure_file("${RunCMake_SOURCE_DIR}/EnvToolchain-toolchain.cmake" "${RunCMake_TEST_BINARY_DIR}/EnvToolchain-toolchain.cmake" COPYONLY) | |
| run_cmake(EnvToolchainRelative) | |
| unset(ENV{CMAKE_TOOLCHAIN_FILE}) | |
| unset(RunCMake_TEST_NO_CLEAN) | |
| set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/EnvToolchainNone-build) | |
| run_cmake(EnvToolchainNone) | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}/CMakeFiles") | |
| set(ENV{CMAKE_TOOLCHAIN_FILE} "${RunCMake_SOURCE_DIR}/EnvToolchain-toolchain.cmake") | |
| run_cmake_command(EnvToolchainNoneExisting ${CMAKE_COMMAND} .) | |
| unset(ENV{CMAKE_TOOLCHAIN_FILE}) | |
| unset(RunCMake_TEST_NO_CLEAN) | |
| endfunction() | |
| run_EnvironmentToolchain() | |
| function(run_EnvironmentColor) | |
| set(ENV{CMAKE_COLOR_DIAGNOSTICS} "ON") | |
| run_cmake(EnvColorOn) | |
| unset(ENV{CMAKE_COLOR_DIAGNOSTICS}) | |
| run_cmake(EnvColorDefault) | |
| endfunction() | |
| run_EnvironmentColor() | |
| if(RunCMake_GENERATOR STREQUAL "Ninja") | |
| # Use a single build tree for a few tests without cleaning. | |
| set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/Build-build) | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") | |
| file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") | |
| set(RunCMake_TEST_OPTIONS -DCMAKE_VERBOSE_MAKEFILE=1) | |
| run_cmake(Build) | |
| unset(RunCMake_TEST_OPTIONS) | |
| run_cmake_command(Build-ninja-v ${CMAKE_COMMAND} --build .) | |
| unset(RunCMake_TEST_BINARY_DIR) | |
| unset(RunCMake_TEST_NO_CLEAN) | |
| endif() | |
| run_cmake_command(E_create_symlink-no-arg | |
| ${CMAKE_COMMAND} -E create_symlink | |
| ) | |
| run_cmake_command(E_create_symlink-missing-dir | |
| ${CMAKE_COMMAND} -E create_symlink T missing-dir/L | |
| ) | |
| # Use a single build tree for a few tests without cleaning. | |
| # These tests are special on Windows since it will only fail if the user | |
| # running the test does not have the priveldge to create symlinks. If this | |
| # happens we clear the msg in the -check.cmake and say that the test passes | |
| set(RunCMake_DEFAULT_stderr "(A required privilege is not held by the client)?") | |
| set(RunCMake_TEST_BINARY_DIR | |
| ${RunCMake_BINARY_DIR}/E_create_symlink-broken-build) | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") | |
| run_cmake_command(E_create_symlink-broken-create | |
| ${CMAKE_COMMAND} -E create_symlink T L | |
| ) | |
| run_cmake_command(E_create_symlink-broken-replace | |
| ${CMAKE_COMMAND} -E create_symlink . L | |
| ) | |
| unset(RunCMake_TEST_BINARY_DIR) | |
| unset(RunCMake_TEST_NO_CLEAN) | |
| unset(RunCMake_DEFAULT_stderr) | |
| run_cmake_command(E_create_symlink-no-replace-dir | |
| ${CMAKE_COMMAND} -E create_symlink T . | |
| ) | |
| #create hard link tests | |
| run_cmake_command(E_create_hardlink-no-arg | |
| ${CMAKE_COMMAND} -E create_hardlink | |
| ) | |
| set(dir ${RunCMake_BINARY_DIR}/hardlink_tests) | |
| file(REMOVE_RECURSE "${dir}") | |
| file(MAKE_DIRECTORY ${dir}) | |
| run_cmake_command(E_create_hardlink-non-existent-source | |
| ${CMAKE_COMMAND} -E create_hardlink ${dir}/I_dont_exist ${dir}/link | |
| ) | |
| file(TOUCH ${dir}/1) | |
| run_cmake_command(E_create_hardlink-ok | |
| ${CMAKE_COMMAND} -E create_hardlink ${dir}/1 ${dir}/1-link | |
| ) | |
| run_cmake_command(E_create_hardlink-no-directory | |
| ${CMAKE_COMMAND} -E create_hardlink ${dir}/1 ${dir}/a/1-link | |
| ) | |
| #On Windows, if the user does not have sufficient privileges | |
| #don't fail this test | |
| set(RunCMake_DEFAULT_stderr "(A required privilege is not held by the client)?") | |
| run_cmake_command(E_create_hardlink-unresolved-symlink-prereq | |
| ${CMAKE_COMMAND} -E create_symlink ${dir}/1 ${dir}/1-symlink | |
| ) | |
| file(REMOVE ${dir}/1) | |
| run_cmake_command(E_create_hardlink-unresolved-symlink | |
| ${CMAKE_COMMAND} -E create_hardlink ${dir}/1-symlink ${dir}/1s-link | |
| ) | |
| unset(RunCMake_DEFAULT_stderr) | |
| set(in ${RunCMake_SOURCE_DIR}/copy_input) | |
| set(out ${RunCMake_BINARY_DIR}/copy_output) | |
| file(REMOVE_RECURSE "${out}") | |
| file(MAKE_DIRECTORY ${out}) | |
| run_cmake_command(E_copy-one-source-file | |
| ${CMAKE_COMMAND} -E copy ${out}/f1.txt) | |
| run_cmake_command(E_copy-one-source-directory-target-is-directory | |
| ${CMAKE_COMMAND} -E copy ${in}/f1.txt ${out}) | |
| run_cmake_command(E_copy-three-source-files-target-is-directory | |
| ${CMAKE_COMMAND} -E copy ${in}/f1.txt ${in}/f2.txt ${in}/f3.txt ${out}) | |
| run_cmake_command(E_copy-three-source-files-target-is-file | |
| ${CMAKE_COMMAND} -E copy ${in}/f1.txt ${in}/f2.txt ${in}/f3.txt ${out}/f1.txt) | |
| run_cmake_command(E_copy-two-good-and-one-bad-source-files-target-is-directory | |
| ${CMAKE_COMMAND} -E copy ${in}/f1.txt ${in}/not_existing_file.bad ${in}/f3.txt ${out}) | |
| run_cmake_command(E_copy-t-argument | |
| ${CMAKE_COMMAND} -E copy ${in}/f1.txt -t ${out} ${in}/f3.txt) | |
| run_cmake_command(E_copy-t-argument-target-is-file | |
| ${CMAKE_COMMAND} -E copy ${in}/f1.txt -t ${out}/f1.txt ${in}/f3.txt) | |
| run_cmake_command(E_copy-t-argument-no-source-files | |
| ${CMAKE_COMMAND} -E copy -t ${out}) | |
| run_cmake_command(E_copy_if_different-one-source-directory-target-is-directory | |
| ${CMAKE_COMMAND} -E copy_if_different ${in}/f1.txt ${out}) | |
| run_cmake_command(E_copy_if_different-three-source-files-target-is-directory | |
| ${CMAKE_COMMAND} -E copy_if_different ${in}/f1.txt ${in}/f2.txt ${in}/f3.txt ${out}) | |
| run_cmake_command(E_copy_if_different-three-source-files-target-is-file | |
| ${CMAKE_COMMAND} -E copy_if_different ${in}/f1.txt ${in}/f2.txt ${in}/f3.txt ${out}/f1.txt) | |
| run_cmake_command(E_copy_if_different-nonexistent-source | |
| ${CMAKE_COMMAND} -E copy_if_different ${in}/nonexistent.txt ${out}) | |
| run_cmake_command(E_copy_if_newer-one-source-directory-target-is-directory | |
| ${CMAKE_COMMAND} -E copy_if_newer ${in}/f1.txt ${out}) | |
| run_cmake_command(E_copy_if_newer-three-source-files-target-is-directory | |
| ${CMAKE_COMMAND} -E copy_if_newer ${in}/f1.txt ${in}/f2.txt ${in}/f3.txt ${out}) | |
| run_cmake_command(E_copy_if_newer-three-source-files-target-is-file | |
| ${CMAKE_COMMAND} -E copy_if_newer ${in}/f1.txt ${in}/f2.txt ${in}/f3.txt ${out}/f1.txt) | |
| run_cmake_command(E_copy_if_newer-nonexistent-source | |
| ${CMAKE_COMMAND} -E copy_if_newer ${in}/nonexistent.txt ${out}) | |
| unset(in) | |
| unset(out) | |
| set(in ${RunCMake_SOURCE_DIR}/copy_input) | |
| set(out ${RunCMake_BINARY_DIR}/copy_directory_different_output) | |
| file(REMOVE_RECURSE "${out}") | |
| file(MAKE_DIRECTORY ${out}) | |
| run_cmake_command(E_copy_directory_if_different | |
| ${CMAKE_COMMAND} -E copy_directory_if_different ${in} ${out}) | |
| run_cmake_command(E_copy_directory_if_newer | |
| ${CMAKE_COMMAND} -E copy_directory_if_newer ${in} ${out}) | |
| run_cmake_command(E_copy_directory_if_newer-nonexistent-source | |
| ${CMAKE_COMMAND} -E copy_directory_if_newer ${in}/nonexistent ${out}/target) | |
| unset(in) | |
| unset(out) | |
| set(in ${RunCMake_SOURCE_DIR}/copy_input) | |
| set(out ${RunCMake_BINARY_DIR}/copy_directory_output) | |
| set(outfile ${out}/file_for_test.txt) | |
| file(REMOVE_RECURSE "${out}") | |
| file(MAKE_DIRECTORY ${out}) | |
| file(WRITE ${outfile} "") | |
| run_cmake_command(E_copy_directory-three-source-files-target-is-directory | |
| ${CMAKE_COMMAND} -E copy_directory ${in}/d1 ${in}/d2 ${in}/d3 ${out}) | |
| run_cmake_command(E_copy_directory-three-source-files-target-is-file | |
| ${CMAKE_COMMAND} -E copy_directory ${in}/d1 ${in}/d2 ${in}/d3 ${outfile}) | |
| run_cmake_command(E_copy_directory-three-source-files-target-is-not-exist | |
| ${CMAKE_COMMAND} -E copy_directory ${in}/d1 ${in}/d2 ${in}/d3 ${out}/not_existing_directory) | |
| unset(in) | |
| unset(out) | |
| unset(outfile) | |
| set(out ${RunCMake_BINARY_DIR}/make_directory_output) | |
| set(outfile ${out}/file_for_test.txt) | |
| file(REMOVE_RECURSE "${out}") | |
| file(MAKE_DIRECTORY ${out}) | |
| file(WRITE ${outfile} "") | |
| run_cmake_command(E_make_directory-three-directories | |
| ${CMAKE_COMMAND} -E make_directory ${out}/d1 ${out}/d2 ${out}/d2) | |
| run_cmake_command(E_remove_directory-three-directories | |
| ${CMAKE_COMMAND} -E remove_directory ${out}/d1 ${out}/d2 ${out}/d2) | |
| run_cmake_command(E_make_directory-directory-with-parent | |
| ${CMAKE_COMMAND} -E make_directory ${out}/parent/child) | |
| run_cmake_command(E_remove_directory-directory-with-parent | |
| ${CMAKE_COMMAND} -E remove_directory ${out}/parent) | |
| run_cmake_command(E_make_directory-two-directories-and-file | |
| ${CMAKE_COMMAND} -E make_directory ${out}/d1 ${out}/d2 ${outfile}) | |
| run_cmake_command(E_remove_directory-two-directories-and-file | |
| ${CMAKE_COMMAND} -E remove_directory ${out}/d1 ${out}/d2 ${outfile}) | |
| if(UNIX) | |
| file(MAKE_DIRECTORY ${out}/dir) | |
| file(CREATE_LINK ${out}/dir ${out}/link_dir SYMBOLIC) | |
| file(CREATE_LINK ${outfile} ${out}/link_file_for_test.txt SYMBOLIC) | |
| run_cmake_command(E_remove_directory-symlink-dir | |
| ${CMAKE_COMMAND} -E remove_directory ${out}/link_dir) | |
| run_cmake_command(E_remove_directory-symlink-file | |
| ${CMAKE_COMMAND} -E remove_directory ${out}/link_file_for_test.txt) | |
| endif() | |
| unset(out) | |
| unset(outfile) | |
| set(out ${RunCMake_BINARY_DIR}/rm_tests) | |
| file(REMOVE_RECURSE "${out}") | |
| file(MAKE_DIRECTORY ${out}) | |
| file(TOUCH ${out}/existing.txt) | |
| run_cmake_command(E_rm_file_force_existing | |
| ${CMAKE_COMMAND} -E rm -f ${out}/existing.txt) | |
| file(TOUCH ${out}/existing.txt) | |
| run_cmake_command(E_rm_file_non_force_existing | |
| ${CMAKE_COMMAND} -E rm ${out}/existing.txt) | |
| run_cmake_command(E_rm_file_force_non_existing | |
| ${CMAKE_COMMAND} -E rm -f ${out}/not_existing.txt) | |
| run_cmake_command(E_rm_file_non_force_non_existing | |
| ${CMAKE_COMMAND} -E rm ${out}/not_existing.txt) | |
| file(TOUCH ${out}/existing.txt) | |
| run_cmake_command(E_rm_file_recursive_existing | |
| ${CMAKE_COMMAND} -E rm -r ${out}/existing.txt) | |
| run_cmake_command(E_rm_file_recursive_non_existing | |
| ${CMAKE_COMMAND} -E rm -r ${out}/not_existing.txt) | |
| file(MAKE_DIRECTORY ${out}/d1 ${out}/d2) | |
| run_cmake_command(E_rm_non_recursive_directory-two-directories | |
| ${CMAKE_COMMAND} -E rm ${out}/d1 ${out}/d2) | |
| run_cmake_command(E_rm_recursive_directory-two-directories | |
| ${CMAKE_COMMAND} -E rm -R ${out}/d1 ${out}/d2) | |
| run_cmake_command(E_rm_no_file_specified | |
| ${CMAKE_COMMAND} -E rm -rf) | |
| run_cmake_command(E_rm_empty_file_specified | |
| ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_rm_empty_file_specified.cmake) | |
| run_cmake_command(E_rm_bad_argument | |
| ${CMAKE_COMMAND} -E rm -rd ${out}/d1 ${out}/d2) | |
| file(MAKE_DIRECTORY ${out}/d1 ${out}/d2) | |
| file(WRITE ${out}/test.txt "") | |
| run_cmake_command(E_rm_force_recursive_directory_with_files | |
| ${CMAKE_COMMAND} -E rm -rf ${out}/) | |
| run_cmake_command(E_rm_force_recursive_non_existing_file | |
| ${CMAKE_COMMAND} -E rm -Rf ${out}/test.txt) | |
| if(NOT WIN32 AND NOT CYGWIN) | |
| file(MAKE_DIRECTORY ${out}) | |
| file(TOUCH ${out}/existing.txt) | |
| file(MAKE_DIRECTORY ${out}/dir) | |
| file(TOUCH ${out}/dir/existing.txt) # add a file in the folder | |
| file(CREATE_LINK ${out}/dir ${out}/link_dir SYMBOLIC) | |
| file(CREATE_LINK ${out}/existing.txt ${out}/existing_file_link.txt SYMBOLIC) | |
| file(CREATE_LINK ${out}/non_existing.txt ${out}/non_existing_file_link.txt SYMBOLIC) | |
| run_cmake_command(E_rm_file_link_existing | |
| ${CMAKE_COMMAND} -E rm ${out}/existing_file_link.txt) | |
| run_cmake_command(E_rm_directory_link_existing | |
| ${CMAKE_COMMAND} -E rm ${out}/link_dir) | |
| run_cmake_command(E_rm_file_link_non_existing | |
| ${CMAKE_COMMAND} -E rm ${out}/non_existing_file_link.txt) | |
| file(CREATE_LINK ${out}/dir ${out}/link_dir SYMBOLIC) | |
| file(CREATE_LINK ${out}/existing.txt ${out}/existing_file_link.txt SYMBOLIC) | |
| file(CREATE_LINK ${out}/non_existing.txt ${out}/non_existing_file_link.txt SYMBOLIC) | |
| run_cmake_command(E_rm_recursive_file_link_existing | |
| ${CMAKE_COMMAND} -E rm -R ${out}/existing_file_link.txt) | |
| run_cmake_command(E_rm_recursive_directory_link_existing | |
| ${CMAKE_COMMAND} -E rm -r ${out}/link_dir) | |
| run_cmake_command(E_rm_recursive_file_link_non_existing | |
| ${CMAKE_COMMAND} -E rm -r ${out}/non_existing_file_link.txt) | |
| endif() | |
| unset(out) | |
| # cat tests | |
| set(out ${RunCMake_BINARY_DIR}/cat_tests) | |
| file(REMOVE_RECURSE "${out}") | |
| file(MAKE_DIRECTORY ${out}) | |
| run_cmake_command(E_cat_non_existing_file | |
| ${CMAKE_COMMAND} -E cat ${out}/non-existing-file.txt) | |
| if(UNIX AND NOT MSYS) | |
| # test non readable file only if not root | |
| execute_process( | |
| COMMAND id -u $ENV{USER} | |
| OUTPUT_VARIABLE uid | |
| OUTPUT_STRIP_TRAILING_WHITESPACE) | |
| if(NOT "${uid}" STREQUAL "0") | |
| # Create non readable file | |
| set(inside_folder "${out}/in") | |
| file(MAKE_DIRECTORY ${inside_folder}) | |
| file(WRITE "${inside_folder}/non_readable_file.txt" "first file to append\n") | |
| file(COPY "${inside_folder}/non_readable_file.txt" DESTINATION "${out}" FILE_PERMISSIONS OWNER_WRITE) | |
| run_cmake_command(E_cat_non_readable_file | |
| ${CMAKE_COMMAND} -E cat "${out}/non_readable_file.txt") | |
| endif() | |
| endif() | |
| run_cmake_command(E_cat_option_not_handled | |
| ${CMAKE_COMMAND} -E cat -f) | |
| run_cmake_command(E_cat_directory | |
| ${CMAKE_COMMAND} -E cat ${out}) | |
| file(WRITE "${out}/first_file.txt" "first file to append\n") | |
| file(WRITE "${out}/second_file.txt" "second file to append\n") | |
| file(WRITE "${out}/empty_file.txt" "") | |
| file(WRITE "${out}/unicode_file.txt" "à éùç - 한êµì–´") # UTF-8: Korean in Korean | |
| run_cmake_command(E_cat_good_cat | |
| ${CMAKE_COMMAND} -E cat "${out}/first_file.txt" "${out}/second_file.txt" "${out}/empty_file.txt" "${out}/unicode_file.txt") | |
| run_cmake_command(E_cat_good_binary_cat | |
| ${CMAKE_COMMAND} -E cat "${RunCMake_SOURCE_DIR}/E_cat_binary_files/binary.obj" "${RunCMake_SOURCE_DIR}/E_cat_binary_files/binary.obj") | |
| # To test whether the double dash (--) works, we need to control the working directory | |
| # in order to be able to pass a relative path that starts with a dash. | |
| file(WRITE "${out}/-file-starting-with-dash.txt" "file starting with dash, not an option\n") | |
| set(RunCMake_TEST_COMMAND_WORKING_DIRECTORY "${out}") | |
| run_cmake_command(E_cat-with-double-dash ${CMAKE_COMMAND} -E cat -- "-file-starting-with-dash.txt") | |
| run_cmake_command(E_cat-without-double-dash ${CMAKE_COMMAND} -E cat "-file-starting-with-dash.txt") | |
| unset(RunCMake_TEST_COMMAND_WORKING_DIRECTORY) | |
| unset(out) | |
| run_cmake_command(E_cat-stdin ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_cat-stdin.cmake) | |
| # Unset environment variables that are used for testing cmake -E | |
| unset(ENV{TEST_ENV}) | |
| unset(ENV{TEST_ENV_EXPECTED}) | |
| run_cmake_command(E_env-no-command0 ${CMAKE_COMMAND} -E env) | |
| run_cmake_command(E_env-no-command1 ${CMAKE_COMMAND} -E env TEST_ENV=1) | |
| run_cmake_command(E_env-bad-arg1 ${CMAKE_COMMAND} -E env -bad-arg1) | |
| run_cmake_command(E_env-set ${CMAKE_COMMAND} -E env TEST_ENV=1 ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-set.cmake) | |
| run_cmake_command(E_env-empty ${CMAKE_COMMAND} -E env TEST_ENV= ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-empty.cmake) | |
| run_cmake_command(E_env-unset ${CMAKE_COMMAND} -E env TEST_ENV=1 ${CMAKE_COMMAND} -E env --unset=TEST_ENV ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-unset.cmake) | |
| run_cmake_command(E_env-stdin ${CMAKE_COMMAND} -DPRINT_STDIN_EXE=${PRINT_STDIN_EXE} -P ${RunCMake_SOURCE_DIR}/E_env-stdin.cmake) | |
| # To test whether the double dash (--) works for the env command, we need a command that e.g. contains an equals sign (=) | |
| # and would normally be interpreted as an NAME=VALUE environment variable. | |
| # Ensuring such a command is done by simply copying the trivial exit_code executable with a different name. | |
| cmake_path(GET EXIT_CODE_EXE FILENAME exit_code) | |
| file(COPY_FILE "${EXIT_CODE_EXE}" "${RunCMake_BINARY_DIR}/env=${exit_code}") | |
| run_cmake_command(E_env-with-double-dash ${CMAKE_COMMAND} -E env TEST_ENV=1 -- "${RunCMake_BINARY_DIR}/env=${exit_code}" zero_exit) | |
| run_cmake_command(E_env-without-double-dash ${CMAKE_COMMAND} -E env TEST_ENV=1 "${RunCMake_BINARY_DIR}/env=${exit_code}" zero_exit) | |
| ## Tests of env --modify | |
| # Repeat the same tests as above | |
| run_cmake_command(E_env_modify-set ${CMAKE_COMMAND} -E env --modify TEST_ENV=set:1 ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-set.cmake) | |
| run_cmake_command(E_env_modify-unset ${CMAKE_COMMAND} -E env --modify TEST_ENV=set:1 ${CMAKE_COMMAND} -E env --modify TEST_ENV=unset: ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-unset.cmake) | |
| run_cmake_command(E_env_modify-with-double-dash ${CMAKE_COMMAND} -E env --modify TEST_ENV=set:1 -- "${RunCMake_BINARY_DIR}/env=${exit_code}" zero_exit) | |
| run_cmake_command(E_env_modify-without-double-dash ${CMAKE_COMMAND} -E env --modify TEST_ENV=set:1 "${RunCMake_BINARY_DIR}/env=${exit_code}" zero_exit) | |
| # Test environment modification commands | |
| run_cmake_command(E_env_modify-reset | |
| ${CMAKE_COMMAND} -E env TEST_ENV=expected | |
| ${CMAKE_COMMAND} -E env TEST_ENV_EXPECTED=expected TEST_ENV=bad_value --modify TEST_ENV=reset: | |
| ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-equal.cmake) | |
| run_cmake_command(E_env_modify-reset-to-unset | |
| ${CMAKE_COMMAND} -E env --unset=TEST_ENV --unset=TEST_ENV_EXPECTED | |
| ${CMAKE_COMMAND} -E env TEST_ENV=bad_value --modify TEST_ENV=reset: | |
| ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-equal.cmake) | |
| run_cmake_command(E_env_modify-string | |
| ${CMAKE_COMMAND} -E env TEST_ENV_EXPECTED=expected | |
| --modify TEST_ENV=unset: | |
| --modify TEST_ENV=string_append:ect | |
| --modify TEST_ENV=string_prepend:exp | |
| --modify TEST_ENV=string_append:ed | |
| ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-equal.cmake) | |
| if (WIN32) | |
| set(SEP "\\;") | |
| else () | |
| set(SEP ":") | |
| endif () | |
| run_cmake_command(E_env_modify-path_list | |
| ${CMAKE_COMMAND} -E env "TEST_ENV_EXPECTED=exp${SEP}ect${SEP}ed" | |
| --modify TEST_ENV=unset: | |
| --modify TEST_ENV=path_list_append:ect | |
| --modify TEST_ENV=path_list_prepend:exp | |
| --modify TEST_ENV=path_list_append:ed | |
| ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-equal.cmake) | |
| run_cmake_command(E_env_modify-cmake_list | |
| ${CMAKE_COMMAND} -E env "TEST_ENV_EXPECTED=exp\\;ect\\;ed" | |
| --modify TEST_ENV=unset: | |
| --modify TEST_ENV=cmake_list_append:ect | |
| --modify TEST_ENV=cmake_list_prepend:exp | |
| --modify TEST_ENV=cmake_list_append:ed | |
| ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}/E_env-equal.cmake) | |
| run_cmake_command(E_env_modify-bad-operation ${CMAKE_COMMAND} -E env --modify TEST_ENV=unknown:) | |
| run_cmake_command(E_md5sum-dir ${CMAKE_COMMAND} -E md5sum .) | |
| run_cmake_command(E_sha1sum-dir ${CMAKE_COMMAND} -E sha1sum .) | |
| run_cmake_command(E_sha224sum-dir ${CMAKE_COMMAND} -E sha224sum .) | |
| run_cmake_command(E_sha256sum-dir ${CMAKE_COMMAND} -E sha256sum .) | |
| run_cmake_command(E_sha384sum-dir ${CMAKE_COMMAND} -E sha384sum .) | |
| run_cmake_command(E_sha512sum-dir ${CMAKE_COMMAND} -E sha512sum .) | |
| run_cmake_command(E_md5sum-no-file ${CMAKE_COMMAND} -E md5sum nonexisting) | |
| run_cmake_command(E_sha1sum-no-file ${CMAKE_COMMAND} -E sha1sum nonexisting) | |
| run_cmake_command(E_sha224sum-no-file ${CMAKE_COMMAND} -E sha224sum nonexisting) | |
| run_cmake_command(E_sha256sum-no-file ${CMAKE_COMMAND} -E sha256sum nonexisting) | |
| run_cmake_command(E_sha384sum-no-file ${CMAKE_COMMAND} -E sha384sum nonexisting) | |
| run_cmake_command(E_sha512sum-no-file ${CMAKE_COMMAND} -E sha512sum nonexisting) | |
| file(WRITE "${RunCMake_BINARY_DIR}/dummy" "dummy") | |
| run_cmake_command(E_md5sum ${CMAKE_COMMAND} -E md5sum ../dummy) | |
| run_cmake_command(E_md5sum-mixed ${CMAKE_COMMAND} -E md5sum . ../dummy nonexisting) | |
| run_cmake_command(E_sha1sum ${CMAKE_COMMAND} -E sha1sum ../dummy) | |
| run_cmake_command(E_sha224sum ${CMAKE_COMMAND} -E sha224sum ../dummy) | |
| run_cmake_command(E_sha256sum ${CMAKE_COMMAND} -E sha256sum ../dummy) | |
| run_cmake_command(E_sha384sum ${CMAKE_COMMAND} -E sha384sum ../dummy) | |
| run_cmake_command(E_sha512sum ${CMAKE_COMMAND} -E sha512sum ../dummy) | |
| block() | |
| set(RunCMake-stdin-file ${RunCMake_BINARY_DIR}/dummy) | |
| run_cmake_command(E_md5sum-stdin ${CMAKE_COMMAND} -E md5sum -) | |
| run_cmake_command(E_sha1sum-stdin ${CMAKE_COMMAND} -E sha1sum -) | |
| run_cmake_command(E_sha224sum-stdin ${CMAKE_COMMAND} -E sha224sum -) | |
| run_cmake_command(E_sha256sum-stdin ${CMAKE_COMMAND} -E sha256sum -) | |
| run_cmake_command(E_sha384sum-stdin ${CMAKE_COMMAND} -E sha384sum -) | |
| run_cmake_command(E_sha512sum-stdin ${CMAKE_COMMAND} -E sha512sum -) | |
| endblock() | |
| file(REMOVE "${RunCMake_BINARY_DIR}/dummy") | |
| set(RunCMake_DEFAULT_stderr ".") | |
| run_cmake_command(E_sleep-no-args ${CMAKE_COMMAND} -E sleep) | |
| unset(RunCMake_DEFAULT_stderr) | |
| run_cmake_command(E_sleep-bad-arg1 ${CMAKE_COMMAND} -E sleep x) | |
| run_cmake_command(E_sleep-bad-arg2 ${CMAKE_COMMAND} -E sleep 1 -1) | |
| run_cmake_command(E_sleep-one-tenth ${CMAKE_COMMAND} -E sleep 0.1) | |
| run_cmake_command(P_directory ${CMAKE_COMMAND} -P ${RunCMake_SOURCE_DIR}) | |
| block() | |
| set(expect ${RunCMake_BINARY_DIR}/P_working-dir-build) | |
| run_cmake_script(P_working-dir -DEXPECTED_WORKING_DIR=${expect}) | |
| # -S and -B have no effect on script mode variables. | |
| set(RunCMake_TEST_VARIANT_DESCRIPTION "-S-B") | |
| run_cmake_script(P_working-dir -DEXPECTED_WORKING_DIR=${expect} -S something_else -B something_else_1) | |
| # Relative PWD is ignored. | |
| set(RunCMake_TEST_VARIANT_DESCRIPTION "-PWD-.") | |
| set(RunCMake_TEST_COMMAND_PWD .) | |
| run_cmake_script(P_working-dir -DEXPECTED_WORKING_DIR=${expect}) | |
| # Lower-case PWD is ignored on case-sensitive filesystems | |
| # and case-normalized on case-insensitive filesystems. | |
| set(RunCMake_TEST_VARIANT_DESCRIPTION "-PWD-case") | |
| string(TOLOWER "${expect}" RunCMake_TEST_COMMAND_PWD) | |
| run_cmake_script(P_working-dir -DEXPECTED_WORKING_DIR=${expect}) | |
| # Backslashed PWD is normalized on Windows and ignored elsewhere. | |
| set(RunCMake_TEST_VARIANT_DESCRIPTION "-PWD-backslash") | |
| string(REPLACE "/" "\\" RunCMake_TEST_COMMAND_PWD "${expect}") | |
| run_cmake_script(P_working-dir -DEXPECTED_WORKING_DIR=${expect}) | |
| endblock() | |
| # Place an initial cache where C_basic will find it when passed the relative path "..". | |
| file(COPY ${RunCMake_SOURCE_DIR}/C_basic_initial-cache.txt DESTINATION ${RunCMake_BINARY_DIR}) | |
| run_cmake_with_options(C_basic -C ../C_basic_initial-cache.txt) | |
| run_cmake_with_options(C_basic_fullpath -C ${RunCMake_BINARY_DIR}/C_basic_initial-cache.txt) | |
| file(COPY ${RunCMake_SOURCE_DIR}/C_target-commands_initial-cache.cmake DESTINATION ${RunCMake_BINARY_DIR}) | |
| run_cmake_command(C_target-commands ${CMAKE_COMMAND} -S ${RunCMake_SOURCE_DIR} -DRunCMake_TEST=C_target-commands -C ../C_target-commands_initial-cache.cmake) | |
| set(RunCMake_TEST_OPTIONS | |
| "-DFOO=-DBAR:BOOL=BAZ") | |
| run_cmake(D_nested_cache) | |
| set(RunCMake_TEST_OPTIONS | |
| "-DFOO:STRING=-DBAR:BOOL=BAZ") | |
| run_cmake(D_typed_nested_cache) | |
| set(RunCMake_TEST_OPTIONS -Wno-dev) | |
| run_cmake(Wno-dev) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Wdev) | |
| run_cmake(Wdev) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Werror=dev) | |
| run_cmake(Werror_dev) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Wno-error=dev) | |
| run_cmake(Wno-error_deprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| # -Wdev should not override deprecated options if specified | |
| set(RunCMake_TEST_OPTIONS -Wdev -Wno-deprecated) | |
| run_cmake(Wno-deprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Wno-deprecated -Wdev) | |
| run_cmake(Wno-deprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| # -Wdev should enable deprecated warnings as well | |
| set(RunCMake_TEST_OPTIONS -Wdev) | |
| run_cmake(Wdeprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| # -Werror=dev should enable deprecated errors as well | |
| set(RunCMake_TEST_OPTIONS -Werror=dev) | |
| run_cmake(Werror_deprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Wdeprecated) | |
| run_cmake(Wdeprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Wno-deprecated) | |
| run_cmake(Wno-deprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Werror=deprecated) | |
| run_cmake(Werror_deprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Wno-error=deprecated) | |
| run_cmake(Wno-error_deprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Werror=deprecated -Wno-error=deprecated) | |
| run_cmake(Wno-error_deprecated) | |
| unset(RunCMake_TEST_OPTIONS) | |
| # Dev warnings should be on by default | |
| run_cmake(Wdev) | |
| # Deprecated warnings should be on by default | |
| run_cmake(Wdeprecated) | |
| # Conflicting -W options should honor the last value | |
| set(RunCMake_TEST_OPTIONS -Wno-dev -Wdev) | |
| run_cmake(Wdev) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Wdev -Wno-dev) | |
| run_cmake(Wno-dev) | |
| unset(RunCMake_TEST_OPTIONS) | |
| run_cmake_command(W_bad-arg1 ${CMAKE_COMMAND} -B DummyBuildDir -W) | |
| run_cmake_command(W_bad-arg2 ${CMAKE_COMMAND} -B DummyBuildDir -Wno-) | |
| run_cmake_command(W_bad-arg3 ${CMAKE_COMMAND} -B DummyBuildDir -Werror=) | |
| set(RunCMake_TEST_OPTIONS --debug-output) | |
| run_cmake(debug-output) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --trace) | |
| run_cmake(trace) | |
| run_cmake(trace-try_compile) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --trace-expand) | |
| run_cmake(trace-expand) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --trace-expand --warn-uninitialized) | |
| run_cmake(trace-expand-warn-uninitialized) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --trace-redirect=${RunCMake_BINARY_DIR}/redirected.trace) | |
| run_cmake(trace-redirect) | |
| run_cmake(trace-try_compile-redirect) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --trace-redirect=/no/such/file.txt) | |
| run_cmake(trace-redirect-nofile) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --trace --trace-format=json-v1 --trace-redirect=${RunCMake_BINARY_DIR}/json-v1.trace) | |
| run_cmake(trace-json-v1) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --trace-expand --trace-format=json-v1 --trace-redirect=${RunCMake_BINARY_DIR}/json-v1-expand.trace) | |
| run_cmake(trace-json-v1-expand) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS -Wno-deprecated --warn-uninitialized) | |
| run_cmake(warn-uninitialized) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --trace-source=trace-only-this-file.cmake) | |
| run_cmake(trace-source) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --debug-trycompile) | |
| run_cmake(debug-trycompile) | |
| unset(RunCMake_TEST_OPTIONS) | |
| run_cmake(trycompile-clean) | |
| function(run_cmake_depends) | |
| set(RunCMake_TEST_SOURCE_DIR "${RunCMake_SOURCE_DIR}/cmake_depends") | |
| set(RunCMake_TEST_BINARY_DIR "${RunCMake_BINARY_DIR}/cmake_depends-build") | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") | |
| file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") | |
| file(WRITE "${RunCMake_TEST_BINARY_DIR}/CMakeFiles/DepTarget.dir/DependInfo.cmake" " | |
| set(CMAKE_DEPENDS_LANGUAGES \"C\") | |
| set(CMAKE_DEPENDS_CHECK_C | |
| \"${RunCMake_TEST_SOURCE_DIR}/test.c\" | |
| \"${RunCMake_TEST_BINARY_DIR}/CMakeFiles/DepTarget.dir/test.c.o\" | |
| ) | |
| ") | |
| file(WRITE "${RunCMake_TEST_BINARY_DIR}/CMakeFiles/CMakeDirectoryInformation.cmake" " | |
| set(CMAKE_RELATIVE_PATH_TOP_SOURCE \"${RunCMake_TEST_SOURCE_DIR}\") | |
| set(CMAKE_RELATIVE_PATH_TOP_BINARY \"${RunCMake_TEST_BINARY_DIR}\") | |
| ") | |
| run_cmake_command(cmake_depends ${CMAKE_COMMAND} -E env VERBOSE=1 | |
| ${CMAKE_COMMAND} -E cmake_depends "Unix Makefiles" | |
| ${RunCMake_TEST_SOURCE_DIR} ${RunCMake_TEST_SOURCE_DIR} | |
| ${RunCMake_TEST_BINARY_DIR} ${RunCMake_TEST_BINARY_DIR} | |
| ${RunCMake_TEST_BINARY_DIR}/CMakeFiles/DepTarget.dir/DependInfo.cmake | |
| ) | |
| endfunction() | |
| run_cmake_depends() | |
| function(accept_fifo) | |
| find_program(BASH_EXECUTABLE bash) | |
| if(BASH_EXECUTABLE) | |
| set(BASH_COMMAND_ARGUMENT "'${CMAKE_COMMAND}' -P <(echo 'return()')") | |
| run_cmake_command(accept_fifo ${BASH_EXECUTABLE} -c ${BASH_COMMAND_ARGUMENT}) | |
| set(source_dir ${RunCMake_SOURCE_DIR}/Toolchain) | |
| run_cmake_command(fifo_empty_initial_cache_process_substitution ${BASH_EXECUTABLE} | |
| -c "\"${CMAKE_COMMAND}\" -C <(echo) -S \"${source_dir}\" -B \"${RunCMake_BINARY_DIR}/fifo-empty-initial-cache\"") | |
| endif() | |
| endfunction() | |
| if(CMAKE_HOST_UNIX AND NOT CMAKE_SYSTEM_NAME STREQUAL "CYGWIN" AND NOT CMAKE_SYSTEM_NAME STREQUAL "MSYS") | |
| accept_fifo() | |
| run_cmake_command(closed_stdin sh -c "\"${CMAKE_COMMAND}\" --version <&-") | |
| run_cmake_command(closed_stdout sh -c "\"${CMAKE_COMMAND}\" --version >&-") | |
| run_cmake_command(closed_stderr sh -c "\"${CMAKE_COMMAND}\" --version 2>&-") | |
| run_cmake_command(closed_stdall sh -c "\"${CMAKE_COMMAND}\" --version <&- >&- 2>&-") | |
| endif() | |
| function(run_llvm_rc) | |
| set(RunCMake_TEST_BINARY_DIR "${RunCMake_BINARY_DIR}/llvm_rc-build") | |
| set(RunCMake_TEST_NO_CLEAN 1) | |
| file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}") | |
| file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}") | |
| run_cmake_command(llvm_rc_no_args ${CMAKE_COMMAND} -E cmake_llvm_rc) | |
| run_cmake_command(llvm_rc_no_-- ${CMAKE_COMMAND} -E cmake_llvm_rc ${RunCMake_TEST_BINARY_DIR}/source_file test.tmp ${CMAKE_COMMAND} -E echo "This is a test") | |
| run_cmake_command(llvm_rc_empty_preprocessor ${CMAKE_COMMAND} -E cmake_llvm_rc ${RunCMake_TEST_BINARY_DIR}/source_file test.tmp ++ ${CMAKE_COMMAND} -E echo "This is a test") | |
| run_cmake_command(llvm_rc_failing_first_command ${CMAKE_COMMAND} -E cmake_llvm_rc ${RunCMake_TEST_BINARY_DIR}/source_file test.tmp ${CMAKE_COMMAND} -P FailedProgram.cmake ++ ${CMAKE_COMMAND} -E echo "This is a test") | |
| run_cmake_command(llvm_rc_failing_second_command ${CMAKE_COMMAND} -E cmake_llvm_rc ${RunCMake_TEST_BINARY_DIR}/source_file test.tmp ${CMAKE_COMMAND} -E echo "This is a test" ++ ${CMAKE_COMMAND} -P FailedProgram.cmake ) | |
| if(EXISTS ${RunCMake_TEST_BINARY_DIR}/test.tmp) | |
| message(SEND_ERROR "${test} - FAILED:\n" | |
| "test.tmp was not deleted") | |
| endif() | |
| file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}/ExpandSourceDir") | |
| run_cmake_command(llvm_rc_full_run ${CMAKE_COMMAND} -E cmake_llvm_rc ${RunCMake_TEST_BINARY_DIR}/ExpandSourceDir/source_file test.tmp ${CMAKE_COMMAND} -E echo "This is a test" ++ ${LLVM_RC} -bad /FO SOURCE_DIR/llvmrc.result test.tmp ) | |
| if(EXISTS ${RunCMake_TEST_BINARY_DIR}/ExpandSourceDir/test.tmp) | |
| message(SEND_ERROR "${test} - FAILED:\n" | |
| "test.tmp was not deleted") | |
| endif() | |
| file(READ ${RunCMake_TEST_BINARY_DIR}/ExpandSourceDir/llvmrc.result LLVMRC_RESULT) | |
| if(NOT "${LLVMRC_RESULT}" STREQUAL "This is a test\n") | |
| message(SEND_ERROR "${test} - FAILED:\n" | |
| "llvmrc.result was not created") | |
| endif() | |
| unset(LLVMRC_RESULT) | |
| endfunction() | |
| run_llvm_rc() | |
| set(RunCMake_TEST_OPTIONS --profiling-output=/no/such/file.txt --profiling-format=google-trace) | |
| run_cmake(profiling-all-params) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --profiling-output=/no/such/file.txt --profiling-format=invalid-format) | |
| run_cmake(profiling-invalid-format) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --profiling-output=/no/such/file.txt) | |
| run_cmake(profiling-missing-format) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_OPTIONS --profiling-format=google-trace) | |
| run_cmake(profiling-missing-output) | |
| unset(RunCMake_TEST_OPTIONS) | |
| set(RunCMake_TEST_BINARY_DIR "${RunCMake_BINARY_DIR}/profiling-test") | |
| set(ProfilingTestOutput ${RunCMake_TEST_BINARY_DIR}/output.json) | |
| set(RunCMake_TEST_OPTIONS --profiling-format=google-trace --profiling-output=${ProfilingTestOutput}) | |
| run_cmake(ProfilingTest) | |
| unset(RunCMake_TEST_OPTIONS) | |
| run_cmake_with_options(help-arbitrary "--help" "CMAKE_CXX_IGNORE_EXTENSIONS") | |
| if (WIN32 OR DEFINED ENV{HOME}) | |
| set(config_dir_test print-config-dir) | |
| if (WIN32) | |
| set(config_dir_test print-config-dir-win) | |
| elseif(APPLE) | |
| set(config_dir_test print-config-dir-apple) | |
| endif() | |
| unset(ENV{CMAKE_CONFIG_DIR}) | |
| unset(ENV{XDG_CONFIG_HOME}) | |
| run_cmake_command(${config_dir_test} ${CMAKE_COMMAND} "--print-config-dir") | |
| endif() | |
| set(ENV{CMAKE_CONFIG_DIR} cmake_config_dir) | |
| run_cmake_command(print-config-dir-env ${CMAKE_COMMAND} "--print-config-dir") | |
| if(RunCMake_GENERATOR MATCHES "^Visual Studio 14 2015") | |
| run_cmake_with_options(DeprecateVS14-WARN-ON -DCMAKE_WARN_VS14=ON) | |
| unset(ENV{CMAKE_WARN_VS14}) | |
| run_cmake(DeprecateVS14-WARN-ON) | |
| run_cmake_with_options(DeprecateVS14-WARN-OFF -DCMAKE_WARN_VS14=OFF) | |
| endif() |