diff options
Diffstat (limited to 'Tests')
56 files changed, 405 insertions, 232 deletions
diff --git a/Tests/CheckSourceTree/CMakeLists.txt b/Tests/CheckSourceTree/CMakeLists.txt index d5019d2..3abc6a9 100644 --- a/Tests/CheckSourceTree/CMakeLists.txt +++ b/Tests/CheckSourceTree/CMakeLists.txt @@ -1,6 +1,6 @@ add_test(NAME CMake.CheckSourceTree - COMMAND ${CMAKE_COMMAND} -D GIT_EXECUTABLE=${GIT_EXECUTABLE} - -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR} - -P ${CMAKE_CURRENT_LIST_DIR}/check.cmake + COMMAND ${CMAKE_CMAKE_COMMAND} -D GIT_EXECUTABLE=${GIT_EXECUTABLE} + -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR} + -P ${CMAKE_CURRENT_LIST_DIR}/check.cmake ) set_property(TEST CMake.CheckSourceTree PROPERTY RUN_SERIAL 1) diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCCompilerFlag.cmake index 276158c..bfb6f72 100644 --- a/Tests/RunCMake/CheckCompilerFlag/CheckCCompilerFlag.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCCompilerFlag.cmake @@ -1,33 +1,27 @@ enable_language (C) -include(CheckCompilerFlag) +include(CheckCCompilerFlag) set(C 1) # test that this is tolerated -# test that the check uses an isolated locale -set(_env_LC_ALL "${LC_ALL}") -set(ENV{LC_ALL} "BAD") - -check_compiler_flag(C "-_this_is_not_a_flag_" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid C compile flag didn't fail.") +if(NOT CMAKE_C_COMPILER_ID STREQUAL "PathScale") + set(DD --) endif() -if(CMAKE_C_COMPILER_ID MATCHES "GNU|LCC|Clang" AND NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC") - check_compiler_flag(C "-x c" SHOULD_WORK) - if(NOT SHOULD_WORK) - message(SEND_ERROR "${CMAKE_C_COMPILER_ID} compiler flag '-x c' check failed") - endif() +check_c_compiler_flag("${DD}-_this_is_not_a_flag_" C_BOGUS_FLAG) +if(C_BOGUS_FLAG) + message(SEND_ERROR "CHECK_C_COMPILER_FLAG() succeeded, but should have failed") endif() - -if(CMAKE_C_COMPILER_ID STREQUAL "GNU") # LCC C compiler silently ignore -frtti instead of failing, so skip it here. - check_compiler_flag(C "-frtti" SHOULD_FAIL_RTTI) - if(SHOULD_FAIL_RTTI) - message(SEND_ERROR "${CMAKE_C_COMPILER_ID} compiler flag '-frtti' check passed but should have failed") - endif() +unset(C_BOGUS_FLAG CACHE) +if(DEFINED C_BOGUS_FLAG) + # Verify that CHECK_C_COMPILER_FLAG didn't construct a normal variable + message(SEND_ERROR "CHECK_C_COMPILER_FLAG shouldn't construct C_BOGUS_FLAG as a normal variable") endif() -if(NOT "$ENV{LC_ALL}" STREQUAL "BAD") - message(SEND_ERROR "ENV{LC_ALL} was not preserved by check_compiler_flag") +if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "LCC") + unset(C_STRICT_PROTOTYPES CACHE) + CHECK_C_COMPILER_FLAG("-Werror;-Wstrict-prototypes" C_STRICT_PROTOTYPES) + if(NOT C_STRICT_PROTOTYPES) + message(SEND_ERROR "CHECK_C_COMPILER_FLAG failed -Werror -Wstrict-prototypes") + endif() endif() -set(ENV{LC_ALL} ${_env_LC_ALL}) diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCXXCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCXXCompilerFlag.cmake index dec31ec..eb20eb4 100644 --- a/Tests/RunCMake/CheckCompilerFlag/CheckCXXCompilerFlag.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCXXCompilerFlag.cmake @@ -1,26 +1,19 @@ enable_language (CXX) -include(CheckCompilerFlag) +include(CheckCXXCompilerFlag) set(CXX 1) # test that this is tolerated -# test that the check uses an isolated locale -set(_env_LC_ALL "${LC_ALL}") -set(ENV{LC_ALL} "BAD") - -check_compiler_flag(CXX "-_this_is_not_a_flag_" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid CXX compile flag didn't fail.") +if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "PathScale") + set(DD --) endif() -if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|LCC|Clang" AND NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") - check_compiler_flag(CXX "-x c++" SHOULD_WORK) - if(NOT SHOULD_WORK) - message(SEND_ERROR "${CMAKE_CXX_COMPILER_ID} compiler flag '-x c++' check failed") - endif() +check_cxx_compiler_flag("${DD}-_this_is_not_a_flag_" CXX_BOGUS_FLAG) +if(CXX_BOGUS_FLAG) + message(SEND_ERROR "CHECK_CXX_COMPILER_FLAG() succeeded, but should have failed") endif() - -if(NOT "$ENV{LC_ALL}" STREQUAL "BAD") - message(SEND_ERROR "ENV{LC_ALL} was not preserved by check_compiler_flag") +unset(CXX_BOGUS_FLAG CACHE) +if(DEFINED CXX_BOGUS_FLAG) + # Verify that CHECK_CXX_COMPILER_FLAG didn't construct a normal variable + message(SEND_ERROR "CHECK_CXX_COMPILER_FLAG shouldn't construct CXX_BOGUS_FLAG as a normal variable") endif() -set(ENV{LC_ALL} ${_env_LC_ALL}) diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagC.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagC.cmake new file mode 100644 index 0000000..276158c --- /dev/null +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagC.cmake @@ -0,0 +1,33 @@ + +enable_language (C) +include(CheckCompilerFlag) + +set(C 1) # test that this is tolerated + +# test that the check uses an isolated locale +set(_env_LC_ALL "${LC_ALL}") +set(ENV{LC_ALL} "BAD") + +check_compiler_flag(C "-_this_is_not_a_flag_" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid C compile flag didn't fail.") +endif() + +if(CMAKE_C_COMPILER_ID MATCHES "GNU|LCC|Clang" AND NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC") + check_compiler_flag(C "-x c" SHOULD_WORK) + if(NOT SHOULD_WORK) + message(SEND_ERROR "${CMAKE_C_COMPILER_ID} compiler flag '-x c' check failed") + endif() +endif() + +if(CMAKE_C_COMPILER_ID STREQUAL "GNU") # LCC C compiler silently ignore -frtti instead of failing, so skip it here. + check_compiler_flag(C "-frtti" SHOULD_FAIL_RTTI) + if(SHOULD_FAIL_RTTI) + message(SEND_ERROR "${CMAKE_C_COMPILER_ID} compiler flag '-frtti' check passed but should have failed") + endif() +endif() + +if(NOT "$ENV{LC_ALL}" STREQUAL "BAD") + message(SEND_ERROR "ENV{LC_ALL} was not preserved by check_compiler_flag") +endif() +set(ENV{LC_ALL} ${_env_LC_ALL}) diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCUDACompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagCUDA.cmake index 681a546..681a546 100644 --- a/Tests/RunCMake/CheckCompilerFlag/CheckCUDACompilerFlag.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagCUDA.cmake diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagCXX.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagCXX.cmake new file mode 100644 index 0000000..dec31ec --- /dev/null +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagCXX.cmake @@ -0,0 +1,26 @@ + +enable_language (CXX) +include(CheckCompilerFlag) + +set(CXX 1) # test that this is tolerated + +# test that the check uses an isolated locale +set(_env_LC_ALL "${LC_ALL}") +set(ENV{LC_ALL} "BAD") + +check_compiler_flag(CXX "-_this_is_not_a_flag_" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid CXX compile flag didn't fail.") +endif() + +if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|LCC|Clang" AND NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC") + check_compiler_flag(CXX "-x c++" SHOULD_WORK) + if(NOT SHOULD_WORK) + message(SEND_ERROR "${CMAKE_CXX_COMPILER_ID} compiler flag '-x c++' check failed") + endif() +endif() + +if(NOT "$ENV{LC_ALL}" STREQUAL "BAD") + message(SEND_ERROR "ENV{LC_ALL} was not preserved by check_compiler_flag") +endif() +set(ENV{LC_ALL} ${_env_LC_ALL}) diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckFortranCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagFortran.cmake index 236f37b..236f37b 100644 --- a/Tests/RunCMake/CheckCompilerFlag/CheckFortranCompilerFlag.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagFortran.cmake diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckHIPCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagHIP.cmake index 339ce18..339ce18 100644 --- a/Tests/RunCMake/CheckCompilerFlag/CheckHIPCompilerFlag.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagHIP.cmake diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckISPCCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagISPC.cmake index 662319a..662319a 100644 --- a/Tests/RunCMake/CheckCompilerFlag/CheckISPCCompilerFlag.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagISPC.cmake diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckOBJCCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJC.cmake index f250f8d..f250f8d 100644 --- a/Tests/RunCMake/CheckCompilerFlag/CheckOBJCCompilerFlag.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJC.cmake diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckOBJCXXCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJCXX.cmake index bc940a6..bc940a6 100644 --- a/Tests/RunCMake/CheckCompilerFlag/CheckOBJCXXCompilerFlag.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJCXX.cmake diff --git a/Tests/RunCMake/CheckCompilerFlag/RunCMakeTest.cmake b/Tests/RunCMake/CheckCompilerFlag/RunCMakeTest.cmake index 77439cb..b0e025c 100644 --- a/Tests/RunCMake/CheckCompilerFlag/RunCMakeTest.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/RunCMakeTest.cmake @@ -5,26 +5,28 @@ run_cmake(NonExistentLanguage) run_cmake(CheckCCompilerFlag) run_cmake(CheckCXXCompilerFlag) +run_cmake(CheckCompilerFlagC) +run_cmake(CheckCompilerFlagCXX) if (APPLE) - run_cmake(CheckOBJCCompilerFlag) - run_cmake(CheckOBJCXXCompilerFlag) + run_cmake(CheckCompilerFlagOBJC) + run_cmake(CheckCompilerFlagOBJCXX) endif() if (CMAKE_Fortran_COMPILER_ID) - run_cmake(CheckFortranCompilerFlag) + run_cmake(CheckCompilerFlagFortran) endif() if (CMake_TEST_CUDA) - run_cmake(CheckCUDACompilerFlag) + run_cmake(CheckCompilerFlagCUDA) endif() if(CMake_TEST_ISPC) - run_cmake(CheckISPCCompilerFlag) + run_cmake(CheckCompilerFlagISPC) endif() if(CMake_TEST_HIP) - run_cmake(CheckHIPCompilerFlag) + run_cmake(CheckCompilerFlagHIP) endif() if(APPLE) diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckCLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagC.cmake index c8e87a4..c8e87a4 100644 --- a/Tests/RunCMake/CheckLinkerFlag/CheckCLinkerFlag.cmake +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagC.cmake diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckCUDALinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCUDA.cmake index 84d6dd9..84d6dd9 100644 --- a/Tests/RunCMake/CheckLinkerFlag/CheckCUDALinkerFlag.cmake +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCUDA.cmake diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckCXXLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCXX.cmake index 4e299b9..4e299b9 100644 --- a/Tests/RunCMake/CheckLinkerFlag/CheckCXXLinkerFlag.cmake +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCXX.cmake diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckFortranLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagFortran.cmake index bca288e..bca288e 100644 --- a/Tests/RunCMake/CheckLinkerFlag/CheckFortranLinkerFlag.cmake +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagFortran.cmake diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckHIPLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagHIP.cmake index 3bf3b30..3bf3b30 100644 --- a/Tests/RunCMake/CheckLinkerFlag/CheckHIPLinkerFlag.cmake +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagHIP.cmake diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckOBJCLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJC.cmake index fa1d18e..fa1d18e 100644 --- a/Tests/RunCMake/CheckLinkerFlag/CheckOBJCLinkerFlag.cmake +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJC.cmake diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckOBJCXXLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJCXX.cmake index 414efb8..414efb8 100644 --- a/Tests/RunCMake/CheckLinkerFlag/CheckOBJCXXLinkerFlag.cmake +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJCXX.cmake diff --git a/Tests/RunCMake/CheckLinkerFlag/RunCMakeTest.cmake b/Tests/RunCMake/CheckLinkerFlag/RunCMakeTest.cmake index 39fc430..5915ba1 100644 --- a/Tests/RunCMake/CheckLinkerFlag/RunCMakeTest.cmake +++ b/Tests/RunCMake/CheckLinkerFlag/RunCMakeTest.cmake @@ -1,22 +1,22 @@ include(RunCMake) if (CMAKE_C_COMPILER_ID MATCHES "Clang|GNU|LCC") - run_cmake(CheckCLinkerFlag) - run_cmake(CheckCXXLinkerFlag) + run_cmake(CheckLinkerFlagC) + run_cmake(CheckLinkerFlagCXX) if (APPLE) - run_cmake(CheckOBJCLinkerFlag) - run_cmake(CheckOBJCXXLinkerFlag) + run_cmake(CheckLinkerFlagOBJC) + run_cmake(CheckLinkerFlagOBJCXX) endif() endif() if (CMAKE_Fortran_COMPILER_ID MATCHES "GNU|LCC") - run_cmake(CheckFortranLinkerFlag) + run_cmake(CheckLinkerFlagFortran) endif() if (CMake_TEST_CUDA) - run_cmake(CheckCUDALinkerFlag) + run_cmake(CheckLinkerFlagCUDA) endif() if (CMake_TEST_HIP) - run_cmake(CheckHIPLinkerFlag) + run_cmake(CheckLinkerFlagHIP) endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckCSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckCSourceCompiles.cmake index 4f73622..7104650 100644 --- a/Tests/RunCMake/CheckSourceCompiles/CheckCSourceCompiles.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/CheckCSourceCompiles.cmake @@ -1,15 +1,15 @@ enable_language (C) -include(CheckSourceCompiles) +include(CheckCSourceCompiles) set(C 1) # test that this is tolerated -check_source_compiles(C "I don't build" SHOULD_FAIL) +check_c_source_compiles("I don't build" SHOULD_FAIL) if(SHOULD_FAIL) message(SEND_ERROR "invalid C source didn't fail.") endif() -check_source_compiles(C "int main() {return 0;}" SHOULD_BUILD) +check_c_source_compiles("int main() {return 0;}" SHOULD_BUILD) if(NOT SHOULD_BUILD) message(SEND_ERROR "Test fail for valid C source.") endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckCXXSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckCXXSourceCompiles.cmake index 97c9c30..7c9830a 100644 --- a/Tests/RunCMake/CheckSourceCompiles/CheckCXXSourceCompiles.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/CheckCXXSourceCompiles.cmake @@ -1,15 +1,15 @@ enable_language (CXX) -include(CheckSourceCompiles) +include(CheckCXXSourceCompiles) set(CXX 1) # test that this is tolerated -check_source_compiles(CXX "I don't build" SHOULD_FAIL) +check_cxx_source_compiles("I don't build" SHOULD_FAIL) if(SHOULD_FAIL) message(SEND_ERROR "invalid CXX source didn't fail.") endif() -check_source_compiles(CXX [=[ +check_cxx_source_compiles([=[ #include <vector> int main() { return 0; @@ -20,8 +20,8 @@ if(NOT SHOULD_BUILD) message(SEND_ERROR "Test fail for valid CXX source.") endif() -check_source_compiles(CXX "void l(char const (&x)[2]){}; int main() { l(\"\\n\"); return 0;}" - SHOULD_BUILD_COMPLEX) +CHECK_CXX_SOURCE_COMPILES("void l(char const (&x)[2]){}; int main() { l(\"\\\\n\"); return 0;}" + SHOULD_BUILD_COMPLEX) if(NOT SHOULD_BUILD_COMPLEX) message(SEND_ERROR "Test fail for valid CXX complex source.") diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckOBJCSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckOBJCSourceCompiles.cmake index 76a5009..ac43a1e 100644 --- a/Tests/RunCMake/CheckSourceCompiles/CheckOBJCSourceCompiles.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/CheckOBJCSourceCompiles.cmake @@ -1,9 +1,14 @@ enable_language (OBJC) -include(CheckSourceCompiles) +include(CheckOBJCSourceCompiles) set(OBJC 1) # test that this is tolerated -check_source_compiles(OBJC [[ +check_objc_source_compiles("I don't build in Objective-C" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid OBJC source didn't fail.") +endif() + +check_objc_source_compiles([[ #import <Foundation/Foundation.h> int main() { NSObject *foo; diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckOBJCXXSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckOBJCXXSourceCompiles.cmake index 814237e..0088956 100644 --- a/Tests/RunCMake/CheckSourceCompiles/CheckOBJCXXSourceCompiles.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/CheckOBJCXXSourceCompiles.cmake @@ -1,9 +1,14 @@ enable_language (OBJCXX) -include(CheckSourceCompiles) +include(CheckOBJCXXSourceCompiles) set(OBJCXX 1) # test that this is tolerated -check_source_compiles(OBJCXX [[ +check_objcxx_source_compiles("I don't build in Objective-C++" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid OBJCXX source didn't fail.") +endif() + +check_objcxx_source_compiles([[ #include <vector> #import <Foundation/Foundation.h> int main() { diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesC.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesC.cmake new file mode 100644 index 0000000..4f73622 --- /dev/null +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesC.cmake @@ -0,0 +1,15 @@ + +enable_language (C) +include(CheckSourceCompiles) + +set(C 1) # test that this is tolerated + +check_source_compiles(C "I don't build" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid C source didn't fail.") +endif() + +check_source_compiles(C "int main() {return 0;}" SHOULD_BUILD) +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for valid C source.") +endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckCUDASourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesCUDA.cmake index 2190649..2190649 100644 --- a/Tests/RunCMake/CheckSourceCompiles/CheckCUDASourceCompiles.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesCUDA.cmake diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesCXX.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesCXX.cmake new file mode 100644 index 0000000..97c9c30 --- /dev/null +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesCXX.cmake @@ -0,0 +1,28 @@ + +enable_language (CXX) +include(CheckSourceCompiles) + +set(CXX 1) # test that this is tolerated + +check_source_compiles(CXX "I don't build" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid CXX source didn't fail.") +endif() + +check_source_compiles(CXX [=[ + #include <vector> + int main() { + return 0; + } +]=] + SHOULD_BUILD) +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for valid CXX source.") +endif() + +check_source_compiles(CXX "void l(char const (&x)[2]){}; int main() { l(\"\\n\"); return 0;}" + SHOULD_BUILD_COMPLEX) + +if(NOT SHOULD_BUILD_COMPLEX) + message(SEND_ERROR "Test fail for valid CXX complex source.") +endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckFortranSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesFortran.cmake index 48dc525..48dc525 100644 --- a/Tests/RunCMake/CheckSourceCompiles/CheckFortranSourceCompiles.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesFortran.cmake diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckHIPSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesHIP.cmake index 911a0d7..911a0d7 100644 --- a/Tests/RunCMake/CheckSourceCompiles/CheckHIPSourceCompiles.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesHIP.cmake diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckISPCSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesISPC.cmake index 74b83c0..74b83c0 100644 --- a/Tests/RunCMake/CheckSourceCompiles/CheckISPCSourceCompiles.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesISPC.cmake diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesOBJC.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesOBJC.cmake new file mode 100644 index 0000000..76a5009 --- /dev/null +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesOBJC.cmake @@ -0,0 +1,16 @@ +enable_language (OBJC) +include(CheckSourceCompiles) + +set(OBJC 1) # test that this is tolerated + +check_source_compiles(OBJC [[ + #import <Foundation/Foundation.h> + int main() { + NSObject *foo; + return 0; + } +]] SHOULD_BUILD) + +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for valid OBJC source.") +endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesOBJCXX.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesOBJCXX.cmake new file mode 100644 index 0000000..814237e --- /dev/null +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesOBJCXX.cmake @@ -0,0 +1,19 @@ +enable_language (OBJCXX) +include(CheckSourceCompiles) + +set(OBJCXX 1) # test that this is tolerated + +check_source_compiles(OBJCXX [[ + #include <vector> + #import <Foundation/Foundation.h> + int main() { + std::vector<int> v; + NSObject *foo; + return 0; + } +]] SHOULD_BUILD) + + +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for OBJCXX source.") +endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/RunCMakeTest.cmake b/Tests/RunCMake/CheckSourceCompiles/RunCMakeTest.cmake index 530f133..df77d3d 100644 --- a/Tests/RunCMake/CheckSourceCompiles/RunCMakeTest.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/RunCMakeTest.cmake @@ -6,24 +6,28 @@ run_cmake(UnknownArgument) run_cmake(CheckCSourceCompiles) run_cmake(CheckCXXSourceCompiles) +run_cmake(CheckSourceCompilesC) +run_cmake(CheckSourceCompilesCXX) if (APPLE) run_cmake(CheckOBJCSourceCompiles) run_cmake(CheckOBJCXXSourceCompiles) + run_cmake(CheckSourceCompilesOBJC) + run_cmake(CheckSourceCompilesOBJCXX) endif() if (CMAKE_Fortran_COMPILER_ID) - run_cmake(CheckFortranSourceCompiles) + run_cmake(CheckSourceCompilesFortran) endif() if (CMake_TEST_CUDA) - run_cmake(CheckCUDASourceCompiles) + run_cmake(CheckSourceCompilesCUDA) endif() if(CMake_TEST_ISPC) - run_cmake(CheckISPCSourceCompiles) + run_cmake(CheckSourceCompilesISPC) endif() if(CMake_TEST_HIP) - run_cmake(CheckHIPSourceCompiles) + run_cmake(CheckSourceCompilesHIP) endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckCSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckCSourceRuns.cmake index 96a1027..c0f9463 100644 --- a/Tests/RunCMake/CheckSourceRuns/CheckCSourceRuns.cmake +++ b/Tests/RunCMake/CheckSourceRuns/CheckCSourceRuns.cmake @@ -1,15 +1,15 @@ enable_language (C) -include(CheckSourceRuns) +include(CheckCSourceRuns) set(C 1) # test that this is tolerated -check_source_runs(C "int main() {return 2;}" SHOULD_FAIL) +check_c_source_runs("int main() {return 2;}" SHOULD_FAIL) if(SHOULD_FAIL) - message(SEND_ERROR "C check_source_runs succeeded, but should have failed.") + message(SEND_ERROR "check_c_source_runs succeeded, but should have failed.") endif() -check_source_runs(C "int main() {return 0;}" SHOULD_RUN) +check_c_source_runs("int main() {return 0;}" SHOULD_RUN) if(NOT SHOULD_RUN) - message(SEND_ERROR "C check_source_runs failed for valid C executable.") + message(SEND_ERROR "check_c_source_runs failed for valid C executable.") endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckCXXSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckCXXSourceRuns.cmake index c4bef6e..c4c9026 100644 --- a/Tests/RunCMake/CheckSourceRuns/CheckCXXSourceRuns.cmake +++ b/Tests/RunCMake/CheckSourceRuns/CheckCXXSourceRuns.cmake @@ -1,15 +1,15 @@ enable_language (CXX) -include(CheckSourceRuns) +include(CheckCXXSourceRuns) set(CXX 1) # test that this is tolerated -check_source_runs(CXX "int main() {return 2;}" SHOULD_FAIL) +check_cxx_source_runs("int main() {return 2;}" SHOULD_FAIL) if(SHOULD_FAIL) - message(SEND_ERROR "CXX check_source_runs succeeded, but should have failed.") + message(SEND_ERROR "check_cxx_source_runs succeeded, but should have failed.") endif() -check_source_runs(CXX +check_cxx_source_runs( [=[ #include <vector> int main() { @@ -18,5 +18,5 @@ check_source_runs(CXX ]=] SHOULD_RUN) if(NOT SHOULD_RUN) - message(SEND_ERROR "CXX check_source_runs failed for valid C executable.") + message(SEND_ERROR "check_cxx_source_runs failed for valid C executable.") endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckOBJCSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckOBJCSourceRuns.cmake index b828352..604b2a1 100644 --- a/Tests/RunCMake/CheckSourceRuns/CheckOBJCSourceRuns.cmake +++ b/Tests/RunCMake/CheckSourceRuns/CheckOBJCSourceRuns.cmake @@ -1,9 +1,14 @@ enable_language (OBJC) -include(CheckSourceRuns) +include(CheckOBJCSourceRuns) set(OBJC 1) # test that this is tolerated -check_source_runs(OBJC [[ +check_objc_source_runs("int main() {return 2;}" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "check_objc_source_runs succeeded, but should have failed.") +endif() + +check_objc_source_runs([[ #import <Foundation/Foundation.h> int main() { NSObject *foo; diff --git a/Tests/RunCMake/CheckSourceRuns/CheckOBJCXXSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckOBJCXXSourceRuns.cmake index 8a56f13..b220166 100644 --- a/Tests/RunCMake/CheckSourceRuns/CheckOBJCXXSourceRuns.cmake +++ b/Tests/RunCMake/CheckSourceRuns/CheckOBJCXXSourceRuns.cmake @@ -1,9 +1,14 @@ enable_language (OBJCXX) -include(CheckSourceRuns) +include(CheckOBJCXXSourceRuns) set(OBJCXX 1) # test that this is tolerated -check_source_runs(OBJCXX [[ +check_objcxx_source_runs("int main() {return 2;}" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "check_objcxx_source_runs succeeded, but should have failed.") +endif() + +check_objcxx_source_runs([[ #include <vector> #import <Foundation/Foundation.h> int main() { diff --git a/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsC.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsC.cmake new file mode 100644 index 0000000..96a1027 --- /dev/null +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsC.cmake @@ -0,0 +1,15 @@ + +enable_language (C) +include(CheckSourceRuns) + +set(C 1) # test that this is tolerated + +check_source_runs(C "int main() {return 2;}" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "C check_source_runs succeeded, but should have failed.") +endif() + +check_source_runs(C "int main() {return 0;}" SHOULD_RUN) +if(NOT SHOULD_RUN) + message(SEND_ERROR "C check_source_runs failed for valid C executable.") +endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckCUDASourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsCUDA.cmake index ea5f4f9..ea5f4f9 100644 --- a/Tests/RunCMake/CheckSourceRuns/CheckCUDASourceRuns.cmake +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsCUDA.cmake diff --git a/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsCXX.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsCXX.cmake new file mode 100644 index 0000000..c4bef6e --- /dev/null +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsCXX.cmake @@ -0,0 +1,22 @@ + +enable_language (CXX) +include(CheckSourceRuns) + +set(CXX 1) # test that this is tolerated + +check_source_runs(CXX "int main() {return 2;}" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "CXX check_source_runs succeeded, but should have failed.") +endif() + +check_source_runs(CXX +[=[ + #include <vector> + int main() { + return 0; + } +]=] + SHOULD_RUN) +if(NOT SHOULD_RUN) + message(SEND_ERROR "CXX check_source_runs failed for valid C executable.") +endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckFortranSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsFortran.cmake index 50e8ec8..50e8ec8 100644 --- a/Tests/RunCMake/CheckSourceRuns/CheckFortranSourceRuns.cmake +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsFortran.cmake diff --git a/Tests/RunCMake/CheckSourceRuns/CheckHIPSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsHIP.cmake index d9fb8c2..d9fb8c2 100644 --- a/Tests/RunCMake/CheckSourceRuns/CheckHIPSourceRuns.cmake +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsHIP.cmake diff --git a/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsOBJC.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsOBJC.cmake new file mode 100644 index 0000000..b828352 --- /dev/null +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsOBJC.cmake @@ -0,0 +1,16 @@ +enable_language (OBJC) +include(CheckSourceRuns) + +set(OBJC 1) # test that this is tolerated + +check_source_runs(OBJC [[ + #import <Foundation/Foundation.h> + int main() { + NSObject *foo; + return 0; + } +]] SHOULD_BUILD) + +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for valid OBJC source.") +endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsOBJCXX.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsOBJCXX.cmake new file mode 100644 index 0000000..8a56f13 --- /dev/null +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsOBJCXX.cmake @@ -0,0 +1,19 @@ +enable_language (OBJCXX) +include(CheckSourceRuns) + +set(OBJCXX 1) # test that this is tolerated + +check_source_runs(OBJCXX [[ + #include <vector> + #import <Foundation/Foundation.h> + int main() { + std::vector<int> v; + NSObject *foo; + return 0; + } +]] SHOULD_BUILD) + + +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for OBJCXX source.") +endif() diff --git a/Tests/RunCMake/CheckSourceRuns/RunCMakeTest.cmake b/Tests/RunCMake/CheckSourceRuns/RunCMakeTest.cmake index 4784103..64cecfc 100644 --- a/Tests/RunCMake/CheckSourceRuns/RunCMakeTest.cmake +++ b/Tests/RunCMake/CheckSourceRuns/RunCMakeTest.cmake @@ -6,20 +6,24 @@ run_cmake(UnknownArgument) run_cmake(CheckCSourceRuns) run_cmake(CheckCXXSourceRuns) +run_cmake(CheckSourceRunsC) +run_cmake(CheckSourceRunsCXX) if (APPLE) run_cmake(CheckOBJCSourceRuns) run_cmake(CheckOBJCXXSourceRuns) + run_cmake(CheckSourceRunsOBJC) + run_cmake(CheckSourceRunsOBJCXX) endif() if (CMAKE_Fortran_COMPILER_ID) - run_cmake(CheckFortranSourceRuns) + run_cmake(CheckSourceRunsFortran) endif() if (CMake_TEST_CUDA) - run_cmake(CheckCUDASourceRuns) + run_cmake(CheckSourceRunsCUDA) endif() if (CMake_TEST_HIP) - run_cmake(CheckHIPSourceRuns) + run_cmake(CheckSourceRunsHIP) endif() diff --git a/Tests/RunCMake/ClangTidy/RunCMakeTest.cmake b/Tests/RunCMake/ClangTidy/RunCMakeTest.cmake index ee41d94..5e3fbc4 100644 --- a/Tests/RunCMake/ClangTidy/RunCMakeTest.cmake +++ b/Tests/RunCMake/ClangTidy/RunCMakeTest.cmake @@ -29,3 +29,4 @@ if (NOT RunCMake_GENERATOR STREQUAL "Watcom WMake") endif() endif() run_tidy(C-bad) +run_tidy(compdb) diff --git a/Tests/RunCMake/ClangTidy/compdb.cmake b/Tests/RunCMake/ClangTidy/compdb.cmake new file mode 100644 index 0000000..f83e0ae --- /dev/null +++ b/Tests/RunCMake/ClangTidy/compdb.cmake @@ -0,0 +1,7 @@ +enable_language(C) + +# Include a --checks option to confirm that we don't match options that start +# with --, only a standalone -- +set(CMAKE_C_CLANG_TIDY "${PSEUDO_TIDY}" -p ${CMAKE_BINARY_DIR} --checks=*) + +add_executable(main main.c) diff --git a/Tests/RunCMake/Ninja/QtAutoMocSkipPch.cmake b/Tests/RunCMake/Ninja/QtAutoMocSkipPch.cmake new file mode 100644 index 0000000..059b917 --- /dev/null +++ b/Tests/RunCMake/Ninja/QtAutoMocSkipPch.cmake @@ -0,0 +1,17 @@ +enable_language(CXX) + +set(QtX Qt${with_qt_version}) + +find_package(${QtX} REQUIRED COMPONENTS Core) + +set(CMAKE_AUTOMOC ON) + +add_library(simple_lib SHARED simple_lib.cpp) +add_executable(app_with_qt app.cpp app_qt.cpp) + +target_link_libraries(app_with_qt PRIVATE simple_lib ${QtX}::Core) + +set_source_files_properties(app.cpp app_qt.cpp + PROPERTIES SKIP_PRECOMPILE_HEADERS ON) + +target_precompile_headers(app_with_qt PRIVATE [["QObject"]]) diff --git a/Tests/RunCMake/Ninja/RunCMakeTest.cmake b/Tests/RunCMake/Ninja/RunCMakeTest.cmake index 2a5b556..9f078e6 100644 --- a/Tests/RunCMake/Ninja/RunCMakeTest.cmake +++ b/Tests/RunCMake/Ninja/RunCMakeTest.cmake @@ -357,6 +357,22 @@ function(run_QtAutoMocDeps) run_ninja("${RunCMake_TEST_BINARY_DIR}") endif() endfunction() + +function(run_QtAutoMocSkipPch) + set(QtX Qt${CMake_TEST_Qt_version}) + if(CMake_TEST_${QtX}Core_Version VERSION_GREATER_EQUAL 5.15.0) + set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/QtAutoMocSkipPch-build) + run_cmake_with_options(QtAutoMocSkipPch + "-Dwith_qt_version=${CMake_TEST_Qt_version}" + "-D${QtX}_DIR=${${QtX}_DIR}" + "-D${QtX}Core_DIR=${${QtX}Core_DIR}" + "-DCMAKE_PREFIX_PATH:STRING=${CMAKE_PREFIX_PATH}" + ) + # Build the project. + run_ninja("${RunCMake_TEST_BINARY_DIR}") + endif() +endfunction() if(CMake_TEST_Qt_version) run_QtAutoMocDeps() + run_QtAutoMocSkipPch() endif() diff --git a/Tests/RunCMake/install/DIRECTORY-symlink-clobber-all-result.txt b/Tests/RunCMake/install/DIRECTORY-symlink-clobber-all-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/install/DIRECTORY-symlink-clobber-all-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/install/DIRECTORY-symlink-clobber-all-stderr.txt b/Tests/RunCMake/install/DIRECTORY-symlink-clobber-all-stderr.txt new file mode 100644 index 0000000..d082b8a --- /dev/null +++ b/Tests/RunCMake/install/DIRECTORY-symlink-clobber-all-stderr.txt @@ -0,0 +1,12 @@ +^CMake Error at cmake_install.cmake:[0-9]+ \(file\): + file INSTALL cannot duplicate symlink + + [^ +]*/Tests/RunCMake/install/DIRECTORY-symlink-clobber-build/new/dir + + at + + [^ +]*/Tests/RunCMake/install/DIRECTORY-symlink-clobber-build/root-all/dest/dir + + because: A directory already exists at that location diff --git a/Tests/RunCMake/install/DIRECTORY-symlink-clobber-all-stdout.txt b/Tests/RunCMake/install/DIRECTORY-symlink-clobber-all-stdout.txt new file mode 100644 index 0000000..db8ca10 --- /dev/null +++ b/Tests/RunCMake/install/DIRECTORY-symlink-clobber-all-stdout.txt @@ -0,0 +1,12 @@ +-- Installing: [^ +]*/Tests/RunCMake/install/DIRECTORY-symlink-clobber-build/root-all/dest/dir +-- Installing: [^ +]*/Tests/RunCMake/install/DIRECTORY-symlink-clobber-build/root-all/dest/dir/file +-- Installing: [^ +]*/Tests/RunCMake/install/DIRECTORY-symlink-clobber-build/root-all/dest/lnk +-- Installing: [^ +]*/Tests/RunCMake/install/DIRECTORY-symlink-clobber-build/root-all/dest/lnk +-- Up-to-date: [^ +]*/Tests/RunCMake/install/DIRECTORY-symlink-clobber-build/root-all/dest/lnk/file +-- Installing: [^ +]*/Tests/RunCMake/install/DIRECTORY-symlink-clobber-build/root-all/dest/dir diff --git a/Tests/RunCMake/install/DIRECTORY-symlink-clobber.cmake b/Tests/RunCMake/install/DIRECTORY-symlink-clobber.cmake new file mode 100644 index 0000000..ac7a2cf --- /dev/null +++ b/Tests/RunCMake/install/DIRECTORY-symlink-clobber.cmake @@ -0,0 +1,11 @@ +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/old/dir) +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/old/dir/file "") +file(CREATE_LINK dir ${CMAKE_CURRENT_BINARY_DIR}/old/lnk SYMBOLIC) +install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/old/dir DESTINATION dest) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/old/lnk DESTINATION dest) + +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/new/lnk) +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/new/lnk/file "") +file(CREATE_LINK lnk ${CMAKE_CURRENT_BINARY_DIR}/new/dir SYMBOLIC) +install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/new/lnk DESTINATION dest) +install(FILES ${CMAKE_CURRENT_BINARY_DIR}/new/dir DESTINATION dest) diff --git a/Tests/RunCMake/install/RunCMakeTest.cmake b/Tests/RunCMake/install/RunCMakeTest.cmake index 7c12d4a..477ffe0 100644 --- a/Tests/RunCMake/install/RunCMakeTest.cmake +++ b/Tests/RunCMake/install/RunCMakeTest.cmake @@ -175,6 +175,10 @@ run_install_test(FILES-PERMISSIONS) run_install_test(TARGETS-RPATH) run_install_test(InstallRequiredSystemLibraries) +if(UNIX) + run_install_test(DIRECTORY-symlink-clobber) +endif() + if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") run_cmake(TARGETS-RUNTIME_DEPENDENCIES-macos-two-bundle) run_cmake(TARGETS-RUNTIME_DEPENDENCIES-macos-no-framework) diff --git a/Tests/RunCMake/pseudo_tidy.c b/Tests/RunCMake/pseudo_tidy.c index 2feeb0f..a43133b 100644 --- a/Tests/RunCMake/pseudo_tidy.c +++ b/Tests/RunCMake/pseudo_tidy.c @@ -5,6 +5,16 @@ int main(int argc, char* argv[]) { int i; for (i = 1; i < argc; ++i) { + if (strcmp(argv[i], "-p") == 0) { + // Ensure compile commands were not appended after the source file + for (++i; i < argc; ++i) { + if (strcmp(argv[i], "--") == 0) { + fprintf(stderr, "Command line arguments unexpectedly appended\n"); + return 1; + } + } + return 0; + } if (strcmp(argv[i], "-bad") == 0) { fprintf(stdout, "stdout from bad command line arg '-bad'\n"); fprintf(stderr, "stderr from bad command line arg '-bad'\n"); diff --git a/Tests/TryCompile/CMakeLists.txt b/Tests/TryCompile/CMakeLists.txt index 5f540e9..3e46ed5 100644 --- a/Tests/TryCompile/CMakeLists.txt +++ b/Tests/TryCompile/CMakeLists.txt @@ -34,30 +34,6 @@ macro(TEST_ASSERT value msg) endif () endmacro() -macro(TEST_FAIL value msg) - if (${value}) - message (SEND_ERROR "Failing test succeeded:" ${msg} ) - endif () -endmacro() - -macro(TEST_EXPECT_EXACT command expected) - if(NOT "x${result}" STREQUAL "x${expected}") - message(SEND_ERROR "${CMAKE_CURRENT_LIST_LINE}: TEST \"${command}\" failed: \"${result}\" expected: \"${expected}\"") - endif() -endmacro() - -macro(TEST_EXPECT_CONTAINS command expected) - if(NOT "${result}" MATCHES "${expected}") - message(SEND_ERROR "${CMAKE_CURRENT_LIST_LINE}: TEST \"${command}\" failed: \"${result}\" expected: \"${expected}\"") - endif() -endmacro() - -if (APPLE) - enable_language(OBJC) - enable_language(OBJCXX) -endif() - - # run old signature tests set(try_compile_bindir_or_SOURCES ${TryCompile_BINARY_DIR}) set(try_compile_redundant_SOURCES SOURCES) @@ -138,126 +114,6 @@ add_executable(TryCompile pass.c) ####################################################################### # -# also test that the CHECK_C_SOURCE_COMPILES, CHECK_CXX_SOURCE_COMPILES -# CHECK_C_SOURCE_RUNS and CHECK_CXX_SOURCE_RUNS macros work - -include(CheckCSourceCompiles) -include(CheckCXXSourceCompiles) -include(CheckCSourceRuns) -include(CheckCXXSourceRuns) - -CHECK_C_SOURCE_COMPILES("I don't build" C_BUILD_SHOULD_FAIL) -CHECK_C_SOURCE_COMPILES("int main() {return 0;}" C_BUILD_SHOULD_WORK) -CHECK_C_SOURCE_RUNS("int main() {return 1;}" C_RUN_SHOULD_FAIL) -CHECK_C_SOURCE_RUNS("int main() {return 0;}" C_RUN_SHOULD_WORK) - -TEST_FAIL(C_BUILD_SHOULD_FAIL "CHECK_C_SOURCE_COMPILES() succeeded, but should have failed") -TEST_ASSERT(C_BUILD_SHOULD_WORK "CHECK_C_SOURCE_COMPILES() failed") -TEST_FAIL(C_RUN_SHOULD_FAIL "CHECK_C_SOURCE_RUNS() succeeded, but should have failed") -TEST_ASSERT(C_RUN_SHOULD_WORK "CHECK_C_SOURCE_RUNS() failed") - -CHECK_CXX_SOURCE_COMPILES("I don't build" CXX_BUILD_SHOULD_FAIL) -CHECK_CXX_SOURCE_COMPILES("int main() {return 0;}" CXX_BUILD_SHOULD_WORK) -CHECK_CXX_SOURCE_COMPILES("void l(char const (&x)[2]){}; int main() { l(\"\\\\n\"); return 0;}" - CXX_BUILD_SHOULD_WORK_COMPLEX) - -CHECK_CXX_SOURCE_RUNS("int main() {return 2;}" CXX_RUN_SHOULD_FAIL) -CHECK_CXX_SOURCE_RUNS("int main() {return 0;}" CXX_RUN_SHOULD_WORK) - -TEST_FAIL(CXX_BUILD_SHOULD_FAIL "CHECK_CXX_SOURCE_COMPILES() succeeded, but should have failed") -TEST_ASSERT(CXX_BUILD_SHOULD_WORK "CHECK_CXX_SOURCE_COMPILES() failed") -TEST_ASSERT(CXX_BUILD_SHOULD_WORK_COMPLEX "CHECK_CXX_SOURCE_COMPILES() failed") -TEST_FAIL(CXX_RUN_SHOULD_FAIL "CHECK_CXX_SOURCE_RUNS() succeeded, but should have failed") -TEST_ASSERT(CXX_RUN_SHOULD_WORK "CHECK_CXX_SOURCE_RUNS() failed") - -foreach(lang C CXX) - if(NOT CMAKE_${lang}_COMPILER_ID STREQUAL "PathScale") - set(${lang}_DD --) - endif() -endforeach() - -unset(C_BOGUS_FLAG CACHE) -include(CheckCCompilerFlag) -CHECK_C_COMPILER_FLAG(${C_DD}-_this_is_not_a_flag_ C_BOGUS_FLAG) -TEST_FAIL(C_BOGUS_FLAG "CHECK_C_COMPILER_FLAG() succeeded, but should have failed") -unset(C_BOGUS_FLAG CACHE) -if(DEFINED C_BOGUS_FLAG) - # Verify that CHECK_C_COMPILER_FLAG didn't construct a normal variable - message(SEND_ERROR "CHECK_C_COMPILER_FLAG shouldn't construct C_BOGUS_FLAG as a normal variable") -endif() - -unset(CXX_BOGUS_FLAG CACHE) -include(CheckCXXCompilerFlag) -CHECK_CXX_COMPILER_FLAG(${CXX_DD}-_this_is_not_a_flag_ CXX_BOGUS_FLAG) -TEST_FAIL(CXX_BOGUS_FLAG "CHECK_CXX_COMPILER_FLAG() succeeded, but should have failed") -unset(CXX_BOGUS_FLAG CACHE) -if(DEFINED CXX_BOGUS_FLAG) - # Verify that CHECK_C_COMPILER_FLAG didn't construct a normal variable - message(SEND_ERROR "CHECK_CXX_COMPILER_FLAG shouldn't construct CXX_BOGUS_FLAG as a normal variable") -endif() - -if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "LCC") - unset(C_STRICT_PROTOTYPES CACHE) - CHECK_C_COMPILER_FLAG("-Werror;-Wstrict-prototypes" C_STRICT_PROTOTYPES) - TEST_ASSERT(C_STRICT_PROTOTYPES "CHECK_C_COMPILER_FLAG failed -Werror -Wstrict-prototypes") -endif() - -######################################################################### -# -# Test that the CHECK_OBJCC_SOURCE_COMPILES, CHECK_OBJCXX_SOURCE_COMPILES -# CHECK_OBJC_SOURCE_RUNS and CHECK_OBJCXX_SOURCE_RUNS macros work - -if (APPLE) - enable_language(OBJC) - enable_language(OBJCXX) - - include(CheckOBJCSourceCompiles) - include(CheckOBJCXXSourceCompiles) - include(CheckOBJCSourceRuns) - include(CheckOBJCXXSourceRuns) - - CHECK_OBJC_SOURCE_COMPILES("I don't build in Objective-C" OBJC_BUILD_SHOULD_FAIL) - CHECK_OBJC_SOURCE_COMPILES("int main() { return 0; }" SIMPLE_OBJC_BUILD_SHOULD_WORK) - - TEST_FAIL(OBJC_BUILD_SHOULD_FAIL "CHECK_OBJC_SOURCE_COMPILES() succeeded, but should have failed") - TEST_ASSERT(SIMPLE_OBJC_BUILD_SHOULD_WORK "CHECK_OBJC_SOURCE_COMPILES() failed, but should have succeeded") - - set(CMAKE_REQUIRED_LIBRARIES "-framework Foundation") - - CHECK_OBJC_SOURCE_COMPILES("#import <Foundation/Foundation.h>\nint main()\n{\nNSObject *foo;\nreturn 0;\n}\n" OBJC_BUILD_SHOULD_WORK) - CHECK_OBJC_SOURCE_RUNS("int main() { return 2; }" SIMPLE_OBJC_RUN_SHOULD_FAIL) - CHECK_OBJC_SOURCE_RUNS("int main() { return 0; }" SIMPLE_OBJC_RUN_SHOULD_WORK) - CHECK_OBJC_SOURCE_RUNS("#import <Foundation/Foundation.h>\nint main()\n{\nNSObject *foo;\nreturn 2;\n}\n" OBJC_RUN_SHOULD_FAIL) - CHECK_OBJC_SOURCE_RUNS("#import <Foundation/Foundation.h>\nint main()\n{\nNSObject *foo;\nreturn 0;\n}\n" OBJC_RUN_SHOULD_WORK) - - TEST_ASSERT(OBJC_BUILD_SHOULD_WORK "CHECK_OBJC_SOURCE_COMPILES() failed, but should have succeeded") - TEST_FAIL(SIMPLE_OBJC_RUN_SHOULD_FAIL "CHECK_OBJC_SOURC_RUNS() succeeds, but should have failed") - TEST_ASSERT(SIMPLE_OBJC_RUN_SHOULD_WORK "CHECK_OBJC_SOURCE_RUNS() failed, but should have succeeded") - TEST_FAIL(OBJC_RUN_SHOULD_FAIL "CHECK_OBJC_SOURCE_RUNS() succeeds, but should have failed") - TEST_ASSERT(OBJC_RUN_SHOULD_WORK "CHECK_OBJC_SOURCE_RUNS() failed, but should have succeeded") - - - CHECK_OBJCXX_SOURCE_COMPILES("I don't build in Objective-C++" OBJCXX_BUILD_SHOULD_FAIL) - CHECK_OBJCXX_SOURCE_COMPILES("int main() { return 0; }" SIMPLE_OBJCXX_BUILD_SHOULD_WORK) - - TEST_FAIL(OBJCXX_BUILD_SHOULD_FAIL "CHECK_OBJCXX_SOURCE_COMPILES() succeeded, but should have failed") - TEST_ASSERT(SIMPLE_OBJCXX_BUILD_SHOULD_WORK "CHECK_OBJCXX_SOURCE_COMPILES() failed, but should have succeeded") - - CHECK_OBJCXX_SOURCE_COMPILES("#import <Foundation/Foundation.h>\n#include <iostream>\nint main()\n{\nNSObject *foo;\nstd::cout << \"Hello\" << std::endl;\nreturn 0;\n}\n" OBJCXX_BUILD_SHOULD_WORK) - CHECK_OBJCXX_SOURCE_RUNS("int main() { return 2; }" SIMPLE_OBJCXX_RUN_SHOULD_FAIL) - CHECK_OBJCXX_SOURCE_RUNS("int main() { return 0; }" SIMPLE_OBJCXX_RUN_SHOULD_WORK) - CHECK_OBJCXX_SOURCE_RUNS("#import <Foundation/Foundation.h>\n#include <vector>\nint main()\n{\nNSObject *foo;\nstd::vector<int> bar;\nreturn 2;\n}\n" OBJCXX_RUN_SHOULD_FAIL) - CHECK_OBJCXX_SOURCE_RUNS("#import <Foundation/Foundation.h>\n#include <vector>\nint main()\n{\nNSObject *foo;\nstd::vector<int> bar;\nreturn 0;\n}\n" OBJCXX_RUN_SHOULD_WORK) - - TEST_ASSERT(OBJCXX_BUILD_SHOULD_WORK "CHECK_OBJCXX_SOURCE_COMPILES() failed, but should have succeeded") - TEST_FAIL(SIMPLE_OBJCXX_RUN_SHOULD_FAIL "CHECK_OBJCXX_SOURC_RUNS() succeeds, but should have failed") - TEST_ASSERT(SIMPLE_OBJCXX_RUN_SHOULD_WORK "CHECK_OBJCXX_SOURCE_RUNS() failed, but should have succeeded") - TEST_FAIL(OBJCXX_RUN_SHOULD_FAIL "CHECK_OBJCXX_SOURCE_RUNS() succeeds, but should have failed") - TEST_ASSERT(OBJCXX_RUN_SHOULD_WORK "CHECK_OBJCXX_SOURCE_RUNS() failed, but should have succeeded") -endif() - -####################################################################### -# # also test that the check_prototype_definition macro works include(CheckPrototypeDefinition) |