mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2025-12-31 10:50:16 -06:00
Code Issues Packages Projects Releases Wiki Activity

try_compile: Add keyword-dispatched signature

Browse Source 
Introduce a new signature for try_compile (and try_run) which removes
the `bindir` argument and requires the SOURCES tag. This will eventually
allow us to add other ways of providing sources, but also allows us to
change the behavior without breaking compatibility.

The old signature uses a special, but non-unique temporary location
inside the specified `bindir`, which conventionally is just the
project's build directory. The new signature unconditionally uses the a
unique temporary directory which is unconditionally within the project's
build directory (which is no longer separately specified). This ensures
that successive runs do not overwrite previous runs, will simplify
debugging, and should also, eventually, allow us to execute multiple
trials in parallel.
This commit is contained in:
Matthew Woehlke
2022-09-02 10:21:12 -04:00
parent d1befe5515
commit aa9220d3a0
78 changed files with 781 additions and 467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
Help/command/try_compile.rst
View File

@@ -41,7 +41,7 @@ Try Compiling Source Files
.. code-block:: cmake
try_compile(<resultVar> <bindir> <srcfile|SOURCES srcfile...>
try_compile(<resultVar> SOURCES <srcfile...>
[CMAKE_FLAGS <flags>...]
[COMPILE_DEFINITIONS <defs>...]
[LINK_OPTIONS <options>...]
@@ -53,6 +53,8 @@ Try Compiling Source Files
[<LANG>_EXTENSIONS <bool>]
)
.. versionadded:: 3.25
Try building an executable or static library from one or more source files
(which one is determined by the :variable:`CMAKE_TRY_COMPILE_TARGET_TYPE`
variable). The success or failure of the ``try_compile``, i.e. ``TRUE`` or
@@ -76,6 +78,39 @@ contain something like the following:
target_link_options(cmTryCompileExec PRIVATE <LINK_OPTIONS from caller>)
target_link_libraries(cmTryCompileExec ${LINK_LIBRARIES})
CMake will automatically generate a unique directory for each ``try_compile``
operation in an unspecified location within the project's binary directory.
These directories will be cleaned automatically unless
:option:`--debug-trycompile <cmake --debug-trycompile>` is passed to ``cmake``.
Such directories from previous runs are also unconditionally cleaned at the
beginning of any ``cmake`` execution.
This command also supports an alternate signature
which was present in older versions of CMake:
.. code-block:: cmake
try_compile(<resultVar> <bindir> <srcfile|SOURCES srcfile...>
[CMAKE_FLAGS <flags>...]
[COMPILE_DEFINITIONS <defs>...]
[LINK_OPTIONS <options>...]
[LINK_LIBRARIES <libs>...]
[OUTPUT_VARIABLE <var>]
[COPY_FILE <fileName> [COPY_FILE_ERROR <var>]]
[<LANG>_STANDARD <std>]
[<LANG>_STANDARD_REQUIRED <bool>]
[<LANG>_EXTENSIONS <bool>]
)
In this version, ``try_compile`` will use ``<bindir>/CMakeFiles/CMakeTmp`` for
its operation, and all such files will be cleaned automatically.
For debugging, :option:`--debug-trycompile <cmake --debug-trycompile>` can be
passed to ``cmake`` to avoid this clean. However, multiple sequential
``try_compile`` operations, if given the same ``<bindir>``, will reuse this
single output directory, such that you can only debug one such ``try_compile``
call at a time. Use of the newer signature is recommended to simplify
debugging of multiple ``try_compile`` operations.
The options are:
``CMAKE_FLAGS <flags>...``
@@ -136,18 +171,6 @@ The options are:
:prop_tgt:`OBJC_EXTENSIONS`, :prop_tgt:`OBJCXX_EXTENSIONS`,
or :prop_tgt:`CUDA_EXTENSIONS` target property of the generated project.
In this version all files in ``<bindir>/CMakeFiles/CMakeTmp`` will be
cleaned automatically. For debugging,
:option:`--debug-trycompile <cmake --debug-trycompile>` can be
passed to ``cmake`` to avoid this clean. However, multiple sequential
``try_compile`` operations reuse this single output directory. If you use
:option:`--debug-trycompile <cmake --debug-trycompile>`, you can only debug
one ``try_compile`` call at a time. The recommended procedure is to protect
all ``try_compile`` calls in your project by ``if(NOT DEFINED <resultVar>)``
logic, configure with cmake all the way through once, then delete the cache
entry associated with the try_compile call of interest, and then re-run cmake
again with :option:`--debug-trycompile <cmake --debug-trycompile>`.
Other Behavior Settings
^^^^^^^^^^^^^^^^^^^^^^^

76
Help/command/try_run.rst
View File

@@ -12,62 +12,68 @@ Try Compiling and Running Source Files
.. code-block:: cmake
try_run(<runResultVar> <compileResultVar>
<bindir> <srcfile> [CMAKE_FLAGS <flags>...]
try_run(<runResultVar> <compileResultVar> SOURCES <srcfile...>
[CMAKE_FLAGS <flags>...]
[COMPILE_DEFINITIONS <defs>...]
[LINK_OPTIONS <options>...]
[LINK_LIBRARIES <libs>...]
[COMPILE_OUTPUT_VARIABLE <var>]
[COPY_FILE <fileName> [COPY_FILE_ERROR <var>]]
[<LANG>_STANDARD <std>]
[<LANG>_STANDARD_REQUIRED <bool>]
[<LANG>_EXTENSIONS <bool>]
[RUN_OUTPUT_VARIABLE <var>]
[RUN_OUTPUT_STDOUT_VARIABLE <var>]
[RUN_OUTPUT_STDERR_VARIABLE <var>]
[OUTPUT_VARIABLE <var>]
[WORKING_DIRECTORY <var>]
[ARGS <args>...])
[ARGS <args>...]
)
.. versionadded:: 3.25
Try compiling a ``<srcfile>``. Returns ``TRUE`` or ``FALSE`` for success
or failure in ``<compileResultVar>``. If the compile succeeded, runs the
executable and returns its exit code in ``<runResultVar>``. If the
executable was built, but failed to run, then ``<runResultVar>`` will be
set to ``FAILED_TO_RUN``. See the :command:`try_compile` command for
information on how the test project is constructed to build the source file.
documentation of options common to both commands, and for information on how
the test project is constructed to build the source file.
The options are:
This command also supports an alternate signature
which was present in older versions of CMake:
``CMAKE_FLAGS <flags>...``
Specify flags of the form :option:`-DVAR:TYPE=VALUE <cmake -D>` to be passed
to the :manual:`cmake(1)` command-line used to drive the test build.
The example in :command:`try_compile` shows how values for variables
``INCLUDE_DIRECTORIES``, ``LINK_DIRECTORIES``, and ``LINK_LIBRARIES``
are used.
.. code-block:: cmake
``COMPILE_DEFINITIONS <defs>...``
Specify ``-Ddefinition`` arguments to pass to :command:`add_definitions`
in the generated test project.
try_run(<runResultVar> <compileResultVar>
<bindir> <srcfile|SOURCES srcfile...>
[CMAKE_FLAGS <flags>...]
[COMPILE_DEFINITIONS <defs>...]
[LINK_OPTIONS <options>...]
[LINK_LIBRARIES <libs>...]
[COMPILE_OUTPUT_VARIABLE <var>]
[COPY_FILE <fileName> [COPY_FILE_ERROR <var>]]
[<LANG>_STANDARD <std>]
[<LANG>_STANDARD_REQUIRED <bool>]
[<LANG>_EXTENSIONS <bool>]
[RUN_OUTPUT_VARIABLE <var>]
[RUN_OUTPUT_STDOUT_VARIABLE <var>]
[RUN_OUTPUT_STDERR_VARIABLE <var>]
[OUTPUT_VARIABLE <var>]
[WORKING_DIRECTORY <var>]
[ARGS <args>...]
)
The options specific to ``try_run`` are:
``COMPILE_OUTPUT_VARIABLE <var>``
Report the compile step build output in a given variable.
``LINK_LIBRARIES <libs>...``
.. versionadded:: 3.2
Specify libraries to be linked in the generated project.
The list of libraries may refer to system libraries and to
:ref:`Imported Targets <Imported Targets>` from the calling project.
If this option is specified, any ``-DLINK_LIBRARIES=...`` value
given to the ``CMAKE_FLAGS`` option will be ignored.
``LINK_OPTIONS <options>...``
.. versionadded:: 3.14
Specify link step options to pass to :command:`target_link_options` in the
generated project.
``OUTPUT_VARIABLE <var>``
Report the compile build output and the output from running the executable
in the given variable. This option exists for legacy reasons. Prefer
``COMPILE_OUTPUT_VARIABLE`` and ``RUN_OUTPUT_VARIABLE`` instead.
in the given variable. This option exists for legacy reasons and is only
supported by the old ``try_run`` signature.
Prefer ``COMPILE_OUTPUT_VARIABLE`` and ``RUN_OUTPUT_VARIABLE`` instead.
``RUN_OUTPUT_VARIABLE <var>``
Report the output from running the executable in a given variable.
@@ -86,7 +92,11 @@ The options are:
.. versionadded:: 3.20
Run the executable in the given directory. If no ``WORKING_DIRECTORY`` is
specified, the executable will run in ``<bindir>``.
specified, the executable will run in ``<bindir>`` or the current build
directory.
``ARGS <args>...``
Additional arguments to pass to the executable when running it.
Other Behavior Settings
^^^^^^^^^^^^^^^^^^^^^^^

8
Help/release/dev/try_compile-signatures.rst Normal file
View File

@@ -0,0 +1,8 @@
try_compile-signatures
----------------------
* The :command:`try_compile` and :command:`try_run` commands gained new
signatures that more consistently use keyword dispatch and do not require a
binary directory to be specified. Additionally, these signatures use a
unique directory for each invocation, which allows multiple outputs to be
preserved when using ``--debug-trycompile``.

103
Source/cmCoreTryCompile.cxx
View File

@@ -31,6 +31,7 @@
#include "cmake.h"
namespace {
constexpr const char* unique_binary_directory = "CMAKE_BINARY_DIR_USE_MKDTEMP";
constexpr size_t lang_property_start = 0;
constexpr size_t lang_property_size = 4;
constexpr size_t pie_property_start = 4;
@@ -122,13 +123,9 @@ ArgumentParser::Continue TryCompileCompileDefs(Arguments& args,
.Bind(#lang "_STANDARD_REQUIRED"_s, TryCompileLangProp) \
.Bind(#lang "_EXTENSIONS"_s, TryCompileLangProp)
auto const TryCompileArgParser =
auto const TryCompileBaseArgParser =
cmArgumentParser<Arguments>{}
.Bind(0, &Arguments::CompileResultVariable)
.Bind(1, &Arguments::BinaryDirectory)
.Bind(2, &Arguments::SourceDirectoryOrFile)
.Bind(3, &Arguments::ProjectName)
.Bind(4, &Arguments::TargetName)
.Bind("SOURCES"_s, &Arguments::Sources)
.Bind("CMAKE_FLAGS"_s, &Arguments::CMakeFlags)
.Bind("COMPILE_DEFINITIONS"_s, TryCompileCompileDefs,
@@ -136,7 +133,6 @@ auto const TryCompileArgParser =
.Bind("LINK_LIBRARIES"_s, &Arguments::LinkLibraries)
.Bind("LINK_OPTIONS"_s, &Arguments::LinkOptions)
.Bind("__CMAKE_INTERNAL"_s, &Arguments::CMakeInternal)
.Bind("OUTPUT_VARIABLE"_s, &Arguments::OutputVariable)
.Bind("COPY_FILE"_s, &Arguments::CopyFileTo)
.Bind("COPY_FILE_ERROR"_s, &Arguments::CopyFileError)
.BIND_LANG_PROPS(C)
@@ -147,8 +143,31 @@ auto const TryCompileArgParser =
.BIND_LANG_PROPS(OBJCXX)
/* keep semicolon on own line */;
auto const TryRunArgParser =
auto const TryCompileArgParser =
cmArgumentParser<Arguments>{ TryCompileBaseArgParser }.Bind(
"OUTPUT_VARIABLE"_s, &Arguments::OutputVariable)
/* keep semicolon on own line */;
auto const TryCompileOldArgParser =
cmArgumentParser<Arguments>{ TryCompileArgParser }
.Bind(1, &Arguments::BinaryDirectory)
.Bind(2, &Arguments::SourceDirectoryOrFile)
.Bind(3, &Arguments::ProjectName)
.Bind(4, &Arguments::TargetName)
/* keep semicolon on own line */;
auto const TryRunArgParser =
cmArgumentParser<Arguments>{ TryCompileBaseArgParser }
.Bind("COMPILE_OUTPUT_VARIABLE"_s, &Arguments::CompileOutputVariable)
.Bind("RUN_OUTPUT_VARIABLE"_s, &Arguments::RunOutputVariable)
.Bind("RUN_OUTPUT_STDOUT_VARIABLE"_s, &Arguments::RunOutputStdOutVariable)
.Bind("RUN_OUTPUT_STDERR_VARIABLE"_s, &Arguments::RunOutputStdErrVariable)
.Bind("WORKING_DIRECTORY"_s, &Arguments::RunWorkingDirectory)
.Bind("ARGS"_s, &Arguments::RunArgs)
/* keep semicolon on own line */;
auto const TryRunOldArgParser =
cmArgumentParser<Arguments>{ TryCompileOldArgParser }
.Bind("COMPILE_OUTPUT_VARIABLE"_s, &Arguments::CompileOutputVariable)
.Bind("RUN_OUTPUT_VARIABLE"_s, &Arguments::RunOutputVariable)
.Bind("RUN_OUTPUT_STDOUT_VARIABLE"_s, &Arguments::RunOutputStdOutVariable)
@@ -161,10 +180,10 @@ auto const TryRunArgParser =
}
Arguments cmCoreTryCompile::ParseArgs(
cmRange<std::vector<std::string>::const_iterator> args, bool isTryRun)
const cmRange<std::vector<std::string>::const_iterator>& args,
const cmArgumentParser<Arguments>& parser,
std::vector<std::string>& unparsedArguments)
{
std::vector<std::string> unparsedArguments;
const auto& parser = (isTryRun ? TryRunArgParser : TryCompileArgParser);
auto arguments = parser.Parse(args, &unparsedArguments, 0);
if (!arguments.MaybeReportError(*(this->Makefile)) &&
!unparsedArguments.empty()) {
@@ -174,6 +193,26 @@ Arguments cmCoreTryCompile::ParseArgs(
}
this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, m);
}
return arguments;
}
Arguments cmCoreTryCompile::ParseArgs(
cmRange<std::vector<std::string>::const_iterator> args, bool isTryRun)
{
std::vector<std::string> unparsedArguments;
if (cmHasLiteralPrefix(*(++args.begin()), "SOURCE")) {
// New signature.
auto arguments =
this->ParseArgs(args, isTryRun ? TryRunArgParser : TryCompileArgParser,
unparsedArguments);
arguments.BinaryDirectory = unique_binary_directory;
return arguments;
}
// Old signature.
auto arguments = this->ParseArgs(
args, isTryRun ? TryRunOldArgParser : TryCompileOldArgParser,
unparsedArguments);
// For historical reasons, treat some empty-valued keyword
// arguments as if they were not specified at all.
if (arguments.OutputVariable && arguments.OutputVariable->empty()) {
@@ -210,6 +249,7 @@ bool cmCoreTryCompile::TryCompileCode(Arguments& arguments,
// which signature were we called with ?
this->SrcFileSignature = true;
bool useUniqueBinaryDirectory = false;
std::string sourceDirectory;
std::string projectName;
std::string targetName;
@@ -230,7 +270,17 @@ bool cmCoreTryCompile::TryCompileCode(Arguments& arguments,
targetName = targetNameBuf;
}
if (arguments.BinaryDirectory && !arguments.BinaryDirectory->empty()) {
if (!arguments.BinaryDirectory || arguments.BinaryDirectory->empty()) {
this->Makefile->IssueMessage(MessageType::FATAL_ERROR,
"No <bindir> specified.");
return false;
}
if (*arguments.BinaryDirectory == unique_binary_directory) {
// leave empty until we're ready to create it, so we don't try to remove
// a non-existing directory if we abort due to e.g. bad arguments
this->BinaryDirectory.clear();
useUniqueBinaryDirectory = true;
} else {
if (!cmSystemTools::FileIsFullPath(*arguments.BinaryDirectory)) {
this->Makefile->IssueMessage(
MessageType::FATAL_ERROR,
@@ -244,10 +294,6 @@ bool cmCoreTryCompile::TryCompileCode(Arguments& arguments,
if (this->SrcFileSignature) {
this->BinaryDirectory += "/CMakeFiles/CMakeTmp";
}
} else {
this->Makefile->IssueMessage(MessageType::FATAL_ERROR,
"No <bindir> specified.");
return false;
}
std::vector<std::string> targets;
@@ -331,7 +377,14 @@ bool cmCoreTryCompile::TryCompileCode(Arguments& arguments,
}
}
// make sure the binary directory exists
cmSystemTools::MakeDirectory(this->BinaryDirectory);
if (useUniqueBinaryDirectory) {
this->BinaryDirectory =
cmStrCat(this->Makefile->GetHomeOutputDirectory(),
"/CMakeFiles/CMakeScratch/TryCompile-XXXXXX");
cmSystemTools::MakeTempDirectory(this->BinaryDirectory);
} else {
cmSystemTools::MakeDirectory(this->BinaryDirectory);
}
// do not allow recursive try Compiles
if (this->BinaryDirectory == this->Makefile->GetHomeOutputDirectory()) {
@@ -635,7 +688,7 @@ bool cmCoreTryCompile::TryCompileCode(Arguments& arguments,
fprintf(fout, " \"%s\"", si.c_str());
// Add dependencies on any non-temporary sources.
if (si.find("CMakeTmp") == std::string::npos) {
if (!IsTemporary(si)) {
this->Makefile->AddCMakeDependFile(si);
}
}
@@ -914,17 +967,23 @@ bool cmCoreTryCompile::TryCompileCode(Arguments& arguments,
return res == 0;
}
bool cmCoreTryCompile::IsTemporary(std::string const& path)
{
return ((path.find("CMakeTmp") != std::string::npos) ||
(path.find("CMakeScratch") != std::string::npos));
}
void cmCoreTryCompile::CleanupFiles(std::string const& binDir)
{
if (binDir.empty()) {
return;
}
if (binDir.find("CMakeTmp") == std::string::npos) {
if (!IsTemporary(binDir)) {
cmSystemTools::Error(
"TRY_COMPILE attempt to remove -rf directory that does not contain "
"CMakeTmp:" +
binDir);
"CMakeTmp or CMakeScratch: \"" +
binDir + "\"");
return;
}
@@ -970,6 +1029,10 @@ void cmCoreTryCompile::CleanupFiles(std::string const& binDir)
}
}
}
if (binDir.find("CMakeScratch") != std::string::npos) {
cmSystemTools::RemoveADirectory(binDir);
}
}
void cmCoreTryCompile::FindOutputFile(const std::string& targetName,

20
Source/cmCoreTryCompile.h
View File

@@ -67,13 +67,21 @@ public:
bool isTryRun);
/**
* This is the core code for try compile. It is here so that other
* commands, such as TryRun can access the same logic without
* duplication.
* This is the core code for try compile. It is here so that other commands,
* such as TryRun can access the same logic without duplication.
*
* This function requires at least two \p arguments and will crash if given
* fewer.
*/
bool TryCompileCode(Arguments& arguments,
cmStateEnums::TargetType targetType);
/**
* Returns \c true if \p path resides within a CMake temporary directory,
* otherwise returns \c false.
*/
static bool IsTemporary(std::string const& path);
/**
* This deletes all the files created by TryCompileCode.
* This way we do not have to rely on the timing and
@@ -94,4 +102,10 @@ public:
std::string FindErrorMessage;
bool SrcFileSignature = false;
cmMakefile* Makefile;
private:
Arguments ParseArgs(
const cmRange<std::vector<std::string>::const_iterator>& args,
const cmArgumentParser<Arguments>& parser,
std::vector<std::string>& unparsedArguments);
};

3
Source/cmake.cxx
View File

@@ -2130,6 +2130,9 @@ int cmake::ActualConfigure()
this->UpdateConversionPathTable();
this->CleanupCommandsAndMacros();
cmSystemTools::RemoveADirectory(this->GetHomeOutputDirectory() +
"/CMakeFiles/CMakeScratch");
int res = this->DoPreConfigureChecks();
if (res < 0) {
return -2;

2
Tests/RunCMake/try_compile/BadLinkLibraries-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at BadLinkLibraries.cmake:2 \(try_compile\):
CMake Error at BadLinkLibraries.cmake:[0-9]+ \(try_compile\):
Only libraries may be used as try_compile or try_run IMPORTED
LINK_LIBRARIES. Got not_a_library of type UTILITY.
Call Stack \(most recent call first\):

6
Tests/RunCMake/try_compile/BadLinkLibraries.cmake
View File

@@ -1,3 +1,7 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
add_custom_target(not_a_library)
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
LINK_LIBRARIES not_a_library)

2
Tests/RunCMake/try_compile/BadSources1-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at BadSources1.cmake:1 \(try_compile\):
CMake Error at BadSources1.cmake:[0-9]+ \(try_compile\):
Unknown extension ".c" for file
.*/Tests/RunCMake/try_compile/src.c

4
Tests/RunCMake/try_compile/BadSources1.cmake
View File

@@ -1 +1,3 @@
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.c)
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.c)

2
Tests/RunCMake/try_compile/BadSources2-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at BadSources2.cmake:2 \(try_compile\):
CMake Error at BadSources2.cmake:[0-9]+ \(try_compile\):
Unknown extension ".cxx" for file
.*/Tests/RunCMake/try_compile/src.cxx

7
Tests/RunCMake/try_compile/BadSources2.cmake
View File

@@ -1,5 +1,6 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(C)
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.c
${CMAKE_CURRENT_SOURCE_DIR}/src.cxx
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
${CMAKE_CURRENT_SOURCE_DIR}/src.cxx
)

2
Tests/RunCMake/try_compile/CStandard-stderr.txt
View File

@@ -1,4 +1,4 @@
^CMake Error at .*/Tests/RunCMake/try_compile/CStandard-build/CMakeFiles/CMakeTmp/CMakeLists.txt:[0-9]+ \(add_executable\):
^CMake Error at .*/Tests/RunCMake/try_compile/CStandard-build/CMakeFiles/CMake(Tmp|Scratch/TryCompile-[^/]+)/CMakeLists.txt:[0-9]+ \(add_executable\):
C_STANDARD is set to invalid value '3'
+
CMake Error at CStandard.cmake:[0-9]+ \(try_compile\):

8
Tests/RunCMake/try_compile/CStandard.cmake
View File

@@ -1,7 +1,11 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(C)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.c
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
C_STANDARD 3
OUTPUT_VARIABLE out
)
message("try_compile output:\n${out}")

15
Tests/RunCMake/try_compile/CStandardGNU.cmake
View File

@@ -1,23 +1,30 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(C)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/CStandardGNU.c
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/CStandardGNU.c
C_STANDARD 99
C_STANDARD_REQUIRED 1
C_EXTENSIONS 0
OUTPUT_VARIABLE out
)
if(NOT result)
message(FATAL_ERROR "try_compile failed:\n${out}")
endif()
cmake_policy(SET CMP0067 NEW)
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED 1)
set(CMAKE_C_EXTENSIONS 0)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/CStandardGNU.c
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/CStandardGNU.c
OUTPUT_VARIABLE out
)
if(NOT result)
message(FATAL_ERROR "try_compile failed:\n${out}")
endif()

8
Tests/RunCMake/try_compile/CStandardNoDefault.cmake
View File

@@ -1,9 +1,13 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(C)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.c
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
C_STANDARD 3 # bogus, but not used
OUTPUT_VARIABLE out
)
if(NOT result)
message(FATAL_ERROR "try_compile failed:\n${out}")
endif()

