diff --git a/CMake/MITKDashboardDriverScript.cmake b/CMake/MITKDashboardDriverScript.cmake
index dbea95424a..03e8207dd1 100644
--- a/CMake/MITKDashboardDriverScript.cmake
+++ b/CMake/MITKDashboardDriverScript.cmake
@@ -1,245 +1,245 @@
 
 #
 # Included from a dashboard script, this cmake file will drive the configure and build
 # steps of MITK
 #
 
 #-----------------------------------------------------------------------------
 # The following variable are expected to be define in the top-level script:
 set(expected_variables
   ADDITIONNAL_CMAKECACHE_OPTION
   CTEST_NOTES_FILES
   CTEST_SITE
   CTEST_DASHBOARD_ROOT
   CTEST_CMAKE_COMMAND
   CTEST_CMAKE_GENERATOR
   WITH_MEMCHECK
   WITH_COVERAGE
   WITH_DOCUMENTATION
   CTEST_BUILD_CONFIGURATION
   CTEST_TEST_TIMEOUT
   CTEST_BUILD_FLAGS
   TEST_TO_EXCLUDE_REGEX
   CTEST_PROJECT_NAME
   CTEST_SOURCE_DIRECTORY
   CTEST_BINARY_DIRECTORY
   CTEST_BUILD_NAME
   SCRIPT_MODE
   CTEST_COVERAGE_COMMAND
   CTEST_MEMORYCHECK_COMMAND
   CTEST_GIT_COMMAND
   QT_QMAKE_EXECUTABLE
   )
 if(WITH_DOCUMENTATION)
   list(APPEND expected_variables DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY)
 endif()
 
 foreach(var ${expected_variables})
   if(NOT DEFINED ${var})
     message(FATAL_ERROR "Variable ${var} should be defined in top-level script !")
   endif()
 endforeach()
 
 # If the dashscript doesn't define a GIT_REPOSITORY variable, let's define it here.
 if (NOT DEFINED GIT_REPOSITORY OR GIT_REPOSITORY STREQUAL "")
   set(GIT_REPOSITORY git@mbits:MITK)
 endif()
 
 # Should binary directory be cleaned?
 set(empty_binary_directory FALSE)
 
 # Attempt to build and test also if 'ctest_update' returned an error
 set(force_build FALSE)
 
 # Set model options
 set(model "")
 if (SCRIPT_MODE STREQUAL "experimental")
   set(empty_binary_directory FALSE)
   set(force_build TRUE)
   set(model Experimental)
 elseif (SCRIPT_MODE STREQUAL "continuous")
   set(empty_binary_directory TRUE)
   set(force_build FALSE)
   set(model Continuous)
 elseif (SCRIPT_MODE STREQUAL "nightly")
   set(empty_binary_directory TRUE)
   set(force_build TRUE)
   set(model Nightly)
 else()
   message(FATAL_ERROR "Unknown script mode: '${SCRIPT_MODE}'. Script mode should be either 'experimental', 'continuous' or 'nightly'")
 endif()
 
 #message("script_mode:${SCRIPT_MODE}")
 #message("model:${model}")
 #message("empty_binary_directory:${empty_binary_directory}")
 #message("force_build:${force_build}")
 
 set(CTEST_USE_LAUNCHERS 1)
 
 if(empty_binary_directory)
   message("Directory ${CTEST_BINARY_DIRECTORY} cleaned !")
   ctest_empty_binary_directory(${CTEST_BINARY_DIRECTORY})
 endif()
 
 if(NOT EXISTS "${CTEST_SOURCE_DIRECTORY}")
   set(CTEST_CHECKOUT_COMMAND "${CTEST_GIT_COMMAND} clone -b bug-7014-dashboard-script ${GIT_REPOSITORY} ${CTEST_SOURCE_DIRECTORY}")
 endif()
 
 set(CTEST_UPDATE_COMMAND "${CTEST_GIT_COMMAND}")
 
 #
 # run_ctest macro
 #
 MACRO(run_ctest)
   ctest_start(${model})
   ctest_update(SOURCE "${CTEST_SOURCE_DIRECTORY}" RETURN_VALUE res)
 
   # force a build if this is the first run and the build dir is empty
   if(NOT EXISTS "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt")
     message("First time build - Initialize CMakeCache.txt")
     set(res 1)
 
     # Write initial cache.
     file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt" "
 CTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
 BUILD_TESTING:BOOL=TRUE
 BLUEBERRY_BUILD_ALL_PLUGINS:BOOL=TRUE
 MITK_BUILD_ALL_PLUGINS:BOOL=TRUE
 CMAKE_BUILD_TYPE:STRING=${CTEST_BUILD_CONFIGURATION}
 QT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
 SUPERBUILD_EXCLUDE_MITKBUILD_TARGET:BOOL=TRUE
 WITH_COVERAGE:BOOL=${WITH_COVERAGE}
 #DOCUMENTATION_TARGET_IN_ALL:BOOL=${WITH_DOCUMENTATION}
 DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY:PATH=${DOCUMENTATION_ARCHIVES_OUTPUT_DIRECTORY}
 ${ADDITIONNAL_CMAKECACHE_OPTION}
 ")
   endif()
   
   if (res GREATER 0 OR force_build)
   
     ctest_submit(PARTS Update)
       
     message("Configure SuperBuild")
     
     set_property(GLOBAL PROPERTY SubProject SuperBuild)
     set_property(GLOBAL PROPERTY Label SuperBuild)
      
     ctest_configure(BUILD "${CTEST_BINARY_DIRECTORY}"
       OPTIONS "-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}"
     )
     ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}")
     ctest_submit(PARTS Configure)
     ctest_submit(FILES "${CTEST_BINARY_DIRECTORY}/Project.xml")
 
     # Build top level
     message("----------- [ Build SuperBuild ] -----------")
     ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND)
     ctest_submit(PARTS Build)
     
     ctest_test(
       BUILD "${CTEST_BINARY_DIRECTORY}" 
       INCLUDE_LABEL "SuperBuild"
       PARALLEL_LEVEL 8
       #EXCLUDE ${TEST_TO_EXCLUDE_REGEX}
       )
     # runs only tests that have a LABELS property matching "${subproject}"
     ctest_submit(PARTS Test)
       
     set(mitk_build_dir "${CTEST_BINARY_DIRECTORY}/MITK-build")
     
     set(CTEST_PROJECT_SUBPROJECTS MITK)
     
     foreach(subproject ${CTEST_PROJECT_SUBPROJECTS})
       set_property(GLOBAL PROPERTY SubProject ${subproject})
       set_property(GLOBAL PROPERTY Label ${subproject})
       message("----------- [ Build ${subproject} ] -----------")
     
       # Configure target
       ctest_configure(BUILD "${CTEST_BINARY_DIRECTORY}"
         OPTIONS "-DCTEST_USE_LAUNCHERS=${CTEST_USE_LAUNCHERS}"
       )
       ctest_read_custom_files("${CTEST_BINARY_DIRECTORY}")
       ctest_submit(PARTS Configure)
      
       # Build target
       set(CTEST_BUILD_TARGET "${subproject}")
       ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND)
       ctest_submit(PARTS Build)
       
       message("----------- [ Test ${subproject} ] -----------")
 
       ctest_test(
         BUILD "${mitk_build_dir}"
         APPEND
-        # INCLUDE_LABEL "${subproject}"
+        INCLUDE_LABEL "${subproject}"
         PARALLEL_LEVEL 8
         #EXCLUDE ${TEST_TO_EXCLUDE_REGEX}
         )
       # runs only tests that have a LABELS property matching "${subproject}"
       
       ctest_submit(PARTS Test)
 
       # Coverage per sub-project
       if (WITH_COVERAGE AND CTEST_COVERAGE_COMMAND)
         message("----------- [ Coverage ${subproject} ] -----------")
         ctest_coverage(BUILD "${mitk_build_dir}") # LABELS "${subproject}")
         ctest_submit(PARTS Coverage)
       endif ()
 
       #if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND)
       #  ctest_memcheck(BUILD "${mitk_build_dir}" INCLUDE_LABEL "${subproject}")
       #  ctest_submit(PARTS MemCheck)
       #endif ()
     endforeach()
     
     if (WITH_DOCUMENTATION)
       message("----------- [ Build Documentation ] -----------")
       set(CTEST_USE_LAUNCHERS 0)
       # Build Documentation target
       set_property(GLOBAL PROPERTY SubProject Documentation)
       set_property(GLOBAL PROPERTY Label Documentation)
       set(CTEST_BUILD_TARGET "doc")
       ctest_build(BUILD "${mitk_build_dir}" APPEND)
       ctest_submit(PARTS Build)
       set(CTEST_USE_LAUNCHERS 1)
     endif()
     
     # HACK Unfortunately ctest_coverage ignores the build argument, try to force it...
     file(READ ${mitk_build_dir}/CMakeFiles/TargetDirectories.txt mitk_build_coverage_dirs)
     file(APPEND "${CTEST_BINARY_DIRECTORY}/CMakeFiles/TargetDirectories.txt" "${mitk_build_coverage_dirs}")
     
     set_property(GLOBAL PROPERTY SubProject SuperBuild)
     set_property(GLOBAL PROPERTY Label SuperBuild)
     
     # Global coverage ... 
     if (WITH_COVERAGE AND CTEST_COVERAGE_COMMAND)
       message("----------- [ Global coverage ] -----------")
       ctest_coverage(BUILD "${mitk_build_dir}" APPEND)
       ctest_submit(PARTS Coverage)
     endif ()
     
     # Global dynamic analysis ...
     if (WITH_MEMCHECK AND CTEST_MEMORYCHECK_COMMAND)
         message("----------- [ Global memcheck ] -----------")
         ctest_memcheck(BUILD "${mitk_build_dir}")
         ctest_submit(PARTS MemCheck)
       endif ()
     
     # Note should be at the end
     ctest_submit(PARTS Notes)
   
   endif()
 endmacro()
 
 if(SCRIPT_MODE STREQUAL "continuous")
   while(${CTEST_ELAPSED_TIME} LESS 68400)
     set(START_TIME ${CTEST_ELAPSED_TIME})
     run_ctest()
     # Loop no faster than once every 5 minutes
     message("Wait for 5 minutes ...")
     ctest_sleep(${START_TIME} 300 ${CTEST_ELAPSED_TIME})
   endwhile()
 else()
   run_ctest()
 endif()
 
diff --git a/CMake/mitkMacroCreateModule.cmake b/CMake/mitkMacroCreateModule.cmake
index 17de9b591d..cb6eee6d5a 100644
--- a/CMake/mitkMacroCreateModule.cmake
+++ b/CMake/mitkMacroCreateModule.cmake
@@ -1,148 +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( <moduleName>
 #     [INCLUDE_DIRS <include directories>]
 #     [INTERNAL_INCLUDE_DIRS <internally used include directories>]
 #     [DEPENDS <modules we need>]
 #     [PROVIDES <library name which is built>]
 #     [PACKAGE_DEPENDS <packages we need, like ITK, VTK, QT>]
 #     [EXPORT_DEFINE <declspec macro name for dll exports>]
 #     [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)
             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)
             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 45e06f4205..89822e2d59 100644
--- a/CMake/mitkMacroCreateModuleTests.cmake
+++ b/CMake/mitkMacroCreateModuleTests.cmake
@@ -1,73 +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)
     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)
     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)
       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)