diff --git a/BlueBerry/Bundles/org.blueberry.osgi/src/application/solstice.ini b/BlueBerry/Bundles/org.blueberry.osgi/src/application/solstice.ini
index 7a4350889b..30c36eee76 100644
--- a/BlueBerry/Bundles/org.blueberry.osgi/src/application/solstice.ini
+++ b/BlueBerry/Bundles/org.blueberry.osgi/src/application/solstice.ini
@@ -1,2 +1,2 @@
 BlueBerry.home=@BLUEBERRY_BINARY_DIR@
-BlueBerry.plugin_dirs=@BLUEBERRY_PLUGINS_OUTPUT_DIR@
+BlueBerry.provisioning=@BLUEBERRY_TESTING_PROVISIONING_FILE@
diff --git a/BlueBerry/Bundles/org.blueberry.osgi/src/internal/berryInternalPlatform.cpp b/BlueBerry/Bundles/org.blueberry.osgi/src/internal/berryInternalPlatform.cpp
index 25d5b91c4b..5b57acb790 100644
--- a/BlueBerry/Bundles/org.blueberry.osgi/src/internal/berryInternalPlatform.cpp
+++ b/BlueBerry/Bundles/org.blueberry.osgi/src/internal/berryInternalPlatform.cpp
@@ -1,483 +1,483 @@
 /*=========================================================================
 
 Program:   BlueBerry Platform
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "berryInternalPlatform.h"
 #include "berryLog.h"
 
 #include <Poco/Exception.h>
 #include <Poco/File.h>
 #include <Poco/FileStream.h>
 #include <Poco/AutoPtr.h>
 #include <Poco/Util/PropertyFileConfiguration.h>
 #include <Poco/StringTokenizer.h>
 #include <Poco/Util/HelpFormatter.h>
 #include <Poco/Util/OptionException.h>
 
 #include <ctkPluginFrameworkLauncher.h>
 #include <ctkPluginFrameworkFactory.h>
 #include <ctkPluginFramework.h>
 #include <ctkPluginContext.h>
 #include <ctkPlugin.h>
 
 #include <iostream>
 
 #include "../berryPlatform.h"
 #include "../berryPlatformException.h"
 #include "../berryDebugUtil.h"
 #include "../event/berryPlatformEvents.h"
 #include "berryPlatformLogChannel.h"
 #include "../berryIBundle.h"
 #include "berryCodeCache.h"
 #include "../berryBundleLoader.h"
 #include "berrySystemBundle.h"
 #include "berryBundleDirectory.h"
 #include "berryProvisioningInfo.h"
 
 #include <QDebug>
 
 namespace berry {
 
 Poco::Mutex InternalPlatform::m_Mutex;
 
 InternalPlatform::InternalPlatform() : m_Initialized(false), m_Running(false),
   m_ConsoleLog(false), m_ServiceRegistry(0),
   m_CodeCache(0), m_BundleLoader(0), m_SystemBundle(0), m_PlatformLogger(0),
   m_ctkPluginFrameworkFactory(0),
   m_EventStarted(PlatformEvent::EV_PLATFORM_STARTED)
 {
 }
 
 InternalPlatform::~InternalPlatform()
 {
 
 }
 
 InternalPlatform* InternalPlatform::GetInstance()
 {
   Poco::Mutex::ScopedLock lock(m_Mutex);
   static InternalPlatform instance;
   return &instance;
 }
 
 bool InternalPlatform::ConsoleLog() const
 {
   return m_ConsoleLog;
 }
 
 ctkPluginContext* InternalPlatform::GetCTKPluginFrameworkContext() const
 {
   if (m_ctkPluginFrameworkFactory)
   {
     return m_ctkPluginFrameworkFactory->getFramework()->getPluginContext();
   }
   return 0;
 }
 
 ServiceRegistry& InternalPlatform::GetServiceRegistry()
 {
   AssertInitialized();
   return *m_ServiceRegistry;
 }
 
 void InternalPlatform::Initialize(int& argc, char** argv, Poco::Util::AbstractConfiguration* config)
 {
   // initialization
   Poco::Mutex::ScopedLock lock(m_Mutex);
 
   m_Argc = &argc;
   m_Argv = argv;
 
   try
   {
     this->init(argc, argv);
   }
   catch (const Poco::Util::UnknownOptionException& e)
   { 
     BERRY_WARN << e.displayText();
   } 
   this->loadConfiguration();
   if (config)
   {
     this->config().add(config, 50, false);
   }
 
   m_ServiceRegistry = new ServiceRegistry();
 
   m_ConsoleLog = this->GetConfiguration().hasProperty(Platform::ARG_CONSOLELOG);
 
   m_ConfigPath.assign(this->GetConfiguration().getString("application.configDir"));
   m_InstancePath.assign(this->GetConfiguration().getString("application.dir"));
   try
   {
     m_InstallPath.assign(this->GetConfiguration().getString(Platform::ARG_HOME));
   }
   catch (Poco::NotFoundException& )
   {
     m_InstallPath.assign(m_InstancePath);
   }
 
   m_UserPath.assign(Poco::Path::home());
   m_UserPath.pushDirectory("." + this->commandName());
   Poco::File userFile(m_UserPath); 
   
   try
   {
     userFile.createDirectory();
     userFile.canWrite();
   }
   catch(const Poco::IOException& e)
   {
     BERRY_WARN << e.displayText();
     m_UserPath.assign(Poco::Path::temp());
     m_UserPath.pushDirectory("." + this->commandName());
     userFile = m_UserPath;
   }
    
   m_BaseStatePath = m_UserPath;
   m_BaseStatePath.pushDirectory(".metadata");
   m_BaseStatePath.pushDirectory(".plugins");
 
   Poco::Path logPath(m_UserPath);
   logPath.setFileName(this->commandName() + ".log");
   m_PlatformLogChannel = new PlatformLogChannel(logPath.toString());
   m_PlatformLogger = &Poco::Logger::create("PlatformLogger", m_PlatformLogChannel, Poco::Message::PRIO_TRACE);
 
   try
   {
     m_CodeCache = new CodeCache(this->GetConfiguration().getString(Platform::ARG_PLUGIN_CACHE));
   }
   catch (Poco::NotFoundException&)
   {
     Poco::Path cachePath(m_UserPath);
     cachePath.pushDirectory("plugin_cache");
     m_CodeCache = new CodeCache(cachePath.toString());
   }
   m_BundleLoader = new BundleLoader(m_CodeCache, *m_PlatformLogger);
 
   // Initialize the CTK Plugin Framework
   ctkProperties fwProps;
   fwProps.insert(ctkPluginConstants::FRAMEWORK_STORAGE, QString::fromStdString(userFile.path()));
   m_ctkPluginFrameworkFactory = new ctkPluginFrameworkFactory(fwProps);
   QSharedPointer<ctkPluginFramework> pfw = m_ctkPluginFrameworkFactory->getFramework();
   pfw->init();
   ctkPluginContext* pfwContext = pfw->getPluginContext();
 
   std::string provisioningFile = this->GetConfiguration().getString(Platform::ARG_PROVISIONING);
   if (!provisioningFile.empty())
   {
     ProvisioningInfo provInfo(QString::fromStdString(provisioningFile));
     foreach(QString pluginPath, provInfo.getPluginDirs())
     {
       ctkPluginFrameworkLauncher::addSearchPath(pluginPath);
     }
 
     QList<QUrl> pluginsToStart = provInfo.getPluginsToStart();
     foreach(QUrl pluginUrl, provInfo.getPluginsToInstall())
     {
       QSharedPointer<ctkPlugin> plugin = pfwContext->installPlugin(pluginUrl);
       if (pluginsToStart.contains(pluginUrl))
       {
         m_CTKPluginsToStart << plugin->getPluginId();
       }
     }
   }
 
   // tell the BundleLoader about the installed CTK plug-ins
   QStringList installedCTKPlugins;
   foreach(QSharedPointer<ctkPlugin> plugin, pfwContext->getPlugins())
   {
     installedCTKPlugins << plugin->getSymbolicName();
   }
   m_BundleLoader->SetCTKPlugins(installedCTKPlugins);
 
   m_Initialized = true;
 
   // Clear the CodeCache
   if (this->GetConfiguration().hasProperty(Platform::ARG_CLEAN))
     m_CodeCache->Clear();
 
   try
   {
     // assemble a list of base plugin-directories (which contain
     // the real plugins as directories)
     std::vector<std::string> pluginBaseDirs;
 
-    Poco::StringTokenizer tokenizer(this->GetConfiguration().getString(Platform::ARG_PLUGIN_DIRS), ";",
+    Poco::StringTokenizer tokenizer(this->GetConfiguration().getString(Platform::ARG_PLUGIN_DIRS, ""), ";",
                                     Poco::StringTokenizer::TOK_IGNORE_EMPTY | Poco::StringTokenizer::TOK_TRIM);
 
     for (Poco::StringTokenizer::Iterator token = tokenizer.begin();
          token != tokenizer.end(); ++token)
     {
       pluginBaseDirs.push_back(*token);
     }
 
     std::vector<Poco::Path> pluginPaths;
     for (std::vector<std::string>::iterator pluginBaseDir = pluginBaseDirs.begin();
          pluginBaseDir != pluginBaseDirs.end(); ++pluginBaseDir)
     {
       BERRY_INFO(m_ConsoleLog) << "Plugin base directory: " << *pluginBaseDir;
       Poco::File pluginDir(*pluginBaseDir);
 
       if (!pluginDir.exists() || !pluginDir.isDirectory())
       {
         BERRY_WARN(m_ConsoleLog) << *pluginBaseDir << " is not a direcotry or does not exist. SKIPPED.\n";
         continue;
       }
     
       std::vector<std::string> pluginList;
       pluginDir.list(pluginList);
 
       std::vector<std::string>::iterator iter;
       for (iter = pluginList.begin(); iter != pluginList.end(); iter++)
       {
         Poco::Path pluginPath = Poco::Path::forDirectory(*pluginBaseDir);
         pluginPath.pushDirectory(*iter);
 
         Poco::File file(pluginPath);
         if (file.exists() && file.isDirectory())
         {
           pluginPaths.push_back(pluginPath);
         }
       }
     }
 
     std::vector<Poco::Path>::iterator pathIter;
     for (pathIter = pluginPaths.begin(); pathIter != pluginPaths.end(); pathIter++)
     {
       try
       {
       Bundle::Pointer bundle = m_BundleLoader->LoadBundle(*pathIter);
       if (bundle)
       {
         BERRY_INFO(m_ConsoleLog) << "Bundle state (" << pathIter->toString() << "): " << bundle->GetStateString() << std::endl;
       }
       }
       catch (const BundleStateException& exc)
       {
         BERRY_WARN << exc.displayText() << std::endl;
       }
     }
 
     // resolve plugins
     m_BundleLoader->ResolveAllBundles();
   }
   catch (Poco::Exception& exc)
   {
     this->logger().log(exc);
   }
 
 #ifdef BLUEBERRY_DEBUG_SMARTPOINTER
   DebugUtil::RestoreState();
 #endif
 
 }
 
 void InternalPlatform::Launch()
 {
   AssertInitialized();
 
   if (m_Running) return;
 
   m_Running = true;
 
   this->run();
 }
 
 void InternalPlatform::Shutdown()
 {
   Poco::Mutex::ScopedLock lock(m_Mutex);
 
   AssertInitialized();
 
   DebugUtil::SaveState();
 
   m_Initialized = false;
 
   this->uninitialize();
 
   delete m_ServiceRegistry;
   delete m_BundleLoader;
   delete m_CodeCache;
 }
 
 
 void InternalPlatform::AssertInitialized()
 {
   if (!m_Initialized)
     throw Poco::SystemException("The Platform has not been initialized yet!");
 }
 
 IExtensionPointService::Pointer InternalPlatform::GetExtensionPointService()
 {
   Poco::Mutex::ScopedLock lock(m_Mutex);
   this->AssertInitialized();
 
   return m_ServiceRegistry->GetServiceById<IExtensionPointService>(IExtensionPointService::SERVICE_ID);
 }
 
 const Poco::Path& InternalPlatform::GetConfigurationPath()
 {
   return m_ConfigPath;
 }
 
 const Poco::Path& InternalPlatform::GetInstallPath()
 {
   return m_InstallPath;
 }
 
 const Poco::Path& InternalPlatform::GetInstancePath()
 {
   return m_InstancePath;
 }
 
 bool InternalPlatform::GetStatePath(Poco::Path& statePath, IBundle::Pointer bundle, bool create)
 {
   statePath = m_BaseStatePath;
   statePath.pushDirectory(bundle->GetSymbolicName());
   try
   {
   Poco::File stateFile(statePath);
   if (!stateFile.exists() && create)
     stateFile.createDirectories();
   }
   catch (Poco::FileException&)
   {
     return false;
   }
 
   return true;
 }
 
 PlatformEvents& InternalPlatform::GetEvents()
 {
   return m_Events;
 }
 
 const Poco::Path& InternalPlatform::GetUserPath()
 {
   return m_UserPath;
 }
 
 bool InternalPlatform::IsRunning() const
 {
   Poco::Mutex::ScopedLock lock(m_Mutex);
   return (m_Initialized && m_Running);
 }
 
 IBundle::Pointer InternalPlatform::GetBundle(const std::string& id)
 {
   Poco::Mutex::ScopedLock lock(m_Mutex);
 
   AssertInitialized();
 
   return m_BundleLoader->FindBundle(id);
 }
 
 std::vector<IBundle::Pointer> InternalPlatform::GetBundles() const
 {
   return m_BundleLoader->GetBundles();
 }
 
 Poco::Logger* InternalPlatform::GetLogger()
 {
   return m_PlatformLogger;
 }
 
 Poco::Util::LayeredConfiguration& InternalPlatform::GetConfiguration() const
 {
   return this->config();
 }
 
 std::vector<std::string> InternalPlatform::GetApplicationArgs() const
 {
   return m_FilteredArgs;
 }
 
 int& InternalPlatform::GetRawApplicationArgs(char**& argv)
 {
   argv = m_Argv;
   return *m_Argc;
 }
 
 void InternalPlatform::defineOptions(Poco::Util::OptionSet& options)
 {
   Poco::Util::Option helpOption("help", "h", "print this help text");
   helpOption.callback(Poco::Util::OptionCallback<InternalPlatform>(this, &InternalPlatform::PrintHelp));
   options.addOption(helpOption);
 
   Poco::Util::Option cleanOption(Platform::ARG_CLEAN, "", "cleans the plugin cache");
   cleanOption.binding(Platform::ARG_CLEAN);
   options.addOption(cleanOption);
 
   Poco::Util::Option appOption(Platform::ARG_APPLICATION, "", "the id of the application extension to be executed");
   appOption.argument("<id>").binding(Platform::ARG_APPLICATION);
   options.addOption(appOption);
 
   Poco::Util::Option consoleLogOption(Platform::ARG_CONSOLELOG, "", "log messages to the console");
   consoleLogOption.binding(Platform::ARG_CONSOLELOG);
   options.addOption(consoleLogOption);
 
   Poco::Util::Option testPluginOption(Platform::ARG_TESTPLUGIN, "", "the plug-in to be tested");
   testPluginOption.argument("<id>").binding(Platform::ARG_TESTPLUGIN);
   options.addOption(testPluginOption);
 
   Poco::Util::Option testAppOption(Platform::ARG_TESTAPPLICATION, "", "the application to be tested");
   testAppOption.argument("<id>").binding(Platform::ARG_TESTAPPLICATION);
   options.addOption(testAppOption);
 
   Poco::Util::Application::defineOptions(options);
 }
 
 int InternalPlatform::main(const std::vector<std::string>& args)
 {
   m_FilteredArgs = args;
   m_FilteredArgs.insert(m_FilteredArgs.begin(), this->config().getString("application.argv[0]"));
 
   ctkPluginContext* context = GetCTKPluginFrameworkContext();
   QFileInfo storageDir = context->getDataFile("");
   BundleDirectory::Pointer bundleStorage(new BundleDirectory(Poco::Path(storageDir.absolutePath().toStdString())));
   SystemBundle::Pointer systemBundle(new SystemBundle(*m_BundleLoader, bundleStorage));
   if (systemBundle == 0)
     throw PlatformException("Could not find the system bundle");
   m_BundleLoader->m_SystemBundle = systemBundle;
   m_BundleLoader->LoadBundle(systemBundle);
 
   m_ctkPluginFrameworkFactory->getFramework()->start();
   foreach(long pluginId, m_CTKPluginsToStart)
   {
     // do not change the autostart setting of this plugin
     context->getPlugin(pluginId)->start(ctkPlugin::START_TRANSIENT | ctkPlugin::START_ACTIVATION_POLICY);
   }
 
   m_BundleLoader->StartSystemBundle(systemBundle);
 
   systemBundle->Resume();
 
   return EXIT_OK;
 }
 
 void InternalPlatform::PrintHelp(const std::string&, const std::string&)
 {
   Poco::Util::HelpFormatter help(this->options());
   help.setAutoIndent();
   help.setCommand(this->commandName());
   help.format(std::cout);
 
   exit(EXIT_OK);
 }
 
 }
diff --git a/BlueBerry/CMakeLists.txt b/BlueBerry/CMakeLists.txt
index e687303c53..70faf821d3 100644
--- a/BlueBerry/CMakeLists.txt
+++ b/BlueBerry/CMakeLists.txt
@@ -1,290 +1,303 @@
 PROJECT(BlueBerry)
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8.2)
 
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMake/")
 
 INCLUDE(MacroParseArguments)
 INCLUDE(MacroConvertSchema)
 INCLUDE(MacroOrganizeSources)
 INCLUDE(berryPluginHelpers)
 INCLUDE(MacroCollectPlugins)
 INCLUDE(MacroParseManifest)
 INCLUDE(MacroCreatePlugin)
 INCLUDE(MacroCreateCTKPlugin)
 INCLUDE(MacroCreateQtHelp)
 INCLUDE(MacroInstallPlugin)
 INCLUDE(MacroInstallCTKPlugin)
 INCLUDE(FunctionCreateProvisioningInfo)
 
 OPTION(BLUEBERRY_INSTALL_RPATH_RELATIVE "Use relative rpath entries when installing" OFF)
 MARK_AS_ADVANCED(BLUEBERRY_INSTALL_RPATH_RELATIVE)
 
 IF(BLUEBERRY_INSTALL_RPATH_RELATIVE)
   SET(CMAKE_INSTALL_RPATH ".")
 ELSE()
   SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/bin")
 ENDIF()
 
 
 IF(MSVC)
   SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4250 /wd4275 /wd4251 /wd4503")
 ENDIF()
 
 IF (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
   SET (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 ENDIF ()
 
 FIND_PACKAGE(mbilog REQUIRED)
 INCLUDE_DIRECTORIES(${mbilog_INCLUDE_DIRS})
 
 OPTION(BLUEBERRY_USE_QT "Use the Qt GUI toolkit" OFF)
 
 IF(NOT DESIRED_QT_VERSION)
   SET(DESIRED_QT_VERSION 4 CACHE STRING "Desired Qt version" FORCE)
   MARK_AS_ADVANCED(DESIRED_QT_VERSION)
 ENDIF()
 
 IF(BLUEBERRY_USE_QT AND NOT DESIRED_QT_VERSION EQUAL 4)
   MESSAGE("Attention: Qt4 GUI libraries are required to build the BlueBerry Qt plug-ins.")
 ENDIF()
 
 IF(BLUEBERRY_USE_QT AND DESIRED_QT_VERSION EQUAL 4)
   SET(BUILD_QT_PLUGINS 1)
   FIND_PACKAGE(Qt4 4.6.2 REQUIRED)
 
   IF(QT_QMAKE_CHANGED)
     SET(QT_HELPGENERATOR_EXECUTABLE NOTFOUND)
     SET(QT_COLLECTIONGENERATOR_EXECUTABLE NOTFOUND)
     SET(QT_ASSISTANT_EXECUTABLE NOTFOUND)
   ENDIF()
 
   FIND_PROGRAM(QT_HELPGENERATOR_EXECUTABLE
     NAMES qhelpgenerator qhelpgenerator-qt4 qhelpgenerator4
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   FIND_PROGRAM(QT_COLLECTIONGENERATOR_EXECUTABLE
     NAMES qcollectiongenerator qcollectiongenerator-qt4 qcollectiongenerator4
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   FIND_PROGRAM(QT_ASSISTANT_EXECUTABLE
     NAMES assistant-qt4 assistant4 assistant
     PATHS ${QT_BINARY_DIR}
     NO_DEFAULT_PATH
   )
 
   OPTION(BLUEBERRY_USE_QT_HELP "Enable support for integrating bundle documentation into Qt Help" ON)
 
   MARK_AS_ADVANCED(BLUEBERRY_USE_QT_HELP
                    QT_HELPGENERATOR_EXECUTABLE
                    QT_COLLECTIONGENERATOR_EXECUTABLE
                    QT_ASSISTANT_EXECUTABLE)
 
   SET(_doxygen_too_old 1)
   IF(BLUEBERRY_USE_QT_HELP)
     FIND_PACKAGE(Doxygen)
     IF(DOXYGEN_FOUND)
       EXECUTE_PROCESS(COMMAND ${DOXYGEN_EXECUTABLE} --version
                       OUTPUT_VARIABLE _doxygen_version)
       IF(${_doxygen_version} VERSION_GREATER 1.6.0 OR
          ${_doxygen_version} VERSION_EQUAL 1.6.0)
         SET(_doxygen_too_old 0)
       ENDIF()
     ENDIF()
   ELSE(BLUEBERRY_USE_QT_HELP)
   
   CONFIGURE_FILE(../Documentation/pregenerated/MITKBlankPage.qch
                  ${MITK_BINARY_DIR}/bin/ExtBundles/org.mitk.gui.qt.extapplication/resources/MITKBlankPage.qch
                  COPYONLY)
 
   CONFIGURE_FILE(../Documentation/pregenerated/MitkExtQtHelpCollection.qhc
                  ${MITK_BINARY_DIR}/bin/ExtBundles/org.mitk.gui.qt.extapplication/resources/MitkExtQtHelpCollection.qhc
                  COPYONLY)
   
   ENDIF(BLUEBERRY_USE_QT_HELP)
 
   IF (BLUEBERRY_USE_QT_HELP AND _doxygen_too_old)
     MESSAGE("Doxygen was not found or is too old. Version 1.6.0 or later is needed if BLUEBERRY_USE_QT_HELP is ON")
     SET(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
   ENDIF()
 
   IF(BLUEBERRY_USE_QT_HELP AND NOT QT_HELPGENERATOR_EXECUTABLE)
     MESSAGE("You have enabled Qt Help support, but QT_HELPGENERATOR_EXECUTABLE is empty")
     SET(BLUEBERRY_USE_QT_HELP OFF CACHE BOOL "Enable support for integrating bundle documentation into Qt Help" FORCE)
   ENDIF()
 
   INCLUDE(${QT_USE_FILE})
 ELSE()
   FIND_PACKAGE(Qt4 4.6.2 COMPONENTS QtCore REQUIRED)
   INCLUDE(${QT_USE_FILE})
 ENDIF()
 
 # =========  CTK specific CMake stuff ============
 CMAKE_POLICY(SET CMP0012 NEW)
 
 FIND_PACKAGE(CTK REQUIRED)
 SET(CTK_PLUGIN_LIBRARIES "${CTK_PLUGIN_LIBRARIES}" CACHE INTERNAL "CTK plugins" FORCE)
 
 # Extract all library names starting with org_blueberry_
 MACRO(GetMyTargetLibraries all_target_libraries varname)
   SET(re_ctkplugin "^org_blueberry_[a-zA-Z0-9_]+$")
   SET(_tmp_list)
   LIST(APPEND _tmp_list ${all_target_libraries})
   ctkMacroListFilter(_tmp_list re_ctkplugin OUTPUT_VARIABLE ${varname})
 ENDMACRO()
 # ================================================
 
 OPTION(BLUEBERRY_BUILD_ALL_PLUGINS "Build all BlueBerry plugins (overriding selection)" OFF)
 MARK_AS_ADVANCED(BLUEBERRY_BUILD_ALL_PLUGINS)
 
 IF(BLUEBERRY_BUILD_ALL_PLUGINS)
   SET(BLUEBERRY_BUILD_ALL_PLUGINS_OPTION "FORCE_BUILD_ALL")
 ENDIF()
 
 OPTION(BLUEBERRY_STATIC "Build all plugins as static libraries" OFF)
 MARK_AS_ADVANCED(BLUEBERRY_STATIC)
 
 OPTION(BLUEBERRY_DEBUG_SMARTPOINTER "Enable code for debugging smart pointers" OFF)
 MARK_AS_ADVANCED(BLUEBERRY_DEBUG_SMARTPOINTER)
 
 FIND_PACKAGE(Poco REQUIRED)
 FIND_PACKAGE(Ant)
 FIND_PACKAGE(Eclipse)
 
 SET(BLUEBERRY_SOURCE_DIR ${BlueBerry_SOURCE_DIR})
 SET(BLUEBERRY_BINARY_DIR ${BlueBerry_BINARY_DIR})
 
 SET(BLUEBERRY_PLUGINS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Bundles)
 SET(BLUEBERRY_PLUGINS_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/Bundles)
 
 SET(OSGI_APP solstice)
 SET(OSGI_UI_APP solstice_ui)
 
 # Force should be removed after everybody has configured their old binary tree
 SET(BLUEBERRY_PLUGINS_OUTPUT_DIR ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/BlueBerry CACHE PATH "Directory where to build the BlueBerry Bundles" FORCE)
 MARK_AS_ADVANCED(BLUEBERRY_PLUGINS_OUTPUT_DIR)
 
 # Clear the cache variables
 SET(BLUEBERRY_PLUGIN_SOURCE_DIRS "" CACHE INTERNAL "List of base plugin source directories" FORCE)
 SET(BLUEBERRY_PLUGIN_BINARY_DIRS "" CACHE INTERNAL "List of base plugin binary directories" FORCE)
 
 IF (Eclipse_DIR)
   SET(BLUEBERRY_DOC_TOOLS_DIR "${Eclipse_DIR}" CACHE PATH "Directory containing additional tools needed for generating the documentation")
 ELSE ()
   SET(BLUEBERRY_DOC_TOOLS_DIR "" CACHE PATH "Directory containing additional tools needed for generating the documentation")
 ENDIF ()
 
 SET(BLUEBERRY_DEBUG_POSTFIX d)
 
 # Testing options
 
 OPTION(BLUEBERRY_BUILD_TESTING "Build the BlueBerry tests." OFF)
 
 IF(WIN32)
   SET(_gui_testing_default "ON")
 ELSE()
   SET(_gui_testing_default "OFF")
 ENDIF()
 
 OPTION(BLUEBERRY_ENABLE_GUI_TESTING "Enable the BlueBerry GUI tests" ${_gui_testing_default})
 MARK_AS_ADVANCED(BLUEBERRY_ENABLE_GUI_TESTING)
 
 IF(BLUEBERRY_BUILD_TESTING)
   ENABLE_TESTING()
 ENDIF()
 
 
 # Add CTK plugins
 
 SET(_ctk_plugins
   Bundles/org.blueberry.osgi:ON
   Bundles/org.blueberry.compat:ON
   Bundles/org.blueberry.core.runtime:ON
   Bundles/org.blueberry.core.expressions:ON
   Bundles/org.blueberry.solstice.common:ON
   Bundles/org.blueberry.core.commands:ON
   Bundles/org.blueberry.core.jobs:OFF
   Bundles/org.blueberry.ui:ON
   Bundles/org.blueberry.ui.qt:ON
   Bundles/org.blueberry.ui.qt.log:OFF
   Bundles/org.blueberry.ui.qt.objectinspector:OFF
 )
 
 SET(_ctk_test_plugins )
 
 SET(_ctk_plugins_include_dirs
   ${Poco_INCLUDE_DIRS}
 )
 
 SET(_ctk_plugins_link_dirs
   ${Poco_LIBRARY_DIR}
 )
 
 INCLUDE_DIRECTORIES(${_ctk_plugins_include_dirs})
 LINK_DIRECTORIES(${_ctk_plugins_link_dirs})
 
 IF(BLUEBERRY_BUILD_TESTING)
   INCLUDE(berryTestingHelpers)
 
   SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}")
   GET_TARGET_PROPERTY(_is_macosx_bundle ${OSGI_APP} MACOSX_BUNDLE)
   IF(APPLE AND _is_macosx_bundle) 
     SET(BLUEBERRY_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_APP}.app/Contents/MacOS/${OSGI_APP}")
   ENDIF()
-  
-  SET(_ctk_test_plugins
+
+  LIST(APPEND _ctk_plugins
     Bundles/org.blueberry.test:OFF
     Bundles/org.blueberry.uitest:OFF
+  )
+
+  SET(_ctk_test_plugins
     Testing/org.blueberry.core.runtime.tests:OFF
     Testing/org.blueberry.osgi.tests:OFF
   )
   
   IF(BLUEBERRY_ENABLE_GUI_TESTING)
     LIST(APPEND _ctk_test_plugins Testing/org.blueberry.ui.tests:OFF)
 
     SET(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_UI_APP}")
     GET_TARGET_PROPERTY(_is_macosx_bundle ${OSGI_UI_APP} MACOSX_BUNDLE)
     IF(APPLE AND _is_macosx_bundle)
       SET(BLUEBERRY_UI_TEST_APP "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${OSGI_UI_APP}.app/Contents/MacOS/${OSGI_UI_APP}")
     ENDIF()
   ENDIF()
 ENDIF()
 
+SET(BLUEBERRY_TESTING_PROVISIONING_FILE "${BlueBerry_BINARY_DIR}/BlueBerryTesting.provisioning")
+
 ADD_CUSTOM_TARGET(BlueBerry)
 
 ctkMacroSetupExternalPlugins(${_ctk_plugins} ${_ctk_test_plugins}
                              BUILD_OPTION_PREFIX BLUEBERRY_BUILD_
                              BUILD_ALL ${BLUEBERRY_BUILD_ALL_PLUGINS}
                              COMPACT_OPTIONS)
 
 SET(BLUEBERRY_PROVISIONING_FILE "${BlueBerry_BINARY_DIR}/BlueBerry.provisioning")
 IF(EXISTS "${BLUEBERRY_PROVISIONING_FILE}")
   FILE(REMOVE "${BLUEBERRY_PROVISIONING_FILE}")
 ENDIF()
 
 FunctionCreateProvisioningInfo(prov_info "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins" ${_ctk_plugins})
 file(APPEND "${BLUEBERRY_PROVISIONING_FILE}" "${prov_info}")
 
+IF(EXISTS "${BLUEBERRY_TESTING_PROVISIONING_FILE}")
+  FILE(REMOVE "${BLUEBERRY_TESTING_PROVISIONING_FILE}")
+ENDIF()
+FunctionCreateProvisioningInfo(prov_testing_info "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins" ${_ctk_plugins})
+file(APPEND "${BLUEBERRY_TESTING_PROVISIONING_FILE}" "${prov_testing_info}")
+FunctionCreateProvisioningInfo(prov_testing_info "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test_plugins" ${_ctk_test_plugins})
+file(APPEND "${BLUEBERRY_TESTING_PROVISIONING_FILE}" "${prov_testing_info}")
+
 ctkMacroGetAllProjectTargetLibraries("${CTK_PLUGIN_LIBRARIES}" _enabled_plugin_targets)
 add_dependencies(BlueBerry ${_enabled_plugin_targets})
 set_property(TARGET ${_enabled_plugin_targets} PROPERTY LABELS BlueBerry)
 
                              
 SET(BB_PLUGIN_USE_FILE "${BlueBerry_BINARY_DIR}/BlueBerryPluginUseFile.cmake")
 ctkFunctionGeneratePluginUseFile(${BB_PLUGIN_USE_FILE})
 
 # CTK Plugin Exports
 SET(BB_PLUGIN_EXPORTS_FILE "${CMAKE_CURRENT_BINARY_DIR}/BlueBerryPluginExports.cmake")
 GetMyTargetLibraries("${CTK_PLUGIN_LIBRARIES}" my_plugin_targets)
 export(TARGETS ${my_plugin_targets} mbilog PocoFoundation PocoUtil PocoXML
        FILE ${BB_PLUGIN_EXPORTS_FILE})
 
 
 ADD_SUBDIRECTORY(Documentation)
 
 CONFIGURE_FILE(BlueBerryConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/BlueBerryConfig.cmake @ONLY)