2
Tests/RunCMake/try_compile/CopyFileErrorNoCopyFile-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at CopyFileErrorNoCopyFile.cmake:1 \(try_compile\):
CMake Error at CopyFileErrorNoCopyFile.cmake:[0-9]+ \(try_compile\):
COPY_FILE_ERROR may be used only with COPY_FILE
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

4
Tests/RunCMake/try_compile/CopyFileErrorNoCopyFile.cmake
View File

@@ -1,2 +1,4 @@
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
COPY_FILE_ERROR _copied)

2
Tests/RunCMake/try_compile/CudaStandard-stderr.txt
View File

@@ -1,4 +1,4 @@
^CMake Error at .*/Tests/RunCMake/try_compile/CudaStandard-build/CMakeFiles/CMakeTmp/CMakeLists.txt:[0-9]+ \(add_executable\):
^CMake Error at .*/Tests/RunCMake/try_compile/CudaStandard-build/CMakeFiles/CMake(Tmp|Scratch/TryCompile-[^/]+)/CMakeLists.txt:[0-9]+ \(add_executable\):
CUDA_STANDARD is set to invalid value '4'
+
CMake Error at CudaStandard.cmake:[0-9]+ \(try_compile\):

8
Tests/RunCMake/try_compile/CudaStandard.cmake
View File

