diff --git a/Core/Code/CppMicroServices/test/usLDAPFilterTest.cpp b/Core/Code/CppMicroServices/test/usLDAPFilterTest.cpp
index 7b2f9b2165..2938c7e5ef 100644
--- a/Core/Code/CppMicroServices/test/usLDAPFilterTest.cpp
+++ b/Core/Code/CppMicroServices/test/usLDAPFilterTest.cpp
@@ -1,150 +1,150 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 #include <usLDAPFilter.h>
 
 #include "usTestingMacros.h"
 
 #include <stdexcept>
 
 US_USE_NAMESPACE
 
 int TestParsing()
 {
   // WELL FORMED Expr
   try
   {
     US_TEST_OUTPUT(<< "Parsing (cn=Babs Jensen)")
     LDAPFilter ldap( "(cn=Babs Jensen)" );
     US_TEST_OUTPUT(<< "Parsing (!(cn=Tim Howes))")
     ldap = LDAPFilter( "(!(cn=Tim Howes))" );
     US_TEST_OUTPUT(<< "Parsing " << std::string("(&(") + ServiceConstants::OBJECTCLASS() + "=Person)(|(sn=Jensen)(cn=Babs J*)))")
     ldap = LDAPFilter( std::string("(&(") + ServiceConstants::OBJECTCLASS() + "=Person)(|(sn=Jensen)(cn=Babs J*)))" );
     US_TEST_OUTPUT(<< "Parsing (o=univ*of*mich*)")
     ldap = LDAPFilter( "(o=univ*of*mich*)" );
   }
   catch (const std::invalid_argument& e)
   {
     US_TEST_OUTPUT(<< e.what());
     return EXIT_FAILURE;
   }
 
 
   // MALFORMED Expr
   try
   {
     US_TEST_OUTPUT( << "Parsing malformed expr: cn=Babs Jensen)")
     LDAPFilter ldap( "cn=Babs Jensen)" );
     return EXIT_FAILURE;
   }
   catch (const std::invalid_argument&)
   {
   }
 
   return EXIT_SUCCESS;
 }
 
 
 int TestEvaluate()
 {
   // EVALUATE
   try
   {
     LDAPFilter ldap( "(Cn=Babs Jensen)" );
     ServiceProperties props;
     bool eval = false;
 
     // Several values
     props["cn"] = std::string("Babs Jensen");
     props["unused"] = std::string("Jansen");
     US_TEST_OUTPUT(<< "Evaluating expr: " << ldap.ToString())
     eval = ldap.Match(props);
     if (!eval)
     {
       return EXIT_FAILURE;
     }
 
     // WILDCARD
     ldap = LDAPFilter( "(cn=Babs *)" );
     props.clear();
     props["cn"] = std::string("Babs Jensen");
     US_TEST_OUTPUT(<< "Evaluating wildcard expr: " << ldap.ToString())
     eval = ldap.Match(props);
     if ( !eval )
     {
       return EXIT_FAILURE;
     }
 
     // NOT FOUND
     ldap = LDAPFilter( "(cn=Babs *)" );
     props.clear();
     props["unused"] = std::string("New");
     US_TEST_OUTPUT(<< "Expr not found test: " << ldap.ToString())
     eval = ldap.Match(props);
     if ( eval )
     {
       return EXIT_FAILURE;
     }
 
     // std::vector with integer values
     ldap = LDAPFilter( "  ( |(cn=Babs *)(sn=1) )" );
     props.clear();
     std::vector<Any> list;
-    list.push_back(std::string("Babs Jensen"));
-    list.push_back(std::string("1"));
+    list.push_back(Any(std::string("Babs Jensen")));
+    list.push_back(Any(std::string("1")));
     props["sn"] = list;
     US_TEST_OUTPUT(<< "Evaluating vector expr: " << ldap.ToString())
     eval = ldap.Match(props);
     if (!eval)
     {
       return EXIT_FAILURE;
     }
 
     // wrong case
     ldap = LDAPFilter( "(cN=Babs *)" );
     props.clear();
     props["cn"] = std::string("Babs Jensen");
     US_TEST_OUTPUT(<< "Evaluating case sensitive expr: " << ldap.ToString())
     eval = ldap.MatchCase(props);
     if (eval)
     {
       return EXIT_FAILURE;
     }
   }
   catch (const std::invalid_argument& e)
   {
     US_TEST_OUTPUT( << e.what() )
     return EXIT_FAILURE;
   }
 
   return EXIT_SUCCESS;
 }
 
 int usLDAPFilterTest(int /*argc*/, char* /*argv*/[])
 {
   US_TEST_BEGIN("LDAPFilterTest");
 
   US_TEST_CONDITION(TestParsing() == EXIT_SUCCESS, "Parsing LDAP expressions: ")
   US_TEST_CONDITION(TestEvaluate() == EXIT_SUCCESS, "Evaluating LDAP expressions: ")
 
   US_TEST_END()
 }
 
