diff --git a/Core/Code/IO/mitkFileWriterSelector.cpp b/Core/Code/IO/mitkFileWriterSelector.cpp
index 9bb807c925..62efdc562d 100644
--- a/Core/Code/IO/mitkFileWriterSelector.cpp
+++ b/Core/Code/IO/mitkFileWriterSelector.cpp
@@ -1,359 +1,359 @@
 /*===================================================================
 
 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 "mitkFileWriterSelector.h"
 
 #include <mitkFileWriterRegistry.h>
 #include <mitkCoreServices.h>
 #include <mitkIMimeTypeProvider.h>
 #include <mitkBaseData.h>
 
 #include <usServiceReference.h>
 #include <usServiceProperties.h>
 #include <usAny.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <set>
 #include <limits>
 #include <iterator>
 
 namespace mitk {
 
 struct FileWriterSelector::Item::Impl : us::SharedData
 {
   Impl()
     : m_FileWriter(NULL)
     , m_ConfidenceLevel(IFileWriter::Unsupported)
     , m_BaseDataIndex(0)
     , m_Id(-1)
   {}
 
   us::ServiceReference<IFileWriter> m_FileWriterRef;
   IFileWriter* m_FileWriter;
   IFileWriter::ConfidenceLevel m_ConfidenceLevel;
   std::size_t m_BaseDataIndex;
   MimeType m_MimeType;
   long m_Id;
 };
 
 struct FileWriterSelector::Impl : us::SharedData
 {
   Impl()
     : m_BestId(-1)
     , m_SelectedId(m_BestId)
   {}
 
   Impl(const Impl& other)
     : us::SharedData(other)
     , m_BestId(-1)
     , m_SelectedId(m_BestId)
   {}
 
   FileWriterRegistry m_WriterRegistry;
   std::map<long, FileWriterSelector::Item> m_Items;
   std::set<MimeType> m_MimeTypes;
   long m_BestId;
   long m_SelectedId;
 };
 
 FileWriterSelector::FileWriterSelector(const FileWriterSelector& other)
   : m_Data(other.m_Data)
 {
 }
 
 FileWriterSelector::FileWriterSelector(const BaseData* baseData, const std::string& mimeType,
                                        const std::string& path)
   : m_Data(new Impl)
 {
   mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
 
   std::string destMimeType = mimeType;
   if (destMimeType.empty() && !path.empty())
   {
     // try to derive a mime-type from the extension
     std::string ext = itksys::SystemTools::GetFilenameExtension(path);
-    if (!ext.empty())
+    if (ext.size() > 1)
     {
-      std::vector<MimeType> mimeTypes = mimeTypeProvider->GetMimeTypesForExtension(ext);
+      std::vector<MimeType> mimeTypes = mimeTypeProvider->GetMimeTypesForExtension(ext.substr(1));
       if (!mimeTypes.empty())
       {
         destMimeType = mimeTypes.front().GetName();
       }
     }
   }
 
   std::vector<std::string> classHierarchy = baseData->GetClassHierarchy();
 
   // Get all writers and their mime types for the given base data type
   std::vector<FileWriterRegistry::WriterReference> refs = m_Data->m_WriterRegistry.GetReferences(baseData, destMimeType);
   us::ServiceReference<IFileWriter> bestRef;
   for (std::vector<FileWriterRegistry::WriterReference>::const_iterator iter = refs.begin(),
        iterEnd = refs.end(); iter != iterEnd; ++iter)
   {
     std::string mimeTypeName = iter->GetProperty(IFileWriter::PROP_MIMETYPE()).ToString();
     if (!mimeTypeName.empty())
     {
       MimeType mimeType = mimeTypeProvider->GetMimeTypeForName(mimeTypeName);
       if (mimeType.IsValid())
       {
         // There is a registered mime-type for this writer. Now get the confidence level
         // of this writer for writing the given base data object.
 
         IFileWriter* writer = m_Data->m_WriterRegistry.GetWriter(*iter);
         if (writer == NULL) continue;
         try
         {
           writer->SetInput(baseData);
           IFileWriter::ConfidenceLevel confidenceLevel = writer->GetConfidenceLevel();
           std::cout << confidenceLevel << std::endl;
           if (confidenceLevel == IFileWriter::Unsupported)
           {
             continue;
           }
 
           std::string baseDataType = iter->GetProperty(IFileWriter::PROP_BASEDATA_TYPE()).ToString();
           std::vector<std::string>::iterator idxIter =
               std::find(classHierarchy.begin(), classHierarchy.end(), baseDataType);
           std::size_t baseDataIndex = std::numeric_limits<std::size_t>::max();
           if (idxIter != classHierarchy.end())
           {
             baseDataIndex = std::distance(classHierarchy.begin(), idxIter);
           }
 
           Item item;
           item.d->m_FileWriterRef = *iter;
           item.d->m_FileWriter = writer;
           item.d->m_ConfidenceLevel = confidenceLevel;
           item.d->m_BaseDataIndex = baseDataIndex;
           item.d->m_MimeType = mimeType;
           item.d->m_Id = us::any_cast<long>(iter->GetProperty(us::ServiceConstants::SERVICE_ID()));
           m_Data->m_Items.insert(std::make_pair(item.d->m_Id, item));
           m_Data->m_MimeTypes.insert(mimeType);
           if (!bestRef || bestRef < *iter)
           {
             bestRef = *iter;
           }
         }
         catch (const us::BadAnyCastException& e)
         {
           MITK_WARN << "Unexpected: " << e.what();
         }
 
         catch (const std::exception& e)
         {
           // Log the error but continue
           MITK_WARN << "IFileWriter::GetConfidenceLevel exception: " << e.what();
         }
       }
     }
   }
 
   if (bestRef)
   {
     try
     {
       m_Data->m_BestId = us::any_cast<long>(bestRef.GetProperty(us::ServiceConstants::SERVICE_ID()));
       m_Data->m_SelectedId = m_Data->m_BestId;
     } catch (const us::BadAnyCastException&) {}
   }
 }
 
 FileWriterSelector::~FileWriterSelector()
 {
 }
 
 FileWriterSelector& FileWriterSelector::operator=(const FileWriterSelector& other)
 {
   m_Data = other.m_Data;
   return *this;
 }
 
 bool FileWriterSelector::IsEmpty() const
 {
   return m_Data->m_Items.empty();
 }
 
 std::vector<FileWriterSelector::Item> FileWriterSelector::Get(const std::string& mimeType) const
 {
   std::vector<Item> result;
   for (std::map<long, Item>::const_iterator iter = m_Data->m_Items.begin(),
        iterEnd = m_Data->m_Items.end(); iter != iterEnd; ++iter)
   {
     if (mimeType.empty() || iter->second.GetMimeType().GetName() == mimeType)
     {
       result.push_back(iter->second);
     }
   }
   std::sort(result.begin(), result.end());
   return result;
 }
 
 std::vector<FileWriterSelector::Item> FileWriterSelector::Get() const
 {
   return Get(this->GetSelected().d->m_MimeType.GetName());
 }
 
 FileWriterSelector::Item FileWriterSelector::Get(long id) const
 {
   std::map<long, Item>::const_iterator iter = m_Data->m_Items.find(id);
   if (iter != m_Data->m_Items.end())
   {
     return iter->second;
   }
   return Item();
 }
 
 FileWriterSelector::Item FileWriterSelector::GetDefault() const
 {
   return Get(m_Data->m_BestId);
 }
 
 long FileWriterSelector::GetDefaultId() const
 {
   return m_Data->m_BestId;
 }
 
 FileWriterSelector::Item FileWriterSelector::GetSelected() const
 {
   return Get(m_Data->m_SelectedId);
 }
 
 long FileWriterSelector::GetSelectedId() const
 {
   return m_Data->m_SelectedId;
 }
 
 bool FileWriterSelector::Select(const std::string& mimeType)
 {
   std::vector<Item> items = Get(mimeType);
   if (items.empty()) return false;
   return Select(items.back());
 }
 
 bool FileWriterSelector::Select(const FileWriterSelector::Item& item)
 {
   return Select(item.d->m_Id);
 }
 
 bool FileWriterSelector::Select(long id)
 {
   if (id > -1)
   {
     if (m_Data->m_Items.find(id) == m_Data->m_Items.end())
     {
       return false;
     }
     m_Data->m_SelectedId = id;
     return true;
   }
   return false;
 }
 
 std::vector<MimeType> FileWriterSelector::GetMimeTypes() const
 {
   std::vector<MimeType> result;
   result.reserve(m_Data->m_MimeTypes.size());
   result.assign(m_Data->m_MimeTypes.begin(), m_Data->m_MimeTypes.end());
   return result;
 }
 
 void FileWriterSelector::Swap(FileWriterSelector& fws)
 {
   m_Data.Swap(fws.m_Data);
 }
 
 FileWriterSelector::Item::Item(const FileWriterSelector::Item& other)
   : d(other.d)
 {
 }
 
 FileWriterSelector::Item::~Item()
 {
 }
 
 FileWriterSelector::Item& FileWriterSelector::Item::operator=(const FileWriterSelector::Item& other)
 {
   d = other.d;
   return *this;
 }
 
 IFileWriter* FileWriterSelector::Item::GetWriter() const
 {
   return d->m_FileWriter;
 }
 
 std::string FileWriterSelector::Item::GetDescription() const
 {
   us::Any descr = d->m_FileWriterRef.GetProperty(IFileWriter::PROP_DESCRIPTION());
   if (descr.Empty()) return std::string();
   return descr.ToString();
 }
 
 IFileWriter::ConfidenceLevel FileWriterSelector::Item::GetConfidenceLevel() const
 {
   return d->m_ConfidenceLevel;
 }
 
 MimeType FileWriterSelector::Item::GetMimeType() const
 {
   return d->m_MimeType;
 }
 
 std::string FileWriterSelector::Item::GetBaseDataType() const
 {
   us::Any any = d->m_FileWriterRef.GetProperty(IFileWriter::PROP_BASEDATA_TYPE());
   if (any.Empty()) return std::string();
   return any.ToString();
 }
 
 us::ServiceReference<IFileWriter> FileWriterSelector::Item::GetReference() const
 {
   return d->m_FileWriterRef;
 }
 
 long FileWriterSelector::Item::GetServiceId() const
 {
   return d->m_Id;
 }
 
 bool FileWriterSelector::Item::operator<(const FileWriterSelector::Item& other) const
 {
   // sort by confidence level first (ascending)
   if (d->m_ConfidenceLevel == other.d->m_ConfidenceLevel)
   {
     // sort by class hierarchy index (writers for more derived
     // based data types are considered a better match)
     if (d->m_BaseDataIndex == other.d->m_BaseDataIndex)
     {
       // sort by file writer service ranking
       return d->m_FileWriterRef < other.d->m_FileWriterRef;
     }
     return other.d->m_BaseDataIndex < d->m_BaseDataIndex;
   }
   return d->m_ConfidenceLevel < other.d->m_ConfidenceLevel;
 }
 
 FileWriterSelector::Item::Item()
   : d(new Impl())
 {}
 
 void swap(FileWriterSelector& fws1, FileWriterSelector& fws2)
 {
   fws1.Swap(fws2);
 }
 
 }
diff --git a/Core/Code/Internal/mitkLegacyFileReaderService.cpp b/Core/Code/Internal/mitkLegacyFileReaderService.cpp
index e8453fdf89..4077c4c71d 100644
--- a/Core/Code/Internal/mitkLegacyFileReaderService.cpp
+++ b/Core/Code/Internal/mitkLegacyFileReaderService.cpp
@@ -1,125 +1,125 @@
 /*===================================================================
 
 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 "mitkLegacyFileReaderService.h"
 
 #include <mitkDicomSeriesReader.h>
 #include <mitkProgressBar.h>
 #include <mitkIOAdapter.h>
 #include <mitkCustomMimeType.h>
 
 mitk::LegacyFileReaderService::LegacyFileReaderService(const mitk::LegacyFileReaderService& other)
   : mitk::AbstractFileReader(other)
 {
 }
 
 mitk::LegacyFileReaderService::LegacyFileReaderService(const std::vector<std::string>& extensions,
                                                        const std::string& category)
   : AbstractFileReader()
 {
-  this->SetMimeTypePrefix("application/vnd.mitk.legacy.reader.");
+  this->SetMimeTypePrefix("application/vnd.mitk.legacy.");
 
   CustomMimeType customMimeType;
   customMimeType.SetCategory(category);
 
   for(std::vector<std::string>::const_iterator iter = extensions.begin(),
       endIter = extensions.end(); iter != endIter; ++iter)
   {
     std::string extension = *iter;
     if (!extension.empty() && extension[0] == '.')
     {
       extension.assign(extension.begin()+1, extension.end());
     }
     customMimeType.AddExtension(extension);
   }
   this->SetDescription(category);
   this->SetMimeType(customMimeType);
 
   m_ServiceReg = this->RegisterService();
 }
 
 mitk::LegacyFileReaderService::~LegacyFileReaderService()
 {
 }
 
 ////////////////////// Reading /////////////////////////
 
 std::vector<itk::SmartPointer<mitk::BaseData> > mitk::LegacyFileReaderService::Read()
 {
   std::vector<BaseData::Pointer> result;
 
   std::list<IOAdapterBase::Pointer> possibleIOAdapter;
   std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("mitkIOAdapter");
 
   for( std::list<itk::LightObject::Pointer>::iterator i = allobjects.begin();
        i != allobjects.end();
        ++i)
   {
     IOAdapterBase* io = dynamic_cast<IOAdapterBase*>(i->GetPointer());
     if(io)
     {
       possibleIOAdapter.push_back(io);
     }
     else
     {
       MITK_ERROR << "Error BaseDataIO factory did not return an IOAdapterBase: "
         << (*i)->GetNameOfClass()
         << std::endl;
     }
   }
 
   const std::string path = this->GetLocalFileName();
   for( std::list<IOAdapterBase::Pointer>::iterator k = possibleIOAdapter.begin();
                                                    k != possibleIOAdapter.end();
                                                    ++k )
   {
     bool canReadFile = (*k)->CanReadFile(path, "", "");       // they could read the file
 
     if( canReadFile )
     {
       BaseProcess::Pointer ioObject = (*k)->CreateIOProcessObject(path, "", "");
       ioObject->Update();
       int numberOfContents = static_cast<int>(ioObject->GetNumberOfOutputs());
 
       if (numberOfContents > 0)
       {
         BaseData::Pointer baseData;
         for(int i=0; i<numberOfContents; ++i)
         {
           baseData = dynamic_cast<BaseData*>(ioObject->GetOutputs()[i].GetPointer());
           if (baseData) // this is what's wanted, right?
           {
             result.push_back( baseData );
           }
         }
       }
 
       break;
     }
   }
 
   if (result.empty())
   {
     mitkThrow() << "Could not read file '" << path << "'";
   }
 
   return result;
 }
 
 mitk::LegacyFileReaderService* mitk::LegacyFileReaderService::Clone() const
 {
   return new LegacyFileReaderService(*this);
 }
diff --git a/Core/Code/Internal/mitkLegacyFileWriterService.cpp b/Core/Code/Internal/mitkLegacyFileWriterService.cpp
index 09d59d8440..099b429ed9 100644
--- a/Core/Code/Internal/mitkLegacyFileWriterService.cpp
+++ b/Core/Code/Internal/mitkLegacyFileWriterService.cpp
@@ -1,86 +1,85 @@
 /*===================================================================
 
 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 "mitkLegacyFileWriterService.h"
 
 #include <mitkDataNode.h>
 #include <mitkCustomMimeType.h>
 
 mitk::LegacyFileWriterService::LegacyFileWriterService(mitk::FileWriter::Pointer legacyWriter,
                                                        const std::string& description)
   : AbstractFileWriter(legacyWriter->GetSupportedBaseData())
   , m_LegacyWriter(legacyWriter)
 {
-  this->SetMimeTypePrefix("application/vnd.mitk.legacy.writer.");
+  this->SetMimeTypePrefix("application/vnd.mitk.legacy.");
   this->SetDescription(description);
 
-  std::vector<std::string> extensions = legacyWriter->GetPossibleFileExtensions();
-
   CustomMimeType customMimeType;
+  std::vector<std::string> extensions = legacyWriter->GetPossibleFileExtensions();
   for(std::vector<std::string>::iterator ext = extensions.begin(); ext != extensions.end(); ext++)
   {
     if (ext->empty()) continue;
 
     std::string extension = *ext;
     if (extension.size() > 1 && extension[0] == '*')
     {
       // remove "*"
       extension = extension.substr(1);
     }
     if (extension.size() > 1 && extension[0] == '.')
     {
       // remove "."
       extension = extension.substr(1);
     }
     std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
     customMimeType.AddExtension(extension);
   }
   this->SetMimeType(customMimeType);
 
   m_ServiceRegistration = RegisterService();
 }
 
 mitk::LegacyFileWriterService::~LegacyFileWriterService()
 {
 }
 
 ////////////////////// Writing /////////////////////////
 
 void mitk::LegacyFileWriterService::Write()
 {
   if (m_LegacyWriter.IsNull())
     mitkThrow() << "LegacyFileWriterService was incorrectly initialized: Has no LegacyFileWriter.";
 
   LocalFile localFile(this);
 
   m_LegacyWriter->SetFileName(localFile.GetFileName().c_str());
   m_LegacyWriter->SetInput(const_cast<BaseData*>(this->GetInput()));
   m_LegacyWriter->Write();
 }
 
 mitk::IFileWriter::ConfidenceLevel mitk::LegacyFileWriterService::GetConfidenceLevel() const
 {
   if (mitk::AbstractFileWriter::GetConfidenceLevel() == Unsupported) return Unsupported;
   DataNode::Pointer node = DataNode::New();
   node->SetData(const_cast<BaseData*>(this->GetInput()));
   return m_LegacyWriter->CanWriteDataType(node) ? Supported : Unsupported;
 }
 
 mitk::LegacyFileWriterService* mitk::LegacyFileWriterService::Clone() const
 {
   return new LegacyFileWriterService(*this);
 }
diff --git a/Core/Code/Testing/files.cmake b/Core/Code/Testing/files.cmake
index 673fa3554a..939ba93d9b 100644
--- a/Core/Code/Testing/files.cmake
+++ b/Core/Code/Testing/files.cmake
@@ -1,199 +1,199 @@
 # tests with no extra command line parameter
 set(MODULE_TESTS
   # IMPORTANT: If you plan to deactivate / comment out a test please write a bug number to the commented out line of code.
   #
   #     Example: #mitkMyTest #this test is commented out because of bug 12345
   #
   # It is important that the bug is open and that the test will be activated again before the bug is closed. This assures that
   # no test is forgotten after it was commented out. If there is no bug for your current problem, please add a new one and
   # mark it as critical.
 
   ################## DISABLED TESTS #################################################
   #mitkAbstractTransformGeometryTest.cpp #seems as tested class mitkExternAbstractTransformGeometry doesnt exist any more
   #mitkStateMachineContainerTest.cpp #rewrite test, indirect since no longer exported Bug 14529
   #mitkRegistrationBaseTest.cpp #tested class  mitkRegistrationBase doesn't exist any more
   #mitkSegmentationInterpolationTest.cpp #file doesn't exist!
   #mitkPipelineSmartPointerCorrectnessTest.cpp #file doesn't exist!
   #mitkITKThreadingTest.cpp #test outdated because itk::Semaphore was removed from ITK
   #mitkAbstractTransformPlaneGeometryTest.cpp #mitkVtkAbstractTransformPlaneGeometry doesn't exist any more
   #mitkTestUtilSharedLibrary.cpp #Linker problem with this test...
   #mitkTextOverlay2DSymbolsRenderingTest.cpp #Implementation of the tested feature is not finished yet. Ask Christoph or see bug 15104 for details.
 
   ################# RUNNING TESTS ###################################################
   mitkAccessByItkTest.cpp
   mitkCoreObjectFactoryTest.cpp
   mitkDataNodeTest.cpp
   mitkMaterialTest.cpp
   mitkActionTest.cpp
   mitkDispatcherTest.cpp
   mitkEnumerationPropertyTest.cpp
   mitkEventTest.cpp
   mitkFileReaderRegistryTest.cpp
   #mitkFileWriterRegistryTest.cpp
   mitkFocusManagerTest.cpp
   mitkGenericPropertyTest.cpp
   mitkGeometry3DTest.cpp
   mitkGeometry3DEqualTest.cpp
   mitkGeometryDataToSurfaceFilterTest.cpp
   mitkGlobalInteractionTest.cpp
   mitkImageCastTest.cpp
   mitkImageEqualTest.cpp
   mitkImageDataItemTest.cpp
   mitkImageGeneratorTest.cpp
   mitkIOUtilTest.cpp
   mitkBaseDataTest.cpp
   mitkImportItkImageTest.cpp
   mitkGrabItkImageMemoryTest.cpp
   mitkInstantiateAccessFunctionTest.cpp
   mitkInteractorTest.cpp
   mitkLevelWindowTest.cpp
   mitkMessageTest.cpp
   mitkPixelTypeTest.cpp
   mitkPlaneGeometryTest.cpp
   mitkPointSetTest.cpp
   mitkPointSetEqualTest.cpp
   mitkPointSetFileIOTest.cpp
   mitkPointSetOnEmptyTest.cpp
   mitkPointSetWriterTest.cpp
   mitkPointSetReaderTest.cpp
   mitkPointSetInteractorTest.cpp
   mitkPointSetPointOperationsTest.cpp
   mitkProgressBarTest.cpp
   mitkPropertyTest.cpp
   mitkPropertyListTest.cpp
   mitkSlicedGeometry3DTest.cpp
   mitkSliceNavigationControllerTest.cpp
   mitkStateMachineTest.cpp
   mitkStateTest.cpp
   mitkSurfaceTest.cpp
   mitkSurfaceEqualTest.cpp
   mitkSurfaceToSurfaceFilterTest.cpp
   mitkTimeGeometryTest.cpp
   mitkProportionalTimeGeometryTest.cpp
   mitkTransitionTest.cpp
   mitkUndoControllerTest.cpp
   mitkVtkWidgetRenderingTest.cpp
   mitkVerboseLimitedLinearUndoTest.cpp
   mitkWeakPointerTest.cpp
   mitkTransferFunctionTest.cpp
   mitkStepperTest.cpp
   mitkRenderingManagerTest.cpp
   vtkMitkThickSlicesFilterTest.cpp
   mitkNodePredicateSourceTest.cpp
   mitkVectorTest.cpp
   mitkClippedSurfaceBoundsCalculatorTest.cpp
   mitkExceptionTest.cpp
   mitkExtractSliceFilterTest.cpp
   mitkLogTest.cpp
   mitkImageDimensionConverterTest.cpp
   mitkLoggingAdapterTest.cpp
   mitkUIDGeneratorTest.cpp
   mitkShaderRepositoryTest.cpp
   mitkPlanePositionManagerTest.cpp
   mitkAffineTransformBaseTest.cpp
   mitkPropertyAliasesTest.cpp
   mitkPropertyDescriptionsTest.cpp
   mitkPropertyExtensionsTest.cpp
   mitkPropertyFiltersTest.cpp
   mitkTinyXMLTest.cpp
   mitkRawImageFileReaderTest.cpp
   mitkInteractionEventTest.cpp
   mitkLookupTableTest.cpp
-  #mitkSTLFileReaderTest.cpp
+  mitkSTLFileReaderTest.cpp
   mitkPointTypeConversionTest.cpp
   mitkVectorTypeConversionTest.cpp
   mitkMatrixTypeConversionTest.cpp
   mitkArrayTypeConversionTest.cpp
   mitkSurfaceToImageFilterTest.cpp
   mitkBaseGeometryTest.cpp
   mitkImageToSurfaceFilterTest.cpp
   mitkEqualTest.cpp
   mitkLineTest.cpp
 )
 
 if(MITK_ENABLE_RENDERING_TESTING) #since mitkInteractionTestHelper is currently creating a vtkRenderWindow
 set(MODULE_TESTS
   ${MODULE_TESTS}
   mitkPointSetDataInteractorTest.cpp
 )
 endif()
 
 
 
 # test with image filename as an extra command line parameter
 set(MODULE_IMAGE_TESTS
   mitkImageTimeSelectorTest.cpp #only runs on images
   mitkImageAccessorTest.cpp #only runs on images
 )
 
 set(MODULE_SURFACE_TESTS
   mitkSurfaceVtkWriterTest.cpp #only runs on surfaces
 )
 
 # list of images for which the tests are run
 set(MODULE_TESTIMAGES
   US4DCyl.nrrd
   Pic3D.nrrd
   Pic2DplusT.nrrd
   BallBinary30x30x30.nrrd
   Png2D-bw.png
 )
 set(MODULE_TESTSURFACES
   binary.stl
   ball.stl
 )
 
 set(MODULE_CUSTOM_TESTS
     mitkDataStorageTest.cpp
     mitkDicomSeriesReaderTest.cpp
     mitkDICOMLocaleTest.cpp
     mitkEventMapperTest.cpp
     mitkEventConfigTest.cpp
     mitkNodeDependentPointSetInteractorTest.cpp
     mitkStateMachineFactoryTest.cpp
     mitkPointSetLocaleTest.cpp
     mitkImageTest.cpp
     mitkImageWriterTest.cpp
     mitkImageVtkMapper2DTest.cpp
     mitkImageVtkMapper2DLevelWindowTest.cpp
     mitkImageVtkMapper2DOpacityTest.cpp
     mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp
     mitkImageVtkMapper2DColorTest.cpp
     mitkImageVtkMapper2DSwivelTest.cpp
     mitkImageVtkMapper2DTransferFunctionTest.cpp
     mitkImageVtkMapper2DOpacityTransferFunctionTest.cpp
     mitkImageVtkMapper2DLookupTableTest.cpp
     mitkSurfaceVtkMapper3DTest
     mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
     mitkSurfaceGLMapper2DColorTest.cpp
     mitkSurfaceGLMapper2DOpacityTest.cpp
     mitkVolumeCalculatorTest.cpp
     mitkLevelWindowManagerTest.cpp
     mitkPointSetVtkMapper2DTest.cpp
     mitkPointSetVtkMapper2DImageTest.cpp
     mitkPointSetVtkMapper2DGlyphTypeTest.cpp
     mitkPointSetVtkMapper2DTransformedPointsTest.cpp
     mitkVTKRenderWindowSizeTest.cpp
     mitkMultiComponentImageDataComparisonFilterTest.cpp
     mitkImageToItkTest.cpp
     mitkImageSliceSelectorTest.cpp
     mitkSurfaceDepthPeelingTest.cpp
     mitkSurfaceDepthSortingTest.cpp
 )
 
 set(MODULE_RESOURCE_FILES
   Interactions/AddAndRemovePoints.xml
   Interactions/globalConfig.xml
   Interactions/StatemachineTest.xml
   Interactions/StatemachineConfigTest.xml
 )
 
 # Embed the resources
 set(testdriver_resources )
 usFunctionEmbedResources(testdriver_resources
                          EXECUTABLE_NAME ${MODULE_NAME}TestDriver
                          ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Resources
                          FILES ${MODULE_RESOURCE_FILES}
                         )
 
 set(TEST_CPP_FILES ${testdriver_init_file} ${testdriver_resources})
diff --git a/Core/Code/Testing/mitkSTLFileReaderTest.cpp b/Core/Code/Testing/mitkSTLFileReaderTest.cpp
index 7876cf03c6..3190525e42 100644
--- a/Core/Code/Testing/mitkSTLFileReaderTest.cpp
+++ b/Core/Code/Testing/mitkSTLFileReaderTest.cpp
@@ -1,84 +1,79 @@
 /*===================================================================
 
 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 "mitkImage.h"
-#include "mitkSTLFileReader.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkSurface.h"
+#include "mitkIOUtil.h"
 #include "mitkTestingMacros.h"
 #include "mitkTestFixture.h"
 #include <vtkSTLReader.h>
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 
 #include <fstream>
 
 class mitkSTLFileReaderTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkSTLFileReaderTestSuite);
   MITK_TEST(testReadFile);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   /** Members used inside the different test methods. All members are initialized via setUp().*/
   std::string m_SurfacePath;
 
 public:
 
   /**
    * @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members for a new test case. (If the members are not used in a test, the method does not need to be called).
    */
   void setUp()
   {
     m_SurfacePath = GetTestDataFilePath("ball.stl");
   }
 
   void tearDown()
   {
   }
 