@@ -1,7 +1,11 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(CUDA)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.cu
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.cu
CUDA_STANDARD 4
OUTPUT_VARIABLE out
)
message("try_compile output:\n${out}")

6
Tests/RunCMake/try_compile/CxxStandard-stderr.txt
View File

@@ -1,13 +1,13 @@
^(CMake Error in .*/Tests/RunCMake/try_compile/CxxStandard-build/CMakeFiles/CMakeTmp/CMakeLists.txt:
^(CMake Error in .*/Tests/RunCMake/try_compile/CxxStandard-build/CMakeFiles/CMake(Tmp|Scratch/TryCompile-[^/]+)/CMakeLists.txt:
The CXX_STANDARD property on target "cmTC_[0-9a-f]*" contained an invalid
value: "3".
)?CMake Error at .*/Tests/RunCMake/try_compile/CxxStandard-build/CMakeFiles/CMakeTmp/CMakeLists.txt:[0-9]+ \(add_executable\):
)?CMake Error at .*/Tests/RunCMake/try_compile/CxxStandard-build/CMakeFiles/CMake(Tmp|Scratch/TryCompile-[^/]+)/CMakeLists.txt:[0-9]+ \(add_executable\):
CXX_STANDARD is set to invalid value '3'
(
CMake Error in .*/Tests/RunCMake/try_compile/CxxStandard-build/CMakeFiles/CMakeTmp/CMakeLists.txt:
CMake Error in .*/Tests/RunCMake/try_compile/CxxStandard-build/CMakeFiles/CMake(Tmp|Scratch/TryCompile-[^/]+)/CMakeLists.txt:
The CXX_STANDARD property on target "cmTC_[0-9a-f]*" contained an invalid
value: "3".

8
Tests/RunCMake/try_compile/CxxStandard.cmake
View File

@@ -1,7 +1,11 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(CXX)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.cxx
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.cxx
CXX_STANDARD 3
OUTPUT_VARIABLE out
)
message("try_compile output:\n${out}")

