061d20be38
When creating an IMPORTED target for a library that has been found on disk, it may not be known whether the library is STATIC or SHARED. However, the library may still be linked using the file found from disk. Use of an IMPORTED target is still important to allow per-configuration files to be specified for the library. This change creates an UNKNOWN type for IMPORTED library targets. The IMPORTED_LOCATION property (and its per-config equivalents) specifies the location of the library. CMake makes no assumptions about the library that cannot be inferred from the file on disk. This will help projects and find-modules import targets found on disk or specified by the user.
384 lines
14 KiB
CMake
384 lines
14 KiB
CMake
cmake_minimum_required (VERSION 2.6)
|
|
PROJECT (TestSimpleInstall)
|
|
SET(CMAKE_VERBOSE_MAKEFILE 1)
|
|
SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY
|
|
"${TestSimpleInstall_BINARY_DIR}/bin")
|
|
SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
|
|
"${TestSimpleInstall_BINARY_DIR}/lib/static")
|
|
SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY
|
|
"${TestSimpleInstall_BINARY_DIR}/lib")
|
|
|
|
# Skip generating the rpath pointing at the build tree to make sure
|
|
# the executable is installed with the proper rpath in the install
|
|
# tree.
|
|
SET(CMAKE_SKIP_BUILD_RPATH 1)
|
|
|
|
# Make sure the executable can run from the install tree.
|
|
SET(CMAKE_INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/MyTest/lib)
|
|
|
|
# Skip the dependency that causes a build when installing. This
|
|
# avoids infinite loops when the post-build rule below installs.
|
|
SET(CMAKE_SKIP_INSTALL_ALL_DEPENDENCY 1)
|
|
SET(CMAKE_SKIP_PACKAGE_ALL_DEPENDENCY 1)
|
|
|
|
SET(CMAKE_DEBUG_POSTFIX "_test_debug_postfix")
|
|
|
|
SET(EXTRA_INSTALL_FLAGS)
|
|
MESSAGE("Extra install: ${EXTRA_INSTALL_FLAGS}")
|
|
|
|
IF(STAGE2)
|
|
SET(LIBPATHS
|
|
${CMAKE_INSTALL_PREFIX}/MyTest/lib/static
|
|
${CMAKE_INSTALL_PREFIX}/MyTest/lib
|
|
)
|
|
SET(t1NAMES test1 test1${CMAKE_DEBUG_POSTFIX} test1rel)
|
|
SET(t2NAMES test2 test2${CMAKE_DEBUG_POSTFIX})
|
|
SET(t4NAMES test4 test4${CMAKE_DEBUG_POSTFIX})
|
|
|
|
# Make sure the install script ran.
|
|
SET(CMAKE_INSTALL_SCRIPT_DID_RUN 0)
|
|
INCLUDE(${CMAKE_INSTALL_PREFIX}/MyTest/InstallScriptOut.cmake OPTIONAL)
|
|
IF(CMAKE_INSTALL_SCRIPT_DID_RUN)
|
|
MESSAGE(STATUS "Stage 1 did run install script 2.")
|
|
ELSE(CMAKE_INSTALL_SCRIPT_DID_RUN)
|
|
MESSAGE(SEND_ERROR "Stage 1 did not run install script 2.")
|
|
ENDIF(CMAKE_INSTALL_SCRIPT_DID_RUN)
|
|
|
|
IF(CYGWIN OR MINGW)
|
|
SET(LIBPATHS ${LIBPATHS} "${CMAKE_INSTALL_PREFIX}/MyTest/bin")
|
|
ENDIF(CYGWIN OR MINGW)
|
|
MESSAGE("Search for library in: ${LIBPATHS}")
|
|
|
|
SET(TEST1_LIBRARY "TEST1_LIBRARY-NOTFOUND" CACHE FILEPATH "Force find." FORCE)
|
|
SET(TEST2_LIBRARY "TEST2_LIBRARY-NOTFOUND" CACHE FILEPATH "Force find." FORCE)
|
|
SET(TEST4_LIBRARY "TEST4_LIBRARY-NOTFOUND" CACHE FILEPATH "Force find." FORCE)
|
|
|
|
FIND_LIBRARY(TEST1_LIBRARY
|
|
NAMES ${t1NAMES}
|
|
PATHS ${LIBPATHS}
|
|
DOC "First library")
|
|
FIND_LIBRARY(TEST2_LIBRARY
|
|
NAMES ${t2NAMES}
|
|
PATHS ${LIBPATHS}
|
|
DOC "Second library")
|
|
FIND_LIBRARY(TEST4_LIBRARY
|
|
NAMES ${t4NAMES}
|
|
PATHS ${LIBPATHS}
|
|
DOC "Fourth library")
|
|
|
|
# Test importing a library found on disk.
|
|
ADD_LIBRARY(lib_test4 UNKNOWN IMPORTED)
|
|
SET_PROPERTY(TARGET lib_test4 PROPERTY IMPORTED_LOCATION ${TEST4_LIBRARY})
|
|
|
|
INCLUDE_DIRECTORIES(${CMAKE_INSTALL_PREFIX}/MyTest/include)
|
|
ADD_EXECUTABLE (SimpleInstExeS2 inst2.cxx foo.c foo.h)
|
|
TARGET_LINK_LIBRARIES(SimpleInstExeS2 ${TEST1_LIBRARY} ${TEST2_LIBRARY} lib_test4)
|
|
SET(install_target SimpleInstExeS2)
|
|
|
|
IF("${TEST1_LIBRARY}" MATCHES "static")
|
|
MESSAGE(STATUS "test1 correctly found in lib/static")
|
|
ELSE("${TEST1_LIBRARY}" MATCHES "static")
|
|
MESSAGE(SEND_ERROR "test1 not found in lib/static!")
|
|
ENDIF("${TEST1_LIBRARY}" MATCHES "static")
|
|
|
|
# Check for failure of configuration-specific installation.
|
|
IF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/include/Release/lib1debug.h")
|
|
MESSAGE(FATAL_ERROR "Debug-configuration file installed for Release!")
|
|
ENDIF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/include/Release/lib1debug.h")
|
|
IF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/include/Debug/lib1release.h")
|
|
MESSAGE(FATAL_ERROR "Release-configuration file installed for Debug!")
|
|
ENDIF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/include/Debug/lib1release.h")
|
|
|
|
# Check for failure of directory installation.
|
|
IF(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/TSD.h")
|
|
MESSAGE(FATAL_ERROR "Directory installation did not install TSD.h")
|
|
ENDIF(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/TSD.h")
|
|
IF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/CVS")
|
|
MESSAGE(FATAL_ERROR "Directory installation installed CVS directory.")
|
|
ENDIF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/CVS")
|
|
IF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/CVS")
|
|
MESSAGE(FATAL_ERROR "Directory installation installed CVS directory.")
|
|
ENDIF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/CVS")
|
|
IF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/CMakeLists.txt")
|
|
MESSAGE(FATAL_ERROR "Directory installation installed CMakeLists.txt.")
|
|
ENDIF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/CMakeLists.txt")
|
|
IF(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/alt/TestSubDir/TSD.h")
|
|
MESSAGE(FATAL_ERROR "Directory installation did not install alternate TSD.h")
|
|
ENDIF(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/alt/TestSubDir/TSD.h")
|
|
IF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/alt/TestSubDir/TSD.cxx")
|
|
MESSAGE(FATAL_ERROR "Directory installation installed alternate TSD.cxx")
|
|
ENDIF(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/alt/TestSubDir/TSD.cxx")
|
|
|
|
# Check that scripts properly installed.
|
|
IF(WIN32 AND NOT CYGWIN)
|
|
SET(BAT .bat)
|
|
ELSE(WIN32 AND NOT CYGWIN)
|
|
SET(BAT)
|
|
ENDIF(WIN32 AND NOT CYGWIN)
|
|
FOREACH(loc share share/old1 share/old2 share/old3 share/alt)
|
|
SET(CUR_SCRIPT "${CMAKE_INSTALL_PREFIX}/MyTest/${loc}/sample_script${BAT}")
|
|
EXECUTE_PROCESS(
|
|
COMMAND ${CUR_SCRIPT}
|
|
RESULT_VARIABLE SAMPLE_SCRIPT_RESULT
|
|
OUTPUT_VARIABLE SAMPLE_SCRIPT_OUTPUT
|
|
)
|
|
IF(NOT "${SAMPLE_SCRIPT_RESULT}" MATCHES "^0$")
|
|
MESSAGE(FATAL_ERROR
|
|
"Sample script [${CUR_SCRIPT}] failed: [${SAMPLE_SCRIPT_RESULT}]")
|
|
ENDIF(NOT "${SAMPLE_SCRIPT_RESULT}" MATCHES "^0$")
|
|
IF(NOT "${SAMPLE_SCRIPT_OUTPUT}" MATCHES "Sample Script Output")
|
|
MESSAGE(FATAL_ERROR
|
|
"Bad sample script [${CUR_SCRIPT}] output: [${SAMPLE_SCRIPT_OUTPUT}]")
|
|
ENDIF(NOT "${SAMPLE_SCRIPT_OUTPUT}" MATCHES "Sample Script Output")
|
|
ENDFOREACH(loc)
|
|
|
|
# Check for failure of empty directory installation.
|
|
IF(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/empty")
|
|
MESSAGE(FATAL_ERROR "Empty directory installation did not install.")
|
|
ENDIF(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/empty")
|
|
FILE(GLOB EMPTY_FILES "${CMAKE_INSTALL_PREFIX}/MyTest/share/empty/*")
|
|
IF(EMPTY_FILES)
|
|
MESSAGE(FATAL_ERROR "Empty directory installed [${EMPTY_FILES}].")
|
|
ENDIF(EMPTY_FILES)
|
|
|
|
# Make sure the test executable can run from the install tree.
|
|
SET_TARGET_PROPERTIES(SimpleInstExeS2 PROPERTIES
|
|
INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/MyTest/lib)
|
|
|
|
INSTALL_TARGETS(/MyTest/bin SimpleInstExeS2)
|
|
|
|
# try to import the exported targets again
|
|
SET(SimpleInstallS1_DIR ${CMAKE_INSTALL_PREFIX}/MyTest/lib)
|
|
FIND_PACKAGE(SimpleInstallS1 REQUIRED)
|
|
GET_TARGET_PROPERTY(simpleInstallImported S1_SimpleInstall IMPORTED)
|
|
IF(NOT simpleInstallImported)
|
|
MESSAGE(FATAL_ERROR "Target S1_SimpleInstall could not be imported")
|
|
ENDIF(NOT simpleInstallImported)
|
|
|
|
ELSE(STAGE2)
|
|
# Wipe out the install directory to do a fresh test.
|
|
FILE(REMOVE_RECURSE ${CMAKE_INSTALL_PREFIX}/MyTest)
|
|
|
|
# this is stage 1, so create libraries and modules and install everything
|
|
ADD_LIBRARY(test1 STATIC lib1.cxx)
|
|
ADD_LIBRARY(test2 SHARED lib2.cxx)
|
|
ADD_LIBRARY(test3 MODULE lib3.cxx)
|
|
ADD_LIBRARY(test4 SHARED lib4.cxx)
|
|
|
|
ADD_EXECUTABLE (SimpleInstall inst.cxx foo.c foo.h)
|
|
TARGET_LINK_LIBRARIES(SimpleInstall test1 test2 test4)
|
|
SET(install_target SimpleInstall)
|
|
|
|
# Make sure the test executable can run from the install tree.
|
|
SET_TARGET_PROPERTIES(SimpleInstall PROPERTIES
|
|
INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/MyTest/lib)
|
|
|
|
# Test per-configuration output name.
|
|
SET_TARGET_PROPERTIES(test1 PROPERTIES RELEASE_OUTPUT_NAME test1rel)
|
|
SET_TARGET_PROPERTIES(test2 PROPERTIES PUBLIC_HEADER foo.h)
|
|
|
|
IF(CMAKE_GENERATOR MATCHES "Makefiles")
|
|
ADD_SUBDIRECTORY(TestSubDir)
|
|
ADD_DEPENDENCIES(SimpleInstall TSD)
|
|
ENDIF(CMAKE_GENERATOR MATCHES "Makefiles")
|
|
|
|
ADD_DEPENDENCIES(SimpleInstall test3)
|
|
ADD_DEPENDENCIES(test2 test3)
|
|
ADD_DEPENDENCIES(test4 test2)
|
|
|
|
INSTALL(TARGETS SimpleInstall test1 test2 test3 EXPORT SimpleInstallS1
|
|
RUNTIME DESTINATION MyTest/bin COMPONENT Runtime # .exe, .dll
|
|
LIBRARY DESTINATION MyTest/lib COMPONENT Runtime # .so, mod.dll
|
|
ARCHIVE DESTINATION MyTest/lib/static COMPONENT Development # .a, .lib
|
|
PUBLIC_HEADER DESTINATION MyTest/include COMPONENT Development
|
|
)
|
|
|
|
INSTALL(TARGETS test4 PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
|
|
RUNTIME DESTINATION MyTest/bin
|
|
LIBRARY DESTINATION MyTest/lib
|
|
ARCHIVE DESTINATION MyTest/lib/static
|
|
OPTIONAL # for coverage...target should always exist
|
|
)
|
|
INSTALL(FILES lib1.h DESTINATION MyTest/include/foo)
|
|
INSTALL(FILES lib2.h
|
|
DESTINATION MyTest/include/foo
|
|
COMPONENT Development
|
|
PERMISSIONS OWNER_READ OWNER_WRITE
|
|
RENAME lib2renamed.h
|
|
)
|
|
|
|
# Test old-style install commands.
|
|
INSTALL_FILES(/MyTest/include FILES lib3.h)
|
|
INSTALL_FILES(/MyTest/include/old .h lib3)
|
|
INSTALL_FILES(/MyTest/include/old "^lib2.h$")
|
|
INSTALL_PROGRAMS(/MyTest/share/old1 FILES
|
|
scripts/sample_script scripts/sample_script.bat)
|
|
INSTALL_PROGRAMS(/MyTest/share/old2
|
|
scripts/sample_script scripts/sample_script.bat)
|
|
|
|
# "export" the targets collected in "SimpleInstallS1"
|
|
INSTALL(EXPORT SimpleInstallS1 FILE SimpleInstallS1Config.cmake
|
|
DESTINATION MyTest/lib
|
|
NAMESPACE S1_ )
|
|
|
|
EXPORT(TARGETS SimpleInstall test1 test2 test3
|
|
FILE "${CMAKE_CURRENT_BINARY_DIR}/SimpleInstallS1Config.cmake"
|
|
NAMESPACE S2_ )
|
|
|
|
ADD_SUBDIRECTORY(scripts)
|
|
|
|
# Test optional installation.
|
|
INSTALL(FILES does_not_exist.h DESTINATION MyTest/include/foo OPTIONAL)
|
|
|
|
# Test configuration-specific installation.
|
|
INSTALL(FILES lib1.h RENAME lib1release.h CONFIGURATIONS Release
|
|
DESTINATION MyTest/include/Release
|
|
)
|
|
INSTALL(FILES lib1.h RENAME lib1debug.h CONFIGURATIONS Debug
|
|
DESTINATION MyTest/include/Debug
|
|
)
|
|
|
|
# Test directory installation.
|
|
FILE(REMOVE_RECURSE "${CMAKE_INSTALL_PREFIX}/MyTest/share/CVS")
|
|
FILE(REMOVE_RECURSE "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/CVS")
|
|
INSTALL(
|
|
DIRECTORY TestSubDir scripts/ DESTINATION MyTest/share
|
|
FILE_PERMISSIONS OWNER_READ OWNER_WRITE
|
|
DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
|
|
GROUP_READ GROUP_EXECUTE
|
|
PATTERN "CVS" EXCLUDE
|
|
REGEX "\\.txt$" EXCLUDE
|
|
PATTERN "scripts/*" PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
|
|
)
|
|
|
|
# Alternate directory installation for coverage.
|
|
INSTALL(
|
|
DIRECTORY scripts/ DESTINATION MyTest/share/alt
|
|
COMPONENT Development
|
|
USE_SOURCE_PERMISSIONS
|
|
PATTERN "CVS" EXCLUDE
|
|
REGEX "\\.txt$" EXCLUDE
|
|
)
|
|
INSTALL(
|
|
DIRECTORY TestSubDir DESTINATION MyTest/share/alt
|
|
FILE_PERMISSIONS OWNER_READ OWNER_WRITE
|
|
DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
|
|
GROUP_READ GROUP_EXECUTE
|
|
FILES_MATCHING PATTERN "*.h"
|
|
)
|
|
|
|
# Test empty directory installation.
|
|
INSTALL(DIRECTORY DESTINATION MyTest/share/empty)
|
|
|
|
# Test user-specified install scripts, with and without COMPONENT.
|
|
INSTALL(
|
|
SCRIPT InstallScript1.cmake
|
|
CODE "SET(INSTALL_CODE_DID_RUN 1)"
|
|
SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/InstallScript2.cmake
|
|
)
|
|
INSTALL(
|
|
SCRIPT InstallScript3.cmake
|
|
CODE "SET(INSTALL_CODE_WITH_COMPONENT_DID_RUN 1)"
|
|
SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/InstallScript4.cmake
|
|
COMPONENT Development
|
|
)
|
|
SET_DIRECTORY_PROPERTIES(PROPERTIES
|
|
ADDITIONAL_MAKE_CLEAN_FILES
|
|
"${CMAKE_INSTALL_PREFIX}/InstallScriptOut.cmake;${CMAKE_INSTALL_PREFIX}/InstallScript4Out.cmake")
|
|
|
|
SET_TARGET_PROPERTIES(SimpleInstall PROPERTIES OUTPUT_NAME SimpleInstExe)
|
|
# Disable VERSION test until it is implemented in the XCode generator.
|
|
IF(NOT XCODE)
|
|
SET_TARGET_PROPERTIES(SimpleInstall PROPERTIES VERSION 1.2)
|
|
ENDIF(NOT XCODE)
|
|
SET_TARGET_PROPERTIES(SimpleInstall PROPERTIES PRE_INSTALL_SCRIPT
|
|
${CMAKE_CURRENT_SOURCE_DIR}/PreInstall.cmake)
|
|
SET_TARGET_PROPERTIES(SimpleInstall PROPERTIES POST_INSTALL_SCRIPT
|
|
${CMAKE_CURRENT_SOURCE_DIR}/PostInstall.cmake)
|
|
SET_TARGET_PROPERTIES(test4 PROPERTIES VERSION 1.2 SOVERSION 3
|
|
INSTALL_NAME_DIR @executable_path/../lib)
|
|
ENDIF(STAGE2)
|
|
|
|
IF(CMAKE_CONFIGURATION_TYPES)
|
|
SET(SI_CONFIG -C ${CMAKE_CFG_INTDIR})
|
|
ELSE(CMAKE_CONFIGURATION_TYPES)
|
|
SET(SI_CONFIG)
|
|
ENDIF(CMAKE_CONFIGURATION_TYPES)
|
|
|
|
# Dummy test of CPack
|
|
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Test of packaging with cpack")
|
|
SET(CPACK_PACKAGE_VENDOR "Kitware")
|
|
SET(CPACK_INSTALL_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/PackageScript.cmake")
|
|
|
|
IF(WIN32 AND NOT UNIX)
|
|
FIND_PROGRAM(NSIS_MAKENSIS NAMES makensis
|
|
PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
|
|
DOC "Where is makensis.exe located"
|
|
)
|
|
IF(NOT NSIS_MAKENSIS)
|
|
SET(CPACK_GENERATOR TGZ)
|
|
ENDIF(NOT NSIS_MAKENSIS)
|
|
ENDIF(WIN32 AND NOT UNIX)
|
|
IF(UNIX AND NOT APPLE)
|
|
SET(CPACK_GENERATOR "TGZ;STGZ;TZ")
|
|
# FIND_PROGRAM(found_compress
|
|
# NAMES compress)
|
|
# IF(found_compress)
|
|
# FIND_PROGRAM(file_command NAMES file)
|
|
# IF(NOT file_command)
|
|
# set(file_command file)
|
|
# ENDIF(NOT file_command)
|
|
# EXECUTE_PROCESS(COMMAND ${file_command} ${found_compress}
|
|
# OUTPUT_VARIABLE output)
|
|
# set(SKIP_TZ FALSE)
|
|
# if("${output}" MATCHES "script")
|
|
# set(SKIP_TZ TRUE)
|
|
# endif("${output}" MATCHES "script")
|
|
# if("${output}" MATCHES "dummy.sh")
|
|
# set(SKIP_TZ TRUE)
|
|
# endif("${output}" MATCHES "dummy.sh")
|
|
# if(NOT SKIP_TZ)
|
|
# message("compress found and it was not a script")
|
|
# message("output from file command: [${output}]")
|
|
# SET(CPACK_GENERATOR "${CPACK_GENERATOR};TZ")
|
|
# else(NOT SKIP_TZ)
|
|
# message("compress found, but it was a script so dont use it")
|
|
# message("output from file command: [${output}]")
|
|
# endif(NOT SKIP_TZ)
|
|
# ENDIF(found_compress)
|
|
FIND_PROGRAM(found_bz2
|
|
NAMES bzip2)
|
|
IF(found_bz2)
|
|
SET(CPACK_GENERATOR "${CPACK_GENERATOR};TBZ2")
|
|
ENDIF(found_bz2)
|
|
ENDIF(UNIX AND NOT APPLE)
|
|
|
|
SET(CPACK_PACKAGE_EXECUTABLES "SimpleInstall" "Simple Install")
|
|
SET(CMAKE_INSTALL_MFC_LIBRARIES 1)
|
|
SET(CMAKE_INSTALL_DEBUG_LIBRARIES 1)
|
|
INCLUDE(InstallRequiredSystemLibraries)
|
|
INCLUDE(CPack)
|
|
|
|
IF(CTEST_TEST_CPACK)
|
|
SET(PACKAGE_TARGET --build-target package)
|
|
ELSE(CTEST_TEST_CPACK)
|
|
SET(PACKAGE_TARGET)
|
|
ENDIF(CTEST_TEST_CPACK)
|
|
|
|
ADD_CUSTOM_COMMAND(
|
|
TARGET ${install_target}
|
|
POST_BUILD
|
|
COMMAND ${CMAKE_CTEST_COMMAND}
|
|
ARGS ${SI_CONFIG}
|
|
--build-and-test
|
|
${CMAKE_SOURCE_DIR}
|
|
${CMAKE_BINARY_DIR}
|
|
--build-generator ${CMAKE_GENERATOR}
|
|
--build-project ${PROJECT_NAME}
|
|
--build-makeprogram ${CMAKE_MAKE_PROGRAM}
|
|
--build-noclean
|
|
--build-target install
|
|
${PACKAGE_TARGET}
|
|
COMMENT "Install Project"
|
|
)
|