From 64ac01451dad389bb4ca00019a38fbb8bd68308e Mon Sep 17 00:00:00 2001 From: Brad King Date: Thu, 6 Oct 2022 09:23:17 -0400 Subject: Tests: Clarify RunCMake.Check* case names Cases for `CheckSource{Compiles,Runs}` and `Check{Compiler,Linker}Flag` cover the modules with the language as a parameter, not the language-specific modules. --- .../CheckCompilerFlag/CheckCCompilerFlag.cmake | 33 ---------------------- .../CheckCompilerFlag/CheckCUDACompilerFlag.cmake | 15 ---------- .../CheckCompilerFlag/CheckCXXCompilerFlag.cmake | 26 ----------------- .../CheckCompilerFlag/CheckCompilerFlagC.cmake | 33 ++++++++++++++++++++++ .../CheckCompilerFlag/CheckCompilerFlagCUDA.cmake | 15 ++++++++++ .../CheckCompilerFlag/CheckCompilerFlagCXX.cmake | 26 +++++++++++++++++ .../CheckCompilerFlagFortran.cmake | 16 +++++++++++ .../CheckCompilerFlag/CheckCompilerFlagHIP.cmake | 13 +++++++++ .../CheckCompilerFlag/CheckCompilerFlagISPC.cmake | 13 +++++++++ .../CheckCompilerFlag/CheckCompilerFlagOBJC.cmake | 14 +++++++++ .../CheckCompilerFlagOBJCXX.cmake | 14 +++++++++ .../CheckFortranCompilerFlag.cmake | 16 ----------- .../CheckCompilerFlag/CheckHIPCompilerFlag.cmake | 13 --------- .../CheckCompilerFlag/CheckISPCCompilerFlag.cmake | 13 --------- .../CheckCompilerFlag/CheckOBJCCompilerFlag.cmake | 14 --------- .../CheckOBJCXXCompilerFlag.cmake | 14 --------- .../RunCMake/CheckCompilerFlag/RunCMakeTest.cmake | 16 +++++------ .../CheckLinkerFlag/CheckCLinkerFlag.cmake | 3 -- .../CheckLinkerFlag/CheckCUDALinkerFlag.cmake | 3 -- .../CheckLinkerFlag/CheckCXXLinkerFlag.cmake | 3 -- .../CheckLinkerFlag/CheckFortranLinkerFlag.cmake | 3 -- .../CheckLinkerFlag/CheckHIPLinkerFlag.cmake | 3 -- .../CheckLinkerFlag/CheckLinkerFlagC.cmake | 3 ++ .../CheckLinkerFlag/CheckLinkerFlagCUDA.cmake | 3 ++ .../CheckLinkerFlag/CheckLinkerFlagCXX.cmake | 3 ++ .../CheckLinkerFlag/CheckLinkerFlagFortran.cmake | 3 ++ .../CheckLinkerFlag/CheckLinkerFlagHIP.cmake | 3 ++ .../CheckLinkerFlag/CheckLinkerFlagOBJC.cmake | 3 ++ .../CheckLinkerFlag/CheckLinkerFlagOBJCXX.cmake | 3 ++ .../CheckLinkerFlag/CheckOBJCLinkerFlag.cmake | 3 -- .../CheckLinkerFlag/CheckOBJCXXLinkerFlag.cmake | 3 -- Tests/RunCMake/CheckLinkerFlag/RunCMakeTest.cmake | 14 ++++----- .../CheckSourceCompiles/CheckCSourceCompiles.cmake | 15 ---------- .../CheckCUDASourceCompiles.cmake | 29 ------------------- .../CheckCXXSourceCompiles.cmake | 28 ------------------ .../CheckFortranSourceCompiles.cmake | 16 ----------- .../CheckHIPSourceCompiles.cmake | 27 ------------------ .../CheckISPCSourceCompiles.cmake | 20 ------------- .../CheckOBJCSourceCompiles.cmake | 16 ----------- .../CheckOBJCXXSourceCompiles.cmake | 19 ------------- .../CheckSourceCompiles/CheckSourceCompilesC.cmake | 15 ++++++++++ .../CheckSourceCompilesCUDA.cmake | 29 +++++++++++++++++++ .../CheckSourceCompilesCXX.cmake | 28 ++++++++++++++++++ .../CheckSourceCompilesFortran.cmake | 16 +++++++++++ .../CheckSourceCompilesHIP.cmake | 27 ++++++++++++++++++ .../CheckSourceCompilesISPC.cmake | 20 +++++++++++++ .../CheckSourceCompilesOBJC.cmake | 16 +++++++++++ .../CheckSourceCompilesOBJCXX.cmake | 19 +++++++++++++ .../CheckSourceCompiles/RunCMakeTest.cmake | 16 +++++------ .../CheckSourceRuns/CheckCSourceRuns.cmake | 15 ---------- .../CheckSourceRuns/CheckCUDASourceRuns.cmake | 23 --------------- .../CheckSourceRuns/CheckCXXSourceRuns.cmake | 22 --------------- .../CheckSourceRuns/CheckFortranSourceRuns.cmake | 16 ----------- .../CheckSourceRuns/CheckHIPSourceRuns.cmake | 21 -------------- .../CheckSourceRuns/CheckOBJCSourceRuns.cmake | 16 ----------- .../CheckSourceRuns/CheckOBJCXXSourceRuns.cmake | 19 ------------- .../CheckSourceRuns/CheckSourceRunsC.cmake | 15 ++++++++++ .../CheckSourceRuns/CheckSourceRunsCUDA.cmake | 23 +++++++++++++++ .../CheckSourceRuns/CheckSourceRunsCXX.cmake | 22 +++++++++++++++ .../CheckSourceRuns/CheckSourceRunsFortran.cmake | 16 +++++++++++ .../CheckSourceRuns/CheckSourceRunsHIP.cmake | 21 ++++++++++++++ .../CheckSourceRuns/CheckSourceRunsOBJC.cmake | 16 +++++++++++ .../CheckSourceRuns/CheckSourceRunsOBJCXX.cmake | 19 +++++++++++++ Tests/RunCMake/CheckSourceRuns/RunCMakeTest.cmake | 14 ++++----- 64 files changed, 497 insertions(+), 497 deletions(-) delete mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCCompilerFlag.cmake delete mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCUDACompilerFlag.cmake delete mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCXXCompilerFlag.cmake create mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagC.cmake create mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagCUDA.cmake create mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagCXX.cmake create mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagFortran.cmake create mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagHIP.cmake create mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagISPC.cmake create mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJC.cmake create mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJCXX.cmake delete mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckFortranCompilerFlag.cmake delete mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckHIPCompilerFlag.cmake delete mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckISPCCompilerFlag.cmake delete mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckOBJCCompilerFlag.cmake delete mode 100644 Tests/RunCMake/CheckCompilerFlag/CheckOBJCXXCompilerFlag.cmake delete mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckCLinkerFlag.cmake delete mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckCUDALinkerFlag.cmake delete mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckCXXLinkerFlag.cmake delete mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckFortranLinkerFlag.cmake delete mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckHIPLinkerFlag.cmake create mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagC.cmake create mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCUDA.cmake create mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCXX.cmake create mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagFortran.cmake create mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagHIP.cmake create mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJC.cmake create mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJCXX.cmake delete mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckOBJCLinkerFlag.cmake delete mode 100644 Tests/RunCMake/CheckLinkerFlag/CheckOBJCXXLinkerFlag.cmake delete mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckCSourceCompiles.cmake delete mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckCUDASourceCompiles.cmake delete mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckCXXSourceCompiles.cmake delete mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckFortranSourceCompiles.cmake delete mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckHIPSourceCompiles.cmake delete mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckISPCSourceCompiles.cmake delete mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckOBJCSourceCompiles.cmake delete mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckOBJCXXSourceCompiles.cmake create mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesC.cmake create mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesCUDA.cmake create mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesCXX.cmake create mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesFortran.cmake create mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesHIP.cmake create mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesISPC.cmake create mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesOBJC.cmake create mode 100644 Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesOBJCXX.cmake delete mode 100644 Tests/RunCMake/CheckSourceRuns/CheckCSourceRuns.cmake delete mode 100644 Tests/RunCMake/CheckSourceRuns/CheckCUDASourceRuns.cmake delete mode 100644 Tests/RunCMake/CheckSourceRuns/CheckCXXSourceRuns.cmake delete mode 100644 Tests/RunCMake/CheckSourceRuns/CheckFortranSourceRuns.cmake delete mode 100644 Tests/RunCMake/CheckSourceRuns/CheckHIPSourceRuns.cmake delete mode 100644 Tests/RunCMake/CheckSourceRuns/CheckOBJCSourceRuns.cmake delete mode 100644 Tests/RunCMake/CheckSourceRuns/CheckOBJCXXSourceRuns.cmake create mode 100644 Tests/RunCMake/CheckSourceRuns/CheckSourceRunsC.cmake create mode 100644 Tests/RunCMake/CheckSourceRuns/CheckSourceRunsCUDA.cmake create mode 100644 Tests/RunCMake/CheckSourceRuns/CheckSourceRunsCXX.cmake create mode 100644 Tests/RunCMake/CheckSourceRuns/CheckSourceRunsFortran.cmake create mode 100644 Tests/RunCMake/CheckSourceRuns/CheckSourceRunsHIP.cmake create mode 100644 Tests/RunCMake/CheckSourceRuns/CheckSourceRunsOBJC.cmake create mode 100644 Tests/RunCMake/CheckSourceRuns/CheckSourceRunsOBJCXX.cmake diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCCompilerFlag.cmake deleted file mode 100644 index 276158c..0000000 --- a/Tests/RunCMake/CheckCompilerFlag/CheckCCompilerFlag.cmake +++ /dev/null @@ -1,33 +0,0 @@ - -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/CheckCUDACompilerFlag.cmake deleted file mode 100644 index 681a546..0000000 --- a/Tests/RunCMake/CheckCompilerFlag/CheckCUDACompilerFlag.cmake +++ /dev/null @@ -1,15 +0,0 @@ - -enable_language (CUDA) -include(CheckCompilerFlag) - -set(CUDA 1) # test that this is tolerated - -check_compiler_flag(CUDA "-_this_is_not_a_flag_" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid CUDA compile flag didn't fail.") -endif() - -check_compiler_flag(CUDA "-DFOO" SHOULD_WORK) -if(NOT SHOULD_WORK) - message(SEND_ERROR "${CMAKE_CUDA_COMPILER_ID} compiler flag '-DFOO' check failed") -endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCXXCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCXXCompilerFlag.cmake deleted file mode 100644 index dec31ec..0000000 --- a/Tests/RunCMake/CheckCompilerFlag/CheckCXXCompilerFlag.cmake +++ /dev/null @@ -1,26 +0,0 @@ - -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/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/CheckCompilerFlagCUDA.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagCUDA.cmake new file mode 100644 index 0000000..681a546 --- /dev/null +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagCUDA.cmake @@ -0,0 +1,15 @@ + +enable_language (CUDA) +include(CheckCompilerFlag) + +set(CUDA 1) # test that this is tolerated + +check_compiler_flag(CUDA "-_this_is_not_a_flag_" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid CUDA compile flag didn't fail.") +endif() + +check_compiler_flag(CUDA "-DFOO" SHOULD_WORK) +if(NOT SHOULD_WORK) + message(SEND_ERROR "${CMAKE_CUDA_COMPILER_ID} compiler flag '-DFOO' check failed") +endif() 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/CheckCompilerFlagFortran.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagFortran.cmake new file mode 100644 index 0000000..236f37b --- /dev/null +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagFortran.cmake @@ -0,0 +1,16 @@ +enable_language (Fortran) +include(CheckCompilerFlag) + +set(Fortran 1) # test that this is tolerated + +check_compiler_flag(Fortran "-_this_is_not_a_flag_" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid Fortran compile flag didn't fail.") +endif() + +if(CMAKE_Fortran_COMPILER_ID STREQUAL "GNU|LCC") + check_compiler_flag(Fortran "-Wall" SHOULD_WORK) + if(NOT SHOULD_WORK) + message(SEND_ERROR "${CMAKE_Fortran_COMPILER_ID} compiler flag '-Wall' check failed") + endif() +endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagHIP.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagHIP.cmake new file mode 100644 index 0000000..339ce18 --- /dev/null +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagHIP.cmake @@ -0,0 +1,13 @@ + +enable_language (HIP) +include(CheckCompilerFlag) + +check_compiler_flag(HIP "-_this_is_not_a_flag_" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid HIP compile flag didn't fail.") +endif() + +check_compiler_flag(HIP "-DFOO" SHOULD_WORK) +if(NOT SHOULD_WORK) + message(SEND_ERROR "${CMAKE_HIP_COMPILER_ID} compiler flag '-DFOO' check failed") +endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagISPC.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagISPC.cmake new file mode 100644 index 0000000..662319a --- /dev/null +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagISPC.cmake @@ -0,0 +1,13 @@ + +enable_language (ISPC) +include(CheckCompilerFlag) + +check_compiler_flag(ISPC "-_this_is_not_a_flag_" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid ISPC compile flag didn't fail.") +endif() + +check_compiler_flag(ISPC "--woff" SHOULD_WORK) +if(NOT SHOULD_WORK) + message(SEND_ERROR "${CMAKE_ISPC_COMPILER_ID} compiler flag '--woff' check failed") +endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJC.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJC.cmake new file mode 100644 index 0000000..f250f8d --- /dev/null +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJC.cmake @@ -0,0 +1,14 @@ +enable_language (OBJC) +include(CheckCompilerFlag) + +set(OBJC 1) # test that this is tolerated + +check_compiler_flag(OBJC "-_this_is_not_a_flag_" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid OBJC compile flag didn't fail.") +endif() + +check_compiler_flag(OBJC "-Wall" SHOULD_WORK) +if(NOT SHOULD_WORK) + message(SEND_ERROR "${CMAKE_OBJC_COMPILER_ID} compiler flag '-Wall' check failed") +endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJCXX.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJCXX.cmake new file mode 100644 index 0000000..bc940a6 --- /dev/null +++ b/Tests/RunCMake/CheckCompilerFlag/CheckCompilerFlagOBJCXX.cmake @@ -0,0 +1,14 @@ +enable_language (OBJCXX) +include(CheckCompilerFlag) + +set(OBJCXX 1) # test that this is tolerated + +check_compiler_flag(OBJCXX "-_this_is_not_a_flag_" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid OBJCXX compile flag didn't fail.") +endif() + +check_compiler_flag(OBJCXX "-Wall" SHOULD_WORK) +if(NOT SHOULD_WORK) + message(SEND_ERROR "${CMAKE_OBJCXX_COMPILER_ID} compiler flag '-Wall' check failed") +endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckFortranCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckFortranCompilerFlag.cmake deleted file mode 100644 index 236f37b..0000000 --- a/Tests/RunCMake/CheckCompilerFlag/CheckFortranCompilerFlag.cmake +++ /dev/null @@ -1,16 +0,0 @@ -enable_language (Fortran) -include(CheckCompilerFlag) - -set(Fortran 1) # test that this is tolerated - -check_compiler_flag(Fortran "-_this_is_not_a_flag_" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid Fortran compile flag didn't fail.") -endif() - -if(CMAKE_Fortran_COMPILER_ID STREQUAL "GNU|LCC") - check_compiler_flag(Fortran "-Wall" SHOULD_WORK) - if(NOT SHOULD_WORK) - message(SEND_ERROR "${CMAKE_Fortran_COMPILER_ID} compiler flag '-Wall' check failed") - endif() -endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckHIPCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckHIPCompilerFlag.cmake deleted file mode 100644 index 339ce18..0000000 --- a/Tests/RunCMake/CheckCompilerFlag/CheckHIPCompilerFlag.cmake +++ /dev/null @@ -1,13 +0,0 @@ - -enable_language (HIP) -include(CheckCompilerFlag) - -check_compiler_flag(HIP "-_this_is_not_a_flag_" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid HIP compile flag didn't fail.") -endif() - -check_compiler_flag(HIP "-DFOO" SHOULD_WORK) -if(NOT SHOULD_WORK) - message(SEND_ERROR "${CMAKE_HIP_COMPILER_ID} compiler flag '-DFOO' check failed") -endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckISPCCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckISPCCompilerFlag.cmake deleted file mode 100644 index 662319a..0000000 --- a/Tests/RunCMake/CheckCompilerFlag/CheckISPCCompilerFlag.cmake +++ /dev/null @@ -1,13 +0,0 @@ - -enable_language (ISPC) -include(CheckCompilerFlag) - -check_compiler_flag(ISPC "-_this_is_not_a_flag_" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid ISPC compile flag didn't fail.") -endif() - -check_compiler_flag(ISPC "--woff" SHOULD_WORK) -if(NOT SHOULD_WORK) - message(SEND_ERROR "${CMAKE_ISPC_COMPILER_ID} compiler flag '--woff' check failed") -endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckOBJCCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckOBJCCompilerFlag.cmake deleted file mode 100644 index f250f8d..0000000 --- a/Tests/RunCMake/CheckCompilerFlag/CheckOBJCCompilerFlag.cmake +++ /dev/null @@ -1,14 +0,0 @@ -enable_language (OBJC) -include(CheckCompilerFlag) - -set(OBJC 1) # test that this is tolerated - -check_compiler_flag(OBJC "-_this_is_not_a_flag_" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid OBJC compile flag didn't fail.") -endif() - -check_compiler_flag(OBJC "-Wall" SHOULD_WORK) -if(NOT SHOULD_WORK) - message(SEND_ERROR "${CMAKE_OBJC_COMPILER_ID} compiler flag '-Wall' check failed") -endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/CheckOBJCXXCompilerFlag.cmake b/Tests/RunCMake/CheckCompilerFlag/CheckOBJCXXCompilerFlag.cmake deleted file mode 100644 index bc940a6..0000000 --- a/Tests/RunCMake/CheckCompilerFlag/CheckOBJCXXCompilerFlag.cmake +++ /dev/null @@ -1,14 +0,0 @@ -enable_language (OBJCXX) -include(CheckCompilerFlag) - -set(OBJCXX 1) # test that this is tolerated - -check_compiler_flag(OBJCXX "-_this_is_not_a_flag_" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid OBJCXX compile flag didn't fail.") -endif() - -check_compiler_flag(OBJCXX "-Wall" SHOULD_WORK) -if(NOT SHOULD_WORK) - message(SEND_ERROR "${CMAKE_OBJCXX_COMPILER_ID} compiler flag '-Wall' check failed") -endif() diff --git a/Tests/RunCMake/CheckCompilerFlag/RunCMakeTest.cmake b/Tests/RunCMake/CheckCompilerFlag/RunCMakeTest.cmake index 77439cb..dce93a5 100644 --- a/Tests/RunCMake/CheckCompilerFlag/RunCMakeTest.cmake +++ b/Tests/RunCMake/CheckCompilerFlag/RunCMakeTest.cmake @@ -3,28 +3,28 @@ include(RunCMake) run_cmake(NotEnabledLanguage) 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/CheckCLinkerFlag.cmake deleted file mode 100644 index c8e87a4..0000000 --- a/Tests/RunCMake/CheckLinkerFlag/CheckCLinkerFlag.cmake +++ /dev/null @@ -1,3 +0,0 @@ - -set (CHECK_LANGUAGE C) -include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckCUDALinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckCUDALinkerFlag.cmake deleted file mode 100644 index 84d6dd9..0000000 --- a/Tests/RunCMake/CheckLinkerFlag/CheckCUDALinkerFlag.cmake +++ /dev/null @@ -1,3 +0,0 @@ - -set (CHECK_LANGUAGE CUDA) -include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckCXXLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckCXXLinkerFlag.cmake deleted file mode 100644 index 4e299b9..0000000 --- a/Tests/RunCMake/CheckLinkerFlag/CheckCXXLinkerFlag.cmake +++ /dev/null @@ -1,3 +0,0 @@ - -set (CHECK_LANGUAGE CXX) -include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckFortranLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckFortranLinkerFlag.cmake deleted file mode 100644 index bca288e..0000000 --- a/Tests/RunCMake/CheckLinkerFlag/CheckFortranLinkerFlag.cmake +++ /dev/null @@ -1,3 +0,0 @@ - -set (CHECK_LANGUAGE Fortran) -include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckHIPLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckHIPLinkerFlag.cmake deleted file mode 100644 index 3bf3b30..0000000 --- a/Tests/RunCMake/CheckLinkerFlag/CheckHIPLinkerFlag.cmake +++ /dev/null @@ -1,3 +0,0 @@ - -set (CHECK_LANGUAGE HIP) -include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagC.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagC.cmake new file mode 100644 index 0000000..c8e87a4 --- /dev/null +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagC.cmake @@ -0,0 +1,3 @@ + +set (CHECK_LANGUAGE C) +include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCUDA.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCUDA.cmake new file mode 100644 index 0000000..84d6dd9 --- /dev/null +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCUDA.cmake @@ -0,0 +1,3 @@ + +set (CHECK_LANGUAGE CUDA) +include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCXX.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCXX.cmake new file mode 100644 index 0000000..4e299b9 --- /dev/null +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagCXX.cmake @@ -0,0 +1,3 @@ + +set (CHECK_LANGUAGE CXX) +include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagFortran.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagFortran.cmake new file mode 100644 index 0000000..bca288e --- /dev/null +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagFortran.cmake @@ -0,0 +1,3 @@ + +set (CHECK_LANGUAGE Fortran) +include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagHIP.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagHIP.cmake new file mode 100644 index 0000000..3bf3b30 --- /dev/null +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagHIP.cmake @@ -0,0 +1,3 @@ + +set (CHECK_LANGUAGE HIP) +include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJC.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJC.cmake new file mode 100644 index 0000000..fa1d18e --- /dev/null +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJC.cmake @@ -0,0 +1,3 @@ + +set (CHECK_LANGUAGE OBJC) +include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJCXX.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJCXX.cmake new file mode 100644 index 0000000..414efb8 --- /dev/null +++ b/Tests/RunCMake/CheckLinkerFlag/CheckLinkerFlagOBJCXX.cmake @@ -0,0 +1,3 @@ + +set (CHECK_LANGUAGE OBJCXX) +include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckOBJCLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckOBJCLinkerFlag.cmake deleted file mode 100644 index fa1d18e..0000000 --- a/Tests/RunCMake/CheckLinkerFlag/CheckOBJCLinkerFlag.cmake +++ /dev/null @@ -1,3 +0,0 @@ - -set (CHECK_LANGUAGE OBJC) -include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.cmake") diff --git a/Tests/RunCMake/CheckLinkerFlag/CheckOBJCXXLinkerFlag.cmake b/Tests/RunCMake/CheckLinkerFlag/CheckOBJCXXLinkerFlag.cmake deleted file mode 100644 index 414efb8..0000000 --- a/Tests/RunCMake/CheckLinkerFlag/CheckOBJCXXLinkerFlag.cmake +++ /dev/null @@ -1,3 +0,0 @@ - -set (CHECK_LANGUAGE OBJCXX) -include ("${CMAKE_CURRENT_SOURCE_DIR}/CheckLinkerFlag.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 deleted file mode 100644 index 4f73622..0000000 --- a/Tests/RunCMake/CheckSourceCompiles/CheckCSourceCompiles.cmake +++ /dev/null @@ -1,15 +0,0 @@ - -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/CheckCUDASourceCompiles.cmake deleted file mode 100644 index 2190649..0000000 --- a/Tests/RunCMake/CheckSourceCompiles/CheckCUDASourceCompiles.cmake +++ /dev/null @@ -1,29 +0,0 @@ - -enable_language (CUDA) -include(CheckSourceCompiles) - -set(CUDA 1) # test that this is tolerated - -check_source_compiles(CUDA "I don't build" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid CUDA source didn't fail.") -endif() - -check_source_compiles(CUDA [=[ - #include - __device__ int d_func() { } - int main() { - return 0; - } -]=] - SHOULD_BUILD) -if(NOT SHOULD_BUILD) - message(SEND_ERROR "Test fail for valid CUDA source.") -endif() - -check_source_compiles(CUDA "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 CUDA complex source.") -endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckCXXSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckCXXSourceCompiles.cmake deleted file mode 100644 index 97c9c30..0000000 --- a/Tests/RunCMake/CheckSourceCompiles/CheckCXXSourceCompiles.cmake +++ /dev/null @@ -1,28 +0,0 @@ - -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 - 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/CheckFortranSourceCompiles.cmake deleted file mode 100644 index 48dc525..0000000 --- a/Tests/RunCMake/CheckSourceCompiles/CheckFortranSourceCompiles.cmake +++ /dev/null @@ -1,16 +0,0 @@ - - -enable_language (Fortran) -include(CheckSourceCompiles) - -set(Fortran 1) # test that this is tolerated - -check_source_compiles(Fortran [=[ - PROGRAM TEST_HAVE_PRINT - PRINT *, 'Hello' - END -]=] SHOULD_BUILD) - -if(NOT SHOULD_BUILD) - message(SEND_ERROR "Test fail for valid Fortran source.") -endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckHIPSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckHIPSourceCompiles.cmake deleted file mode 100644 index 911a0d7..0000000 --- a/Tests/RunCMake/CheckSourceCompiles/CheckHIPSourceCompiles.cmake +++ /dev/null @@ -1,27 +0,0 @@ - -enable_language (HIP) -include(CheckSourceCompiles) - -check_source_compiles(HIP "I don't build" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid HIP source didn't fail.") -endif() - -check_source_compiles(HIP [=[ - #include - __device__ int d_func() { } - int main() { - return 0; - } -]=] - SHOULD_BUILD) -if(NOT SHOULD_BUILD) - message(SEND_ERROR "Test fail for valid HIP source.") -endif() - -check_source_compiles(HIP "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 HIP complex source.") -endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckISPCSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckISPCSourceCompiles.cmake deleted file mode 100644 index 74b83c0..0000000 --- a/Tests/RunCMake/CheckSourceCompiles/CheckISPCSourceCompiles.cmake +++ /dev/null @@ -1,20 +0,0 @@ - -enable_language (ISPC) -include(CheckSourceCompiles) - -check_source_compiles(ISPC "I don't build" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "invalid ISPC source didn't fail.") -endif() - -check_source_compiles(ISPC [=[ - -float func(uniform int32, float a) -{ - return a / 2.25; -} -]=] - SHOULD_BUILD) -if(NOT SHOULD_BUILD) - message(SEND_ERROR "Test fail for valid ISPC source.") -endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckOBJCSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckOBJCSourceCompiles.cmake deleted file mode 100644 index 76a5009..0000000 --- a/Tests/RunCMake/CheckSourceCompiles/CheckOBJCSourceCompiles.cmake +++ /dev/null @@ -1,16 +0,0 @@ -enable_language (OBJC) -include(CheckSourceCompiles) - -set(OBJC 1) # test that this is tolerated - -check_source_compiles(OBJC [[ - #import - 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/CheckOBJCXXSourceCompiles.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckOBJCXXSourceCompiles.cmake deleted file mode 100644 index 814237e..0000000 --- a/Tests/RunCMake/CheckSourceCompiles/CheckOBJCXXSourceCompiles.cmake +++ /dev/null @@ -1,19 +0,0 @@ -enable_language (OBJCXX) -include(CheckSourceCompiles) - -set(OBJCXX 1) # test that this is tolerated - -check_source_compiles(OBJCXX [[ - #include - #import - int main() { - std::vector 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/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/CheckSourceCompilesCUDA.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesCUDA.cmake new file mode 100644 index 0000000..2190649 --- /dev/null +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesCUDA.cmake @@ -0,0 +1,29 @@ + +enable_language (CUDA) +include(CheckSourceCompiles) + +set(CUDA 1) # test that this is tolerated + +check_source_compiles(CUDA "I don't build" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid CUDA source didn't fail.") +endif() + +check_source_compiles(CUDA [=[ + #include + __device__ int d_func() { } + int main() { + return 0; + } +]=] + SHOULD_BUILD) +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for valid CUDA source.") +endif() + +check_source_compiles(CUDA "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 CUDA complex source.") +endif() 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 + 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/CheckSourceCompilesFortran.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesFortran.cmake new file mode 100644 index 0000000..48dc525 --- /dev/null +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesFortran.cmake @@ -0,0 +1,16 @@ + + +enable_language (Fortran) +include(CheckSourceCompiles) + +set(Fortran 1) # test that this is tolerated + +check_source_compiles(Fortran [=[ + PROGRAM TEST_HAVE_PRINT + PRINT *, 'Hello' + END +]=] SHOULD_BUILD) + +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for valid Fortran source.") +endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesHIP.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesHIP.cmake new file mode 100644 index 0000000..911a0d7 --- /dev/null +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesHIP.cmake @@ -0,0 +1,27 @@ + +enable_language (HIP) +include(CheckSourceCompiles) + +check_source_compiles(HIP "I don't build" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid HIP source didn't fail.") +endif() + +check_source_compiles(HIP [=[ + #include + __device__ int d_func() { } + int main() { + return 0; + } +]=] + SHOULD_BUILD) +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for valid HIP source.") +endif() + +check_source_compiles(HIP "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 HIP complex source.") +endif() diff --git a/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesISPC.cmake b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesISPC.cmake new file mode 100644 index 0000000..74b83c0 --- /dev/null +++ b/Tests/RunCMake/CheckSourceCompiles/CheckSourceCompilesISPC.cmake @@ -0,0 +1,20 @@ + +enable_language (ISPC) +include(CheckSourceCompiles) + +check_source_compiles(ISPC "I don't build" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "invalid ISPC source didn't fail.") +endif() + +check_source_compiles(ISPC [=[ + +float func(uniform int32, float a) +{ + return a / 2.25; +} +]=] + SHOULD_BUILD) +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for valid ISPC source.") +endif() 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 + 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 + #import + int main() { + std::vector 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..64555d8 100644 --- a/Tests/RunCMake/CheckSourceCompiles/RunCMakeTest.cmake +++ b/Tests/RunCMake/CheckSourceCompiles/RunCMakeTest.cmake @@ -4,26 +4,26 @@ run_cmake(NotEnabledLanguage) run_cmake(NonExistentLanguage) 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 deleted file mode 100644 index 96a1027..0000000 --- a/Tests/RunCMake/CheckSourceRuns/CheckCSourceRuns.cmake +++ /dev/null @@ -1,15 +0,0 @@ - -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/CheckCUDASourceRuns.cmake deleted file mode 100644 index ea5f4f9..0000000 --- a/Tests/RunCMake/CheckSourceRuns/CheckCUDASourceRuns.cmake +++ /dev/null @@ -1,23 +0,0 @@ - -enable_language (CUDA) -include(CheckSourceRuns) - -set(CUDA 1) # test that this is tolerated - -check_source_runs(CUDA "int main() {return 2;}" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "CUDA check_source_runs succeeded, but should have failed.") -endif() - -check_source_runs(CUDA -[=[ - #include - __device__ __host__ void fake_function(); - __host__ int main() { - return 0; - } -]=] - SHOULD_RUN) -if(NOT SHOULD_RUN) - message(SEND_ERROR "CUDA check_source_runs failed for valid CUDA executable.") -endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckCXXSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckCXXSourceRuns.cmake deleted file mode 100644 index c4bef6e..0000000 --- a/Tests/RunCMake/CheckSourceRuns/CheckCXXSourceRuns.cmake +++ /dev/null @@ -1,22 +0,0 @@ - -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 - 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/CheckFortranSourceRuns.cmake deleted file mode 100644 index 50e8ec8..0000000 --- a/Tests/RunCMake/CheckSourceRuns/CheckFortranSourceRuns.cmake +++ /dev/null @@ -1,16 +0,0 @@ - - -enable_language (Fortran) -include(CheckSourceRuns) - -set(Fortran 1) # test that this is tolerated - -check_source_runs(Fortran [=[ - PROGRAM TEST_HAVE_PRINT - PRINT *, 'Hello' - END -]=] SHOULD_BUILD) - -if(NOT SHOULD_BUILD) - message(SEND_ERROR "Test fail for valid Fortran source.") -endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckHIPSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckHIPSourceRuns.cmake deleted file mode 100644 index d9fb8c2..0000000 --- a/Tests/RunCMake/CheckSourceRuns/CheckHIPSourceRuns.cmake +++ /dev/null @@ -1,21 +0,0 @@ - -enable_language (HIP) -include(CheckSourceRuns) - -check_source_runs(HIP "int main() {return 2;}" SHOULD_FAIL) -if(SHOULD_FAIL) - message(SEND_ERROR "HIP check_source_runs succeeded, but should have failed.") -endif() - -check_source_runs(HIP -[=[ - #include - __device__ __host__ void fake_function(); - __host__ int main() { - return 0; - } -]=] - SHOULD_RUN) -if(NOT SHOULD_RUN) - message(SEND_ERROR "HIP check_source_runs failed for valid HIP executable.") -endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckOBJCSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckOBJCSourceRuns.cmake deleted file mode 100644 index b828352..0000000 --- a/Tests/RunCMake/CheckSourceRuns/CheckOBJCSourceRuns.cmake +++ /dev/null @@ -1,16 +0,0 @@ -enable_language (OBJC) -include(CheckSourceRuns) - -set(OBJC 1) # test that this is tolerated - -check_source_runs(OBJC [[ - #import - 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/CheckOBJCXXSourceRuns.cmake b/Tests/RunCMake/CheckSourceRuns/CheckOBJCXXSourceRuns.cmake deleted file mode 100644 index 8a56f13..0000000 --- a/Tests/RunCMake/CheckSourceRuns/CheckOBJCXXSourceRuns.cmake +++ /dev/null @@ -1,19 +0,0 @@ -enable_language (OBJCXX) -include(CheckSourceRuns) - -set(OBJCXX 1) # test that this is tolerated - -check_source_runs(OBJCXX [[ - #include - #import - int main() { - std::vector 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/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/CheckSourceRunsCUDA.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsCUDA.cmake new file mode 100644 index 0000000..ea5f4f9 --- /dev/null +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsCUDA.cmake @@ -0,0 +1,23 @@ + +enable_language (CUDA) +include(CheckSourceRuns) + +set(CUDA 1) # test that this is tolerated + +check_source_runs(CUDA "int main() {return 2;}" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "CUDA check_source_runs succeeded, but should have failed.") +endif() + +check_source_runs(CUDA +[=[ + #include + __device__ __host__ void fake_function(); + __host__ int main() { + return 0; + } +]=] + SHOULD_RUN) +if(NOT SHOULD_RUN) + message(SEND_ERROR "CUDA check_source_runs failed for valid CUDA executable.") +endif() 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 + 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/CheckSourceRunsFortran.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsFortran.cmake new file mode 100644 index 0000000..50e8ec8 --- /dev/null +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsFortran.cmake @@ -0,0 +1,16 @@ + + +enable_language (Fortran) +include(CheckSourceRuns) + +set(Fortran 1) # test that this is tolerated + +check_source_runs(Fortran [=[ + PROGRAM TEST_HAVE_PRINT + PRINT *, 'Hello' + END +]=] SHOULD_BUILD) + +if(NOT SHOULD_BUILD) + message(SEND_ERROR "Test fail for valid Fortran source.") +endif() diff --git a/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsHIP.cmake b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsHIP.cmake new file mode 100644 index 0000000..d9fb8c2 --- /dev/null +++ b/Tests/RunCMake/CheckSourceRuns/CheckSourceRunsHIP.cmake @@ -0,0 +1,21 @@ + +enable_language (HIP) +include(CheckSourceRuns) + +check_source_runs(HIP "int main() {return 2;}" SHOULD_FAIL) +if(SHOULD_FAIL) + message(SEND_ERROR "HIP check_source_runs succeeded, but should have failed.") +endif() + +check_source_runs(HIP +[=[ + #include + __device__ __host__ void fake_function(); + __host__ int main() { + return 0; + } +]=] + SHOULD_RUN) +if(NOT SHOULD_RUN) + message(SEND_ERROR "HIP check_source_runs failed for valid HIP executable.") +endif() 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 + 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 + #import + int main() { + std::vector 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..ee5ab22 100644 --- a/Tests/RunCMake/CheckSourceRuns/RunCMakeTest.cmake +++ b/Tests/RunCMake/CheckSourceRuns/RunCMakeTest.cmake @@ -4,22 +4,22 @@ run_cmake(NotEnabledLanguage) run_cmake(NonExistentLanguage) 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() -- cgit v0.12