15
Tests/RunCMake/try_compile/CxxStandardGNU.cmake
View File

@@ -1,23 +1,30 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(CXX)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/CxxStandardGNU.cxx
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/CxxStandardGNU.cxx
CXX_STANDARD 11
CXX_STANDARD_REQUIRED 1
CXX_EXTENSIONS 0
OUTPUT_VARIABLE out
)
if(NOT result)
message(FATAL_ERROR "try_compile failed:\n${out}")
endif()
cmake_policy(SET CMP0067 NEW)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED 1)
set(CMAKE_CXX_EXTENSIONS 0)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/CxxStandardGNU.cxx
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/CxxStandardGNU.cxx
OUTPUT_VARIABLE out
)
if(NOT result)
message(FATAL_ERROR "try_compile failed:\n${out}")
endif()

8
Tests/RunCMake/try_compile/CxxStandardNoDefault.cmake
View File

@@ -1,9 +1,13 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(CXX)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.cxx
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.cxx
CXX_STANDARD 3 # bogus, but not used
OUTPUT_VARIABLE out
)
if(NOT result)
message(FATAL_ERROR "try_compile failed:\n${out}")
endif()

5
Tests/RunCMake/try_compile/EmptyListArgs.cmake
View File

@@ -1,6 +1,9 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(C)
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
CMAKE_FLAGS # no values
COMPILE_DEFINITIONS # no values
LINK_LIBRARIES # no values

7
Tests/RunCMake/try_compile/EmptyValueArgs.cmake
View File

@@ -1,4 +1,7 @@
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
COPY_FILE "")
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
COPY_FILE "x" COPY_FILE_ERROR "")

6
Tests/RunCMake/try_compile/EnvConfig.cmake
View File

@@ -1,3 +1,5 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(C)
set(ENV{CMAKE_BUILD_TYPE} "Bad")
@@ -6,8 +8,8 @@ set(ENV{CMAKE_CONFIGURATION_TYPES} "Bad;Debug")
add_library(tc_defs INTERFACE IMPORTED)
target_compile_definitions(tc_defs INTERFACE "TC_CONFIG_$<UPPER_CASE:$<CONFIG>>")
try_compile(ENV_CONFIG_RESULT "${CMAKE_BINARY_DIR}"
SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/EnvConfig.c"
try_compile(ENV_CONFIG_RESULT "${try_compile_bindir_or_SOURCES}"
${try_compile_redundant_SOURCES} "${CMAKE_CURRENT_SOURCE_DIR}/EnvConfig.c"
COPY_FILE "${CMAKE_CURRENT_BINARY_DIR}/EnvConfig.bin"
OUTPUT_VARIABLE tc_output
LINK_LIBRARIES tc_defs

12
Tests/RunCMake/try_compile/ISPCDuplicateTarget.cmake
View File

@@ -1,8 +1,12 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(ISPC)
set(CMAKE_ISPC_INSTRUCTION_SETS avx512skx-i32x16
avx512skx-i32x16)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.ispc
set(CMAKE_ISPC_INSTRUCTION_SETS avx512skx-i32x16 avx512skx-i32x16)
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.ispc
OUTPUT_VARIABLE out
)
message("try_compile output:\n${out}")

13
Tests/RunCMake/try_compile/ISPCDuplicateTargetNinja.cmake
View File

@@ -1,11 +1,16 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(ISPC)
set(CMAKE_ISPC_INSTRUCTION_SETS avx512skx-i32x16
avx512skx-i32x16)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.ispc
set(CMAKE_ISPC_INSTRUCTION_SETS avx512skx-i32x16 avx512skx-i32x16)
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.ispc
OUTPUT_VARIABLE out
)
message("try_compile output:\n${out}")
if(NOT result)
message(FATAL_ERROR "making Ninja and Ninja Multi-Config behave the same")
endif()

9
Tests/RunCMake/try_compile/ISPCInvalidTarget.cmake
View File

