194 lines
7.4 KiB
CMake
194 lines
7.4 KiB
CMake
PROJECT(TryCompile)
|
|
|
|
MACRO(TEST_ASSERT value msg)
|
|
IF (NOT ${value})
|
|
MESSAGE (SEND_ERROR "Assertion failure:" ${msg} )
|
|
ENDIF (NOT ${value})
|
|
ENDMACRO(TEST_ASSERT)
|
|
|
|
MACRO(TEST_FAIL value msg)
|
|
IF (${value})
|
|
MESSAGE (SEND_ERROR "Failing test succeeded:" ${msg} )
|
|
ENDIF (${value})
|
|
ENDMACRO(TEST_FAIL)
|
|
|
|
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(NOT "x${result}" STREQUAL "x${expected}")
|
|
ENDMACRO(TEST_EXPECT_EXACT command expected)
|
|
|
|
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(NOT "${result}" MATCHES "${expected}")
|
|
ENDMACRO(TEST_EXPECT_CONTAINS command expected)
|
|
|
|
# try to compile a file that should compile
|
|
# also check that COPY_FILE works
|
|
TRY_COMPILE(SHOULD_PASS
|
|
${TryCompile_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
|
|
${TryCompile_SOURCE_DIR}/pass.c
|
|
OUTPUT_VARIABLE TRY_OUT
|
|
COPY_FILE ${TryCompile_BINARY_DIR}/CopyOfPass
|
|
)
|
|
|
|
IF(NOT SHOULD_PASS)
|
|
MESSAGE(SEND_ERROR "should pass failed ${TRY_OUT}")
|
|
ENDIF(NOT SHOULD_PASS)
|
|
IF(NOT EXISTS "${TryCompile_BINARY_DIR}/CopyOfPass")
|
|
MESSAGE(SEND_ERROR "COPY_FILE to \"${TryCompile_BINARY_DIR}/CopyOfPass\" failed")
|
|
ELSE(NOT EXISTS "${TryCompile_BINARY_DIR}/CopyOfPass")
|
|
FILE(REMOVE "${TryCompile_BINARY_DIR}/CopyOfPass")
|
|
ENDIF(NOT EXISTS "${TryCompile_BINARY_DIR}/CopyOfPass")
|
|
|
|
# try to compile a file that should not compile
|
|
TRY_COMPILE(SHOULD_FAIL
|
|
${TryCompile_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
|
|
${TryCompile_SOURCE_DIR}/fail.c
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
IF(SHOULD_FAIL)
|
|
MESSAGE(SEND_ERROR "Should fail passed ${TRY_OUT}")
|
|
ENDIF(SHOULD_FAIL)
|
|
|
|
# try to compile a file that should compile
|
|
TRY_COMPILE(SHOULD_PASS
|
|
${TryCompile_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
|
|
${TryCompile_SOURCE_DIR}/pass.c
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
IF(NOT SHOULD_PASS)
|
|
MESSAGE(SEND_ERROR "should pass failed ${TRY_OUT}")
|
|
ENDIF(NOT SHOULD_PASS)
|
|
|
|
# try to compile a file that should not compile
|
|
TRY_COMPILE(SHOULD_FAIL
|
|
${TryCompile_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
|
|
${TryCompile_SOURCE_DIR}/fail.c
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
IF(SHOULD_FAIL)
|
|
MESSAGE(SEND_ERROR "Should fail passed ${TRY_OUT}")
|
|
ENDIF(SHOULD_FAIL)
|
|
|
|
IF(NOT SHOULD_FAIL)
|
|
IF(SHOULD_PASS)
|
|
MESSAGE("All Tests passed, ignore all previous output.")
|
|
ELSE(SHOULD_PASS)
|
|
MESSAGE("Test failed")
|
|
ENDIF(SHOULD_PASS)
|
|
ELSE(NOT SHOULD_FAIL)
|
|
MESSAGE("Test failed")
|
|
ENDIF(NOT SHOULD_FAIL)
|
|
TRY_COMPILE(CMAKE_ANSI_FOR_SCOPE
|
|
${TryCompile_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
|
|
${CMAKE_ROOT}/Modules/TestForAnsiForScope.cxx OUTPUT_VARIABLE OUT)
|
|
IF (CMAKE_ANSI_FOR_SCOPE)
|
|
MESSAGE("Compiler supports ansi for")
|
|
ELSE(CMAKE_ANSI_FOR_SCOPE)
|
|
MESSAGE("Compiler does not support ansi for scope")
|
|
ENDIF(CMAKE_ANSI_FOR_SCOPE)
|
|
|
|
TRY_COMPILE(CMAKE_ANSI_FOR_SCOPE
|
|
${TryCompile_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
|
|
${CMAKE_ROOT}/Modules/TestForAnsiForScope.cxx OUTPUT_VARIABLE OUT)
|
|
IF (CMAKE_ANSI_FOR_SCOPE)
|
|
MESSAGE("Compiler supports ansi for")
|
|
ELSE(CMAKE_ANSI_FOR_SCOPE)
|
|
MESSAGE("Compiler does not support ansi for scope")
|
|
ENDIF(CMAKE_ANSI_FOR_SCOPE)
|
|
|
|
MESSAGE("use the module now")
|
|
INCLUDE(${CMAKE_ROOT}/Modules/TestForANSIForScope.cmake)
|
|
IF (CMAKE_ANSI_FOR_SCOPE)
|
|
MESSAGE("Compiler supports ansi for")
|
|
ELSE(CMAKE_ANSI_FOR_SCOPE)
|
|
MESSAGE("Compiler does not support ansi for scope")
|
|
ENDIF(CMAKE_ANSI_FOR_SCOPE)
|
|
|
|
ADD_EXECUTABLE(TryCompile pass.c)
|
|
|
|
######################################
|
|
|
|
# now two tests for TRY_RUN
|
|
|
|
# try to run a file that should compile and run without error
|
|
# also check that OUTPUT_VARIABLE contains both the compile output
|
|
# and the run output
|
|
TRY_RUN(SHOULD_RUN SHOULD_COMPILE
|
|
${TryCompile_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
|
|
${TryCompile_SOURCE_DIR}/exit_success.c
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
IF(NOT SHOULD_COMPILE)
|
|
MESSAGE(SEND_ERROR "exit_success failed compiling: ${TRY_OUT}")
|
|
ENDIF(NOT SHOULD_COMPILE)
|
|
IF(NOT "${SHOULD_RUN}" STREQUAL "0")
|
|
MESSAGE(SEND_ERROR "exit_success failed running with exit code ${SHOULD_RUN}")
|
|
ENDIF(NOT "${SHOULD_RUN}" STREQUAL "0")
|
|
# check the compile output for the filename
|
|
IF(NOT "${TRY_OUT}" MATCHES "exit_success")
|
|
MESSAGE(SEND_ERROR " TRY_OUT didn't contain \"exit_success\": \"${TRY_OUT}\"")
|
|
ENDIF(NOT "${TRY_OUT}" MATCHES "exit_success")
|
|
# check the run output
|
|
IF(NOT "${TRY_OUT}" MATCHES "hello world")
|
|
MESSAGE(SEND_ERROR " TRY_OUT didn't contain \"hello world\": \"${TRY_OUT}\"")
|
|
ENDIF(NOT "${TRY_OUT}" MATCHES "hello world")
|
|
|
|
|
|
# try to run a file that should compile and run, but return an error
|
|
TRY_RUN(SHOULD_EXIT_WITH_ERROR SHOULD_COMPILE
|
|
${TryCompile_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
|
|
${TryCompile_SOURCE_DIR}/exit_with_error.c
|
|
COMPILE_OUTPUT_VARIABLE COMPILE_OUTPUT
|
|
RUN_OUTPUT_VARIABLE RUN_OUTPUT)
|
|
|
|
IF(NOT SHOULD_COMPILE)
|
|
MESSAGE(STATUS " exit_with_error failed compiling: ${COMPILE_OUTPUT}")
|
|
ENDIF(NOT SHOULD_COMPILE)
|
|
IF("${SHOULD_EXIT_WITH_ERROR}" STREQUAL "0")
|
|
MESSAGE(SEND_ERROR " exit_with_error passed with exit code ${SHOULD_EXIT_WITH_ERROR}")
|
|
ENDIF("${SHOULD_EXIT_WITH_ERROR}" STREQUAL "0")
|
|
|
|
# check the compile output, it should contain the filename
|
|
IF(NOT "${COMPILE_OUTPUT}" MATCHES "exit_with_error")
|
|
MESSAGE(SEND_ERROR " COMPILE_OUT didn't contain \"exit_with_error\": \"${COMPILE_OUTPUT}\"")
|
|
ENDIF(NOT "${COMPILE_OUTPUT}" MATCHES "exit_with_error")
|
|
#... but not the run time output
|
|
IF("${COMPILE_OUTPUT}" MATCHES "hello world")
|
|
MESSAGE(SEND_ERROR " COMPILE_OUT contains the run output: \"${COMPILE_OUTPUT}\"")
|
|
ENDIF("${COMPILE_OUTPUT}" MATCHES "hello world")
|
|
# check the run output, it should stdout
|
|
IF(NOT "${RUN_OUTPUT}" MATCHES "hello world")
|
|
MESSAGE(SEND_ERROR " RUN_OUTPUT didn't contain \"hello world\": \"${RUN_OUTPUT}\"")
|
|
ENDIF(NOT "${RUN_OUTPUT}" MATCHES "hello world")
|
|
|
|
#######################################################################
|
|
#
|
|
# 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 dont 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 dont build" CXX_BUILD_SHOULD_FAIL)
|
|
CHECK_CXX_SOURCE_COMPILES("int main() {return 0;}" CXX_BUILD_SHOULD_WORK)
|
|
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_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")
|
|
|
|
|