-void testReadFile()
+  void testReadFile()
   {
-  //Read STL-Image from file
-  mitk::STLFileReader::Pointer reader = mitk::STLFileReader::New();
-  if (!reader->CanReadFile(m_SurfacePath, "", "")) {CPPUNIT_FAIL("Cannot read test data STL file.");}
-  reader->SetFileName(m_SurfacePath);
-  reader->Update();
-  mitk::Surface::Pointer surface = reader->GetOutput();
-
-  //check some basic stuff
-  CPPUNIT_ASSERT_MESSAGE("Reader output not NULL",surface.IsNotNull());
-  CPPUNIT_ASSERT_MESSAGE("IsInitialized()",surface->IsInitialized());
-  CPPUNIT_ASSERT_MESSAGE("mitk::Surface::SetVtkPolyData()",(surface->GetVtkPolyData()!=NULL));
-  CPPUNIT_ASSERT_MESSAGE("Availability of geometry",(surface->GetGeometry()!=NULL));
-
-  //use vtk stl reader for reference
-  vtkSmartPointer<vtkSTLReader> myVtkSTLReader = vtkSmartPointer<vtkSTLReader>::New();
-  myVtkSTLReader->SetFileName( m_SurfacePath.c_str() );
-  myVtkSTLReader->Update();
-  vtkSmartPointer<vtkPolyData> myVtkPolyData = myVtkSTLReader->GetOutput();
-  //vtkPolyData from vtkSTLReader directly
-  int n = myVtkPolyData->GetNumberOfPoints();
-  //vtkPolyData from mitkSTLFileReader
-  int m = surface->GetVtkPolyData()->GetNumberOfPoints();
-  CPPUNIT_ASSERT_MESSAGE("Number of Points in VtkPolyData",(n == m));
-
+    //Read STL-Image from file
+    mitk::Surface::Pointer surface = mitk::IOUtil::LoadSurface(m_SurfacePath);
+
+    //check some basic stuff
+    CPPUNIT_ASSERT_MESSAGE("Reader output not NULL",surface.IsNotNull());
+    CPPUNIT_ASSERT_MESSAGE("IsInitialized()",surface->IsInitialized());
+    CPPUNIT_ASSERT_MESSAGE("mitk::Surface::SetVtkPolyData()",(surface->GetVtkPolyData()!=NULL));
+    CPPUNIT_ASSERT_MESSAGE("Availability of geometry",(surface->GetGeometry()!=NULL));
+
+    //use vtk stl reader for reference
+    vtkSmartPointer<vtkSTLReader> myVtkSTLReader = vtkSmartPointer<vtkSTLReader>::New();
+    myVtkSTLReader->SetFileName( m_SurfacePath.c_str() );
+    myVtkSTLReader->Update();
+    vtkSmartPointer<vtkPolyData> myVtkPolyData = myVtkSTLReader->GetOutput();
+    //vtkPolyData from vtkSTLReader directly
+    int n = myVtkPolyData->GetNumberOfPoints();
+    //vtkPolyData from mitkSTLFileReader
+    int m = surface->GetVtkPolyData()->GetNumberOfPoints();
+    CPPUNIT_ASSERT_MESSAGE("Number of Points in VtkPolyData",(n == m));
   }
 
 };
 MITK_TEST_SUITE_REGISTRATION(mitkSTLFileReader)