@@ -1,7 +1,12 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(ISPC)
set(CMAKE_ISPC_INSTRUCTION_SETS "avxknl-i32x16")
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.ispc
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.ispc
OUTPUT_VARIABLE out
)
message("try_compile output:\n${out}")

9
Tests/RunCMake/try_compile/ISPCTargets.cmake
View File

@@ -1,7 +1,12 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(ISPC)
set(CMAKE_ISPC_INSTRUCTION_SETS avx512knl-i32x16 avx512skx-i32x16)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.ispc
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.ispc
OUTPUT_VARIABLE out
)
message("try_compile output:\n${out}")

2
Tests/RunCMake/try_compile/NoArgs-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NoArgs.cmake:1 \(try_compile\):
CMake Error at NoArgs.cmake:[0-9]+ \(try_compile\):
try_compile unknown error.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

2
Tests/RunCMake/try_compile/NoCStandard-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NoCStandard.cmake:1 \(try_compile\):
CMake Error at NoCStandard.cmake:[0-9]+ \(try_compile\):
Error after keyword "C_STANDARD":
missing required value

4
Tests/RunCMake/try_compile/NoCStandard.cmake
View File

@@ -1,2 +1,4 @@
try_compile(result ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_compile(result ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
C_STANDARD)

2
Tests/RunCMake/try_compile/NoCopyFile-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NoCopyFile.cmake:1 \(try_compile\):
CMake Error at NoCopyFile.cmake:[0-9]+ \(try_compile\):
Error after keyword "COPY_FILE":
missing required value

4
Tests/RunCMake/try_compile/NoCopyFile.cmake
View File

@@ -1,2 +1,4 @@
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
COPY_FILE)

2
Tests/RunCMake/try_compile/NoCopyFile2-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NoCopyFile2.cmake:1 \(try_compile\):
CMake Error at NoCopyFile2.cmake:[0-9]+ \(try_compile\):
Error after keyword "COPY_FILE":
missing required value

4
Tests/RunCMake/try_compile/NoCopyFile2.cmake
View File

@@ -1,2 +1,4 @@
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
COPY_FILE CMAKE_FLAGS -DA=B)

2
Tests/RunCMake/try_compile/NoCopyFileError-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NoCopyFileError.cmake:1 \(try_compile\):
CMake Error at NoCopyFileError.cmake:[0-9]+ \(try_compile\):
Error after keyword "COPY_FILE_ERROR":
missing required value

4
Tests/RunCMake/try_compile/NoCopyFileError.cmake
View File

@@ -1,2 +1,4 @@
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/copied.bin COPY_FILE_ERROR)

2
Tests/RunCMake/try_compile/NoOutputVariable-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NoOutputVariable.cmake:1 \(try_compile\):
CMake Error at NoOutputVariable.cmake:[0-9]+ \(try_compile\):
Error after keyword "OUTPUT_VARIABLE":
missing required value

4
Tests/RunCMake/try_compile/NoOutputVariable.cmake
View File

@@ -1,2 +1,4 @@
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
OUTPUT_VARIABLE)

2
Tests/RunCMake/try_compile/NoOutputVariable2-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NoOutputVariable2.cmake:1 \(try_compile\):
CMake Error at NoOutputVariable2.cmake:[0-9]+ \(try_compile\):
Error after keyword "OUTPUT_VARIABLE":
missing required value

4
Tests/RunCMake/try_compile/NoOutputVariable2.cmake
View File

@@ -1,2 +1,4 @@
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
OUTPUT_VARIABLE CMAKE_FLAGS -DA=B)

2
Tests/RunCMake/try_compile/NoSources-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NoSources.cmake:1 \(try_compile\):
CMake Error at NoSources.cmake:[0-9]+ \(try_compile\):
Error after keyword "SOURCES":
missing required value

2
Tests/RunCMake/try_compile/NonSourceCompileDefinitions-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NonSourceCompileDefinitions.cmake:1 \(try_compile\):
CMake Error at NonSourceCompileDefinitions.cmake:[0-9]+ \(try_compile\):
COMPILE_DEFINITIONS specified on a srcdir type TRY_COMPILE
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

2
Tests/RunCMake/try_compile/NonSourceCopyFile-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at NonSourceCopyFile.cmake:1 \(try_compile\):
CMake Error at NonSourceCopyFile.cmake:[0-9]+ \(try_compile\):
COPY_FILE specified on a srcdir type TRY_COMPILE
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

2
Tests/RunCMake/try_compile/ObjCStandard-stderr.txt
View File

@@ -1,4 +1,4 @@
^CMake Error at .*/Tests/RunCMake/try_compile/ObjCStandard-build/CMakeFiles/CMakeTmp/CMakeLists.txt:[0-9]+ \(add_executable\):
^CMake Error at .*/Tests/RunCMake/try_compile/ObjCStandard-build/CMakeFiles/CMake(Tmp|Scratch/TryCompile-[^/]+)/CMakeLists.txt:[0-9]+ \(add_executable\):
OBJC_STANDARD is set to invalid value '3'
+
CMake Error at ObjCStandard.cmake:[0-9]+ \(try_compile\):

8
Tests/RunCMake/try_compile/ObjCStandard.cmake
View File

@@ -1,7 +1,11 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(OBJC)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.m
try_compile(result ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.m
OBJC_STANDARD 3
OUTPUT_VARIABLE out
)
message("try_compile output:\n${out}")

2
Tests/RunCMake/try_compile/ObjCxxStandard-stderr.txt
View File

@@ -1,4 +1,4 @@
^CMake Error at .*/Tests/RunCMake/try_compile/ObjCxxStandard-build/CMakeFiles/CMakeTmp/CMakeLists.txt:[0-9]+ \(add_executable\):
^CMake Error at .*/Tests/RunCMake/try_compile/ObjCxxStandard-build/CMakeFiles/CMake(Tmp|Scratch/TryCompile-[^/]+)/CMakeLists.txt:[0-9]+ \(add_executable\):
OBJCXX_STANDARD is set to invalid value '3'
+
CMake Error at ObjCxxStandard.cmake:[0-9]+ \(try_compile\):

8
Tests/RunCMake/try_compile/ObjCxxStandard.cmake
View File

@@ -1,7 +1,11 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(OBJCXX)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.mm
try_compile(result ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.mm
OBJCXX_STANDARD 3
OUTPUT_VARIABLE out
)
message("try_compile output:\n${out}")

2
Tests/RunCMake/try_compile/OneArg-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at OneArg.cmake:1 \(try_compile\):
CMake Error at OneArg.cmake:[0-9]+ \(try_compile\):
try_compile unknown error.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

65
Tests/RunCMake/try_compile/RunCMakeTest.cmake
View File

