You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
277 lines
9.2 KiB
277 lines
9.2 KiB
# try to compile a file that should compile
|
|
try_compile(SHOULD_PASS
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/pass.c
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
EXPECT_PASS(SHOULD_PASS "${TRY_OUT}")
|
|
|
|
# try to compile a file that should compile
|
|
# also check that COPY_FILE works
|
|
try_compile(SHOULD_PASS
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/pass.c
|
|
OUTPUT_VARIABLE TRY_OUT
|
|
COPY_FILE ${TryCompile_BINARY_DIR}/CopyOfPass
|
|
)
|
|
EXPECT_PASS(SHOULD_PASS "${TRY_OUT}")
|
|
|
|
if(NOT EXISTS "${TryCompile_BINARY_DIR}/CopyOfPass")
|
|
message(SEND_ERROR "COPY_FILE to \"${TryCompile_BINARY_DIR}/CopyOfPass\" failed")
|
|
else()
|
|
file(REMOVE "${TryCompile_BINARY_DIR}/CopyOfPass")
|
|
endif()
|
|
|
|
# try to compile a file that should compile
|
|
# also check that COPY_FILE_ERROR works
|
|
file(WRITE ${TryCompile_BINARY_DIR}/invalid "")
|
|
try_compile(SHOULD_PASS
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/pass.c
|
|
OUTPUT_VARIABLE TRY_OUT
|
|
COPY_FILE ${TryCompile_BINARY_DIR}/invalid/path
|
|
COPY_FILE_ERROR _captured
|
|
)
|
|
EXPECT_PASS(SHOULD_PASS "${TRY_OUT}")
|
|
|
|
if(NOT _captured MATCHES "Cannot copy output executable.*/invalid/path")
|
|
message(SEND_ERROR "COPY_FILE_ERROR did not capture expected message")
|
|
endif()
|
|
|
|
# try to compile a file that should not compile
|
|
try_compile(SHOULD_FAIL
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/fail.c
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
EXPECT_FAIL(SHOULD_FAIL "${TRY_OUT}")
|
|
|
|
# try to compile two files that should compile
|
|
try_compile(SHOULD_PASS
|
|
${try_compile_bindir_or_SOURCES}
|
|
${try_compile_redundant_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/pass2a.c
|
|
${TryCompile_SOURCE_DIR}/pass2b.cxx
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
EXPECT_PASS(SHOULD_PASS "${TRY_OUT}")
|
|
|
|
# try to compile two files that should not compile
|
|
try_compile(SHOULD_FAIL
|
|
${try_compile_bindir_or_SOURCES}
|
|
${try_compile_redundant_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/fail2a.c
|
|
${TryCompile_SOURCE_DIR}/fail2b.c
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
EXPECT_FAIL(SHOULD_FAIL "${TRY_OUT}")
|
|
|
|
# try to compile a file that should compile
|
|
set(_c_flags "${CMAKE_C_FLAGS}")
|
|
if(WATCOM)
|
|
string(APPEND CMAKE_C_FLAGS " -dTESTDEF")
|
|
else()
|
|
string(APPEND CMAKE_C_FLAGS " \"-DTESTDEF\"")
|
|
endif()
|
|
try_compile(SHOULD_PASS
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/testdef.c
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
EXPECT_PASS(SHOULD_PASS "${TRY_OUT}")
|
|
set(CMAKE_C_FLAGS "${_c_flags}")
|
|
|
|
try_compile(CMAKE_ANSI_FOR_SCOPE
|
|
${try_compile_bindir_or_SOURCES}
|
|
${CMAKE_ROOT}/Modules/TestForAnsiForScope.cxx OUTPUT_VARIABLE OUT)
|
|
if(CMAKE_ANSI_FOR_SCOPE)
|
|
message("Compiler supports ansi for")
|
|
else()
|
|
message("Compiler does not support ansi for scope")
|
|
endif()
|
|
|
|
message("use the module now")
|
|
include(${CMAKE_ROOT}/Modules/TestForANSIForScope.cmake)
|
|
if(CMAKE_ANSI_FOR_SCOPE)
|
|
message("Compiler supports ansi for")
|
|
else()
|
|
message("Compiler does not support ansi for scope")
|
|
endif()
|
|
|
|
# test that COMPILE_DEFINITIONS are correctly expanded
|
|
try_compile(COMPILE_DEFINITIONS_LIST_EXPANDED
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/check_a_b.c
|
|
OUTPUT_VARIABLE output
|
|
COMPILE_DEFINITIONS "-DDEF_A;-DDEF_B"
|
|
)
|
|
if(COMPILE_DEFINITIONS_LIST_EXPANDED)
|
|
message(STATUS "COMPILE_DEFINITIONS list expanded correctly")
|
|
else()
|
|
string(REPLACE "\n" "\n " output " ${output}")
|
|
message(SEND_ERROR "COMPILE_DEFINITIONS list did not expand correctly\n${output}")
|
|
endif()
|
|
|
|
# try to compile a file that doesn't exist
|
|
try_compile(SHOULD_FAIL_DUE_TO_BAD_SOURCE
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/pass.c
|
|
OUTPUT_VARIABLE output
|
|
COMPILE_DEFINITIONS "bad#source.c"
|
|
)
|
|
if(SHOULD_FAIL_DUE_TO_BAD_SOURCE AND NOT CMAKE_GENERATOR MATCHES "Watcom WMake|NMake Makefiles")
|
|
string(REPLACE "\n" "\n " output " ${output}")
|
|
message(SEND_ERROR "try_compile with bad#source.c did not fail:\n${output}")
|
|
elseif(NOT output MATCHES [[(bad#source\.c|bad\.c|bad[':])]])
|
|
string(REPLACE "\n" "\n " output " ${output}")
|
|
message(SEND_ERROR "try_compile with bad#source.c failed without mentioning bad source:\n${output}")
|
|
else()
|
|
message(STATUS "try_compile with bad#source.c correctly failed")
|
|
endif()
|
|
|
|
if(APPLE)
|
|
# try to compile a file that should compile
|
|
try_compile(SHOULD_PASS
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/pass.m
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
EXPECT_PASS(SHOULD_PASS "${TRY_OUT}")
|
|
|
|
# try to compile a file that should not compile
|
|
try_compile(SHOULD_FAIL
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/fail.m
|
|
OUTPUT_VARIABLE TRY_OUT)
|
|
EXPECT_FAIL(SHOULD_FAIL "${TRY_OUT}")
|
|
endif()
|
|
|
|
# check that try_compile honors NO_CACHE
|
|
function(try_compile_scope_test)
|
|
try_compile(
|
|
CACHED_RESULT
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/pass.c)
|
|
try_compile(
|
|
SHOULD_NOT_ESCAPE_SCOPE_RESULT
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/pass.c
|
|
NO_CACHE)
|
|
endfunction()
|
|
|
|
try_compile_scope_test()
|
|
|
|
if(NOT DEFINED CACHE{CACHED_RESULT})
|
|
message(SEND_ERROR " Result from try_compile was not cached")
|
|
endif()
|
|
if(DEFINED SHOULD_NOT_ESCAPE_SCOPE_RESULT)
|
|
message(SEND_ERROR " Result from try_compile(NO_CACHE) leaked")
|
|
endif()
|
|
|
|
######################################
|
|
|
|
# now test 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
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/exit_success.c
|
|
${try_compile_output_vars})
|
|
EXPECT_COMPILED("exit_success" SHOULD_COMPILE "${${try_compile_compile_output_var}}")
|
|
EXPECT_RUN_RESULT("exit_success" SHOULD_RUN 0)
|
|
|
|
# check the compile output for the filename
|
|
if(NOT "${${try_compile_compile_output_var}}" MATCHES "exit_success")
|
|
message(SEND_ERROR
|
|
" ${try_compile_compile_output_var} didn't contain \"exit_success\":"
|
|
" \"${${try_compile_compile_output_var}}\"")
|
|
endif()
|
|
# check the run output
|
|
if(NOT "${${try_compile_run_output_var}}" MATCHES "hello world")
|
|
message(SEND_ERROR
|
|
" ${try_compile_run_output_var} didn't contain \"hello world\":"
|
|
" \"${${try_compile_run_output_var}}\"")
|
|
endif()
|
|
|
|
try_run(ARG_TEST_RUN ARG_TEST_COMPILE
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/expect_arg.c
|
|
COMPILE_OUTPUT_VARIABLE TRY_OUT
|
|
ARGS arg1 arg2)
|
|
EXPECT_COMPILED("expect_arg" ARG_TEST_COMPILE "${TRY_OUT}")
|
|
EXPECT_RUN_RESULT("expect_arg" ARG_TEST_RUN 0)
|
|
|
|
# try to run a file that should compile and run, but return an error
|
|
try_run(SHOULD_EXIT_WITH_ERROR SHOULD_COMPILE
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/exit_with_error.c
|
|
COMPILE_OUTPUT_VARIABLE COMPILE_OUTPUT
|
|
RUN_OUTPUT_VARIABLE RUN_OUTPUT)
|
|
EXPECT_COMPILED("exit_with_error" SHOULD_COMPILE "${COMPILE_OUTPUT}")
|
|
EXPECT_RUN_RESULT("exit_with_error" SHOULD_EXIT_WITH_ERROR 1)
|
|
|
|
# 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()
|
|
#... but not the run time output
|
|
if("${COMPILE_OUTPUT}" MATCHES "hello world")
|
|
message(SEND_ERROR " COMPILE_OUT contains the run output: \"${COMPILE_OUTPUT}\"")
|
|
endif()
|
|
# check the run output, it should contain stdout
|
|
if(NOT "${RUN_OUTPUT}" MATCHES "hello world")
|
|
message(SEND_ERROR " RUN_OUTPUT didn't contain \"hello world\": \"${RUN_OUTPUT}\"")
|
|
endif()
|
|
|
|
# try to run a file and parse stdout and stderr separately
|
|
# also check that COPY_FILE works
|
|
try_run(SHOULD_EXIT_WITH_ERROR SHOULD_COMPILE
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/stdout_and_stderr.c
|
|
COPY_FILE ${TryCompile_BINARY_DIR}/CopyOfRun
|
|
COMPILE_OUTPUT_VARIABLE COMPILE_OUTPUT
|
|
RUN_OUTPUT_STDOUT_VARIABLE RUN_OUTPUT_STDOUT
|
|
RUN_OUTPUT_STDERR_VARIABLE RUN_OUTPUT_STDERR)
|
|
EXPECT_PASS(SHOULD_COMPILE "${COMPILE_OUTPUT}")
|
|
|
|
if(NOT EXISTS "${TryCompile_BINARY_DIR}/CopyOfRun")
|
|
message(SEND_ERROR "COPY_FILE to \"${TryCompile_BINARY_DIR}/CopyOfRun\" failed")
|
|
else()
|
|
file(REMOVE "${TryCompile_BINARY_DIR}/CopyOfRun")
|
|
endif()
|
|
|
|
# check the run stdout output
|
|
if(NOT "${RUN_OUTPUT_STDOUT}" MATCHES "hello world")
|
|
message(SEND_ERROR " RUN_OUTPUT_STDOUT didn't contain \"hello world\": \"${RUN_OUTPUT_STDOUT}\"")
|
|
endif()
|
|
# check the run stderr output
|
|
if(NOT "${RUN_OUTPUT_STDERR}" MATCHES "error")
|
|
message(SEND_ERROR " RUN_OUTPUT_STDERR didn't contain \"error\": \"${RUN_OUTPUT_STDERR}\"")
|
|
endif()
|
|
|
|
# check that try_run honors NO_CACHE
|
|
function(try_run_scope_test)
|
|
try_run(
|
|
CACHED_RUN_RESULT
|
|
CACHED_COMPILE_RESULT
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/exit_success.c)
|
|
try_run(
|
|
SHOULD_NOT_ESCAPE_SCOPE_RUN_RESULT
|
|
SHOULD_NOT_ESCAPE_SCOPE_COMPILE_RESULT
|
|
${try_compile_bindir_or_SOURCES}
|
|
${TryCompile_SOURCE_DIR}/exit_success.c
|
|
NO_CACHE)
|
|
endfunction()
|
|
|
|
try_run_scope_test()
|
|
|
|
if(NOT DEFINED CACHE{CACHED_COMPILE_RESULT})
|
|
message(SEND_ERROR " Compile result from try_run was not cached")
|
|
endif()
|
|
if(NOT DEFINED CACHE{CACHED_RUN_RESULT})
|
|
message(SEND_ERROR " Run result from try_run was not cached")
|
|
endif()
|
|
if(DEFINED SHOULD_NOT_ESCAPE_SCOPE_COMPILE_RESULT)
|
|
message(SEND_ERROR " Compile result from try_run(NO_CACHE) leaked")
|
|
endif()
|
|
if(DEFINED SHOULD_NOT_ESCAPE_SCOPE_RUN_RESULT)
|
|
message(SEND_ERROR " Run result from try_run(NO_CACHE) leaked")
|
|
endif()
|