diff --git a/Core/Code/Testing/mitkLogTest.cpp b/Core/Code/Testing/mitkLogTest.cpp
index a1fb4a281f..28add3c397 100644
--- a/Core/Code/Testing/mitkLogTest.cpp
+++ b/Core/Code/Testing/mitkLogTest.cpp
@@ -1,202 +1,232 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkCommon.h"
 #include "mitkTestingMacros.h"
 #include <mitkLog.h>
+#include <mitkVector.h>
 #include <itkMultiThreader.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkStandardFileLocations.h>
 
 
 /** Documentation
   *
   * @brief Objects of this class can start an internal thread by calling the Start() method.
   *        The thread is then logging messages until the method Stop() is called. The class
   *        can be used to test if logging is thread-save by using multiple objects and let 
   *        them log simuntanously.
   */
 class mitkTestLoggingThread
 {
 protected:
 
 bool LoggingRunning;
 
 int ThreadID;
 
 itk::MultiThreader::Pointer m_MultiThreader;
 
 void LogMessages()
   {
   
   while(LoggingRunning)
     {
     MITK_INFO << "Test info stream in thread " << ThreadID;
     MITK_WARN << "Test warning stream in thread " << ThreadID;
     MITK_DEBUG << "Test debugging stream in thread " << ThreadID;
     MITK_ERROR << "Test error stream in thread " << ThreadID;
     MITK_FATAL << "Test fatal stream in thread " << ThreadID;
     }
   }
 
 
 static ITK_THREAD_RETURN_TYPE ThreadStartTracking(void* pInfoStruct)
   {
   /* extract this pointer from Thread Info structure */
   struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
   if (pInfo == NULL)
   {
     return ITK_THREAD_RETURN_VALUE;
   }
   if (pInfo->UserData == NULL)
   {
     return ITK_THREAD_RETURN_VALUE;
   }
   mitkTestLoggingThread *thisthread = (mitkTestLoggingThread*)pInfo->UserData;
 
   if (thisthread != NULL)
     thisthread->LogMessages();
 
   return ITK_THREAD_RETURN_VALUE;
   }
 
 public:
 
 mitkTestLoggingThread(int number, itk::MultiThreader::Pointer MultiThreader)
   {
   ThreadID = number;
   m_MultiThreader = MultiThreader;
   }
 
 void Start()
   {
   LoggingRunning = true;
   m_MultiThreader->SpawnThread(this->ThreadStartTracking, this);
   }
 
 void Stop()
   {
   LoggingRunning = false;
   }
 
 };
 
 /** Documentation
  *
  *  @brief This class holds static test methods to sturcture the test of the mitk logging mechanism.   
  */
 class mitkLogTestClass
 { 
 
 public:
 
 static void TestSimpleLog()
     {
     bool testSucceded = true;
     try
       {
       MITK_INFO << "Test info stream.";
       MITK_WARN << "Test warning stream.";
       MITK_DEBUG << "Test debugging stream."; //only activated if cmake variable is on!
                                               //so no worries if you see no output for this line
       MITK_ERROR << "Test error stream.";
       MITK_FATAL << "Test fatal stream.";
       }
     catch(mitk::Exception e)
       {
       testSucceded = false;
       }  
     MITK_TEST_CONDITION_REQUIRED(testSucceded,"Test logging streams.");
     }
 
+static void TestObjectInfoLogging()
+    {
+    bool testSucceded = true;
+    try
+      {
+      int i = 123;
+      float f = .32234;
+      double d = 123123;
+      std::string testString = "testString";
+      std::stringstream testStringStream;
+      testStringStream << "test" << "String" << "Stream";
+      mitk::Point3D testMitkPoint;
+      testMitkPoint.Fill(2);
+      
+      MITK_INFO << i;
+      MITK_INFO << f;
+      MITK_INFO << d;
+      MITK_INFO << testString;
+      MITK_INFO << testStringStream;
+      MITK_INFO << testMitkPoint;      
+      }
+    catch(mitk::Exception e)
+      {
+      testSucceded = false;
+      }  
+    MITK_TEST_CONDITION_REQUIRED(testSucceded,"Test logging of object information.");
+    }
+
 static void TestThreadSaveLog()
     {
     bool testSucceded = true;
 
     try
       {
       //initialize two threads...
       itk::MultiThreader::Pointer myThreader = itk::MultiThreader::New();
       mitkTestLoggingThread myThreadClass1 = mitkTestLoggingThread(1,myThreader);
       mitkTestLoggingThread myThreadClass2 = mitkTestLoggingThread(2,myThreader);
       
       //start them
       myThreadClass1.Start();
       myThreadClass2.Start();
       
 
       //wait for 500 ms
       itksys::SystemTools::Delay(500);
 
       //stop them
       myThreadClass1.Stop();
       myThreadClass2.Stop();
 
       //sleep again to let all threads end
       itksys::SystemTools::Delay(200);
       }
     catch(...)
       {
       testSucceded = false;
       }
 
     //if no error occured until now, everything is ok
     MITK_TEST_CONDITION_REQUIRED(testSucceded,"Test logging in different threads.");
     }
 
 static void TestLoggingToFile()
     {
     std::string filename = mitk::StandardFileLocations::GetInstance()->GetOptionDirectory() + "/testlog.log";
     mitk::LoggingBackend::SetLogFile(filename.c_str());
     MITK_INFO << "Test logging to default filename: " << mitk::LoggingBackend::GetLogFile();
     MITK_TEST_CONDITION_REQUIRED(itksys::SystemTools::FileExists(filename.c_str()),"Testing if log file exists.");
     //TODO delete log file?
     }
 
 static void TestAddAndRemoveBackends()
     {
     mbilog::BackendCout myBackend = mbilog::BackendCout();
     mbilog::RegisterBackend(&myBackend);
     MITK_INFO << "Test logging";
     mbilog::UnregisterBackend(&myBackend);
 
     //if no error occured until now, everything is ok
     MITK_TEST_CONDITION_REQUIRED(true,"Test add/remove logging backend.");
     }
 
 static void  TestDefaultBackend()
     {
     //not possible now, because we cannot unregister the mitk logging backend in the moment. If such a method is added to mbilog utility one may add this test.
     }
 
 
 };
 
 int mitkLogTest(int /* argc */, char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("Log")
 
   MITK_TEST_OUTPUT(<<"TESTING ALL LOGGING OUTPUTS, ERROR MESSAGES ARE ALSO TESTED AND NOT MEANING AN ERROR OCCURED!")
   
   mitkLogTestClass::TestSimpleLog();
+  mitkLogTestClass::TestObjectInfoLogging();
   //mitkLogTestClass::TestThreadSaveLog();
   //mitkLogTestClass::TestLoggingToFile();
   //mitkLogTestClass::TestAddAndRemoveBackends();
   
   // always end with this!
   MITK_TEST_END()
 }
