User:David.cole

From KitwarePublic
Revision as of 19:02, 6 January 2010 by David.cole (talk | contribs)
Jump to navigationJump to search

sample CMakeLists.txt:

<source lang="CMake">

  1. a macro for tests that have a simple format where the name matches the
  2. directory and project

MACRO(ADD_TEST_MACRO NAME COMMAND)

 STRING(REPLACE "." "/" dir "${NAME}")
 STRING(REGEX REPLACE "[^.]*\\." "" proj "${NAME}")
 ADD_TEST(${NAME} ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/${dir}"
   "${CMake_BINARY_DIR}/Tests/${dir}"
   --build-two-config
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-project ${proj}
   --test-command ${COMMAND})
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${dir}")

ENDMACRO(ADD_TEST_MACRO)

  1. Fake a user home directory to avoid polluting the real one.

IF(DEFINED ENV{HOME} AND NOT CTEST_NO_TEST_HOME)

 SET(TEST_HOME "${CMake_BINARY_DIR}/Tests/CMakeFiles/TestHome")
 FILE(MAKE_DIRECTORY "${TEST_HOME}")
 FILE(WRITE "${TEST_HOME}/.cvspass" ":pserver:anoncvs@www.cmake.org:/cvsroot/KWSys A\n")
 SET(TEST_HOME_ENV_CODE "# Fake a user home directory to avoid polluting the real one.

SET(ENV{HOME} \"${TEST_HOME}\")") ENDIF()

  1. Choose a default configuration for CTest tests.

SET(CTestTest_CONFIG Debug) IF(NOT CMAKE_CONFIGURATION_TYPES AND CMAKE_BUILD_TYPE)

 SET(CTestTest_CONFIG ${CMAKE_BUILD_TYPE})

ENDIF()

CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/EnforceConfig.cmake.in

              ${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake @ONLY)
  1. Testing

IF(BUILD_TESTING)

 ADD_SUBDIRECTORY(CMakeLib)
 # Collect a list of all test build directories.
 SET(TEST_BUILD_DIRS)
 # Should the long tests be run?
 OPTION(CMAKE_RUN_LONG_TESTS 
   "Should the long tests be run (such as Bootstrap)." ON)
 MARK_AS_ADVANCED(CMAKE_RUN_LONG_TESTS)
 IF (CMAKE_RUN_LONG_TESTS)
   OPTION(CTEST_TEST_CTEST 
     "Should the tests that run a full sub ctest process be run?" 
     OFF)
   MARK_AS_ADVANCED(CTEST_TEST_CTEST)
   OPTION(TEST_KDE4_STABLE_BRANCH
     "Should the KDE4 stable branch test be run?" 
     OFF)
   MARK_AS_ADVANCED(TEST_KDE4_STABLE_BRANCH)
 ENDIF (CMAKE_RUN_LONG_TESTS)
 # Should tests that use CVS be run?
 #
 set(do_cvs_tests 0)
 if(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
   find_package(CVS QUIET)
 else(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
   find_program(CVS_EXECUTABLE NAMES cvs)
 endif(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
 if(CVS_EXECUTABLE)
   set(do_cvs_tests 1)
 endif(CVS_EXECUTABLE)
 if(do_cvs_tests AND NOT UNIX)
   if("${CVS_EXECUTABLE}" MATCHES "cygwin")
     set(do_cvs_tests 0)
   endif("${CVS_EXECUTABLE}" MATCHES "cygwin")
 endif(do_cvs_tests AND NOT UNIX)
 # Should CPack tests be run? By default, yes, but...
 #
 # Disable packaging test on Apple 10.3 and below. PackageMaker starts
 # DiskManagementTool as root and disowns it
 # (http://lists.apple.com/archives/installer-dev/2005/Jul/msg00005.html).
 # It is left holding open pipe handles and preventing ProcessUNIX from
 # detecting end-of-data even after its immediate child exits. Then
 # the test hangs until it times out and is killed. This is a
 # well-known bug in kwsys process execution that I would love to get
 # time to fix.
 #
 OPTION(CTEST_TEST_CPACK
   "Should the tests that use '--build-target package' be run?"
   ON)
 MARK_AS_ADVANCED(CTEST_TEST_CPACK)
 SET(CTEST_TEST_OSX_ARCH 0)
 IF(APPLE)
   EXECUTE_PROCESS(
     COMMAND sw_vers -productVersion
     OUTPUT_VARIABLE OSX_VERSION
     OUTPUT_STRIP_TRAILING_WHITESPACE
     )
   IF(OSX_VERSION MATCHES "^10\\.[0123]" OR OSX_VERSION MATCHES "ProductVersion:\t10\\.[0123]")
     MESSAGE(STATUS "Forcing CTEST_TEST_CPACK=OFF on OSX < 10.4")
     MESSAGE(STATUS "OSX_VERSION='${OSX_VERSION}'")
     SET(CTEST_TEST_CPACK OFF)
   ELSE(OSX_VERSION MATCHES "^10\\.[0123]" OR OSX_VERSION MATCHES "ProductVersion:\t10\\.[0123]")
     SET(CTEST_TEST_OSX_ARCH 1)
   ENDIF(OSX_VERSION MATCHES "^10\\.[0123]" OR OSX_VERSION MATCHES "ProductVersion:\t10\\.[0123]")
 ENDIF(APPLE)
 # Use 1500 or CTEST_TEST_TIMEOUT for long test timeout value,
 # whichever is greater.
 SET(CMAKE_LONG_TEST_TIMEOUT 1500)
 IF(CTEST_TEST_TIMEOUT)
   SET(CMAKE_LONG_TEST_TIMEOUT ${CTEST_TEST_TIMEOUT})
 ENDIF(CTEST_TEST_TIMEOUT)
 IF(CMAKE_LONG_TEST_TIMEOUT LESS 1500)
   SET(CMAKE_LONG_TEST_TIMEOUT 1500)
 ENDIF(CMAKE_LONG_TEST_TIMEOUT LESS 1500)
 # add a bunch of standard build-and-test style tests
 ADD_TEST_MACRO(CommandLineTest CommandLineTest)
 ADD_TEST_MACRO(FindPackageTest FindPackageTest)
 ADD_TEST_MACRO(FindModulesExecuteAll FindModulesExecuteAll)
 ADD_TEST_MACRO(StringFileTest StringFileTest)
 ADD_TEST_MACRO(TryCompile TryCompile)
 ADD_TEST_MACRO(TarTest TarTest)
 ADD_TEST_MACRO(SystemInformation SystemInformation)
 ADD_TEST_MACRO(MathTest MathTest)
 ADD_TEST_MACRO(Simple Simple)
 ADD_TEST_MACRO(PreOrder PreOrder)
 ADD_TEST_MACRO(COnly COnly)
 ADD_TEST_MACRO(CxxOnly CxxOnly)
 ADD_TEST_MACRO(IPO COnly/COnly)
 ADD_TEST_MACRO(OutDir runtime/OutDir)
 ADD_TEST_MACRO(NewlineArgs NewlineArgs)
 ADD_TEST_MACRO(SetLang SetLang)
 ADD_TEST_MACRO(ExternalOBJ ExternalOBJ)
 ADD_TEST_MACRO(LoadCommand LoadedCommand)
 ADD_TEST_MACRO(LinkDirectory bin/LinkDirectory)
 ADD_TEST_MACRO(LinkLanguage LinkLanguage)
 ADD_TEST_MACRO(LinkLine LinkLine)
 ADD_TEST_MACRO(MacroTest miniMacroTest)
 ADD_TEST_MACRO(FunctionTest miniFunctionTest)
 ADD_TEST_MACRO(ReturnTest ReturnTest)
 ADD_TEST_MACRO(Properties Properties)
 ADD_TEST_MACRO(Assembler HelloAsm)
 ADD_TEST_MACRO(SourceGroups SourceGroups)
 ADD_TEST_MACRO(Preprocess Preprocess)
 ADD_TEST_MACRO(ExportImport ExportImport)
 ADD_TEST_MACRO(Unset Unset)
 ADD_TEST_MACRO(PolicyScope PolicyScope)
 ADD_TEST_MACRO(CrossCompile CrossCompile)
 SET_TESTS_PROPERTIES(CrossCompile PROPERTIES
   PASS_REGULAR_EXPRESSION "TRY_RUN.. invoked in cross-compiling mode")
 IF("${CMAKE_TEST_GENERATOR}" MATCHES "Make")
   ADD_TEST_MACRO(Policy0002 Policy0002)
 ENDIF("${CMAKE_TEST_GENERATOR}" MATCHES "Make")
 IF(CTEST_TEST_OSX_ARCH)
   ADD_TEST_MACRO(Architecture Architecture)
   SET_TESTS_PROPERTIES(Architecture PROPERTIES
     PASS_REGULAR_EXPRESSION "(file is not of required architecture|does not match cputype)")
 ENDIF(CTEST_TEST_OSX_ARCH)
 LIST(APPEND TEST_BUILD_DIRS ${CMake_TEST_INSTALL_PREFIX})
 SET(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/COnly")
 SET(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/CMakeBuildCOnly")
 CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake" @ONLY)
 ADD_TEST(CMakeBuildTest ${CMAKE_CMAKE_COMMAND} -P
   "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake")
 LIST(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
 ADD_TEST_MACRO(Module.CheckTypeSize CheckTypeSize)
 # If we are running right now with a UnixMakefiles based generator,
 # build the "Simple" test with the ExtraGenerators, if available
 # This doesn't test whether the generated project files work (unfortunately), 
 # mainly it tests that cmake doesn't crash when generating these project files.
 IF(${CMAKE_TEST_GENERATOR} MATCHES "Unix Makefiles"  OR  ${CMAKE_TEST_GENERATOR} MATCHES "KDevelop")
   # check which generators we have
   EXEC_PROGRAM(${CMAKE_CMAKE_COMMAND} ARGS --help OUTPUT_VARIABLE cmakeOutput )
   # check for the Eclipse generator
   IF ("${cmakeOutput}" MATCHES Eclipse)
     ADD_TEST(Simple_EclipseGenerator ${CMAKE_CTEST_COMMAND}
        --build-and-test
        "${CMake_SOURCE_DIR}/Tests/Simple"
        "${CMake_BINARY_DIR}/Tests/Simple_EclipseGenerator"
        --build-two-config
        --build-generator "Eclipse CDT4 - Unix Makefiles"
        --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
        --build-project Simple
        --test-command Simple)
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_EclipseGenerator")
   ENDIF ("${cmakeOutput}" MATCHES Eclipse)
   # check for the CodeBlocks generator
   IF ("${cmakeOutput}" MATCHES CodeBlocks)
     ADD_TEST(Simple_CodeBlocksGenerator ${CMAKE_CTEST_COMMAND}
        --build-and-test
        "${CMake_SOURCE_DIR}/Tests/Simple"
        "${CMake_BINARY_DIR}/Tests/Simple_CodeBlocksGenerator"
        --build-two-config
        --build-generator "CodeBlocks - Unix Makefiles"
        --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
        --build-project Simple
        --test-command Simple)
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_CodeBlocksGenerator")
   ENDIF ("${cmakeOutput}" MATCHES CodeBlocks)
   # check for the KDevelop3 generator
   IF ("${cmakeOutput}" MATCHES KDevelop3)
     ADD_TEST(Simple_KDevelop3Generator ${CMAKE_CTEST_COMMAND}
        --build-and-test
        "${CMake_SOURCE_DIR}/Tests/Simple"
        "${CMake_BINARY_DIR}/Tests/Simple_KDevelop3Generator"
        --build-two-config
        --build-generator "KDevelop3 - Unix Makefiles"
        --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
        --build-project Simple
        --test-command Simple)
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_KDevelop3Generator")
   ENDIF ("${cmakeOutput}" MATCHES KDevelop3)
 ENDIF(${CMAKE_TEST_GENERATOR} MATCHES "Unix Makefiles"  OR  ${CMAKE_TEST_GENERATOR} MATCHES "KDevelop")
 # test for correct sub-project generation
 # not implemented in VS6 or Xcode
 IF(NOT MSVC60 AND NOT XCODE AND NOT MSVC70)
   # run cmake and configure all of SubProject
   # but only build the independent executable car
   ADD_TEST(SubProject ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/SubProject"
     "${CMake_BINARY_DIR}/Tests/SubProject"
     --build-project SubProject
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-target car
     --test-command car
     )
   # For stage 2, do not run cmake again.
   # Then build the foo sub project which should build
   # the bar library which should be referenced because
   # foo links to the static library bar, but bar is not
   # directly in the foo sub project
   ADD_TEST(SubProject-Stage2  ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/SubProject/foo"
     "${CMake_BINARY_DIR}/Tests/SubProject/foo" 
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-nocmake 
     --build-project foo
     --build-target foo
     --test-command foo
     )
   SET_TESTS_PROPERTIES ( SubProject-Stage2 PROPERTIES DEPENDS SubProject)
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubProject")
 ENDIF(NOT MSVC60 AND NOT XCODE AND NOT MSVC70)
 IF (CMAKE_STRICT)
   ADD_TEST_MACRO(DocTest DocTest)
 ENDIF (CMAKE_STRICT)
 # macro to add a test that will build a nightly release
 # of CMake for given platform using the release scripts
 MACRO(ADD_NIGHTLY_BUILD_TEST name script)
   SET(_TEST_DIR "${CMake_BINARY_DIR}/Tests/${name}")
   FILE(MAKE_DIRECTORY "${_TEST_DIR}")
   FILE(WRITE "${_TEST_DIR}/nightly-cmake.sh"
     "cd ${_TEST_DIR}

${CMake_BINARY_DIR}/bin/cmake -DCMAKE_CREATE_VERSION=CVS -P ${CMake_SOURCE_DIR}/Utilities/Release/${script} ${CMake_BINARY_DIR}/bin/cmake -DVERSION=CVS -P ${CMake_SOURCE_DIR}/Utilities/Release/upload_release.cmake

   ")
   ADD_TEST(${name} /bin/sh ${_TEST_DIR}/nightly-cmake.sh)
   IF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY)
     SET_TESTS_PROPERTIES (${name} PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
   ENDIF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY)
 ENDMACRO(ADD_NIGHTLY_BUILD_TEST)
 IF(CMAKE_BUILD_NIGHTLY_RELEASES)
   ADD_NIGHTLY_BUILD_TEST(CMakeNightlyWindows
     dash2win64_release.cmake)
   ADD_NIGHTLY_BUILD_TEST(CMakeNightlyMac
     dashmacmini2_release.cmake)
   ADD_NIGHTLY_BUILD_TEST(CMakeNightlyLinux
     magrathea_release.cmake)
 ENDIF(CMAKE_BUILD_NIGHTLY_RELEASES)
 # add tests with more complex invocations
 ADD_TEST(Framework ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/Framework"
   "${CMake_BINARY_DIR}/Tests/Framework"
   --build-two-config
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-project Framework
   --build-options
   "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/Framework/Install"
   --test-command bar)
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Framework")
 ADD_TEST(TargetName ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/TargetName"
   "${CMake_BINARY_DIR}/Tests/TargetName"
   --build-two-config
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-project TargetName
   --test-command ${CMAKE_CMAKE_COMMAND} -E compare_files 
   ${CMake_SOURCE_DIR}/Tests/TargetName/scripts/hello_world
   ${CMake_BINARY_DIR}/Tests/TargetName/scripts/hello_world)
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TargetName")
 ADD_TEST(LibName ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/LibName"
   "${CMake_BINARY_DIR}/Tests/LibName"
   --build-two-config
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-project LibName 
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/LibName/lib"
   --test-command foobar
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LibName")
 ADD_TEST(CustComDepend ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/CustComDepend"
   "${CMake_BINARY_DIR}/Tests/CustComDepend"
   --build-two-config
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-project CustComDepend 
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustComDepend/bin"
   --test-command foo bar.c
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustComDepend")
 ADD_TEST(CustomCommand  ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/CustomCommand"
   "${CMake_BINARY_DIR}/Tests/CustomCommand"
   --build-two-config
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project CustomCommand
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustomCommand/bin"
   --test-command CustomCommand
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommand")
 ADD_TEST(CustomCommandWorkingDirectory  ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/CustomCommandWorkingDirectory"
   "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory"
   --build-two-config
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project TestWorkingDir
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --test-command working
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory")
  #ADD_TEST(SimpleExclude ${CMAKE_CTEST_COMMAND}
  #  --build-and-test
  #  "${CMake_SOURCE_DIR}/Tests/SimpleExclude"
  #  "${CMake_BINARY_DIR}/Tests/SimpleExclude"
  #  --build-generator ${CMAKE_TEST_GENERATOR}
  #  --build-project SimpleExclude
  #  --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
  #  --build-two-config
  #  --test-command t4
  #--test-command "${CMAKE_COMMAND}"
  #"-DCONFIGURATION=\${CTEST_CONFIGURATION_TYPE}"
  #-P "${CMAKE_BINARY_DIR}/Tests/SimpleExclude/run.cmake"
  #)
  1. ADD_TEST(SameName ${CMAKE_CTEST_COMMAND}
  2. --build-and-test
  3. "${CMake_SOURCE_DIR}/Tests/SameName"
  4. "${CMake_BINARY_DIR}/Tests/SameName"
  5. --build-generator ${CMAKE_TEST_GENERATOR}
  6. --build-project SameName
  7. --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
  8. --build-two-config
  9. --test-command
  10. "${CMake_BINARY_DIR}/Tests/SameName/Exe1/mytest2")
 ADD_TEST(OutOfSource ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/OutOfSource"
   "${CMake_BINARY_DIR}/Tests/OutOfSource"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project OutOfSource
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-two-config
   --test-command
   "${CMake_BINARY_DIR}/Tests/OutOfSource/SubDir/OutOfSourceSubdir/simple")
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSource")
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSourceDeep")
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfBinary")
 ADD_TEST(BuildDepends ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/BuildDepends"
   "${CMake_BINARY_DIR}/Tests/BuildDepends"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project BuildDepends
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BuildDepends")
 
 SET(SimpleInstallInstallDir
   "${CMake_BINARY_DIR}/Tests/SimpleInstall/InstallDirectory")
 ADD_TEST(SimpleInstall ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/SimpleInstall"
   "${CMake_BINARY_DIR}/Tests/SimpleInstall"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project TestSimpleInstall
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-two-config
   --build-options
   "-DCMAKE_INSTALL_PREFIX:PATH=${SimpleInstallInstallDir}"
   "-DCTEST_TEST_CPACK:BOOL=${CTEST_TEST_CPACK}"
   --test-command   ${SimpleInstallInstallDir}/MyTest/bin/SimpleInstExe)
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleInstall")
 ADD_TEST(SimpleInstall-Stage2 ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/SimpleInstallS2"
   "${CMake_BINARY_DIR}/Tests/SimpleInstallS2"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project TestSimpleInstall
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-two-config
   --build-options
   "-DCMAKE_INSTALL_PREFIX:PATH=${SimpleInstallInstallDir}"
   "-DSTAGE2:BOOL=1"
   --test-command   ${SimpleInstallInstallDir}/MyTest/bin/SimpleInstExeS2)
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleInstallS2")
 # By default, run the CPackComponents test if the CTEST_TEST_CPACK
 # option is ON:
 #
 set(CTEST_RUN_CPackComponents ${CTEST_TEST_CPACK})
 set(CTEST_package_X11_TEST ${CTEST_TEST_CPACK})
 find_program(NSIS_MAKENSIS_EXECUTABLE NAMES makensis
   PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
   DOC "makensis program location"
   )
 # But on Windows, only run the CPackComponents test if the NSIS
 # installer builder is available:
 #
 if(WIN32)
   if(NSIS_MAKENSIS_EXECUTABLE)
     set(CTEST_RUN_CPackComponents ON)
   else(NSIS_MAKENSIS_EXECUTABLE)
     set(CTEST_RUN_CPackComponents OFF)
     set(CTEST_package_X11_TEST OFF)
   endif(NSIS_MAKENSIS_EXECUTABLE)
 endif(WIN32)
 IF(CTEST_RUN_CPackComponents)
   set(CPackComponents_EXTRA_OPTIONS)
   if(APPLE)
     set(CPackComponents_EXTRA_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
   endif(APPLE)
   if(NSIS_MAKENSIS_EXECUTABLE)
     set(CPackComponents_EXTRA_OPTIONS ${CPackComponents_EXTRA_OPTIONS}
       -DCPACK_BINARY_NSIS:BOOL=ON)
   endif(NSIS_MAKENSIS_EXECUTABLE)
   ADD_TEST(CPackComponents ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/CPackComponents"
     "${CMake_BINARY_DIR}/Tests/CPackComponents"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-project CPackComponents
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-two-config
     --build-target package
     --build-options
       -DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
       -DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
       ${CPackComponents_EXTRA_OPTIONS}
       --graphviz=CPackComponents.dot
     --test-command ${CMAKE_CMAKE_COMMAND}
       "-DCPackComponents_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponents"
       -P "${CMake_SOURCE_DIR}/Tests/CPackComponents/VerifyResult.cmake")
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponents")
 ENDIF(CTEST_RUN_CPackComponents)
 # By default, turn this test off (because it takes a long time...)
 #
 if(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
   set(CTEST_RUN_CPackTestAllGenerators OFF)
   # ...but: if it appears to be a coverage dashboard, or long tests are
   # on, then set it to the generic CTEST_TEST_CPACK setting.
   #
   if(CMAKE_CXX_FLAGS MATCHES "-ftest-coverage" OR
     NOT "$ENV{COVFILE}" STREQUAL "" OR
     CMAKE_RUN_LONG_TESTS)
     set(CTEST_RUN_CPackTestAllGenerators ${CTEST_TEST_CPACK})
   endif(CMAKE_CXX_FLAGS MATCHES "-ftest-coverage" OR
     NOT "$ENV{COVFILE}" STREQUAL "" OR
     CMAKE_RUN_LONG_TESTS)
 endif(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
 IF(CTEST_RUN_CPackTestAllGenerators)
   ADD_TEST(CPackTestAllGenerators ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators"
     "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-project CPackTestAllGenerators
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --test-command
     ${CMAKE_CMAKE_COMMAND}
       -D dir=${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators
       -D cpack=${CMAKE_CPACK_COMMAND}
       -P ${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators/RunCPack.cmake
     )
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators")
 ENDIF(CTEST_RUN_CPackTestAllGenerators)
 IF(CTEST_package_X11_TEST)
   SET(X11_build_target_arg --build-target package)
 ELSE(CTEST_package_X11_TEST)
   SET(X11_build_target_arg)
 ENDIF(CTEST_package_X11_TEST)
 ADD_TEST(X11 ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/X11"
   "${CMake_BINARY_DIR}/Tests/X11"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project UseX11
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-two-config
   ${X11_build_target_arg}
   --test-command  UseX11)
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/X11")
 if(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
   set(CTEST_RUN_CMakeTestAllGenerators ON)
 endif(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
 IF(CTEST_RUN_CMakeTestAllGenerators)
   ADD_TEST(CMakeTestAllGenerators ${CMAKE_CMAKE_COMMAND}
       -D dir=${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators
       -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
       -P ${CMake_SOURCE_DIR}/Tests/CMakeTestAllGenerators/RunCMake.cmake
     )
   LIST(APPEND TEST_BUILD_DIRS
     "${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators")
 ENDIF(CTEST_RUN_CMakeTestAllGenerators)
 if(NOT DEFINED CTEST_RUN_CMakeTestBadCommandLines)
   set(CTEST_RUN_CMakeTestBadCommandLines ON)
 endif(NOT DEFINED CTEST_RUN_CMakeTestBadCommandLines)
 IF(CTEST_RUN_CMakeTestBadCommandLines)
   ADD_TEST(CMakeTestBadCommandLines ${CMAKE_CMAKE_COMMAND}
       -D dir=${CMake_BINARY_DIR}/Tests/CMakeTestBadCommandLines
       -D gen=${CMAKE_TEST_GENERATOR}
       -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
       -P ${CMake_SOURCE_DIR}/Tests/CMakeTestBadCommandLines/RunCMake.cmake
     )
   LIST(APPEND TEST_BUILD_DIRS
     "${CMake_BINARY_DIR}/Tests/CMakeTestBadCommandLines")
 ENDIF(CTEST_RUN_CMakeTestBadCommandLines)
 if(NOT DEFINED CTEST_RUN_CMakeTestMultipleConfigures)
   set(CTEST_RUN_CMakeTestMultipleConfigures ON)
 endif(NOT DEFINED CTEST_RUN_CMakeTestMultipleConfigures)
 IF(CTEST_RUN_CMakeTestMultipleConfigures)
   ADD_TEST(CMakeTestMultipleConfigures ${CMAKE_CMAKE_COMMAND}
       -D dir=${CMake_BINARY_DIR}/Tests/CMakeTestMultipleConfigures
       -D gen=${CMAKE_TEST_GENERATOR}
       -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
       -P ${CMake_SOURCE_DIR}/Tests/CMakeTestMultipleConfigures/RunCMake.cmake
     )
   LIST(APPEND TEST_BUILD_DIRS
     "${CMake_BINARY_DIR}/Tests/CMakeTestMultipleConfigures")
 ENDIF(CTEST_RUN_CMakeTestMultipleConfigures)
 ADD_TEST(LoadedCommandOneConfig  ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/LoadCommandOneConfig"
   "${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project LoadCommand
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --test-command  LoadedCommand
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig")
 # Como does not seem to support shared libraries.
 GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_CXX_COMPILER} NAME_WE)
 IF(CMAKE_BASE_NAME MATCHES "^como$")
   SET(COMPILER_IS_COMO 1)
 ENDIF(CMAKE_BASE_NAME MATCHES "^como$")
 IF(NOT COMPILER_IS_COMO)
   SET(COMPLEX_TEST_CMAKELIB 1)
   IF(CMAKE_TEST_DIFFERENT_GENERATOR OR CMAKE_TEST_SYSTEM_LIBRARIES)
     SET(COMPLEX_TEST_CMAKELIB 0)
   ENDIF(CMAKE_TEST_DIFFERENT_GENERATOR OR CMAKE_TEST_SYSTEM_LIBRARIES)
   IF(BORLAND)
     SET(COMPLEX_TEST_CMAKELIB 0)
   ENDIF(BORLAND)
   ADD_TEST(complex  ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/Complex"
     "${CMake_BINARY_DIR}/Tests/Complex"
     --build-two-config
     --build-config-sample "${CMAKE_CTEST_COMMAND}"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-project Complex
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Complex/bin"
     --build-options
     -DCOMPLEX_TEST_CMAKELIB:BOOL=${COMPLEX_TEST_CMAKELIB}
     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
     --test-command complex
     )
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Complex")
   ADD_TEST(complexOneConfig  ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/ComplexOneConfig"
     "${CMake_BINARY_DIR}/Tests/ComplexOneConfig"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-project Complex
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-exe-dir "${CMake_BINARY_DIR}/Tests/ComplexOneConfig/bin"
     --build-options
     -DCOMPLEX_TEST_CMAKELIB:BOOL=${COMPLEX_TEST_CMAKELIB}
     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
     --test-command complex)
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ComplexOneConfig")
   # because of the registry write these tests depend on each other
   SET_TESTS_PROPERTIES ( complex PROPERTIES DEPENDS complexOneConfig)
  1. This fails on VS 70
  2. works on Xcode and makefiles
  3. ADD_TEST(ConvLibrary ${CMAKE_CTEST_COMMAND}
  4. --build-and-test
  5. "${CMake_SOURCE_DIR}/Tests/ConvLibrary"
  6. "${CMake_BINARY_DIR}/Tests/ConvLibrary"
  7. --build-two-config
  8. --build-generator ${CMAKE_TEST_GENERATOR}
  9. --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
  10. --build-project ConvLibrary
  11. --test-command bartest)


  1. ADD_TEST(complexRelativePaths ${CMAKE_CTEST_COMMAND}
  2. --build-and-test
  3. "${CMake_SOURCE_DIR}/Tests/ComplexRelativePaths"
  4. "${CMake_BINARY_DIR}/Tests/ComplexRelativePaths"
  5. --build-generator ${CMAKE_TEST_GENERATOR}
  6. --build-project complex
  7. --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
  8. --build-exe-dir "${CMake_BINARY_DIR}/Tests/ComplexRelativePaths/bin"
  9. --build-options -DCMAKE_USE_RELATIVE_PATHS:BOOL=ON
  10. --test-command complex)
 ENDIF(NOT COMPILER_IS_COMO)
 ADD_TEST(Example ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Example"
   "${CMake_BINARY_DIR}/Example"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project HELLO
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-exe-dir "${CMake_BINARY_DIR}/Example/Demo"
   --test-command helloDemo
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Example")
 ADD_TEST(Environment ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/Environment"
   "${CMake_BINARY_DIR}/Tests/Environment"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project EnvironmentProj
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/Environment"
   --force-new-ctest-process
   --test-command ${CMAKE_CTEST_COMMAND} -V
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Environment")
 ADD_TEST(ExternalProject ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/ExternalProject"
   "${CMake_BINARY_DIR}/Tests/ExternalProject"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project ExternalProjectTest
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProject"
   --force-new-ctest-process
   --test-command ${CMAKE_CTEST_COMMAND} -V
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProject")
 # The ExternalProject test takes 900 seconds on some machines!
 GET_TEST_PROPERTY(ExternalProject TIMEOUT PREVIOUS_TIMEOUT)
 IF("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
   SET_TESTS_PROPERTIES(ExternalProject PROPERTIES TIMEOUT 1000)
 ENDIF("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
 # do each of the tutorial steps
 FOREACH(STP RANGE 1 7)
   ADD_TEST(TutorialStep${STP} ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/Tutorial/Step${STP}"
     "${CMake_BINARY_DIR}/Tests/Tutorial/Step${STP}"
     --build-two-config
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-project Tutorial
     --test-command Tutorial 25.0)
 ENDFOREACH(STP)
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Tutorial")
 ADD_TEST(testing ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/Testing"
   "${CMake_BINARY_DIR}/Tests/Testing"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project Testing
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Testing")
 ADD_TEST(wrapping  ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/Wrapping"
   "${CMake_BINARY_DIR}/Tests/Wrapping"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project Wrapping
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
   --test-command wrapping
   )
 ADD_TEST(qtwrapping  ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/Wrapping"
   "${CMake_BINARY_DIR}/Tests/Wrapping"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-project Wrapping
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
     --test-command qtwrapping
     )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Wrapping")
 ADD_TEST(testdriver1 ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/TestDriver"
   "${CMake_BINARY_DIR}/Tests/TestDriver"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
   --build-project TestDriverTest
   --test-command TestDriverTest test1
   )
 ADD_TEST(testdriver2 ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/TestDriver"
   "${CMake_BINARY_DIR}/Tests/TestDriver"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
   --build-project TestDriverTest
   --test-command TestDriverTest test2
   )
 ADD_TEST(testdriver3  ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/TestDriver"
   "${CMake_BINARY_DIR}/Tests/TestDriver"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
   --build-project TestDriverTest
   --test-command TestDriverTest subdir/test3
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver")
 ADD_TEST(Dependency ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/Dependency"
   "${CMake_BINARY_DIR}/Tests/Dependency"
   --build-exe-dir "${CMake_BINARY_DIR}/Tests/Dependency/Exec"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-project Dependency
   --test-command exec
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Dependency")
 IF("${CMAKE_SYSTEM_NAME}" MATCHES syllable)
  1. RPATH isn't supported under Syllable, so the tests don't
  2. find their libraries. In order to fix that LIBRARY_OUTPUT_DIR
  3. in the tests would have to be adjusted to ${EXECUTABLE_OUTPUT_DIR}/lib .
  4. For now we just require on Syllable that the user adjusts the DLL_PATH
  5. environment variable, so except the two tests below all other tests will succeed.
   SET(_DLL_PATH "$ENV{DLL_PATH}")
   IF(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.(:.*)?$")
     MESSAGE(FATAL_ERROR "In order to successfully run the CMake test suite on Syllable you need to add \"\\@bindir\\@/.\" to the DLL_PATH environment variable")
   ENDIF(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.(:.*)?$")
   IF(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.\\./lib(:.*)?$")
     MESSAGE(FATAL_ERROR "In order to successfully run the CMake test suite on Syllable you need to add \"\\@bindir\\@/../lib\" to the DLL_PATH environment variable")
   ENDIF(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.\\./lib(:.*)?$")
 ELSE("${CMAKE_SYSTEM_NAME}" MATCHES syllable)
   ADD_TEST(JumpWithLibOut  ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/Jump"
     "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut"
     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Executable"
     --build-project Jump
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-options
     -DLIBRARY_OUTPUT_PATH:PATH=${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Lib
     --test-command jumpExecutable
     )
   ADD_TEST(JumpNoLibOut  ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/Jump"
     "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut"
     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
     --build-run-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
     --build-project Jump
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --test-command jumpExecutable
     )
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Jump")
   ADD_TEST(Plugin ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/Plugin"
     "${CMake_BINARY_DIR}/Tests/Plugin"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-project Plugin
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-two-config
     --test-command bin/example)
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Plugin")
   IF(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
     ADD_TEST_MACRO(RuntimePath RuntimePath)
   ENDIF(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
 ENDIF("${CMAKE_SYSTEM_NAME}" MATCHES syllable)
 ADD_TEST(linkorder1 ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
   "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-project LinkLineOrder
   --test-command Exec1
   )
 ADD_TEST(linkorder2  ${CMAKE_CTEST_COMMAND}
   --build-and-test
   "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
   "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
   --build-generator ${CMAKE_TEST_GENERATOR}
   --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
   --build-project LinkLineOrder
   --test-command Exec2
   )
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkLineOrder")
 SET_TESTS_PROPERTIES ( qtwrapping PROPERTIES DEPENDS wrapping)
 SET_TESTS_PROPERTIES ( testdriver1 PROPERTIES DEPENDS qtwrapping)
 SET_TESTS_PROPERTIES ( testdriver2 PROPERTIES DEPENDS testdriver1)
 SET_TESTS_PROPERTIES ( testdriver3 PROPERTIES DEPENDS testdriver2)
 SET_TESTS_PROPERTIES ( linkorder2 PROPERTIES DEPENDS linkorder1)
 SET_TESTS_PROPERTIES ( SimpleInstall-Stage2 PROPERTIES DEPENDS SimpleInstall)
 IF(NOT CMAKE_TEST_DIFFERENT_GENERATOR)
   ADD_TEST(kwsys ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Source/kwsys"
     "${CMake_BINARY_DIR}/Tests/kwsys"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-project kwsys
     --test-command kwsysTestsCxx testIOS
     )
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/kwsys")
 ENDIF(NOT CMAKE_TEST_DIFFERENT_GENERATOR)
 SET(MAKE_IS_GNU )
 IF(${CMAKE_TEST_MAKEPROGRAM} MATCHES make)
   EXEC_PROGRAM(
     ${CMAKE_TEST_MAKEPROGRAM} ARGS no_such_target --version
     RETURN_VALUE res OUTPUT_VARIABLE out
     )
   IF("${res}" EQUAL 0)
     IF("${out}" MATCHES "GNU")
       SET(MAKE_IS_GNU 1)
     ENDIF("${out}" MATCHES "GNU")
   ENDIF("${res}" EQUAL 0)
 ENDIF(${CMAKE_TEST_MAKEPROGRAM} MATCHES make)
 # only add this test on platforms that support it
 # some old versions of make simply cannot handle spaces in paths
 IF (MAKE_IS_GNU OR 
     "${CMAKE_TEST_MAKEPROGRAM}" MATCHES "nmake|gmake|wmake" OR
     "${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio|XCode|Borland")
   ADD_TEST(SubDirSpaces ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/SubDirSpaces"
     "${CMake_BINARY_DIR}/Tests/SubDirSpaces"
     --build-exe-dir 
     "${CMake_BINARY_DIR}/Tests/SubDirSpaces/Executable Sources"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-project SUBDIR
     --test-command test
     "${CMake_BINARY_DIR}/Tests/SubDirSpaces/ShouldBeHere"
     "${CMake_BINARY_DIR}/Tests/SubDirSpaces/testfromsubdir.obj"
     )
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDirSpaces")
 ENDIF (MAKE_IS_GNU OR
   "${CMAKE_TEST_MAKEPROGRAM}" MATCHES "nmake|gmake|wmake" OR
   "${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio|XCode|Borland")
 IF (WIN32)
   ADD_TEST(SubDir ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/SubDir"
     "${CMake_BINARY_DIR}/Tests/SubDir"
     --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-project SUBDIR
     --test-command test
     "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
     "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.obj"
     )
 ELSE (WIN32)
   ADD_TEST(SubDir ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/SubDir"
     "${CMake_BINARY_DIR}/Tests/SubDir"
     --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-project SUBDIR
     --test-command test
     "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
     "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.o"
     )
 ENDIF (WIN32)
 LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDir")
 IF(CMAKE_TEST_MSVC)
   ADD_TEST_MACRO(PrecompiledHeader foo)
   ADD_TEST_MACRO(ModuleDefinition example_exe)
 ENDIF(CMAKE_TEST_MSVC)
 IF("${CMAKE_TEST_GENERATOR}" MATCHES "Makefile")
   ADD_TEST(MakeClean ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/MakeClean"
     "${CMake_BINARY_DIR}/Tests/MakeClean"
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-project MakeClean
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-exe-dir "${CMake_BINARY_DIR}/MakeClean"
     --test-command check_clean
     )
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MakeClean")
 ENDIF("${CMAKE_TEST_GENERATOR}" MATCHES "Makefile")
 IF(${CMAKE_TEST_GENERATOR} MATCHES "Visual Studio")
   ADD_TEST(VSExternalInclude ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/VSExternalInclude"
     "${CMake_BINARY_DIR}/Tests/VSExternalInclude"
     --build-two-config
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-project VSExternalInclude
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --test-command VSExternalInclude)
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExternalInclude")
 ENDIF(${CMAKE_TEST_GENERATOR} MATCHES "Visual Studio")
 IF (APPLE AND CMAKE_COMPILER_IS_GNUCXX)
   SET(BundleTestInstallDir
     "${CMake_BINARY_DIR}/Tests/BundleTest/InstallDirectory")
   ADD_TEST(BundleTest ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/BundleTest"
     "${CMake_BINARY_DIR}/Tests/BundleTest"
     --build-two-config
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-project BundleTest
     --build-target install
  1. --build-target package
     --build-options "-DCMAKE_INSTALL_PREFIX:PATH=${BundleTestInstallDir}"
      "-DCMake_SOURCE_DIR:PATH=${CMAKE_SOURCE_DIR}"
     --test-command
     ${BundleTestInstallDir}/Applications/SecondBundleExe.app/Contents/MacOS/SecondBundleExe)
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleTest")
   ADD_TEST_MACRO(ObjC++ ObjC++)
 ENDIF (APPLE AND CMAKE_COMPILER_IS_GNUCXX)
 IF(APPLE AND CTEST_TEST_CPACK)
   ADD_TEST(BundleGeneratorTest ${CMAKE_CTEST_COMMAND}
     --build-and-test
     "${CMake_SOURCE_DIR}/Tests/BundleGeneratorTest"
     "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest"
     --build-two-config
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} 
     --build-project BundleGeneratorTest
     --build-target package
     --build-options "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/BundleGeneratorTest/InstallDirectory"
     )
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest")
 ENDIF(APPLE AND CTEST_TEST_CPACK)
 # Make sure CTest can handle a test with no newline in output.
 ADD_TEST(CTest.NoNewline
   ${CMAKE_COMMAND} -E echo_append "This line has no newline!")
 # A simple test for ctest in script mode
 CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake.in"
         "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake" @ONLY)
  1. ADD_TEST(CTest.ScriptMode ${CMAKE_CTEST_COMMAND}
  2. -S "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake"
  3. )
 SET(CTEST_TEST_UPDATE 1)
 IF(CTEST_TEST_UPDATE)
   # Test CTest Update with Subversion
   FIND_PACKAGE(Subversion QUIET)
   IF(Subversion_FOUND)
     GET_FILENAME_COMPONENT(_Subversion_BIN_DIR
       ${Subversion_SVN_EXECUTABLE} PATH)
     FIND_PROGRAM(Subversion_SVNADMIN_EXECUTABLE svnadmin
       HINTS ${_Subversion_BIN_DIR}
       )
     MARK_AS_ADVANCED(Subversion_SVNADMIN_EXECUTABLE)
     IF(NOT Subversion_SVNADMIN_EXECUTABLE)
       SET(Subversion_FOUND FALSE)
     ENDIF(NOT Subversion_SVNADMIN_EXECUTABLE)
   ENDIF(Subversion_FOUND)
   IF(Subversion_FOUND)
     SET(CTestUpdateSVN_DIR "CTest UpdateSVN")
     CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateSVN.cmake.in"
       "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake" @ONLY)
     ADD_TEST(CTest.UpdateSVN ${CMAKE_CMAKE_COMMAND}
       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake"
       )
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateSVN_DIR}")
   ENDIF(Subversion_FOUND)
   # Test CTest Update with CVS
   IF(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
     FIND_PACKAGE(CVS QUIET)
   ELSE(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
     FIND_PROGRAM(CVS_EXECUTABLE NAMES cvs)
     SET(CVS_FOUND ${CVS_EXECUTABLE})
   ENDIF(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
   SET(CTEST_TEST_UPDATE_CVS ${CVS_FOUND})
   IF(CTEST_TEST_UPDATE_CVS AND NOT UNIX)
     IF("${CVS_EXECUTABLE}" MATCHES "cygwin")
       MESSAGE(STATUS "No CTest.UpdateCVS test with cygwin cvs.exe outside cygwin!")
       SET(CTEST_TEST_UPDATE_CVS 0)
     ENDIF("${CVS_EXECUTABLE}" MATCHES "cygwin")
   ENDIF(CTEST_TEST_UPDATE_CVS AND NOT UNIX)
   IF(CTEST_TEST_UPDATE_CVS)
     SET(CTestUpdateCVS_DIR "CTest UpdateCVS")
     CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateCVS.cmake.in"
       "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake" @ONLY)
     ADD_TEST(CTest.UpdateCVS ${CMAKE_CMAKE_COMMAND}
       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake"
       )
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateCVS_DIR}")
   ENDIF(CTEST_TEST_UPDATE_CVS)
   # Test CTest Update with BZR
   FIND_PROGRAM(BZR_EXECUTABLE NAMES bzr)
   MARK_AS_ADVANCED(BZR_EXECUTABLE)
   SET(CTEST_TEST_UPDATE_BZR 0)
   IF(BZR_EXECUTABLE)
     IF(NOT "${BZR_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
       SET(CTEST_TEST_UPDATE_BZR 1)
     ENDIF(NOT "${BZR_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
   ENDIF(BZR_EXECUTABLE)
   IF(CTEST_TEST_UPDATE_BZR)
     # Check if xmloutput plugin is there
     EXECUTE_PROCESS(COMMAND ${BZR_EXECUTABLE} xmlplugins RESULT_VARIABLE xmlplugres
       OUTPUT_QUIET ERROR_QUIET)
     IF( NOT ${xmlplugres} )
       SET(CTestUpdateBZR_DIR "CTest UpdateBZR")
       CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
         "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake" @ONLY)
       ADD_TEST(CTest.UpdateBZR ${CMAKE_CMAKE_COMMAND}
         -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake"
         )
       LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
       SET(CTestUpdateBZR_DIR "CTest UpdateBZR_CLocale")
       CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
         "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake" @ONLY)
       ADD_TEST(CTest.UpdateBZR.CLocale ${CMAKE_CMAKE_COMMAND}
         -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake"
         )
       SET_TESTS_PROPERTIES(CTest.UpdateBZR.CLocale PROPERTIES ENVIRONMENT LC_ALL=C)
       LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
     ENDIF( NOT ${xmlplugres} )
   ENDIF(CTEST_TEST_UPDATE_BZR)
   # Test CTest Update with GIT
   FIND_PROGRAM(GIT_EXECUTABLE NAMES git)
   MARK_AS_ADVANCED(GIT_EXECUTABLE)
   SET(CTEST_TEST_UPDATE_GIT 0)
   IF(GIT_EXECUTABLE)
     IF(NOT "${GIT_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
       SET(CTEST_TEST_UPDATE_GIT 1)
     ENDIF(NOT "${GIT_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
   ENDIF(GIT_EXECUTABLE)
   IF(CTEST_TEST_UPDATE_GIT)
     SET(CTestUpdateGIT_DIR "CTest UpdateGIT")
     CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateGIT.cmake.in"
       "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake" @ONLY)
     ADD_TEST(CTest.UpdateGIT ${CMAKE_CMAKE_COMMAND}
       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake"
       )
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateGIT_DIR}")
   ENDIF(CTEST_TEST_UPDATE_GIT)
   # Test CTest Update with HG
   FIND_PROGRAM(HG_EXECUTABLE NAMES hg)
   MARK_AS_ADVANCED(HG_EXECUTABLE)
   SET(CTEST_TEST_UPDATE_HG 0)
   IF(HG_EXECUTABLE)
     IF(NOT "${HG_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
       SET(CTEST_TEST_UPDATE_HG 1)
     ENDIF(NOT "${HG_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
   ENDIF(HG_EXECUTABLE)
   IF(CTEST_TEST_UPDATE_HG)
     SET(CTestUpdateHG_DIR "CTest UpdateHG")
     CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateHG.cmake.in"
       "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake" @ONLY)
     ADD_TEST(CTest.UpdateHG ${CMAKE_CMAKE_COMMAND}
       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake"
       )
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateHG_DIR}")
   ENDIF(CTEST_TEST_UPDATE_HG)
 ENDIF(CTEST_TEST_UPDATE)
 CONFIGURE_FILE(
   "${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoBuild.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake"
   @ONLY ESCAPE_QUOTES)
 ADD_TEST(CTestTestNoBuild ${CMAKE_CTEST_COMMAND}
   -S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake" -V
   --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut1.log"
   )
 SET_TESTS_PROPERTIES(CTestTestNoBuild PROPERTIES
   FAIL_REGULAR_EXPRESSION "Error" WILL_FAIL true)
 CONFIGURE_FILE(
   "${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoExe.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake"
   @ONLY ESCAPE_QUOTES)
 ADD_TEST(CTestTestNoExe ${CMAKE_CTEST_COMMAND}
   -S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake" -V
   --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut2.log"
   )
 SET_TESTS_PROPERTIES(CTestTestNoExe PROPERTIES DEPENDS CTestTestNoBuild
   PASS_REGULAR_EXPRESSION "Could not find executable"
   FAIL_REGULAR_EXPRESSION "SegFault")


 # Use macro, not function so that build can still be driven by CMake 2.4.
 # After 2.6 is required, this could be a function without the extra 'set'
 # calls.
 #
 macro(add_config_tests cfg)
   set(cfg "${cfg}")
   set(base "${CMake_BINARY_DIR}/Tests/CTestConfig")
   # Test -S script with a -C config arg to ctest:
   configure_file(
     "${CMake_SOURCE_DIR}/Tests/CTestConfig/script.cmake.in"
     "${base}/${cfg}-script.cmake"
     @ONLY ESCAPE_QUOTES)
   add_test(CTestConfig.Script.${cfg} ${CMAKE_CTEST_COMMAND}
     -C ${cfg}
     -S "${base}/${cfg}-script.cmake" -VV
     --output-log "${base}/${cfg}-script.log"
     )
   # Test -D dashboard with a -C config arg to ctest.
   # (Actual commands inside a cmake -P script because we need to be able to set
   #  the working directory reliably...)
   configure_file(
     "${CMake_SOURCE_DIR}/Tests/CTestConfig/dashboard.cmake.in"
     "${base}/${cfg}-dashboard.cmake"
     @ONLY ESCAPE_QUOTES)
   add_test(CTestConfig.Dashboard.${cfg} ${CMAKE_CMAKE_COMMAND}
     -P "${base}/${cfg}-dashboard.cmake" -VV
     )
 endmacro()
 add_config_tests(Debug)
 add_config_tests(MinSizeRel)
 add_config_tests(Release)
 add_config_tests(RelWithDebInfo)
 add_test(CMakeCommands.build_command ${CMAKE_CMAKE_COMMAND}
   -DCMake_SOURCE_DIR=${CMake_SOURCE_DIR}
   -Ddir=${CMake_BINARY_DIR}/Tests/CMakeCommands/build_command
   -Dgen=${CMAKE_TEST_GENERATOR}
   -P "${CMake_SOURCE_DIR}/Tests/CMakeCommands/build_command/RunCMake.cmake"
 )
 CONFIGURE_FILE(
   "${CMake_SOURCE_DIR}/Tests/CTestTestCrash/test.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake"
   @ONLY ESCAPE_QUOTES)
 ADD_TEST(CTestTestCrash ${CMAKE_CTEST_COMMAND}
   -S "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake" -V
   --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCrash/testOutput.log"
   )
 # with watcom the SEGFAULT is not found, it just fails
 IF(CMAKE_TEST_GENERATOR MATCHES "Watcom WMake")
   SET_TESTS_PROPERTIES(CTestTestCrash PROPERTIES
     PASS_REGULAR_EXPRESSION "Failed")
 ELSE(CMAKE_TEST_GENERATOR MATCHES "Watcom WMake")
   SET_TESTS_PROPERTIES(CTestTestCrash PROPERTIES
     PASS_REGULAR_EXPRESSION "SegFault")
 ENDIF(CMAKE_TEST_GENERATOR MATCHES "Watcom WMake")
   
 CONFIGURE_FILE(
   "${CMake_SOURCE_DIR}/Tests/CTestTestBadExe/test.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake"
   @ONLY ESCAPE_QUOTES)
 ADD_TEST(CTestTestBadExe ${CMAKE_CTEST_COMMAND}
   -S "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake" -V
   --output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/testOutput.log"
   )
 SET(CTestTestBadExe_REGEX "BAD_COMMAND")
 # cygwin can not be made to produce a BAD_COMMAND error
 # the best we can get from it is a failed test
 IF(CYGWIN)
   SET(CTestTestBadExe_REGEX "\\*\\*\\*Failed")
 ENDIF()
 SET_TESTS_PROPERTIES(CTestTestBadExe PROPERTIES
   PASS_REGULAR_EXPRESSION "${CTestTestBadExe_REGEX}")
 CONFIGURE_FILE(
   "${CMake_SOURCE_DIR}/Tests/CTestTestParallel/test.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake"
   @ONLY ESCAPE_QUOTES)
 ADD_TEST(CTestTestParallel ${CMAKE_CTEST_COMMAND}
   -S "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake" -V
   --output-log "${CMake_BINARY_DIR}/Tests/CTestTestParallel/testOutput.log"
   )
 
 CONFIGURE_FILE(
   "${CMake_SOURCE_DIR}/Tests/CTestTestSubdir/test.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake"
   @ONLY ESCAPE_QUOTES)
 ADD_TEST(CTestTestSubdir ${CMAKE_CTEST_COMMAND}
   -S "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake" -V
   --output-log "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/testOutput.log"
   )
 #make sure all 3 subdirs were added
 SET_TESTS_PROPERTIES(CTestTestSubdir PROPERTIES
   PASS_REGULAR_EXPRESSION "0 tests failed out of 3")
   
 CONFIGURE_FILE(
   "${CMake_SOURCE_DIR}/Tests/CTestTestTimeout/test.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake"
   @ONLY ESCAPE_QUOTES)
 ADD_TEST(CTestTestTimeout ${CMAKE_CTEST_COMMAND}
   -C "\${CTestTest_CONFIG}"
   -S "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake" -V
   --output-log "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/testOutput.log"
   )
 SET_TESTS_PROPERTIES(CTestTestTimeout PROPERTIES
   PASS_REGULAR_EXPRESSION "TestTimeout *\\.+ *\\*\\*\\*Timeout.*CheckChild *\\.+ *Passed")
 
 CONFIGURE_FILE(
   "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/test.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake"
   @ONLY ESCAPE_QUOTES)
 CONFIGURE_FILE(
   "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/hello.cmake.in"
   "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/hello.cmake"
   @ONLY ESCAPE_QUOTES)
 ADD_TEST(CTestTestRunScript ${CMAKE_CTEST_COMMAND}
   -S "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake" -V
   --output-log "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/testOutput.log"
   )
 ADD_TEST(CTestTestShowOnly ${CMAKE_CTEST_COMMAND} -N)
 ADD_TEST(CTestBatchTest ${CMAKE_CTEST_COMMAND} -B)
 # Use macro, not function so that build can still be driven by CMake 2.4.
 # After 2.6 is required, this could be a function without the extra 'set'
 # calls.
 #
 macro(add_failed_submit_test name source build in out log regex)
   # Have variables named source, build and drop_method because the
   # configure_file call expects those variables to be defined.
   #
   set(source "${source}")
   set(build "${build}")
   configure_file("${in}" "${out}" @ONLY)
   add_test(${name} ${CMAKE_CTEST_COMMAND} -S "${out}" -V --output-log "${log}")
   set_tests_properties(${name} PROPERTIES PASS_REGULAR_EXPRESSION "${regex}")
 endmacro()
 set(regex "(Problems when submitting via S*CP")
 set(regex "${regex}|Error message was: ")
 set(regex "${regex}([Cc]ould *n.t resolve host")
 set(regex "${regex}|[Cc]ould *n.t connect to host")
 set(regex "${regex}|The requested URL returned error")
 set(regex "${regex}|libcurl was built with SSL disabled. https: not supported)")
 set(regex "${regex}|Submission method .xmlrpc. not compiled into CTest")
 set(regex "${regex}|Submission successful)")
 set(ctest_coverage_labels_args "")
 foreach(drop_method cp ftp http https scp xmlrpc)
   # Cycle through these values each time through the loop:
   if(ctest_coverage_labels_args STREQUAL "")
     set(ctest_coverage_labels_args "LABELS Everything")
   elseif(ctest_coverage_labels_args STREQUAL "LABELS Everything")
     set(ctest_coverage_labels_args "LABELS 0ArgTest")
   else()
     set(ctest_coverage_labels_args "")
   endif()
   add_failed_submit_test(CTestTestFailedSubmit-${drop_method}
     "${CMake_SOURCE_DIR}/Tests/CTestTest/SmallAndFast"
     "${CMake_BINARY_DIR}/Tests/CTestTestFailedSubmits/${drop_method}"
     "${CMake_SOURCE_DIR}/Tests/CTestTestFailedSubmits/test.cmake.in"
     "${CMake_BINARY_DIR}/Tests/CTestTestFailedSubmits/test-${drop_method}.cmake"
     "${CMake_BINARY_DIR}/Tests/CTestTestFailedSubmits/test-${drop_method}.log"
     "${regex}"
     )
 endforeach()


 IF (CTEST_TEST_CTEST AND CMAKE_RUN_LONG_TESTS)
   CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestTest/test.cmake.in"
     "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" @ONLY ESCAPE_QUOTES)
   ADD_TEST(CTestTest ${CMAKE_CTEST_COMMAND}
     -S "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" -V
     --output-log "${CMake_BINARY_DIR}/Tests/CTestTest/testOutput.log"
     )
   CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestTest2/test.cmake.in"
     "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" @ONLY ESCAPE_QUOTES)
   ADD_TEST(CTestTest2 ${CMAKE_CTEST_COMMAND}
     -S "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" -V
     --output-log "${CMake_BINARY_DIR}/Tests/CTestTest2/testOutput.log"
     )
   CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestTest3/test.cmake.in"
     "${CMake_BINARY_DIR}/Tests/CTestTest3/test.cmake" @ONLY ESCAPE_QUOTES)
   ADD_TEST(CTestTest3 ${CMAKE_CTEST_COMMAND}
     -S "${CMake_BINARY_DIR}/Tests/CTestTest3/test.cmake" -V
     --output-log "${CMake_BINARY_DIR}/Tests/CTestTest3/testOutput.log"
     )
   
   # these tests take a long time, make sure they have it
   # if timeouts have not already been set
   GET_TEST_PROPERTY(CTestTest TIMEOUT PREVIOUS_TIMEOUT)
   IF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
     SET_TESTS_PROPERTIES ( CTestTest
       PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
   ENDIF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
   GET_TEST_PROPERTY(CTestTest2 TIMEOUT PREVIOUS_TIMEOUT)
   IF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
     SET_TESTS_PROPERTIES ( CTestTest2
       PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
   ENDIF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
   GET_TEST_PROPERTY(CTestTest3 TIMEOUT PREVIOUS_TIMEOUT)
   IF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
     SET_TESTS_PROPERTIES ( CTestTest3
       PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
   ENDIF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
 ENDIF (CTEST_TEST_CTEST AND CMAKE_RUN_LONG_TESTS)
 IF (CMAKE_RUN_LONG_TESTS AND TEST_KDE4_STABLE_BRANCH)
   IF(UNIX)
     IF(NOT QT4_FOUND)
        FIND_PACKAGE(Qt4)
     ENDIF(NOT QT4_FOUND)
     SET(TRY_BUILD_KDE4 TRUE)
     IF(QT4_FOUND)
       # check whether it's Qt 4.5 in a cmake 2.4. compatible way:
       IF(NOT EXISTS "${QT_QTNETWORK_INCLUDE_DIR}/QAbstractNetworkCache")
         SET(TRY_BUILD_KDE4 FALSE)
       ENDIF(NOT EXISTS "${QT_QTNETWORK_INCLUDE_DIR}/QAbstractNetworkCache")
     ELSE(QT4_FOUND)
       SET(TRY_BUILD_KDE4 FALSE)
     ENDIF(QT4_FOUND)
     FIND_PACKAGE(Perl)
     IF(NOT PERL_FOUND)
       SET(TRY_BUILD_KDE4 FALSE)
     ENDIF(NOT PERL_FOUND)
     FIND_PACKAGE(ZLIB)
     IF(NOT ZLIB_FOUND)
       SET(TRY_BUILD_KDE4 FALSE)
     ENDIF(NOT ZLIB_FOUND)
     IF(TRY_BUILD_KDE4)
       FILE(MAKE_DIRECTORY ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest)
       SET(TEST_KDE4_BASE_DIR ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest)
       CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/KDE4StableBranchTest/test_kde4.sh.in ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest/test_kde4.sh @ONLY)
       EXECUTE_PROCESS(COMMAND chmod 755 ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest/test_kde4.sh )
       ADD_TEST(KDE4StableBranchTest ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest/test_kde4.sh)
     ENDIF(TRY_BUILD_KDE4)
   ENDIF(UNIX)
 ENDIF (CMAKE_RUN_LONG_TESTS AND TEST_KDE4_STABLE_BRANCH)
 
 IF("${CMAKE_TEST_GENERATOR}" MATCHES Xcode)
   SET(CMAKE_SKIP_BOOTSTRAP_TEST 1)
 ENDIF("${CMAKE_TEST_GENERATOR}" MATCHES Xcode)
 IF(EXISTS "${CMAKE_BINARY_DIR}/CMakeLists.txt")
   # If there is CMakeLists.txt in the binary tree, assume in-source build
   SET(CMAKE_SKIP_BOOTSTRAP_TEST 1)
 ENDIF(EXISTS "${CMAKE_BINARY_DIR}/CMakeLists.txt")
 IF(UNIX AND CMAKE_RUN_LONG_TESTS AND NOT CMAKE_SKIP_BOOTSTRAP_TEST)


   ADD_TEST(BootstrapTest ${CMAKE_CTEST_COMMAND}
     --build-and-test
     ${CMake_SOURCE_DIR}
     ${CMake_BINARY_DIR}/Tests/BootstrapTest
     --build-nocmake
     --build-noclean
     --build-makeprogram ${CMake_SOURCE_DIR}/bootstrap
     --build-generator "${CMAKE_TEST_GENERATOR}"
     --test-command 
     ${CMake_BINARY_DIR}/Tests/BootstrapTest/Bootstrap.cmk/cmake)
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BootstrapTest")
   # provide more time for the bootstrap test
   GET_TEST_PROPERTY(BootstrapTest TIMEOUT PREVIOUS_TIMEOUT)
   IF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
     SET_TESTS_PROPERTIES ( BootstrapTest
       PROPERTIES TIMEOUT 5400)
   ENDIF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
 ENDIF(UNIX AND CMAKE_RUN_LONG_TESTS AND NOT CMAKE_SKIP_BOOTSTRAP_TEST)
 # fortran does not work for IDE builds because
 # CMAKE_STANDARD_LIBRARIES needs to be per language
 IF(CMAKE_TEST_GENERATOR MATCHES "Make|KDevelop")
   INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/CheckFortran.cmake)
   IF(CMAKE_Fortran_COMPILER)
     ADD_TEST(Fortran ${CMAKE_CTEST_COMMAND}
       --build-and-test
       "${CMake_SOURCE_DIR}/Tests/Fortran"
       "${CMake_BINARY_DIR}/Tests/Fortran"
       --build-generator ${CMAKE_TEST_GENERATOR}
       --build-project testf
       --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
       --build-two-config
       --test-command testf)
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Fortran")
     # FortranCInterface tests.
     IF(UNIX)
       CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/FortranC/Flags.cmake.in
                      ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake @ONLY)
       ADD_TEST(FortranC.Flags ${CMAKE_CMAKE_COMMAND} -P
         ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake)
       LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC/Flags")
     ENDIF()
   ENDIF()
 ENDIF()
 IF(NOT CMAKE_TEST_GENERATOR MATCHES "Xcode")
   INCLUDE(FindJava)
   IF(JAVA_COMPILE AND JAVA_RUNTIME AND JAVA_ARCHIVE AND NOT MINGW)
     GET_FILENAME_COMPONENT(JNIPATH ${JAVA_COMPILE} PATH)
     FIND_FILE(JNI_H jni.h
       "${JNIPATH}/../include"
       "${JNIPATH}/../java/include")
     IF(JNI_H)
       FILE(READ "${JNI_H}" JNI_FILE)
       IF("${JNI_FILE}" MATCHES "JDK1_2")
         ADD_TEST(Java ${CMAKE_CTEST_COMMAND}
           --build-and-test
           "${CMake_SOURCE_DIR}/Tests/Java"
           "${CMake_BINARY_DIR}/Tests/Java"
           --build-generator ${CMAKE_TEST_GENERATOR}
           --build-project hello
           --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
           --build-two-config
           --build-run-dir "${CMake_BINARY_DIR}/Tests/Java/"
           --test-command ${JAVA_RUNTIME} -classpath hello.jar HelloWorld)
         LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Java")
       ENDIF("${JNI_FILE}" MATCHES "JDK1_2")
     ENDIF(JNI_H)
   ENDIF(JAVA_COMPILE AND JAVA_RUNTIME AND JAVA_ARCHIVE AND NOT MINGW)
 ENDIF(NOT CMAKE_TEST_GENERATOR MATCHES "Xcode")
 # add some cross compiler tests, for now only with makefile based generators
 IF(CMAKE_TEST_GENERATOR MATCHES "Makefiles" OR CMAKE_TEST_GENERATOR MATCHES "KDevelop")
   # if sdcc is found, build the SimpleCOnly project with sdcc
   FIND_PROGRAM(SDCC_EXECUTABLE sdcc)
   MARK_AS_ADVANCED(SDCC_EXECUTABLE)
   IF(SDCC_EXECUTABLE)
     ADD_TEST(SimpleCOnly_sdcc ${CMAKE_CTEST_COMMAND}
       --build-and-test
       "${CMake_SOURCE_DIR}/Tests/SimpleCOnly"
       "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc"
       --build-generator ${CMAKE_TEST_GENERATOR}
       --build-project SimpleC
       --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
       --build-options
       "-DCMAKE_SYSTEM_NAME=Generic"
       "-DCMAKE_C_COMPILER=${SDCC_EXECUTABLE}")
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc")
   ENDIF(SDCC_EXECUTABLE)
   
   
   FIND_PROGRAM(MINGW_CC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-gcc)
   FIND_PROGRAM(MINGW_CXX_LINUX2WIN_EXECUTABLE i586-mingw32msvc-g++)
   MARK_AS_ADVANCED(MINGW_CC_LINUX2WIN_EXECUTABLE MINGW_CXX_LINUX2WIN_EXECUTABLE)
   IF(MINGW_CC_LINUX2WIN_EXECUTABLE  AND  MINGW_CXX_LINUX2WIN_EXECUTABLE)
     ADD_TEST(Simple_Mingw_Linux2Win ${CMAKE_CTEST_COMMAND}
       --build-and-test
       "${CMake_SOURCE_DIR}/Tests/Simple"
       "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win"
       --build-generator ${CMAKE_TEST_GENERATOR}
       --build-project Simple
       --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
       --build-options
       "-DCMAKE_SYSTEM_NAME=Windows"
       "-DCMAKE_C_COMPILER=${MINGW_CC_LINUX2WIN_EXECUTABLE}"
       "-DCMAKE_CXX_COMPILER=${MINGW_CXX_LINUX2WIN_EXECUTABLE}")
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win")
   ENDIF(MINGW_CC_LINUX2WIN_EXECUTABLE  AND  MINGW_CXX_LINUX2WIN_EXECUTABLE)
   
   
 ENDIF(CMAKE_TEST_GENERATOR MATCHES "Makefiles" OR CMAKE_TEST_GENERATOR MATCHES "KDevelop")
 IF(UNIX)
   STRING(COMPARE EQUAL "${CMAKE_INSTALL_PREFIX}" "${CMake_BINARY_DIR}/Tests/TestShellInstall/Prefix"
     PREFIX_IS_FOR_TEST)
   IF(PREFIX_IS_FOR_TEST)
     CONFIGURE_FILE(
       ${CMake_SOURCE_DIR}/Tests/TestInstall.sh.in
       ${CMake_BINARY_DIR}/Tests/TestShellInstall/TestInstall.sh
       @ONLY IMMEDIATE
       )
     ADD_TEST(ShellInstall /bin/sh ${CMake_BINARY_DIR}/Tests/TestShellInstall/TestShellInstall.sh)
   ENDIF(PREFIX_IS_FOR_TEST)
 ENDIF(UNIX)
 IF(CMAKE_TEST_PROJECT_CSE_DIR)
   SET(script "${CMAKE_TEST_PROJECT_CSE_DIR}/BuildProjectCSE.cmake")
   IF(NOT EXISTS "${script}")
     SET(script "${CMAKE_TEST_PROJECT_CSE_DIR}/cse_build.cmake")
   ENDIF(NOT EXISTS "${script}")
   IF(NOT EXISTS "${script}")
     MESSAGE("warning: CMAKE_TEST_PROJECT_CSE_DIR set, but no build script found...")
   ENDIF(NOT EXISTS "${script}")
   ADD_TEST(BuildCSE ${CMAKE_CTEST_COMMAND} -V -S "${script}")
   SET_TESTS_PROPERTIES(BuildCSE PROPERTIES TIMEOUT 5400)
 ENDIF(CMAKE_TEST_PROJECT_CSE_DIR)
 IF(CMAKE_TEST_PLPLOT_DIR)
   ADD_TEST(plplot ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_PLPLOT_DIR}/../../EasyDashboardScripts/plplot.cmake )
   SET_TESTS_PROPERTIES ( plplot PROPERTIES TIMEOUT 5400)
 ENDIF(CMAKE_TEST_PLPLOT_DIR)
 IF(CMAKE_TEST_CHICKEN_DIR)
   ADD_TEST(Chicken ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_CHICKEN_DIR}/../../EasyDashboardScripts/Chicken.cmake )
   SET_TESTS_PROPERTIES ( Chicken PROPERTIES TIMEOUT 5400)
 ENDIF(CMAKE_TEST_CHICKEN_DIR)
 IF(CMAKE_TEST_KDELIBS_ALPHA_1_DIR)
   ADD_TEST(KDELibsAlpha1 ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_KDELIBS_ALPHA_1_DIR}/../../EasyDashboardScripts/kdelibs.cmake )
   SET_TESTS_PROPERTIES ( KDELibsAlpha1 PROPERTIES TIMEOUT 5400)
 ENDIF(CMAKE_TEST_KDELIBS_ALPHA_1_DIR)
 # If this is not an in-source build, provide a target to wipe out
 # all the test build directories.
 IF(NOT EXISTS "${CMAKE_BINARY_DIR}/CMakeLists.txt")
   CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/test_clean.cmake.in
                  ${CMake_BINARY_DIR}/Tests/test_clean.cmake @ONLY)
   ADD_CUSTOM_TARGET(test_clean
     COMMAND ${CMAKE_COMMAND} -P ${CMake_BINARY_DIR}/Tests/test_clean.cmake
     COMMENT "Removing test build directories."
     )
 ENDIF(NOT EXISTS "${CMAKE_BINARY_DIR}/CMakeLists.txt")
 ADD_TEST(CMakeWizardTest ${CMAKE_CMAKE_COMMAND}
   -D build_dir:STRING=${CMAKE_CURRENT_BINARY_DIR}/CMakeWizardTest
   -D source_dir:STRING=${CMAKE_CURRENT_SOURCE_DIR}/Tutorial/Step3
   -D CMAKE_CTEST_COMMAND:STRING=${CMAKE_CTEST_COMMAND}
   -P ${CMAKE_CURRENT_SOURCE_DIR}/CMakeWizardTest.cmake)

ENDIF(BUILD_TESTING)

SUBDIRS(CMakeTests) </source>