@@ -1,38 +1,28 @@
include(RunCMake)
run_cmake(CopyFileErrorNoCopyFile)
run_cmake(NoArgs)
run_cmake(OneArg)
run_cmake(TwoArgs)
run_cmake(NoCopyFile)
run_cmake(NoCopyFile2)
run_cmake(NoCopyFileError)
run_cmake(NoCStandard)
run_cmake(NoOutputVariable)
run_cmake(NoOutputVariable2)
run_cmake(NoSources)
run_cmake(BadLinkLibraries)
run_cmake(BadSources1)
run_cmake(BadSources2)
run_cmake(NonSourceCopyFile)
run_cmake(NonSourceCompileDefinitions)
run_cmake(BinDirEmpty)
run_cmake(BinDirRelative)
run_cmake(EmptyValueArgs)
run_cmake(EmptyListArgs)
run_cmake(TryRunArgs)
run_cmake(EnvConfig)
set(RunCMake_TEST_OPTIONS -Dtry_compile_DEFS=old_signature.cmake)
include(${RunCMake_SOURCE_DIR}/old_and_new_signature_tests.cmake)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Dtry_compile_DEFS=new_signature.cmake)
include(${RunCMake_SOURCE_DIR}/old_and_new_signature_tests.cmake)
unset(RunCMake_TEST_OPTIONS)
run_cmake(NonSourceCopyFile)
run_cmake(NonSourceCompileDefinitions)
set(RunCMake_TEST_OPTIONS --debug-trycompile)
run_cmake(PlatformVariables)
run_cmake(WarnDeprecated)
unset(RunCMake_TEST_OPTIONS)
run_cmake(TargetTypeExe)
run_cmake(TargetTypeInvalid)
run_cmake(TargetTypeStatic)
if (CMAKE_SYSTEM_NAME MATCHES "^(Linux|Darwin|Windows)$" AND
CMAKE_C_COMPILER_ID MATCHES "^(MSVC|GNU|LCC|Clang|AppleClang)$")
set (RunCMake_TEST_OPTIONS -DRunCMake_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
@@ -40,41 +30,6 @@ if (CMAKE_SYSTEM_NAME MATCHES "^(Linux|Darwin|Windows)$" AND
unset (RunCMake_TEST_OPTIONS)
endif()
if(CMAKE_C_STANDARD_DEFAULT)
run_cmake(CStandard)
elseif(DEFINED CMAKE_C_STANDARD_DEFAULT)
run_cmake(CStandardNoDefault)
endif()
if(CMAKE_OBJC_STANDARD_DEFAULT)
run_cmake(ObjCStandard)
endif()
if(CMAKE_CXX_STANDARD_DEFAULT)
run_cmake(CxxStandard)
elseif(DEFINED CMAKE_CXX_STANDARD_DEFAULT)
run_cmake(CxxStandardNoDefault)
endif()
if(CMAKE_OBJCXX_STANDARD_DEFAULT)
run_cmake(ObjCxxStandard)
endif()
if(CMake_TEST_CUDA)
run_cmake(CudaStandard)
endif()
if(CMake_TEST_ISPC)
run_cmake(ISPCTargets)
run_cmake(ISPCInvalidTarget)
set(ninja "")
if(RunCMake_GENERATOR MATCHES "Ninja")
set(ninja "Ninja")
endif()
run_cmake(ISPCDuplicateTarget${ninja})
endif()
if((CMAKE_C_COMPILER_ID MATCHES "GNU" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.4) OR CMAKE_C_COMPILER_ID MATCHES "LCC")
run_cmake(CStandardGNU)
endif()
if((CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4) OR CMAKE_C_COMPILER_ID MATCHES "LCC")
run_cmake(CxxStandardGNU)
endif()
run_cmake(CMP0056)
run_cmake(CMP0066)
run_cmake(CMP0067)

10
Tests/RunCMake/try_compile/TargetTypeExe.cmake
View File

@@ -1,14 +1,20 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(C)
set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src.c
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
OUTPUT_VARIABLE out
COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/copy
COPY_FILE_ERROR copy_err
)
if(NOT result)
message(FATAL_ERROR "try_compile failed:\n${out}")
endif()
if(copy_err)
message(FATAL_ERROR "try_compile COPY_FILE failed:\n${copy_err}")
endif()

2
Tests/RunCMake/try_compile/TargetTypeInvalid-stderr.txt
View File

@@ -1,4 +1,4 @@
^CMake Error at TargetTypeInvalid.cmake:2 \(try_compile\):
^CMake Error at TargetTypeInvalid.cmake:[0-9]+ \(try_compile\):
Invalid value 'INVALID' for CMAKE_TRY_COMPILE_TARGET_TYPE. Only
'EXECUTABLE' and 'STATIC_LIBRARY' are allowed.
Call Stack \(most recent call first\):

6
Tests/RunCMake/try_compile/TargetTypeInvalid.cmake
View File

@@ -1,2 +1,6 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
set(CMAKE_TRY_COMPILE_TARGET_TYPE INVALID)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c)
try_compile(result ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c)

10
Tests/RunCMake/try_compile/TargetTypeStatic.cmake
View File

