CMake/Tests/Complex/Executable/complex.cxx

897 lines
26 KiB
C++
Raw Normal View History

#include "Aout.h"
#include "ExtraSources/file1.h"
2001-08-23 21:57:45 +04:00
#include "cmTestConfigure.h"
#include "cmTestConfigureEscape.h"
#include "cmTestGeneratedHeader.h"
2002-04-22 19:51:26 +04:00
#include "cmVersion.h"
2001-08-23 21:57:45 +04:00
#include "file2.h"
#include "sharedFile.h"
extern "C" {
#include "testConly.h"
}
#include <iostream>
#include <string.h>
#include <string>
#include <vector>
#include <stdio.h>
#include <sys/stat.h>
#if !defined(S_ISDIR)
#define S_ISDIR(mode) ((mode)&_S_IFDIR)
#endif
#ifdef COMPLEX_TEST_LINK_STATIC
extern "C" {
int TestLinkGetType();
}
#endif
2001-08-23 21:57:45 +04:00
2002-01-20 08:12:27 +03:00
int cm_passed = 0;
int cm_failed = 0;
// ======================================================================
void cmFailed(const char* Message, const char* m2 = "", const char* m3 = "")
{
std::cout << "FAILED: " << Message << m2 << m3 << "\n";
cm_failed++;
}
// ======================================================================
void cmPassed(const char* Message, const char* m2 = "")
{
std::cout << "Passed: " << Message << m2 << "\n";
cm_passed++;
}
2001-08-23 21:57:45 +04:00
#ifndef COMPLEX_DEFINED_PRE
#error "COMPLEX_DEFINED_PRE not defined!"
#endif
#ifdef COMPLEX_DEFINED
#error "COMPLEX_DEFINED is defined but it should not!"
#endif
#ifndef COMPLEX_DEFINED_POST
#error "COMPLEX_DEFINED_POST not defined!"
#endif
2004-04-15 21:59:29 +04:00
#ifndef CMAKE_IS_REALLY_FUN
#error This is a problem. Looks like ADD_DEFINITIONS and REMOVE_DEFINITIONS does not work
#endif
#if defined(NDEBUG) && !defined(CMAKE_IS_FUN_IN_RELEASE_MODE)
#error Per-configuration directory-level definition not inherited.
2004-04-15 21:59:29 +04:00
#endif
// ======================================================================
void TestAndRemoveFile(const char* filename)
2002-01-18 20:03:32 +03:00
{
struct stat st;
if (stat(filename, &st) < 0) {
2002-01-20 08:12:27 +03:00
cmFailed("Could not find file: ", filename);
} else {
if (remove(filename) < 0) {
cmFailed("Unable to remove file. It does not imply that this test "
"failed, but it *will* be corrupted thereafter if this file is "
"not removed: ",
filename);
} else {
2002-01-20 08:12:27 +03:00
cmPassed("Find and remove file: ", filename);
2002-01-18 20:03:32 +03:00
}
}
2002-01-18 20:03:32 +03:00
}
// ======================================================================
void TestDir(const char* filename)
2002-01-19 03:21:43 +03:00
{
struct stat st;
if (stat(filename, &st) < 0 || !S_ISDIR(st.st_mode)) {
2002-01-20 08:12:27 +03:00
cmFailed("Could not find dir: ", filename);
} else {
cmPassed("Find dir: ", filename);
}
2002-01-19 03:21:43 +03:00
}
// Here is a stupid function that tries to use std::string methods
// so that the dec cxx compiler will instantiate the stuff that
// we are using from the CMakeLib library....
void ForceStringUse()
{
std::vector<std::string> v;
std::vector<std::string> v2;
v = v2;
std::string cachetest = CACHE_TEST_VAR_INTERNAL;
v.push_back(cachetest);
v2 = v;
std::string x(5, 'x');
char buff[5];
x.copy(buff, 1, 0);
x[0] = 'a';
std::string::size_type pos = 0;
x.replace(pos, pos, pos, 'x');
std::string copy = cachetest;
cachetest.find("bar");
cachetest.rfind("bar");
copy.append(cachetest);
copy = cachetest.substr(0, cachetest.size());
}
// defined in testcflags.c
extern "C" int TestCFlags(char* m);
2006-01-25 16:38:06 +03:00
extern "C" int TestTargetCompileFlags(char* m);
#if 0
// defined in Sub1/NameConflictTest.c
extern "C" int NameConflictTest1();
// defined in Sub2/NameConflictTest.c
extern "C" int NameConflictTest2();
#endif
// ======================================================================
int main()
2001-08-23 21:57:45 +04:00
{
#if 0
if(NameConflictTest1() == 0 && NameConflictTest2() == 0)
{
cmPassed("Sub dir with same named source works");
}
else
{
cmFailed("Sub dir with same named source fails");
}
#endif
if (file1() != 1) {
2002-01-20 08:12:27 +03:00
cmFailed("Call to file1 function from library failed.");
} else {
2002-01-20 08:12:27 +03:00
cmPassed("Call to file1 function returned 1.");
}
2006-01-25 16:38:06 +03:00
#ifndef COMPLEX_TARGET_FLAG
cmFailed("COMPILE_FLAGS did not work with SET_TARGET_PROPERTIES");
#else
cmPassed("COMPILE_FLAGS did work with SET_TARGET_PROPERTIES");
#endif
2006-09-22 19:49:56 +04:00
#ifdef ELSEIF_RESULT
cmPassed("ELSEIF did work");
#else
cmFailed("ELSEIF did not work");
#endif
#ifdef CONDITIONAL_PARENTHESES
cmPassed("CONDITIONAL_PARENTHESES did work");
#else
cmFailed("CONDITIONAL_PARENTHESES did not work");
#endif
if (file2() != 1) {
2002-01-20 08:12:27 +03:00
cmFailed("Call to file2 function from library failed.");
} else {
2002-01-20 08:12:27 +03:00
cmPassed("Call to file2 function returned 1.");
}
#ifndef TEST_CXX_FLAGS
cmFailed("CMake CMAKE_CXX_FLAGS is not being passed to the compiler!");
#else
cmPassed("CMake CMAKE_CXX_FLAGS is being passed to the compiler.");
#endif
std::string gen = CMAKE_GENERATOR;
// visual studio is currently broken for c flags
2006-01-25 16:38:06 +03:00
char msg[1024];
if (gen.find("Visual") == gen.npos) {
#ifdef TEST_C_FLAGS
cmFailed(
"CMake CMAKE_C_FLAGS are being passed to c++ files the compiler!");
#else
cmPassed("CMake CMAKE_C_FLAGS are not being passed to c++ files.");
#endif
if (TestCFlags(msg)) {
cmPassed("CMake CMAKE_C_FLAGS are being passed to c files and CXX flags "
"are not.");
} else {
cmFailed(msg);
}
}
if (TestTargetCompileFlags(msg)) {
2006-01-25 16:38:06 +03:00
cmPassed(msg);
} else {
2006-01-25 16:38:06 +03:00
cmFailed(msg);
}
2006-01-25 16:38:06 +03:00
// ----------------------------------------------------------------------
// Test ADD_DEFINITIONS
2001-08-23 21:57:45 +04:00
#ifndef CMAKE_IS_FUN
2002-01-20 08:12:27 +03:00
cmFailed("CMake is not fun, so it is broken and should be fixed.");
2001-08-23 21:57:45 +04:00
#else
2002-01-20 08:12:27 +03:00
cmPassed("CMAKE_IS_FUN is defined.");
2001-08-23 21:57:45 +04:00
#endif
#if defined(CMAKE_ARGV1) && defined(CMAKE_ARGV2) && defined(CMAKE_ARGV3) && \
defined(CMAKE_ARGV4)
2004-04-26 19:12:19 +04:00
cmPassed("Variable args for MACROs are working.");
#else
cmFailed("Variable args for MACROs are failing.");
#endif
// ----------------------------------------------------------------------
// Test GET_SOURCE_FILE_PROPERTY for location
2006-03-22 23:01:22 +03:00
#ifndef CMAKE_FOUND_ACXX
cmFailed("CMake did not get the location of A.cxx correctly");
#else
cmPassed("CMake found A.cxx properly");
#endif
// ----------------------------------------------------------------------
// Test GET_DIRECTORY_PROPERTY for parent
2006-03-22 23:01:22 +03:00
#ifndef CMAKE_FOUND_PARENT
cmFailed("CMake did not get the location of the parent directory properly");
#else
cmPassed("CMake found the parent directory properly");
#endif
// ----------------------------------------------------------------------
// Test GET_DIRECTORY_PROPERTY for listfiles
2006-03-22 23:01:22 +03:00
#ifndef CMAKE_FOUND_LISTFILE_STACK
cmFailed("CMake did not get the listfile stack properly");
#else
cmPassed("CMake found the listfile stack properly");
#endif
// ----------------------------------------------------------------------
// Test SET, VARIABLE_REQUIRES
2001-08-23 21:57:45 +04:00
#ifdef SHOULD_NOT_BE_DEFINED
2002-01-20 08:12:27 +03:00
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED is defined.");
2001-08-23 21:57:45 +04:00
#else
2002-01-20 08:12:27 +03:00
cmPassed("SHOULD_NOT_BE_DEFINED is not defined.");
2001-08-23 21:57:45 +04:00
#endif
2001-08-23 21:57:45 +04:00
#ifndef SHOULD_BE_DEFINED
2002-01-20 08:12:27 +03:00
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED is not defined.\n");
2001-08-23 21:57:45 +04:00
#else
2002-01-20 08:12:27 +03:00
cmPassed("SHOULD_BE_DEFINED is defined.");
2001-08-23 21:57:45 +04:00
#endif
#ifndef ONE_VAR
2002-01-20 08:12:27 +03:00
cmFailed("cmakedefine is broken, ONE_VAR is not defined.");
#else
2002-01-20 08:12:27 +03:00
cmPassed("ONE_VAR is defined.");
#endif
#ifndef ONE_VAR_IS_DEFINED
2002-01-20 08:12:27 +03:00
cmFailed("cmakedefine, SET or VARIABLE_REQUIRES is broken, "
"ONE_VAR_IS_DEFINED is not defined.");
#else
2002-01-20 08:12:27 +03:00
cmPassed("ONE_VAR_IS_DEFINED is defined.");
#endif
#ifdef ZERO_VAR
2002-01-20 08:12:27 +03:00
cmFailed("cmakedefine is broken, ZERO_VAR is defined.");
#else
2002-01-20 08:12:27 +03:00
cmPassed("ZERO_VAR is not defined.");
#endif
#ifndef STRING_VAR
2002-01-20 08:12:27 +03:00
cmFailed("the CONFIGURE_FILE command is broken, STRING_VAR is not defined.");
#else
if (strcmp(STRING_VAR, "CMake is great") != 0) {
cmFailed("the SET or CONFIGURE_FILE command is broken. STRING_VAR == ",
STRING_VAR);
} else {
2002-01-20 08:12:27 +03:00
cmPassed("STRING_VAR == ", STRING_VAR);
}
#endif
// ----------------------------------------------------------------------
// Test various IF/ELSE combinations
2002-01-20 09:58:57 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_NOT
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_NOT is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_NOT is not defined.");
#endif
2002-01-20 09:58:57 +03:00
#ifndef SHOULD_BE_DEFINED_NOT
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_NOT is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_NOT is defined.");
#endif
2002-01-20 09:58:57 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_NOT2
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_NOT2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_NOT2 is not defined.");
#endif
2002-01-20 09:58:57 +03:00
#ifndef SHOULD_BE_DEFINED_NOT2
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_NOT2 is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_NOT2 is defined.");
#endif
2002-01-19 04:32:06 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_AND
2002-01-20 08:12:27 +03:00
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_AND is defined.");
2002-01-19 04:32:06 +03:00
#else
2002-01-20 08:12:27 +03:00
cmPassed("SHOULD_NOT_BE_DEFINED_AND is not defined.");
2002-01-19 04:32:06 +03:00
#endif
2002-01-19 04:32:06 +03:00
#ifndef SHOULD_BE_DEFINED_AND
2002-01-20 08:12:27 +03:00
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_AND is not defined.\n");
2002-01-19 04:32:06 +03:00
#else
2002-01-20 08:12:27 +03:00
cmPassed("SHOULD_BE_DEFINED_AND is defined.");
2002-01-19 04:32:06 +03:00
#endif
2002-01-20 09:58:57 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_AND2
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_AND2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_AND2 is not defined.");
#endif
2002-01-20 09:58:57 +03:00
#ifndef SHOULD_BE_DEFINED_AND2
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_AND2 is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_AND2 is defined.");
#endif
2002-01-19 04:32:06 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_OR
2002-01-20 08:12:27 +03:00
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_OR is defined.");
2002-01-19 04:32:06 +03:00
#else
2002-01-20 08:12:27 +03:00
cmPassed("SHOULD_NOT_BE_DEFINED_OR is not defined.");
2002-01-19 04:32:06 +03:00
#endif
2002-01-19 04:32:06 +03:00
#ifndef SHOULD_BE_DEFINED_OR
2002-01-20 08:12:27 +03:00
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_OR is not defined.\n");
2002-01-19 04:32:06 +03:00
#else
2002-01-20 08:12:27 +03:00
cmPassed("SHOULD_BE_DEFINED_OR is defined.");
2002-01-19 04:32:06 +03:00
#endif
2002-01-20 09:58:57 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_OR2
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_OR2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_OR2 is not defined.");
#endif
2002-01-20 09:58:57 +03:00
#ifndef SHOULD_BE_DEFINED_OR2
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_OR2 is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_OR2 is defined.");
#endif
2002-01-19 04:32:06 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_MATCHES
2002-01-20 08:12:27 +03:00
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_MATCHES is defined.");
2002-01-19 04:32:06 +03:00
#else
2002-01-20 08:12:27 +03:00
cmPassed("SHOULD_NOT_BE_DEFINED_MATCHES is not defined.");
2002-01-19 04:32:06 +03:00
#endif
2002-01-19 04:32:06 +03:00
#ifndef SHOULD_BE_DEFINED_MATCHES
2002-01-20 08:12:27 +03:00
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_MATCHES is not defined.\n");
2002-01-19 04:32:06 +03:00
#else
2002-01-20 08:12:27 +03:00
cmPassed("SHOULD_BE_DEFINED_MATCHES is defined.");
#endif
2002-01-20 09:58:57 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_MATCHES2
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_MATCHES2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_MATCHES2 is not defined.");
#endif
2002-01-20 09:58:57 +03:00
#ifndef SHOULD_BE_DEFINED_MATCHES2
cmFailed(
"IF or SET is broken, SHOULD_BE_DEFINED_MATCHES2 is not defined.\n");
2002-01-20 09:58:57 +03:00
#else
cmPassed("SHOULD_BE_DEFINED_MATCHES2 is defined.");
#endif
2002-01-20 08:12:27 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_COMMAND
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_COMMAND is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_COMMAND is not defined.");
#endif
2002-01-20 08:12:27 +03:00
#ifndef SHOULD_BE_DEFINED_COMMAND
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_COMMAND is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_COMMAND is defined.");
2002-01-19 04:32:06 +03:00
#endif
2002-01-20 09:58:57 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_COMMAND2
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_COMMAND2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_COMMAND2 is not defined.");
#endif
2002-01-20 09:58:57 +03:00
#ifndef SHOULD_BE_DEFINED_COMMAND2
cmFailed(
"IF or SET is broken, SHOULD_BE_DEFINED_COMMAND2 is not defined.\n");
2002-01-20 09:58:57 +03:00
#else
cmPassed("SHOULD_BE_DEFINED_COMMAND2 is defined.");
#endif
2002-01-21 18:22:51 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_EXISTS
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_EXISTS is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_EXISTS is not defined.");
#endif
2002-01-21 18:22:51 +03:00
#ifndef SHOULD_BE_DEFINED_EXISTS
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_EXISTS is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_EXISTS is defined.");
#endif
2002-01-21 18:22:51 +03:00
#ifdef SHOULD_NOT_BE_DEFINED_EXISTS2
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_EXISTS2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_EXISTS2 is not defined.");
#endif
2002-01-21 18:22:51 +03:00
#ifndef SHOULD_BE_DEFINED_EXISTS2
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_EXISTS2 is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_EXISTS2 is defined.");
#endif
2006-03-22 23:01:22 +03:00
#ifndef SHOULD_BE_DEFINED_IS_DIRECTORY
cmFailed(
"IF or SET is broken, SHOULD_BE_DEFINED_IS_DIRECTORY is not defined.\n");
2006-03-22 23:01:22 +03:00
#else
cmPassed("SHOULD_BE_DEFINED_IS_DIRECTORY is defined.");
#endif
#ifndef SHOULD_BE_DEFINED_IS_DIRECTORY2
cmFailed(
"IF or SET is broken, SHOULD_BE_DEFINED_IS_DIRECTORY2 is not defined.\n");
2006-03-22 23:01:22 +03:00
#else
cmPassed("SHOULD_BE_DEFINED_IS_DIRECTORY2 is defined.");
#endif
#ifdef SHOULD_NOT_BE_DEFINED_LESS
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_LESS is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_LESS is not defined.");
#endif
#ifndef SHOULD_BE_DEFINED_LESS
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_LESS is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_LESS is defined.");
#endif
#ifdef SHOULD_NOT_BE_DEFINED_LESS2
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_LESS2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_LESS2 is not defined.");
#endif
#ifndef SHOULD_BE_DEFINED_LESS2
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_LESS2 is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_LESS2 is defined.");
#endif
#ifdef SHOULD_NOT_BE_DEFINED_GREATER
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_GREATER is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_GREATER is not defined.");
#endif
2004-04-28 18:09:50 +04:00
#ifdef SHOULD_NOT_BE_DEFINED_EQUAL
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_EQUAL is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_EQUAL is not defined.");
#endif
#ifndef SHOULD_BE_DEFINED_EQUAL
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_EQUAL is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_EQUAL is defined.");
#endif
#ifndef SHOULD_BE_DEFINED_GREATER
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_GREATER is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_GREATER is defined.");
#endif
#ifdef SHOULD_NOT_BE_DEFINED_GREATER2
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_GREATER2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_GREATER2 is not defined.");
#endif
#ifndef SHOULD_BE_DEFINED_GREATER2
cmFailed(
"IF or SET is broken, SHOULD_BE_DEFINED_GREATER2 is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_GREATER2 is defined.");
#endif
#ifdef SHOULD_NOT_BE_DEFINED_STRLESS
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_STRLESS is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_STRLESS is not defined.");
#endif
#ifndef SHOULD_BE_DEFINED_STRLESS
cmFailed("IF or SET is broken, SHOULD_BE_DEFINED_STRLESS is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_STRLESS is defined.");
#endif
#ifdef SHOULD_NOT_BE_DEFINED_STRLESS2
cmFailed("IF or SET is broken, SHOULD_NOT_BE_DEFINED_STRLESS2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_STRLESS2 is not defined.");
#endif
#ifndef SHOULD_BE_DEFINED_STRLESS2
cmFailed(
"IF or SET is broken, SHOULD_BE_DEFINED_STRLESS2 is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_STRLESS2 is defined.");
#endif
#ifdef SHOULD_NOT_BE_DEFINED_STRGREATER
cmFailed(
"IF or SET is broken, SHOULD_NOT_BE_DEFINED_STRGREATER is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_STRGREATER is not defined.");
#endif
#ifndef SHOULD_BE_DEFINED_STRGREATER
cmFailed(
"IF or SET is broken, SHOULD_BE_DEFINED_STRGREATER is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_STRGREATER is defined.");
#endif
#ifdef SHOULD_NOT_BE_DEFINED_STRGREATER2
cmFailed(
"IF or SET is broken, SHOULD_NOT_BE_DEFINED_STRGREATER2 is defined.");
#else
cmPassed("SHOULD_NOT_BE_DEFINED_STRGREATER2 is not defined.");
#endif
#ifndef SHOULD_BE_DEFINED_STRGREATER2
cmFailed(
"IF or SET is broken, SHOULD_BE_DEFINED_STRGREATER2 is not defined.\n");
#else
cmPassed("SHOULD_BE_DEFINED_STRGREATER2 is defined.");
#endif
// ----------------------------------------------------------------------
// Test FOREACH
2002-01-18 20:03:32 +03:00
#ifndef FOREACH_VAR1
2002-01-20 08:12:27 +03:00
cmFailed("the FOREACH, SET or CONFIGURE_FILE command is broken, "
"FOREACH_VAR1 is not defined.");
2002-01-18 20:03:32 +03:00
#else
if (strcmp(FOREACH_VAR1, "VALUE1") != 0) {
2002-01-20 08:12:27 +03:00
cmFailed("the FOREACH, SET or CONFIGURE_FILE command is broken, "
"FOREACH_VAR1 == ",
FOREACH_VAR1);
} else {
2002-01-20 08:12:27 +03:00
cmPassed("FOREACH_VAR1 == ", FOREACH_VAR1);
}
2002-01-18 20:03:32 +03:00
#endif
2002-01-18 20:03:32 +03:00
#ifndef FOREACH_VAR2
2002-01-20 08:12:27 +03:00
cmFailed("the FOREACH, SET or CONFIGURE_FILE command is broken, "
"FOREACH_VAR2 is not defined.");
2002-01-18 20:03:32 +03:00
#else
if (strcmp(FOREACH_VAR2, "VALUE2") != 0) {
2002-01-20 08:12:27 +03:00
cmFailed("the FOREACH, SET or CONFIGURE_FILE command is broken, "
"FOREACH_VAR2 == ",
FOREACH_VAR2);
} else {
2002-01-20 08:12:27 +03:00
cmPassed("FOREACH_VAR2 == ", FOREACH_VAR2);
}
2002-01-18 20:03:32 +03:00
#endif
#ifndef FOREACH_CONCAT
cmFailed("the FOREACH, SET or CONFIGURE_FILE command is broken, "
"FOREACH_CONCAT is not defined.");
#else
if (strcmp(FOREACH_CONCAT, "abcdefg") != 0) {
cmFailed("the FOREACH, SET or CONFIGURE_FILE command is broken, "
"FOREACH_CONCAT == ",
FOREACH_CONCAT);
} else {
cmPassed("FOREACH_CONCAT == ", FOREACH_CONCAT);
}
#endif
// ----------------------------------------------------------------------
// Test WHILE
if (WHILE_VALUE != 1000) {
cmFailed("WHILE command is not working");
} else {
cmPassed("WHILE command is working");
}
// ----------------------------------------------------------------------
// Test LOAD_CACHE
2002-01-19 03:21:43 +03:00
#ifndef CACHE_TEST_VAR1
2002-01-20 08:12:27 +03:00
cmFailed("the LOAD_CACHE or CONFIGURE_FILE command is broken, "
"CACHE_TEST_VAR1 is not defined.");
2002-01-19 03:21:43 +03:00
#else
if (strcmp(CACHE_TEST_VAR1, "foo") != 0) {
2002-01-20 08:12:27 +03:00
cmFailed("the LOAD_CACHE or CONFIGURE_FILE command is broken, "
"CACHE_TEST_VAR1 == ",
CACHE_TEST_VAR1);
} else {
2002-01-20 08:12:27 +03:00
cmPassed("CACHE_TEST_VAR1 == ", CACHE_TEST_VAR1);
}
2002-01-19 03:21:43 +03:00
#endif
#ifndef CACHE_TEST_VAR2
2002-01-20 08:12:27 +03:00
cmFailed("the LOAD_CACHE or CONFIGURE_FILE command is broken, "
"CACHE_TEST_VAR2 is not defined.");
2002-01-19 03:21:43 +03:00
#else
if (strcmp(CACHE_TEST_VAR2, "bar") != 0) {
2002-01-20 08:12:27 +03:00
cmFailed("the LOAD_CACHE or CONFIGURE_FILE command is broken, "
"CACHE_TEST_VAR2 == ",
CACHE_TEST_VAR2);
} else {
2002-01-20 08:12:27 +03:00
cmPassed("CACHE_TEST_VAR2 == ", CACHE_TEST_VAR2);
}
2002-01-19 03:21:43 +03:00
#endif
#ifndef CACHE_TEST_VAR3
2002-01-20 08:12:27 +03:00
cmFailed("the LOAD_CACHE or CONFIGURE_FILE command is broken, "
"CACHE_TEST_VAR3 is not defined.");
2002-01-19 03:21:43 +03:00
#else
if (strcmp(CACHE_TEST_VAR3, "1") != 0) {
2002-01-20 08:12:27 +03:00
cmFailed("the LOAD_CACHE or CONFIGURE_FILE command is broken, "
"CACHE_TEST_VAR3 == ",
CACHE_TEST_VAR3);
} else {
2002-01-20 08:12:27 +03:00
cmPassed("CACHE_TEST_VAR3 == ", CACHE_TEST_VAR3);
}
2002-01-20 08:12:27 +03:00
#endif
#ifdef CACHE_TEST_VAR_EXCLUDED
cmFailed(
"the LOAD_CACHE or CONFIGURE_FILE command or cmakedefine is broken, "
"CACHE_TEST_VAR_EXCLUDED is defined (should not have been loaded).");
2002-01-20 08:12:27 +03:00
#else
cmPassed("CACHE_TEST_VAR_EXCLUDED is not defined.");
#endif
#ifndef CACHE_TEST_VAR_INTERNAL
cmFailed("the LOAD_CACHE or CONFIGURE_FILE command is broken, "
"CACHE_TEST_VAR_INTERNAL is not defined.");
2002-01-20 08:12:27 +03:00
#else
std::string cachetest = CACHE_TEST_VAR_INTERNAL;
if (cachetest != "bar") {
2002-01-20 08:12:27 +03:00
cmFailed("the LOAD_CACHE or CONFIGURE_FILE command is broken, "
"CACHE_TEST_VAR_INTERNAL == ",
CACHE_TEST_VAR_INTERNAL);
} else {
2002-01-20 08:12:27 +03:00
cmPassed("CACHE_TEST_VAR_INTERNAL == ", CACHE_TEST_VAR_INTERNAL);
}
2002-01-19 03:21:43 +03:00
#endif
// ----------------------------------------------------------------------
// Some pre-build/pre-link/post-build custom-commands have been
// attached to the lib (see Library/).
// Each runs ${CREATE_FILE_EXE} which will create a file.
// It also copies that file again using cmake -E.
// Similar rules have been added to this executable.
2002-01-21 23:30:37 +03:00
//
// WARNING: if you run 'complex' manually, this *will* fail, because
// the file was removed the last time 'complex' was run, and it is
// only created during a build.
2002-01-18 20:03:32 +03:00
TestAndRemoveFile("Library/prebuild.txt");
TestAndRemoveFile("Library/prelink.txt");
TestAndRemoveFile("Library/postbuild.txt");
TestAndRemoveFile("Library/postbuild2.txt");
TestAndRemoveFile("Executable/prebuild.txt");
TestAndRemoveFile("Executable/prelink.txt");
TestAndRemoveFile("Executable/postbuild.txt");
TestAndRemoveFile("Executable/postbuild2.txt");
2002-01-18 20:03:32 +03:00
// ----------------------------------------------------------------------
2002-01-19 03:21:43 +03:00
// A custom target has been created (see Library/).
// It runs ${CREATE_FILE_EXE} which will create a file.
2002-01-21 23:30:37 +03:00
//
// WARNING: if you run 'complex' manually, this *will* fail, because
// the file was removed the last time 'complex' was run, and it is
// only created during a build.
2002-01-19 03:21:43 +03:00
TestAndRemoveFile("Library/custom_target1.txt");
// ----------------------------------------------------------------------
2002-01-19 03:21:43 +03:00
// A directory has been created.
2002-01-18 20:03:32 +03:00
TestDir("make_dir");
2002-01-20 08:12:27 +03:00
// ----------------------------------------------------------------------
// Test OUTPUT_REQUIRED_FILES
// The files required by 'complex' have been output to a file.
// The contents of this file is not tested (absolute paths).
2002-01-21 23:30:37 +03:00
//
// WARNING: if you run 'complex' manually, this *will* fail, because
// the file was removed the last time 'complex' was run, and it is
// only created during a build.
2002-01-20 08:12:27 +03:00
TestAndRemoveFile("Executable/Temp/complex-required.txt");
2002-01-20 08:12:27 +03:00
// ----------------------------------------------------------------------
// Test FIND_LIBRARY
2002-03-29 23:02:18 +03:00
#ifndef FIND_DUMMY_LIB
cmFailed("the CONFIGURE_FILE command is broken, "
"FIND_DUMMY_LIB is not defined.");
2002-03-29 23:02:18 +03:00
#else
if (strstr(FIND_DUMMY_LIB, "dummylib") == NULL) {
2002-03-29 23:02:18 +03:00
cmFailed("the FIND_LIBRARY or CONFIGURE_FILE command is broken, "
"FIND_DUMMY_LIB == ",
FIND_DUMMY_LIB);
} else {
2002-03-29 23:02:18 +03:00
cmPassed("FIND_DUMMY_LIB == ", FIND_DUMMY_LIB);
}
2002-03-29 23:02:18 +03:00
#endif
// ----------------------------------------------------------------------
// Test SET_SOURCE_FILES_PROPERTIES
2002-03-29 23:02:18 +03:00
#ifndef FILE_HAS_EXTRA_COMPILE_FLAGS
cmFailed("SET_SOURCE_FILES_PROPERTIES failed at setting "
"FILE_HAS_EXTRA_COMPILE_FLAGS flag");
2002-03-29 23:02:18 +03:00
#else
cmPassed("SET_SOURCE_FILES_PROPERTIES succeeded in setting "
"FILE_HAS_EXTRA_COMPILE_FLAGS flag");
2002-03-29 23:02:18 +03:00
#endif
#if 0 // Disable until implemented everywhere.
#ifndef FILE_DEFINE_STRING
cmFailed("SET_SOURCE_FILES_PROPERTIES failed at setting FILE_DEFINE_STRING flag");
#else
if(strcmp(FILE_DEFINE_STRING, "hello") != 0)
{
cmFailed("SET_SOURCE_FILES_PROPERTIES failed at setting FILE_DEFINE_STRING flag correctly");
}
else
{
cmPassed("SET_SOURCE_FILES_PROPERTIES succeeded in setting FILE_DEFINE_STRING flag");
}
#endif
#endif
2002-03-29 23:02:18 +03:00
#ifndef FILE_HAS_ABSTRACT
cmFailed("SET_SOURCE_FILES_PROPERTIES failed at setting ABSTRACT flag");
#else
cmPassed("SET_SOURCE_FILES_PROPERTIES succeeded in setting ABSTRACT flag");
#endif
#ifndef FILE_HAS_WRAP_EXCLUDE
cmFailed("FILE_HAS_WRAP_EXCLUDE failed at setting WRAP_EXCLUDE flag");
#else
cmPassed("FILE_HAS_WRAP_EXCLUDE succeeded in setting WRAP_EXCLUDE flag");
#endif
#ifndef FILE_COMPILE_FLAGS
cmFailed("the CONFIGURE_FILE command is broken, FILE_COMPILE_FLAGS is not "
"defined.");
2002-03-29 23:02:18 +03:00
#else
if (strcmp(FILE_COMPILE_FLAGS, "-foo -bar") != 0) {
cmFailed("the SET_SOURCE_FILES_PROPERTIES or CONFIGURE_FILE command is "
"broken. FILE_COMPILE_FLAGS == ",
2002-03-29 23:02:18 +03:00
FILE_COMPILE_FLAGS);
} else {
cmPassed(
"SET_SOURCE_FILES_PROPERTIES succeeded in setting extra flags == ",
FILE_COMPILE_FLAGS);
}
2002-03-29 23:02:18 +03:00
#endif
// ----------------------------------------------------------------------
// Test registry (win32)
#if defined(_WIN32) && !defined(__CYGWIN__)
#ifndef REGISTRY_TEST_PATH
cmFailed("the CONFIGURE_FILE command is broken, REGISTRY_TEST_PATH is not "
"defined.");
#else
std::cout << "REGISTRY_TEST_PATH == " << REGISTRY_TEST_PATH << "\n";
if (stricmp(REGISTRY_TEST_PATH, BINARY_DIR "/registry_dir") != 0) {
cmFailed("the 'read registry value' function or CONFIGURE_FILE command is "
"broken. REGISTRY_TEST_PATH == ",
REGISTRY_TEST_PATH, " is not " BINARY_DIR "/registry_dir");
} else {
cmPassed("REGISTRY_TEST_PATH == ", REGISTRY_TEST_PATH);
}
#endif
#endif // defined(_WIN32) && !defined(__CYGWIN__)
if (strcmp(CMAKE_MINIMUM_REQUIRED_VERSION, "2.4") == 0) {
cmPassed("CMAKE_MINIMUM_REQUIRED_VERSION is set to 2.4");
} else {
cmFailed("CMAKE_MINIMUM_REQUIRED_VERSION is not set to the expected 2.4");
}
2002-04-22 19:51:26 +04:00
// ----------------------------------------------------------------------
// Test REMOVE command
if (strcmp("a;b;d", REMOVE_STRING) == 0) {
2002-04-22 19:51:26 +04:00
cmPassed("REMOVE is working");
} else {
2002-04-22 19:51:26 +04:00
cmFailed("REMOVE is not working");
}
2002-04-30 22:01:07 +04:00
// ----------------------------------------------------------------------
// Test SEPARATE_ARGUMENTS
if (strcmp("a;b;c", TEST_SEP) == 0) {
2002-04-30 22:01:07 +04:00
cmPassed("SEPARATE_ARGUMENTS is working");
} else {
2002-04-30 22:01:07 +04:00
cmFailed("SEPARATE_ARGUMENTS is not working");
}
// ----------------------------------------------------------------------
// Test Escape Quotes
if (strcmp("\"hello world\"", STRING_WITH_QUOTES) == 0) {
cmPassed("ESCAPE_QUOTES is working");
} else {
cmFailed("ESCAPE_QUOTES is not working");
}
// ----------------------------------------------------------------------
// Test if IF command inside a FOREACH works.
#if defined(IF_INSIDE_FOREACH_THEN_EXECUTED) && \
!defined(IF_INSIDE_FOREACH_ELSE_EXECUTED)
cmPassed("IF inside a FOREACH block works");
#else
cmFailed("IF inside a FOREACH block is broken");
#endif
#if defined(GENERATED_HEADER_INCLUDED)
cmPassed("Generated header included by non-generated source works.");
#else
cmFailed("Generated header included by non-generated source failed.");
#endif
if (SHOULD_BE_ZERO == 0) {
cmPassed("cmakedefine01 is working for 0");
} else {
cmFailed("cmakedefine01 is not working for 0");
}
if (SHOULD_BE_ONE == 1) {
cmPassed("cmakedefine01 is working for 1");
} else {
cmFailed("cmakedefine01 is not working for 1");
}
2002-10-09 23:54:34 +04:00
#ifdef FORCE_TEST
cmFailed("CMake SET CACHE FORCE");
#else
cmPassed("CMake SET CACHE FORCE");
#endif
#ifdef COMPLEX_TEST_LINK_STATIC
if (TestLinkGetType()) {
cmPassed("Link to static over shared worked.");
} else {
cmFailed("Link to static over shared failed.");
}
#endif
#if defined(A_VALUE) && A_VALUE == 10
cmPassed("Single-character executable A worked.");
#else
cmFailed("Single-character executable A failed.");
#endif
// ----------------------------------------------------------------------
// Summary
2002-01-20 08:12:27 +03:00
std::cout << "Passed: " << cm_passed << "\n";
if (cm_failed) {
2002-01-20 08:12:27 +03:00
std::cout << "Failed: " << cm_failed << "\n";
return cm_failed;
}
2001-08-23 21:57:45 +04:00
return 0;
}