diff --git a/CMake/mitkMacroCreateDefaultTests.cmake b/CMake/mitkMacroCreateDefaultTests.cmake index 04113785fa..6f1df524ac 100644 --- a/CMake/mitkMacroCreateDefaultTests.cmake +++ b/CMake/mitkMacroCreateDefaultTests.cmake @@ -1,58 +1,61 @@ # Create TestDriver and default tests for MITK # # CMake variables used: # # ${${KITNAME}_GUI_TESTS} : filenames of all tests that run without a parameter # ${${KITNAME}_IMAGE_GUI_TESTS : filenames of all tests that run with an image filename as parameter # ${${KITNAME}_TESTS} : filenames of all tests that run without a parameter # ${${KITNAME}_IMAGE_TESTS : filenames of all tests that run with an image filename as parameter # ${${KITNAME}_TESTIMAGES} : list of images passed as parameter for the IMAGE_TESTS # ${${KITNAME}_CUSTOM_TESTS} : filenames of custom tests which are just added to the TestDriver. Execution # of these has to be specified manually with the ADD_TEST CMake command. # MACRO(MITK_CREATE_DEFAULT_TESTS) # add tests which need a GUI if it is not disabled IF(NOT MITK_GUI_TESTS_DISABLED) SET( ${KITNAME}_TESTS ${${KITNAME}_TESTS} ${${KITNAME}_GUI_TESTS} ) SET( ${KITNAME}_IMAGE_TESTS ${${KITNAME}_IMAGE_TESTS} ${${KITNAME}_IMAGE_GUI_TESTS} ) ENDIF(NOT MITK_GUI_TESTS_DISABLED) # # Create the TestDriver binary which contains all the tests. # CREATE_TEST_SOURCELIST(MITKTEST_SOURCE ${KITNAME}TestDriver.cpp ${${KITNAME}_TESTS} ${${KITNAME}_IMAGE_TESTS} ${${KITNAME}_CUSTOM_TESTS} ) ADD_EXECUTABLE(${KITNAME}TestDriver ${MITKTEST_SOURCE}) + set_property(TARGET ${KITNAME}TestDriver PROPERTY LABELS ${PROJECT_NAME}) TARGET_LINK_LIBRARIES(${KITNAME}TestDriver ${${KITNAME}_CORE_LIBRARIES} ${${KITNAME}_LIBRARIES} ${LIBRARIES_FOR_${KITNAME}_CORE}) # # Now tell CMake which tests should be run. This is done automatically # for all tests in ${KITNAME}_TESTS and ${KITNAME}_IMAGE_TESTS. The IMAGE_TESTS # are run for each image in the TESTIMAGES list. # FOREACH( test ${${KITNAME}_TESTS} ) GET_FILENAME_COMPONENT(TName ${test} NAME_WE) ADD_TEST(${TName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KITNAME}TestDriver ${TName}) + set_property(TEST ${TName} PROPERTY LABELS ${PROJECT_NAME}) ENDFOREACH( test ) FOREACH(image ${${KITNAME}_TESTIMAGES} ${ADDITIONAL_TEST_IMAGES} ) IF(EXISTS ${image}) SET(IMAGE_FULL_PATH ${image}) ELSE(EXISTS ${image}) # todo: maybe search other paths as well # yes, please in mitk/Testing/Data, too SET(IMAGE_FULL_PATH ${CMAKE_CURRENT_SOURCE_DIR}/Data/${image}) ENDIF(EXISTS ${image}) IF(EXISTS ${IMAGE_FULL_PATH}) FOREACH( test ${${KITNAME}_IMAGE_TESTS} ) GET_FILENAME_COMPONENT(TName ${test} NAME_WE) GET_FILENAME_COMPONENT(ImageName ${IMAGE_FULL_PATH} NAME) ADD_TEST(${TName}_${ImageName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KITNAME}TestDriver ${TName} ${IMAGE_FULL_PATH}) + set_property(TEST ${TName}_${ImageName} PROPERTY LABELS ${PROJECT_NAME}) ENDFOREACH( test ) ELSE(EXISTS ${IMAGE_FULL_PATH}) MESSAGE("!!!!! No such file: ${IMAGE_FULL_PATH} !!!!!") ENDIF(EXISTS ${IMAGE_FULL_PATH}) ENDFOREACH( image ) ENDMACRO(MITK_CREATE_DEFAULT_TESTS) diff --git a/CMake/mitkMacroCreateModule.cmake b/CMake/mitkMacroCreateModule.cmake index cb6eee6d5a..286f1aae98 100644 --- a/CMake/mitkMacroCreateModule.cmake +++ b/CMake/mitkMacroCreateModule.cmake @@ -1,150 +1,150 @@ ################################################################## # # MITK_CREATE_MODULE # # Creates a module for the automatic module dependeny system within MITK. # Configurations are generated in the moduleConf directory. # # USAGE: # # MITK_CREATE_MODULE( # [INCLUDE_DIRS ] # [INTERNAL_INCLUDE_DIRS ] # [DEPENDS ] # [PROVIDES ] # [PACKAGE_DEPENDS ] # [EXPORT_DEFINE ] # [QT_MODULE] # ################################################################## MACRO(MITK_CREATE_MODULE MODULE_NAME_IN) MACRO_PARSE_ARGUMENTS(MODULE "INCLUDE_DIRS;INTERNAL_INCLUDE_DIRS;DEPENDS;DEPENDS_INTERNAL;PROVIDES;PACKAGE_DEPENDS;EXPORT_DEFINE;ADDITIONAL_LIBS;GENERATED_CPP" "QT_MODULE;FORCE_STATIC;HEADERS_ONLY" ${ARGN}) SET(MODULE_NAME ${MODULE_NAME_IN}) # assume worst case SET(MODULE_IS_ENABLED 0) # first of all we check for the dependencies MITK_CHECK_MODULE(_MISSING_DEP ${MODULE_DEPENDS}) IF(_MISSING_DEP) MESSAGE("Module ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}") SET(MODULE_IS_ENABLED 0) ELSE(_MISSING_DEP) SET(MODULE_IS_ENABLED 1) # now check for every package if it is enabled. This overlaps a bit with # MITK_CHECK_MODULE ... FOREACH(_package ${MODULE_PACKAGE_DEPENDS}) IF((DEFINED MITK_USE_${_package}) AND NOT (MITK_USE_${_package})) MESSAGE("Module ${MODULE_NAME} won't be built. Turn on MITK_USE_${_package} if you want to use it.") SET(MODULE_IS_ENABLED 0) ENDIF() ENDFOREACH() IF(MODULE_IS_ENABLED) IF(NOT MODULE_QT_MODULE OR MITK_USE_QT) SET(MODULE_IS_ENABLED 1) _MITK_CREATE_MODULE_CONF() IF(NOT MODULE_EXPORT_DEFINE) SET(MODULE_EXPORT_DEFINE ${MODULE_NAME}_EXPORT) ENDIF(NOT MODULE_EXPORT_DEFINE) CONFIGURE_FILE(${MITK_SOURCE_DIR}/CMake/moduleExports.h.in ${MITK_MODULES_CONF_DIR}/${MODULE_NAME}Exports.h @ONLY) IF(MITK_GENERATE_MODULE_DOT) MESSAGE("MODULEDOTNAME ${MODULE_NAME}") FOREACH(dep ${MODULE_DEPENDS}) MESSAGE("MODULEDOT \"${MODULE_NAME}\" -> \"${dep}\" ; ") ENDFOREACH(dep) ENDIF(MITK_GENERATE_MODULE_DOT) SET(DEPENDS "${MODULE_DEPENDS}") SET(DEPENDS_BEFORE "not initialized") SET(PACKAGE_DEPENDS "${MODULE_PACKAGE_DEPENDS}") MITK_USE_MODULE("${MODULE_DEPENDS}") # ok, now create the module itself INCLUDE_DIRECTORIES(. ${ALL_INCLUDE_DIRECTORIES}) INCLUDE(files.cmake) IF(NOT MODULE_QT_MODULE) ORGANIZE_SOURCES(SOURCE ${CPP_FILES} HEADER ${H_FILES} TXX ${TXX_FILES} DOC ${DOX_FILES} ) IF(MODULE_FORCE_STATIC) SET(_STATIC ${MITK_WIN32_FORCE_STATIC}) ENDIF(MODULE_FORCE_STATIC) IF(NOT MODULE_HEADERS_ONLY) IF(ALL_LIBRARY_DIRS) # LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) ENDIF(ALL_LIBRARY_DIRS) ADD_LIBRARY(${MODULE_PROVIDES} ${_STATIC} ${CPP_FILES} ${H_FILES} ${CPP_FILES_GENERATED} ${GLOBBED__H_FILES} ${CORRESPONDING__H_FILES} ${TXX_FILES} ${DOX_FILES} ${UI_FILES} ${TOOL_CPPS}) - set_property(TARGET ${MODULE_PROVIDES} PROPERTY LABELS MITK) + set_property(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${PROJECT_NAME}) IF(ALL_LIBRARIES) TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${ALL_LIBRARIES}) ENDIF(ALL_LIBRARIES) ENDIF() ELSE(NOT MODULE_QT_MODULE) INCLUDE(files.cmake) IF(UI_FILES) QT4_WRAP_UI(Q${KITNAME}_GENERATED_UI_CPP ${UI_FILES}) ENDIF(UI_FILES) IF(MOC_H_FILES) QT4_WRAP_CPP(Q${KITNAME}_GENERATED_MOC_CPP ${MOC_H_FILES}) ENDIF(MOC_H_FILES) IF(QRC_FILES) QT4_ADD_RESOURCES(Q${KITNAME}_GENERATED_QRC_CPP ${QRC_FILES}) ENDIF(QRC_FILES) SET(Q${KITNAME}_GENERATED_CPP ${Q${KITNAME}_GENERATED_CPP} ${Q${KITNAME}_GENERATED_UI_CPP} ${Q${KITNAME}_GENERATED_MOC_CPP} ${Q${KITNAME}_GENERATED_QRC_CPP}) ORGANIZE_SOURCES(SOURCE ${CPP_FILES} HEADER ${H_FILES} TXX ${TXX_FILES} DOC ${DOX_FILES} UI ${UI_FILES} QRC ${QRC_FILES} MOC ${Q${KITNAME}_GENERATED_MOC_CPP} GEN_QRC ${Q${KITNAME}_GENERATED_QRC_CPP} GEN_UI ${Q${KITNAME}_GENERATED_UI_CPP}) # MITK_GENERATE_TOOLS_LIBRARY(Qmitk${LIBPOSTFIX} "NO") IF(NOT MODULE_HEADERS_ONLY) IF(ALL_LIBRARY_DIRS) # LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES LINK_DIRECTORIES(${ALL_LIBRARY_DIRS}) ENDIF(ALL_LIBRARY_DIRS) ADD_LIBRARY(${MODULE_PROVIDES} ${CPP_FILES} ${CPP_FILES_GENERATED} ${Q${KITNAME}_GENERATED_CPP} ${CORRESPONDING__H_FILES} ${GLOBBED__H_FILES} ${TXX_FILES} ${DOX_FILES} ${UI_FILES} ${QRC_FILES} ${TOOL_GUI_CPPS}) - set_property(TARGET ${MODULE_PROVIDES} PROPERTY LABELS MITK) + set_property(TARGET ${MODULE_PROVIDES} PROPERTY LABELS ${PROJECT_NAME}) TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${QT_LIBRARIES} ${ALL_LIBRARIES} QVTK) ENDIF() ENDIF(NOT MODULE_QT_MODULE) # install only if shared lib (for now) IF(NOT _STATIC OR MINGW) IF(NOT MODULE_HEADERS_ONLY) # # deprecated: MITK_INSTALL_TARGETS(${MODULE_PROVIDES}) ENDIF() ENDIF(NOT _STATIC OR MINGW) ENDIF(NOT MODULE_QT_MODULE OR MITK_USE_QT) ENDIF(MODULE_IS_ENABLED) ENDIF(_MISSING_DEP) IF(NOT MODULE_IS_ENABLED) _MITK_CREATE_MODULE_CONF() ENDIF(NOT MODULE_IS_ENABLED) ENDMACRO(MITK_CREATE_MODULE) diff --git a/CMake/mitkMacroCreateModuleTests.cmake b/CMake/mitkMacroCreateModuleTests.cmake index 89822e2d59..4dfdf2d87d 100644 --- a/CMake/mitkMacroCreateModuleTests.cmake +++ b/CMake/mitkMacroCreateModuleTests.cmake @@ -1,74 +1,74 @@ # # Create tests and testdriver for this module # # Usage: MITK_CREATE_MODULE_TESTS( [EXTRA_DRIVER_INIT init_code] ) # # EXTRA_DRIVER_INIT is inserted as c++ code in the testdriver and will be executed before each test # MACRO(MITK_CREATE_MODULE_TESTS) MACRO_PARSE_ARGUMENTS(MODULE_TEST "EXTRA_DRIVER_INIT;EXTRA_DRIVER_INCLUDE" "" ${ARGN}) IF(BUILD_TESTING AND MODULE_IS_ENABLED) SET(OLD_MOC_H_FILES ${MOC_H_FILES}) SET(MOC_H_FILES) INCLUDE(files.cmake) INCLUDE_DIRECTORIES(.) IF(DEFINED MOC_H_FILES) QT4_WRAP_CPP(MODULE_TEST_GENERATED_MOC_CPP ${MOC_H_FILES}) ENDIF(DEFINED MOC_H_FILES) SET(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "mitk::LoggingBackend::Register(); ${MODULE_TEST_EXTRA_DRIVER_INIT};") SET(CMAKE_TESTDRIVER_AFTER_TESTMAIN "mitk::LoggingBackend::Unregister();") IF(NOT MODULE_TEST_EXTRA_DRIVER_INCLUDE) # this is necessary to make the LoggingBackend calls available if nothing else is included SET(MODULE_TEST_EXTRA_DRIVER_INCLUDE "mitkLog.h") ENDIF(NOT MODULE_TEST_EXTRA_DRIVER_INCLUDE) CREATE_TEST_SOURCELIST(MODULETEST_SOURCE ${MODULE_NAME}TestDriver.cpp ${MODULE_TESTS} ${MODULE_IMAGE_TESTS} ${MODULE_CUSTOM_TESTS} EXTRA_INCLUDE ${MODULE_TEST_EXTRA_DRIVER_INCLUDE} ) SET(TESTDRIVER ${MODULE_NAME}TestDriver) ADD_EXECUTABLE(${TESTDRIVER} ${MODULETEST_SOURCE} ${MODULE_TEST_GENERATED_MOC_CPP}) - set_property(TARGET ${TESTDRIVER} PROPERTY LABELS MITK) + set_property(TARGET ${TESTDRIVER} PROPERTY LABELS ${PROJECT_NAME}) TARGET_LINK_LIBRARIES(${TESTDRIVER} ${MODULE_PROVIDES} ${ALL_LIBRARIES}) # # Now tell CMake which tests should be run. This is done automatically # for all tests in ${KITNAME}_TESTS and ${KITNAME}_IMAGE_TESTS. The IMAGE_TESTS # are run for each image in the TESTIMAGES list. # FOREACH( test ${MODULE_TESTS} ) GET_FILENAME_COMPONENT(TName ${test} NAME_WE) ADD_TEST(${TName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName}) - set_property(TEST ${TName} PROPERTY LABELS MITK) + set_property(TEST ${TName} PROPERTY LABELS ${PROJECT_NAME}) ENDFOREACH( test ) FOREACH(image ${MODULE_TESTIMAGES} ${ADDITIONAL_TEST_IMAGES} ) IF(EXISTS ${image}) SET(IMAGE_FULL_PATH ${image}) ELSE(EXISTS ${image}) # todo: maybe search other paths as well # yes, please in mitk/Testing/Data, too SET(IMAGE_FULL_PATH ${MITK_SOURCE_DIR}/Core/Code/Testing/Data/${image}) ENDIF(EXISTS ${image}) IF(EXISTS ${IMAGE_FULL_PATH}) FOREACH( test ${MODULE_IMAGE_TESTS} ) GET_FILENAME_COMPONENT(TName ${test} NAME_WE) GET_FILENAME_COMPONENT(ImageName ${IMAGE_FULL_PATH} NAME) ADD_TEST(${TName}_${ImageName} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTDRIVER} ${TName} ${IMAGE_FULL_PATH}) - set_property(TEST ${TName}_${ImageName} PROPERTY LABELS MITK) + set_property(TEST ${TName}_${ImageName} PROPERTY LABELS ${PROJECT_NAME}) ENDFOREACH( test ) ELSE(EXISTS ${IMAGE_FULL_PATH}) MESSAGE("!!!!! No such file: ${IMAGE_FULL_PATH} !!!!!") ENDIF(EXISTS ${IMAGE_FULL_PATH}) ENDFOREACH( image ) SET(MOC_H_FILES ${OLD_MOC_H_FILES}) ENDIF(BUILD_TESTING AND MODULE_IS_ENABLED) ENDMACRO(MITK_CREATE_MODULE_TESTS)