diff --git a/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp b/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp
index 3cdb0f0da0..d373bff0af 100644
--- a/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp
+++ b/Modules/IGT/IGTFilters/mitkNavigationDataSequentialPlayer.cpp
@@ -1,227 +1,227 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center, 
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without 
 even the implied warranty of MERCHANTABILITY or FITNESS FOR 
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkNavigationDataSequentialPlayer.h"
 
 #include <itksys/SystemTools.hxx> //for the pause
 
 #include <mitkTimeStamp.h>
 #include <fstream>
 #include <sstream>
 
 //Exceptions
 #include "mitkIGTException.h"
 #include "mitkIGTIOException.h"
 
 mitk::NavigationDataSequentialPlayer::NavigationDataSequentialPlayer() 
   : mitk::NavigationDataPlayerBase()
   , m_Doc(new TiXmlDocument)
   , m_DataElem(0)
   , m_CurrentElem(0)
   , m_Repeat(false)
   , m_NumberOfSnapshots(0)
   , m_LastGoTo(0)
 {
 }
 
 
 mitk::NavigationDataSequentialPlayer::~NavigationDataSequentialPlayer()
 {
   delete m_Doc;
 }
 
 void mitk::NavigationDataSequentialPlayer::ReinitXML()
 {
   m_DataElem = m_Doc->FirstChildElement("Data");
   int toolcount;
   if(!m_DataElem)
   {
     MITK_WARN << "Data element not found";
     mitkThrowException(mitk::IGTException) << "Data element not found"; 
   }
   else
   {
     m_DataElem->QueryIntAttribute("ToolCount", &toolcount);
     this->SetNumberOfOutputs(toolcount);
 
     mitk::NavigationData::Pointer emptyNd = mitk::NavigationData::New();
     mitk::NavigationData::PositionType position;
     mitk::NavigationData::OrientationType orientation(0.0,0.0,0.0,0.0);
     position.Fill(0.0);
 
     emptyNd->SetPosition(position);
     emptyNd->SetOrientation(orientation);
     emptyNd->SetDataValid(false);
 
     mitk::NavigationData::Pointer tmp;
     for (unsigned int index = 0; index < this->GetNumberOfOutputs(); index++)
     {
       tmp = mitk::NavigationData::New();
       tmp->Graft(emptyNd);
       this->SetNthOutput(index, tmp);
     }
 
     // find out _NumberOfSnapshots
     m_NumberOfSnapshots = 0;
     TiXmlElement* nextND = m_DataElem->FirstChildElement("NavigationData");
     while(nextND)
     {
       ++m_NumberOfSnapshots;
       nextND = nextND->NextSiblingElement("NavigationData");
     }
     // e.g. 12 nd found and 2 tools used => number of snapshots is 12:2=6
     m_NumberOfSnapshots = m_NumberOfSnapshots/toolcount;
 
   }
 }
 
 void mitk::NavigationDataSequentialPlayer::GoToSnapshot(int i)
 {
   if(!m_Repeat && (this->GetNumberOfSnapshots()<i))
     {
       MITK_ERROR << "Snaphot " << i << " does not exist and repat is off: can't go to that snapshot!";
       mitkThrowException(mitk::IGTException) << "Snaphot " << i << " does not exist and repat is off: can't go to that snapshot!";
     }
 
   assert(m_DataElem);
 
   int numOfUpdateCalls = 0;
 
   // i.e. number of snapshots 10
   // goto(7), m_LastGoTo=3 => numOfUpdateCalls = 4
   if(m_LastGoTo <= i)
     numOfUpdateCalls = i - m_LastGoTo;
   // goto(4), m_LastGoTo=7 => numOfUpdateCalls = 7
   else
   {
     if(!m_Repeat)
     {
       std::stringstream message;
-      message <<"cannot go back to snapshot " << i << " because the "
+      message <<"Cannot go back to snapshot " << i << " because the "
           << this->GetNameOfClass() << " is configured to not repeat the"
-          << " navigation data";
-      MITK_WARN << message;
-      mitkThrowException(mitk::IGTException) << message;
+          << " navigation data.";
+      MITK_WARN << message.str();
+      mitkThrowException(mitk::IGTException) << message.str();
     }
     else
     {
       numOfUpdateCalls = (m_NumberOfSnapshots - m_LastGoTo) + i;
     }
   }
 
   for(int j=0; j<numOfUpdateCalls; ++j)
     this->Update();
 
   m_LastGoTo = i;
 }
 
 void mitk::NavigationDataSequentialPlayer::
     SetFileName(const std::string& _FileName)
 {
   m_FileName = _FileName;
   
   if(!m_Doc->LoadFile(m_FileName))
   {
     this->SetNumberOfOutputs(0);
     std::ostringstream s;
     s << "File " << _FileName << " could not be loaded";
     mitkThrowException(mitk::IGTIOException)<<s.str();
   }
   else
   {
     this->ReinitXML();
   }
 
   this->Modified();
 }
 
 void mitk::NavigationDataSequentialPlayer::
     SetXMLString(const std::string& _XMLString)
 {
   m_XMLString = _XMLString;
   if((m_Doc->Parse( m_XMLString.c_str()))== NULL)
   {
     this->ReinitXML();
   } 
   else 
   {
     //if the string is not an XML string
     std::ostringstream s;
     s << "String" << _XMLString << " is not an XML string";
     mitkThrowException(mitk::IGTIOException)<<s.str();
   } 
   this->Modified();
 }
 
 void mitk::NavigationDataSequentialPlayer::GenerateData()
 {
   assert(m_DataElem);
   // very important: go through the tools (there could be more than one)
   mitk::NavigationData::Pointer tmp;
   
   for (unsigned int index = 0; index < this->GetNumberOfOutputs(); index++)
   {
     // go to the first element
     if(!m_CurrentElem)
       m_CurrentElem = m_DataElem->FirstChildElement("NavigationData");
     // go to the next element
     else
       {
       m_CurrentElem = m_CurrentElem->NextSiblingElement();
       }
 
     // if repeat is on: go back to the first element (prior calls delivered NULL
     // elem)
     if(!m_CurrentElem && m_Repeat)
       m_CurrentElem = m_DataElem->FirstChildElement("NavigationData");
 
     mitk::NavigationData* output = this->GetOutput(index);
     tmp = this->ReadVersion1();
     if(tmp.IsNotNull())
       {
       output->Graft(tmp);
       m_StreamValid = true;
       }
     else // no valid output
       {
       output->SetDataValid(false);
       m_StreamValid = false;
       
       m_ErrorMessage = "Error: Cannot parse input file.";
       mitkThrowException(mitk::IGTException)<<m_ErrorMessage;
       }
   }
 }
 
 mitk::NavigationData::Pointer mitk::NavigationDataSequentialPlayer::ReadVersion1()
 {
 
   TiXmlElement* elem = m_CurrentElem;
 
   if(!elem)
     return NULL;
 
   return this->ReadNavigationData(elem);
 }
 
 void mitk::NavigationDataSequentialPlayer::UpdateOutputInformation()
 {
   this->Modified();  // make sure that we need to be updated
   Superclass::UpdateOutputInformation();
 }