@@ -1,14 +1,20 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(C)
set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
try_compile(result ${CMAKE_CURRENT_BINARY_DIR}
SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/other.c
try_compile(result ${try_compile_bindir_or_SOURCES}
${try_compile_redundant_SOURCES} ${CMAKE_CURRENT_SOURCE_DIR}/other.c
OUTPUT_VARIABLE out
COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/copy
COPY_FILE_ERROR copy_err
)
if(NOT result)
message(FATAL_ERROR "try_compile failed:\n${out}")
endif()
if(copy_err)
message(FATAL_ERROR "try_compile COPY_FILE failed:\n${copy_err}")
endif()

5
Tests/RunCMake/try_compile/TryRunArgs.cmake
View File

@@ -1,6 +1,9 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
enable_language(C)
try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src.c
try_compile(RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
COPY_FILE "${CMAKE_CURRENT_BINARY_DIR}/out.bin"
COMPILE_OUTPUT_VARIABLE compOutputVar
RUN_OUTPUT_VARIABLE runOutputVar

2
Tests/RunCMake/try_compile/TwoArgs-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at TwoArgs.cmake:1 \(try_compile\):
CMake Error at TwoArgs.cmake:[0-9]+ \(try_compile\):
try_compile unknown error.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

2
Tests/RunCMake/try_compile/new_signature.cmake Normal file
View File

@@ -0,0 +1,2 @@
set(try_compile_bindir_or_SOURCES SOURCES)
set(try_compile_redundant_SOURCES "")

54
Tests/RunCMake/try_compile/old_and_new_signature_tests.cmake Normal file
View File

@@ -0,0 +1,54 @@
run_cmake(CopyFileErrorNoCopyFile)
run_cmake(NoCopyFile)
run_cmake(NoCopyFile2)
run_cmake(NoCopyFileError)
run_cmake(NoCStandard)
run_cmake(NoOutputVariable)
run_cmake(NoOutputVariable2)
run_cmake(BadLinkLibraries)
run_cmake(BadSources1)
run_cmake(BadSources2)
run_cmake(EmptyValueArgs)
run_cmake(EmptyListArgs)
run_cmake(TryRunArgs)
run_cmake(EnvConfig)
run_cmake(TargetTypeExe)
run_cmake(TargetTypeInvalid)
run_cmake(TargetTypeStatic)
if(CMAKE_C_STANDARD_DEFAULT)
run_cmake(CStandard)
elseif(DEFINED CMAKE_C_STANDARD_DEFAULT)
run_cmake(CStandardNoDefault)
endif()
if(CMAKE_OBJC_STANDARD_DEFAULT)
run_cmake(ObjCStandard)
endif()
if(CMAKE_CXX_STANDARD_DEFAULT)
run_cmake(CxxStandard)
elseif(DEFINED CMAKE_CXX_STANDARD_DEFAULT)
run_cmake(CxxStandardNoDefault)
endif()
if(CMAKE_OBJCXX_STANDARD_DEFAULT)
run_cmake(ObjCxxStandard)
endif()
if(CMake_TEST_CUDA)
run_cmake(CudaStandard)
endif()
if(CMake_TEST_ISPC)
run_cmake(ISPCTargets)
run_cmake(ISPCInvalidTarget)
set(ninja "")
if(RunCMake_GENERATOR MATCHES "Ninja")
set(ninja "Ninja")
endif()
run_cmake(ISPCDuplicateTarget${ninja})
endif()
if((CMAKE_C_COMPILER_ID MATCHES "GNU" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.4) OR CMAKE_C_COMPILER_ID MATCHES "LCC")
run_cmake(CStandardGNU)
endif()
if((CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4) OR CMAKE_C_COMPILER_ID MATCHES "LCC")
run_cmake(CxxStandardGNU)
endif()

2
Tests/RunCMake/try_compile/old_signature.cmake Normal file
View File

@@ -0,0 +1,2 @@
set(try_compile_bindir_or_SOURCES ${CMAKE_CURRENT_BINARY_DIR})
set(try_compile_redundant_SOURCES SOURCES)

2
Tests/RunCMake/try_run/BadLinkLibraries-stderr.txt
View File

@@ -1,4 +1,4 @@
CMake Error at BadLinkLibraries.cmake:2 \(try_run\):
CMake Error at BadLinkLibraries.cmake:[0-9+] \(try_run\):
Only libraries may be used as try_compile or try_run IMPORTED
LINK_LIBRARIES. Got not_a_library of type UTILITY.
Call Stack \(most recent call first\):

7
Tests/RunCMake/try_run/BadLinkLibraries.cmake
View File

@@ -1,4 +1,7 @@
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
add_custom_target(not_a_library)
try_run(RUN_RESULT COMPILE_RESULT
${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp ${CMAKE_CURRENT_SOURCE_DIR}/src.c
try_run(RUN_RESULT COMPILE_RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
LINK_LIBRARIES not_a_library)

6
Tests/RunCMake/try_run/NoCompileOutputVariable.cmake
View File

@@ -1,4 +1,6 @@
try_run(RUN_RESULT COMPILE_RESULT
${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_run(RUN_RESULT COMPILE_RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
COMPILE_OUTPUT_VARIABLE
)

6
Tests/RunCMake/try_run/NoRunOutputVariable.cmake
View File

@@ -1,4 +1,6 @@
try_run(RUN_RESULT COMPILE_RESULT
${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_run(RUN_RESULT COMPILE_RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
RUN_OUTPUT_VARIABLE
)

2
Tests/RunCMake/try_run/NoRunStdErrVariable-stderr.txt
View File

@@ -1,4 +1,4 @@
^CMake Error at NoRunStdErrVariable.cmake:1 \(try_run\):
^CMake Error at NoRunStdErrVariable.cmake:[0-9]+ \(try_run\):
Error after keyword "RUN_OUTPUT_STDERR_VARIABLE":
missing required value

6
Tests/RunCMake/try_run/NoRunStdErrVariable.cmake
View File

@@ -1,5 +1,7 @@
try_run(RUN_RESULT COMPILE_RESULT
${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_run(RUN_RESULT COMPILE_RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp/workdir
RUN_OUTPUT_STDERR_VARIABLE
)

2
Tests/RunCMake/try_run/NoRunStdOutVariable-stderr.txt
View File

@@ -1,4 +1,4 @@
^CMake Error at NoRunStdOutVariable.cmake:1 \(try_run\):
^CMake Error at NoRunStdOutVariable.cmake:[0-9]+ \(try_run\):
Error after keyword "RUN_OUTPUT_STDOUT_VARIABLE":
missing required value

6
Tests/RunCMake/try_run/NoRunStdOutVariable.cmake
View File

@@ -1,5 +1,7 @@
try_run(RUN_RESULT COMPILE_RESULT
${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_run(RUN_RESULT COMPILE_RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp/workdir
RUN_OUTPUT_STDOUT_VARIABLE
)

6
Tests/RunCMake/try_run/NoWorkingDirectory.cmake
View File

@@ -1,4 +1,6 @@
try_run(RUN_RESULT COMPILE_RESULT
${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_run(RUN_RESULT COMPILE_RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
WORKING_DIRECTORY
)

19
Tests/RunCMake/try_run/RunCMakeTest.cmake
View File

@@ -1,8 +1,16 @@
include(RunCMake)
run_cmake(BadLinkLibraries)
run_cmake(BinDirEmpty)
run_cmake(BinDirRelative)
run_cmake(NoOutputVariable)
set(RunCMake_TEST_OPTIONS -Dtry_compile_DEFS=old_signature.cmake)
include(${RunCMake_SOURCE_DIR}/old_and_new_signature_tests.cmake)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Dtry_compile_DEFS=new_signature.cmake)
include(${RunCMake_SOURCE_DIR}/old_and_new_signature_tests.cmake)
unset(RunCMake_TEST_OPTIONS)
if (CMAKE_SYSTEM_NAME MATCHES "^(Linux|Darwin|Windows)$" AND
CMAKE_C_COMPILER_ID MATCHES "^(MSVC|GNU|LCC|Clang|AppleClang)$")
@@ -10,12 +18,3 @@ if (CMAKE_SYSTEM_NAME MATCHES "^(Linux|Darwin|Windows)$" AND
run_cmake(LinkOptions)
unset (RunCMake_TEST_OPTIONS)
endif()
run_cmake(WorkingDirArg)
run_cmake(NoOutputVariable)
run_cmake(NoCompileOutputVariable)
run_cmake(NoRunOutputVariable)
run_cmake(NoRunStdOutVariable)
run_cmake(NoRunStdErrVariable)
run_cmake(NoWorkingDirectory)

6
Tests/RunCMake/try_run/WorkingDirArg.cmake
View File

@@ -1,5 +1,7 @@
try_run(RUN_RESULT COMPILE_RESULT
${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp ${CMAKE_CURRENT_SOURCE_DIR}/src.c
include(${CMAKE_CURRENT_SOURCE_DIR}/${try_compile_DEFS})
try_run(RUN_RESULT COMPILE_RESULT ${try_compile_bindir_or_SOURCES}
${CMAKE_CURRENT_SOURCE_DIR}/src.c
RUN_OUTPUT_VARIABLE RUN_OUTPUT
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/CMakeTmp/workdir
)

2
Tests/RunCMake/try_run/new_signature.cmake Normal file
View File

@@ -0,0 +1,2 @@
set(try_compile_bindir_or_SOURCES SOURCES)
set(try_compile_redundant_SOURCES "")

11
Tests/RunCMake/try_run/old_and_new_signature_tests.cmake Normal file
View File

@@ -0,0 +1,11 @@
run_cmake(BadLinkLibraries)
run_cmake(BinDirEmpty)
run_cmake(BinDirRelative)
run_cmake(WorkingDirArg)
run_cmake(NoCompileOutputVariable)
run_cmake(NoRunOutputVariable)
run_cmake(NoRunStdOutVariable)
run_cmake(NoRunStdErrVariable)
run_cmake(NoWorkingDirectory)

2
Tests/RunCMake/try_run/old_signature.cmake Normal file
View File

@@ -0,0 +1,2 @@
set(try_compile_bindir_or_SOURCES ${CMAKE_CURRENT_BINARY_DIR})
set(try_compile_redundant_SOURCES SOURCES)

267
Tests/TryCompile/CMakeLists.txt
View File

@@ -4,6 +4,18 @@ if(POLICY CMP0129)
endif()
project(TryCompile)
macro(EXPECT_PASS var out)
if(NOT ${var})
message(SEND_ERROR "Should pass failed ${out}")
endif()
endmacro()
macro(EXPECT_FAIL var out)
if(${var})
message(SEND_ERROR "Should fail passed ${out}")
endif()
endmacro()
macro(TEST_ASSERT value msg)
if (NOT ${value})
message (SEND_ERROR "Assertion failure:" ${msg} )
@@ -28,112 +40,31 @@ macro(TEST_EXPECT_CONTAINS command expected)
endif()
endmacro()
# try to compile a file that should compile
try_compile(SHOULD_PASS
${TryCompile_BINARY_DIR}
${TryCompile_SOURCE_DIR}/pass.c
OUTPUT_VARIABLE TRY_OUT)
if(NOT SHOULD_PASS)
message(SEND_ERROR "should pass failed ${TRY_OUT}")
if (APPLE)
enable_language(OBJC)
enable_language(OBJCXX)
endif()
# try to compile a file that should compile
# also check that COPY_FILE works
try_compile(SHOULD_PASS
${TryCompile_BINARY_DIR}
${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()
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()
# run old signature tests
set(try_compile_bindir_or_SOURCES ${TryCompile_BINARY_DIR})
set(try_compile_redundant_SOURCES SOURCES)
set(try_compile_output_vars OUTPUT_VARIABLE TRY_OUT)
set(try_compile_compile_output_var TRY_OUT)
set(try_compile_run_output_var TRY_OUT)
include(old_and_new_signature_tests.cmake)
# 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
${TryCompile_BINARY_DIR}
${TryCompile_SOURCE_DIR}/pass.c
OUTPUT_VARIABLE TRY_OUT
COPY_FILE ${TryCompile_BINARY_DIR}/invalid/path
COPY_FILE_ERROR _captured
)
if(NOT SHOULD_PASS)
message(SEND_ERROR "should pass failed ${TRY_OUT}")
endif()
if(NOT _captured MATCHES "Cannot copy output executable.*/invalid/path")
message(SEND_ERROR "COPY_FILE_ERROR did not capture expected message")
endif()
# run new signature tests
set(try_compile_bindir_or_SOURCES SOURCES)
set(try_compile_redundant_SOURCES "")
set(try_compile_output_vars
COMPILE_OUTPUT_VARIABLE COMPILE_OUT
RUN_OUTPUT_VARIABLE RUN_OUTPUT)
set(try_compile_compile_output_var COMPILE_OUT)
set(try_compile_run_output_var RUN_OUTPUT)
include(old_and_new_signature_tests.cmake)
# try to compile a file that should not compile
try_compile(SHOULD_FAIL
${TryCompile_BINARY_DIR}
${TryCompile_SOURCE_DIR}/fail.c
OUTPUT_VARIABLE TRY_OUT)
if(SHOULD_FAIL)
message(SEND_ERROR "Should fail passed ${TRY_OUT}")
endif()
# try to compile two files that should compile
try_compile(SHOULD_PASS
${TryCompile_BINARY_DIR}
SOURCES ${TryCompile_SOURCE_DIR}/pass2a.c ${TryCompile_SOURCE_DIR}/pass2b.cxx
OUTPUT_VARIABLE TRY_OUT)
if(NOT SHOULD_PASS)
message(SEND_ERROR "should pass failed ${TRY_OUT}")
endif()
# try to compile two files that should not compile
try_compile(SHOULD_FAIL
${TryCompile_BINARY_DIR}
SOURCES ${TryCompile_SOURCE_DIR}/fail2a.c ${TryCompile_SOURCE_DIR}/fail2b.c
OUTPUT_VARIABLE TRY_OUT)
if(SHOULD_FAIL)
message(SEND_ERROR "Should fail passed ${TRY_OUT}")
endif()
# 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
${TryCompile_BINARY_DIR}
${TryCompile_SOURCE_DIR}/testdef.c
OUTPUT_VARIABLE TRY_OUT)
if(NOT SHOULD_PASS)
message(SEND_ERROR "should pass failed ${TRY_OUT}")
endif()
set(CMAKE_C_FLAGS "${_c_flags}")
try_compile(CMAKE_ANSI_FOR_SCOPE
${TryCompile_BINARY_DIR}
${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()
# try to compile a project
# try to compile a project (old signature)
message("Testing try_compile project mode")
try_compile(TEST_INNER
${TryCompile_BINARY_DIR}/CMakeFiles/Inner
@@ -142,123 +73,8 @@ try_compile(TEST_INNER
OUTPUT_VARIABLE output)
TEST_ASSERT(TEST_INNER "try_compile project mode failed:\n${output}")
try_compile(COMPILE_DEFINITIONS_LIST_EXPANDED
${TryCompile_BINARY_DIR}
${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_compile(SHOULD_FAIL_DUE_TO_BAD_SOURCE
${TryCompile_BINARY_DIR}
${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()
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}
${TryCompile_SOURCE_DIR}/exit_success.c
OUTPUT_VARIABLE TRY_OUT)
if(NOT SHOULD_COMPILE)
message(SEND_ERROR "exit_success failed compiling: ${TRY_OUT}")
endif()
if(NOT "${SHOULD_RUN}" STREQUAL "0")
message(SEND_ERROR "exit_success failed running with exit code ${SHOULD_RUN}")
endif()
# 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()
# check the run output
if(NOT "${TRY_OUT}" MATCHES "hello world")
message(SEND_ERROR " TRY_OUT didn't contain \"hello world\": \"${TRY_OUT}\"")
endif()
try_run(ARG_TEST_RUN ARG_TEST_COMPILE
${TryCompile_BINARY_DIR}
${TryCompile_SOURCE_DIR}/expect_arg.c
OUTPUT_VARIABLE TRY_OUT
ARGS arg1 arg2)
if(NOT ARG_TEST_COMPILE)
message(SEND_ERROR "expect_arg failed compiling: ${TRY_OUT}")
endif()
if(NOT "${ARG_TEST_RUN}" STREQUAL "0")
message(SEND_ERROR "expect_arg failed running with exit code ${ARG_TEST_RUN} ${TRY_OUT}")
endif()
# 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}
${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()
if("${SHOULD_EXIT_WITH_ERROR}" STREQUAL "0")
message(SEND_ERROR " exit_with_error passed with exit code ${SHOULD_EXIT_WITH_ERROR}")
endif()
# 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
try_run(SHOULD_EXIT_WITH_ERROR SHOULD_COMPILE
${TryCompile_BINARY_DIR}
${TryCompile_SOURCE_DIR}/stdout_and_stderr.c
COMPILE_OUTPUT_VARIABLE COMPILE_OUTPUT
RUN_OUTPUT_STDOUT_VARIABLE RUN_OUTPUT_STDOUT
RUN_OUTPUT_STDERR_VARIABLE RUN_OUTPUT_STDERR)
if(NOT SHOULD_COMPILE)
message(STATUS " exit_with_error failed compiling: ${COMPILE_OUTPUT}")
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()
#######################################################################
#
# also test that the CHECK_C_SOURCE_COMPILES, CHECK_CXX_SOURCE_COMPILES
@@ -377,25 +193,6 @@ if (APPLE)
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")
# try to compile a file that should compile
try_compile(SHOULD_PASS
${TryCompile_BINARY_DIR}
${TryCompile_SOURCE_DIR}/pass.m
OUTPUT_VARIABLE TRY_OUT)
if(NOT SHOULD_PASS)
message(SEND_ERROR "should pass failed ${TRY_OUT}")
endif()
# try to compile a file that should not compile
try_compile(SHOULD_FAIL
${TryCompile_BINARY_DIR}
${TryCompile_SOURCE_DIR}/fail.m
OUTPUT_VARIABLE TRY_OUT)
if(SHOULD_FAIL)
message(SEND_ERROR "Should fail passed ${TRY_OUT}")
endif()
endif()
#######################################################################

245
Tests/TryCompile/old_and_new_signature_tests.cmake Normal file
View File

@@ -0,0 +1,245 @@
# 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)
if(NOT SHOULD_PASS)
message(SEND_ERROR "should pass failed ${TRY_OUT}")
endif()
# 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)
if(SHOULD_FAIL)
message(SEND_ERROR "Should fail passed ${TRY_OUT}")
endif()
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})
if(NOT SHOULD_COMPILE)
message(SEND_ERROR
"exit_success failed compiling: ${${try_compile_compile_output_var}}")
endif()
if(NOT "${SHOULD_RUN}" STREQUAL "0")
message(SEND_ERROR
"exit_success failed running with exit code ${SHOULD_RUN}")
endif()
# 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)
if(NOT ARG_TEST_COMPILE)
message(SEND_ERROR "expect_arg failed compiling: ${TRY_OUT}")
endif()
if(NOT "${ARG_TEST_RUN}" STREQUAL "0")
message(SEND_ERROR "expect_arg failed running with exit code ${ARG_TEST_RUN} ${TRY_OUT}")
endif()
# 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)
if(NOT SHOULD_COMPILE)
message(STATUS " exit_with_error failed compiling: ${COMPILE_OUTPUT}")
endif()
if("${SHOULD_EXIT_WITH_ERROR}" STREQUAL "0")
message(SEND_ERROR " exit_with_error passed with exit code ${SHOULD_EXIT_WITH_ERROR}")
endif()
# 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)
if(NOT SHOULD_COMPILE)
message(STATUS " exit_with_error failed compiling: ${COMPILE_OUTPUT}")
endif()
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()