diff --git a/Modules/Core/include/mitkIOMetaInformationPropertyConstants.h b/Modules/Core/include/mitkIOMetaInformationPropertyConstants.h
index f3d724afc8..166bd66d3e 100644
--- a/Modules/Core/include/mitkIOMetaInformationPropertyConstants.h
+++ b/Modules/Core/include/mitkIOMetaInformationPropertyConstants.h
@@ -1,44 +1,44 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITKIOMETAINFORMATIONCONSTANTS_H_
 #define MITKIOMETAINFORMATIONCONSTANTS_H_
 
 #include <MitkCoreExports.h>
 
 #include "mitkPropertyKeyPath.h"
 
 namespace mitk
 {
   /**
    * @ingroup IO
-   * @brief The IOMetaInformationPropertyConsants struct
+   * @brief The IOMetaInformationPropertyConstants struct
    */
-  struct MITKCORE_EXPORT IOMetaInformationPropertyConsants
+  struct MITKCORE_EXPORT IOMetaInformationPropertyConstants
   {
     //Path to the property containing the name of the reader used
     static PropertyKeyPath READER_DESCRIPTION();
     //Path to the property containing the version of mitk used to read the data
     static PropertyKeyPath READER_VERSION();
     //Path to the property containing the mine name detected used to read the data
     static PropertyKeyPath READER_MIME_NAME();
     //Path to the property containing the mime category detected to read the data
     static PropertyKeyPath READER_MIME_CATEGORY();
     //Path to the property containing the input location if loaded by file used to read the data
     static PropertyKeyPath READER_INPUTLOCATION();
     //Path to the properties containing the reader optins used to read the data
     static PropertyKeyPath READER_OPTION_ROOT();
     static PropertyKeyPath READER_OPTIONS_ANY();
   };
 }
 
 #endif // MITKIOCONSTANTS_H_
diff --git a/Modules/Core/src/IO/mitkAbstractFileReader.cpp b/Modules/Core/src/IO/mitkAbstractFileReader.cpp
index 1dcf0a3d45..af38ca14ad 100644
--- a/Modules/Core/src/IO/mitkAbstractFileReader.cpp
+++ b/Modules/Core/src/IO/mitkAbstractFileReader.cpp
@@ -1,332 +1,332 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkAbstractFileReader.h>
 
 #include <mitkCustomMimeType.h>
 #include <mitkIOUtil.h>
 
 #include <mitkFileReaderWriterBase.h>
 #include <mitkVersion.h>
 #include <mitkIOMetaInformationPropertyConstants.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usPrototypeServiceFactory.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include <fstream>
 
 namespace mitk
 {
   AbstractFileReader::InputStream::InputStream(IFileReader *reader, std::ios_base::openmode mode)
     : std::istream(nullptr), m_Stream(nullptr)
   {
     std::istream *stream = reader->GetInputStream();
     if (stream)
     {
       this->init(stream->rdbuf());
     }
     else
     {
       m_Stream = new std::ifstream(reader->GetInputLocation().c_str(), mode);
       this->init(m_Stream->rdbuf());
     }
   }
 
   AbstractFileReader::InputStream::~InputStream() { delete m_Stream; }
   class AbstractFileReader::Impl : public FileReaderWriterBase
   {
   public:
     Impl() : FileReaderWriterBase(), m_Stream(nullptr), m_PrototypeFactory(nullptr) {}
     Impl(const Impl &other) : FileReaderWriterBase(other), m_Stream(nullptr), m_PrototypeFactory(nullptr) {}
     std::string m_Location;
     std::string m_TmpFile;
     std::istream *m_Stream;
 
     us::PrototypeServiceFactory *m_PrototypeFactory;
     us::ServiceRegistration<IFileReader> m_Reg;
   };
 
   AbstractFileReader::AbstractFileReader() : d(new Impl) {}
   AbstractFileReader::~AbstractFileReader()
   {
     UnregisterService();
 
     delete d->m_PrototypeFactory;
 
     if (!d->m_TmpFile.empty())
     {
       std::remove(d->m_TmpFile.c_str());
     }
   }
 
   AbstractFileReader::AbstractFileReader(const AbstractFileReader &other) : IFileReader(), d(new Impl(*other.d.get()))
   {
   }
 
   AbstractFileReader::AbstractFileReader(const CustomMimeType &mimeType, const std::string &description) : d(new Impl)
   {
     d->SetMimeType(mimeType);
     d->SetDescription(description);
   }
 
   ////////////////////// Reading /////////////////////////
 
   std::vector<BaseData::Pointer> AbstractFileReader::Read()
   {
     std::vector<BaseData::Pointer> result = this->DoRead();
 
     const auto options = this->GetOptions();
 
     for (auto& data : result)
     {
-      data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConsants::READER_DESCRIPTION()), StringProperty::New(d->GetDescription()));
-      data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConsants::READER_VERSION()), StringProperty::New(MITK_VERSION_STRING));
-      data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConsants::READER_MIME_NAME()), StringProperty::New(d->GetMimeType()->GetName()));
-      data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConsants::READER_MIME_CATEGORY()), StringProperty::New(d->GetMimeType()->GetCategory()));
+      data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_DESCRIPTION()), StringProperty::New(d->GetDescription()));
+      data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_VERSION()), StringProperty::New(MITK_VERSION_STRING));
+      data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_MIME_NAME()), StringProperty::New(d->GetMimeType()->GetName()));
+      data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_MIME_CATEGORY()), StringProperty::New(d->GetMimeType()->GetCategory()));
       if (this->GetInputStream() == nullptr)
       {
-        data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConsants::READER_INPUTLOCATION()), StringProperty::New(this->GetInputLocation()));
+        data->SetProperty(PropertyKeyPathToPropertyName(IOMetaInformationPropertyConstants::READER_INPUTLOCATION()), StringProperty::New(this->GetInputLocation()));
       }
 
       for (const auto& option : options)
       {
-        auto optionpath = IOMetaInformationPropertyConsants::READER_OPTION_ROOT().AddElement(option.first);
+        auto optionpath = IOMetaInformationPropertyConstants::READER_OPTION_ROOT().AddElement(option.first);
         data->SetProperty(PropertyKeyPathToPropertyName(optionpath), StringProperty::New(option.second.ToString()));
       }
     }
 
     return result;
   }
 
   DataStorage::SetOfObjects::Pointer AbstractFileReader::Read(DataStorage &ds)
   {
     DataStorage::SetOfObjects::Pointer result = DataStorage::SetOfObjects::New();
     std::vector<BaseData::Pointer> data = this->Read();
     for (auto iter = data.begin(); iter != data.end(); ++iter)
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(*iter);
       this->SetDefaultDataNodeProperties(node, this->GetInputLocation());
       ds.Add(node);
       result->InsertElement(result->Size(), node);
     }
     return result;
   }
 
   IFileReader::ConfidenceLevel AbstractFileReader::GetConfidenceLevel() const
   {
     if (d->m_Stream)
     {
       if (*d->m_Stream)
         return Supported;
     }
     else
     {
       if (itksys::SystemTools::FileExists(this->GetInputLocation().c_str(), true))
       {
         return Supported;
       }
     }
     return Unsupported;
   }
 
   //////////// µS Registration & Properties //////////////
 
   us::ServiceRegistration<IFileReader> AbstractFileReader::RegisterService(us::ModuleContext *context)
   {
     if (d->m_PrototypeFactory)
       return us::ServiceRegistration<IFileReader>();
 
     if (context == nullptr)
     {
       context = us::GetModuleContext();
     }
 
     d->RegisterMimeType(context);
 
     if (this->GetMimeType()->GetName().empty())
     {
       MITK_WARN << "Not registering reader due to empty MIME type.";
       return us::ServiceRegistration<IFileReader>();
     }
 
     struct PrototypeFactory : public us::PrototypeServiceFactory
     {
       AbstractFileReader *const m_Prototype;
 
       PrototypeFactory(AbstractFileReader *prototype) : m_Prototype(prototype) {}
       us::InterfaceMap GetService(us::Module * /*module*/,
                                   const us::ServiceRegistrationBase & /*registration*/) override
       {
         return us::MakeInterfaceMap<IFileReader>(m_Prototype->Clone());
       }
 
       void UngetService(us::Module * /*module*/,
                         const us::ServiceRegistrationBase & /*registration*/,
                         const us::InterfaceMap &service) override
       {
         delete us::ExtractInterface<IFileReader>(service);
       }
     };
 
     d->m_PrototypeFactory = new PrototypeFactory(this);
     us::ServiceProperties props = this->GetServiceProperties();
     d->m_Reg = context->RegisterService<IFileReader>(d->m_PrototypeFactory, props);
     return d->m_Reg;
   }
 
   void AbstractFileReader::UnregisterService()
   {
     try
     {
       d->m_Reg.Unregister();
     }
     catch (const std::exception &)
     {
     }
   }
 
   us::ServiceProperties AbstractFileReader::GetServiceProperties() const
   {
     us::ServiceProperties result;
 
     result[IFileReader::PROP_DESCRIPTION()] = this->GetDescription();
     result[IFileReader::PROP_MIMETYPE()] = this->GetMimeType()->GetName();
     result[us::ServiceConstants::SERVICE_RANKING()] = this->GetRanking();
     return result;
   }
 
   us::ServiceRegistration<CustomMimeType> AbstractFileReader::RegisterMimeType(us::ModuleContext *context)
   {
     return d->RegisterMimeType(context);
   }
 
   std::vector< std::string > AbstractFileReader::GetReadFiles(){ return m_ReadFiles; }
 
   void AbstractFileReader::SetMimeType(const CustomMimeType &mimeType) { d->SetMimeType(mimeType); }
   void AbstractFileReader::SetDescription(const std::string &description) { d->SetDescription(description); }
   void AbstractFileReader::SetRanking(int ranking) { d->SetRanking(ranking); }
   int AbstractFileReader::GetRanking() const { return d->GetRanking(); }
   std::string AbstractFileReader::GetLocalFileName() const
   {
     std::string localFileName;
     if (d->m_Stream)
     {
       if (d->m_TmpFile.empty())
       {
         // write the stream contents to temporary file
         std::string ext = itksys::SystemTools::GetFilenameExtension(this->GetInputLocation());
         std::ofstream tmpStream;
         localFileName = mitk::IOUtil::CreateTemporaryFile(
           tmpStream, std::ios_base::out | std::ios_base::trunc | std::ios_base::binary, "XXXXXX" + ext);
         tmpStream << d->m_Stream->rdbuf();
         d->m_TmpFile = localFileName;
       }
       else
       {
         localFileName = d->m_TmpFile;
       }
     }
     else
     {
       localFileName = d->m_Location;
     }
     return localFileName;
   }
 
   //////////////////////// Options ///////////////////////
 
   void AbstractFileReader::SetDefaultOptions(const IFileReader::Options &defaultOptions)
   {
     d->SetDefaultOptions(defaultOptions);
   }
 
   IFileReader::Options AbstractFileReader::GetDefaultOptions() const { return d->GetDefaultOptions(); }
   void AbstractFileReader::SetInput(const std::string &location)
   {
     d->m_Location = location;
     d->m_Stream = nullptr;
   }
 
   void AbstractFileReader::SetInput(const std::string &location, std::istream *is)
   {
     if (d->m_Stream != is && !d->m_TmpFile.empty())
     {
       std::remove(d->m_TmpFile.c_str());
       d->m_TmpFile.clear();
     }
     d->m_Location = location;
     d->m_Stream = is;
   }
 
   std::string AbstractFileReader::GetInputLocation() const { return d->m_Location; }
   std::istream *AbstractFileReader::GetInputStream() const { return d->m_Stream; }
   MimeType AbstractFileReader::GetRegisteredMimeType() const { return d->GetRegisteredMimeType(); }
   IFileReader::Options AbstractFileReader::GetOptions() const { return d->GetOptions(); }
   us::Any AbstractFileReader::GetOption(const std::string &name) const { return d->GetOption(name); }
   void AbstractFileReader::SetOptions(const Options &options) { d->SetOptions(options); }
   void AbstractFileReader::SetOption(const std::string &name, const us::Any &value) { d->SetOption(name, value); }
   ////////////////// MISC //////////////////
 
   void AbstractFileReader::AddProgressCallback(const ProgressCallback &callback) { d->AddProgressCallback(callback); }
   void AbstractFileReader::RemoveProgressCallback(const ProgressCallback &callback)
   {
     d->RemoveProgressCallback(callback);
   }
 
   ////////////////// µS related Getters //////////////////
 
   const CustomMimeType *AbstractFileReader::GetMimeType() const { return d->GetMimeType(); }
   void AbstractFileReader::SetMimeTypePrefix(const std::string &prefix) { d->SetMimeTypePrefix(prefix); }
   std::string AbstractFileReader::GetMimeTypePrefix() const { return d->GetMimeTypePrefix(); }
   std::string AbstractFileReader::GetDescription() const { return d->GetDescription(); }
   void AbstractFileReader::SetDefaultDataNodeProperties(DataNode *node, const std::string &filePath)
   {
     // path
     if (!filePath.empty())
     {
       mitk::StringProperty::Pointer pathProp =
         mitk::StringProperty::New(itksys::SystemTools::GetFilenamePath(filePath));
       node->SetProperty(StringProperty::PATH, pathProp);
     }
 
     // name already defined?
     mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty *>(node->GetProperty("name"));
     if (nameProp.IsNull() || nameProp->GetValue() == DataNode::NO_NAME_VALUE())
     {
       // name already defined in BaseData
       mitk::StringProperty::Pointer baseDataNameProp =
         dynamic_cast<mitk::StringProperty *>(node->GetData()->GetProperty("name").GetPointer());
       if (baseDataNameProp.IsNull() || baseDataNameProp->GetValue() == DataNode::NO_NAME_VALUE())
       {
         // name neither defined in node, nor in BaseData -> name = filebasename;
         nameProp = mitk::StringProperty::New(this->GetRegisteredMimeType().GetFilenameWithoutExtension(filePath));
         node->SetProperty("name", nameProp);
       }
       else
       {
         // name defined in BaseData!
         nameProp = mitk::StringProperty::New(baseDataNameProp->GetValue());
         node->SetProperty("name", nameProp);
       }
     }
 
     // visibility
     if (!node->GetProperty("visible"))
     {
       node->SetVisibility(true);
     }
   }
 }
diff --git a/Modules/Core/src/IO/mitkIOMetaInformationPropertyConstants.cpp b/Modules/Core/src/IO/mitkIOMetaInformationPropertyConstants.cpp
index 8bbc5d7aa2..a57c640107 100644
--- a/Modules/Core/src/IO/mitkIOMetaInformationPropertyConstants.cpp
+++ b/Modules/Core/src/IO/mitkIOMetaInformationPropertyConstants.cpp
@@ -1,52 +1,52 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkIOMetaInformationPropertyConstants.h"
 
 namespace mitk
 {
 
-  PropertyKeyPath IOMetaInformationPropertyConsants::READER_DESCRIPTION()
+  PropertyKeyPath IOMetaInformationPropertyConstants::READER_DESCRIPTION()
   {
     return PropertyKeyPath({ "MITK", "IO", "reader", "description" });
   }
 
-  PropertyKeyPath IOMetaInformationPropertyConsants::READER_VERSION()
+  PropertyKeyPath IOMetaInformationPropertyConstants::READER_VERSION()
   {
     return PropertyKeyPath({ "MITK", "IO", "reader", "version" });
   }
 
-  PropertyKeyPath IOMetaInformationPropertyConsants::READER_MIME_NAME()
+  PropertyKeyPath IOMetaInformationPropertyConstants::READER_MIME_NAME()
   {
     return PropertyKeyPath({ "MITK", "IO", "reader", "mime", "name" });
   }
 
-  PropertyKeyPath IOMetaInformationPropertyConsants::READER_MIME_CATEGORY()
+  PropertyKeyPath IOMetaInformationPropertyConstants::READER_MIME_CATEGORY()
   {
     return PropertyKeyPath({ "MITK", "IO", "reader", "mime", "category" });
   }
 
-  PropertyKeyPath IOMetaInformationPropertyConsants::READER_INPUTLOCATION()
+  PropertyKeyPath IOMetaInformationPropertyConstants::READER_INPUTLOCATION()
   {
     return PropertyKeyPath({ "MITK", "IO", "reader", "inputlocation" });
   }
 
-  PropertyKeyPath IOMetaInformationPropertyConsants::READER_OPTION_ROOT()
+  PropertyKeyPath IOMetaInformationPropertyConstants::READER_OPTION_ROOT()
   {
     return PropertyKeyPath({ "MITK", "IO", "reader", "option" });
   }
 
-  PropertyKeyPath IOMetaInformationPropertyConsants::READER_OPTIONS_ANY()
+  PropertyKeyPath IOMetaInformationPropertyConstants::READER_OPTIONS_ANY()
   {
     return READER_OPTION_ROOT().AddAnyElement();
   }
 }
diff --git a/Modules/Core/src/mitkCoreActivator.cpp b/Modules/Core/src/mitkCoreActivator.cpp
index a181bb1316..4e2a3363d9 100644
--- a/Modules/Core/src/mitkCoreActivator.cpp
+++ b/Modules/Core/src/mitkCoreActivator.cpp
@@ -1,357 +1,357 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkCoreActivator.h"
 
 #include <mitkCoreServices.h>
 #include <mitkPropertyPersistenceInfo.h>
 
 // File IO
 #include <mitkIOMetaInformationPropertyConstants.h>
 #include <mitkGeometryDataReaderService.h>
 #include <mitkGeometryDataWriterService.h>
 #include <mitkIOMimeTypes.h>
 #include <mitkIOUtil.h>
 #include <mitkImageVtkLegacyIO.h>
 #include <mitkImageVtkXmlIO.h>
 #include <mitkItkImageIO.h>
 #include <mitkMimeTypeProvider.h>
 #include <mitkPointSetReaderService.h>
 #include <mitkPointSetWriterService.h>
 #include <mitkRawImageFileReader.h>
 #include <mitkSurfaceStlIO.h>
 #include <mitkSurfaceVtkLegacyIO.h>
 #include <mitkSurfaceVtkXmlIO.h>
 
 #include "mitkLegacyFileWriterService.h"
 #include <mitkFileWriter.h>
 
 #include <itkGDCMImageIO.h>
 #include <itkNiftiImageIO.h>
 
 // Micro Services
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usModuleEvent.h>
 #include <usModuleInitialization.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <usModuleSettings.h>
 #include <usServiceTracker.h>
 
 // ITK "injects" static initialization code for IO factories
 // via the itkImageIOFactoryRegisterManager.h header (which
 // is generated in the application library build directory).
 // To ensure that the code is called *before* the CppMicroServices
 // static initialization code (which triggers the Activator::Start
 // method), we include the ITK header here.
 #include <itkImageIOFactoryRegisterManager.h>
 
 void HandleMicroServicesMessages(us::MsgType type, const char *msg)
 {
   switch (type)
   {
     case us::DebugMsg:
       MITK_DEBUG << msg;
       break;
     case us::InfoMsg:
       MITK_INFO << msg;
       break;
     case us::WarningMsg:
       MITK_WARN << msg;
       break;
     case us::ErrorMsg:
       MITK_ERROR << msg;
       break;
   }
 }
 
 void AddMitkAutoLoadPaths(const std::string &programPath)
 {
   us::ModuleSettings::AddAutoLoadPath(programPath);
 #ifdef __APPLE__
   // Walk up three directories since that is where the .dylib files are located
   // for build trees.
   std::string additionalPath = programPath;
   bool addPath = true;
   for (int i = 0; i < 3; ++i)
   {
     std::size_t index = additionalPath.find_last_of('/');
     if (index != std::string::npos)
     {
       additionalPath = additionalPath.substr(0, index);
     }
     else
     {
       addPath = false;
       break;
     }
   }
   if (addPath)
   {
     us::ModuleSettings::AddAutoLoadPath(additionalPath);
   }
 #endif
 }
 
 void AddPropertyPersistence(const mitk::PropertyKeyPath& propPath)
 {
   mitk::CoreServicePointer<mitk::IPropertyPersistence> persistenceService(mitk::CoreServices::GetPropertyPersistence());
 
-  mitk::PropertyPersistenceInfo::Pointer info = mitk::PropertyPersistenceInfo::New();
+  auto info = mitk::PropertyPersistenceInfo::New();
   if (propPath.IsExplicit())
   {
     std::string name = mitk::PropertyKeyPathToPropertyName(propPath);
     std::string key = name;
     std::replace(key.begin(), key.end(), '.', '_');
     info->SetNameAndKey(name, key);
   }
   else
   {
     std::string key = mitk::PropertyKeyPathToPersistenceKeyRegEx(propPath);
     std::string keyTemplate = mitk::PropertyKeyPathToPersistenceKeyTemplate(propPath);
     std::string propRegEx = mitk::PropertyKeyPathToPropertyRegEx(propPath);
     std::string propTemplate = mitk::PropertyKeyPathToPersistenceNameTemplate(propPath);
     info->UseRegEx(propRegEx, propTemplate, key, keyTemplate);
   }
 
   persistenceService->AddInfo(info);
 }
 
 class FixedNiftiImageIO : public itk::NiftiImageIO
 {
 public:
   /** Standard class typedefs. */
   typedef FixedNiftiImageIO Self;
   typedef itk::NiftiImageIO Superclass;
   typedef itk::SmartPointer<Self> Pointer;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self)
 
     /** Run-time type information (and related methods). */
     itkTypeMacro(FixedNiftiImageIO, Superclass)
 
       bool SupportsDimension(unsigned long dim) override
   {
     return dim > 1 && dim < 5;
   }
 };
 
 void MitkCoreActivator::Load(us::ModuleContext *context)
 {
   // Handle messages from CppMicroServices
   us::installMsgHandler(HandleMicroServicesMessages);
 
   this->m_Context = context;
 
   // Add the current application directory to the auto-load paths.
   // This is useful for third-party executables.
   std::string programPath = mitk::IOUtil::GetProgramPath();
   if (programPath.empty())
   {
     MITK_WARN << "Could not get the program path.";
   }
   else
   {
     AddMitkAutoLoadPaths(programPath);
   }
 
   // m_RenderingManager = mitk::RenderingManager::New();
   // context->RegisterService<mitk::RenderingManager>(renderingManager.GetPointer());
   m_PlanePositionManager.reset(new mitk::PlanePositionManagerService);
   context->RegisterService<mitk::PlanePositionManagerService>(m_PlanePositionManager.get());
 
   m_PropertyAliases.reset(new mitk::PropertyAliases);
   context->RegisterService<mitk::IPropertyAliases>(m_PropertyAliases.get());
 
   m_PropertyDescriptions.reset(new mitk::PropertyDescriptions);
   context->RegisterService<mitk::IPropertyDescriptions>(m_PropertyDescriptions.get());
 
   m_PropertyExtensions.reset(new mitk::PropertyExtensions);
   context->RegisterService<mitk::IPropertyExtensions>(m_PropertyExtensions.get());
 
   m_PropertyFilters.reset(new mitk::PropertyFilters);
   context->RegisterService<mitk::IPropertyFilters>(m_PropertyFilters.get());
 
   m_PropertyPersistence.reset(new mitk::PropertyPersistence);
   context->RegisterService<mitk::IPropertyPersistence>(m_PropertyPersistence.get());
 
   m_PropertyRelations.reset(new mitk::PropertyRelations);
   context->RegisterService<mitk::IPropertyRelations>(m_PropertyRelations.get());
 
   m_MimeTypeProvider.reset(new mitk::MimeTypeProvider);
   m_MimeTypeProvider->Start();
   m_MimeTypeProviderReg = context->RegisterService<mitk::IMimeTypeProvider>(m_MimeTypeProvider.get());
 
   this->RegisterDefaultMimeTypes();
   this->RegisterItkReaderWriter();
   this->RegisterVtkReaderWriter();
 
   // Add custom Reader / Writer Services
   m_FileReaders.push_back(new mitk::PointSetReaderService());
   m_FileWriters.push_back(new mitk::PointSetWriterService());
   m_FileReaders.push_back(new mitk::GeometryDataReaderService());
   m_FileWriters.push_back(new mitk::GeometryDataWriterService());
   m_FileReaders.push_back(new mitk::RawImageFileReaderService());
 
   //add properties that should be persistent (if possible/supported by the writer)
-  AddPropertyPersistence(mitk::IOMetaInformationPropertyConsants::READER_DESCRIPTION());
-  AddPropertyPersistence(mitk::IOMetaInformationPropertyConsants::READER_INPUTLOCATION());
-  AddPropertyPersistence(mitk::IOMetaInformationPropertyConsants::READER_MIME_CATEGORY());
-  AddPropertyPersistence(mitk::IOMetaInformationPropertyConsants::READER_MIME_NAME());
-  AddPropertyPersistence(mitk::IOMetaInformationPropertyConsants::READER_VERSION());
-  AddPropertyPersistence(mitk::IOMetaInformationPropertyConsants::READER_OPTIONS_ANY());
+  AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_DESCRIPTION());
+  AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_INPUTLOCATION());
+  AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_MIME_CATEGORY());
+  AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_MIME_NAME());
+  AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_VERSION());
+  AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_OPTIONS_ANY());
 
   /*
     There IS an option to exchange ALL vtkTexture instances against vtkNeverTranslucentTextureFactory.
     This code is left here as a reminder, just in case we might need to do that some time.
 
     vtkNeverTranslucentTextureFactory* textureFactory = vtkNeverTranslucentTextureFactory::New();
     vtkObjectFactory::RegisterFactory( textureFactory );
     textureFactory->Delete();
     */
 
   this->RegisterLegacyWriter();
 }
 
 void MitkCoreActivator::Unload(us::ModuleContext *)
 {
   for (auto &elem : m_FileReaders)
   {
     delete elem;
   }
 
   for (auto &elem : m_FileWriters)
   {
     delete elem;
   }
 
   for (auto &elem : m_FileIOs)
   {
     delete elem;
   }
 
   for (auto &elem : m_LegacyWriters)
   {
     delete elem;
   }
 
   // The mitk::ModuleContext* argument of the Unload() method
   // will always be 0 for the Mitk library. It makes no sense
   // to use it at this stage anyway, since all libraries which
   // know about the module system have already been unloaded.
 
   // we need to close the internal service tracker of the
   // MimeTypeProvider class here. Otherwise it
   // would hold on to the ModuleContext longer than it is
   // actually valid.
   m_MimeTypeProviderReg.Unregister();
   m_MimeTypeProvider->Stop();
 
   for (std::vector<mitk::CustomMimeType *>::const_iterator mimeTypeIter = m_DefaultMimeTypes.begin(),
                                                            iterEnd = m_DefaultMimeTypes.end();
        mimeTypeIter != iterEnd;
        ++mimeTypeIter)
   {
     delete *mimeTypeIter;
   }
 }
 
 void MitkCoreActivator::RegisterDefaultMimeTypes()
 {
   // Register some default mime-types
 
   std::vector<mitk::CustomMimeType *> mimeTypes = mitk::IOMimeTypes::Get();
   for (std::vector<mitk::CustomMimeType *>::const_iterator mimeTypeIter = mimeTypes.begin(), iterEnd = mimeTypes.end();
        mimeTypeIter != iterEnd;
        ++mimeTypeIter)
   {
     m_DefaultMimeTypes.push_back(*mimeTypeIter);
     m_Context->RegisterService(m_DefaultMimeTypes.back());
   }
 }
 
 void MitkCoreActivator::RegisterItkReaderWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("itkImageIOBase");
 
   for (auto &allobject : allobjects)
   {
     auto *io = dynamic_cast<itk::ImageIOBase *>(allobject.GetPointer());
 
     // NiftiImageIO does not provide a correct "SupportsDimension()" methods
     // and the supported read/write extensions are not ordered correctly
     if (dynamic_cast<itk::NiftiImageIO *>(io))
       continue;
 
     // Use a custom mime-type for GDCMImageIO below
     if (dynamic_cast<itk::GDCMImageIO *>(allobject.GetPointer()))
     {
       // MITK provides its own DICOM reader (which internally uses GDCMImageIO).
       continue;
     }
 
     if (io)
     {
       m_FileIOs.push_back(new mitk::ItkImageIO(io));
     }
     else
     {
       MITK_WARN << "Error ImageIO factory did not return an ImageIOBase: " << (allobject)->GetNameOfClass();
     }
   }
 
   FixedNiftiImageIO::Pointer itkNiftiIO = FixedNiftiImageIO::New();
   mitk::ItkImageIO *niftiIO = new mitk::ItkImageIO(mitk::IOMimeTypes::NIFTI_MIMETYPE(), itkNiftiIO.GetPointer(), 0);
   m_FileIOs.push_back(niftiIO);
 }
 
 void MitkCoreActivator::RegisterVtkReaderWriter()
 {
   m_FileIOs.push_back(new mitk::SurfaceVtkXmlIO());
   m_FileIOs.push_back(new mitk::SurfaceStlIO());
   m_FileIOs.push_back(new mitk::SurfaceVtkLegacyIO());
 
   m_FileIOs.push_back(new mitk::ImageVtkXmlIO());
   m_FileIOs.push_back(new mitk::ImageVtkLegacyIO());
 }
 
 void MitkCoreActivator::RegisterLegacyWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("IOWriter");
 
   for (auto i = allobjects.begin(); i != allobjects.end(); ++i)
   {
     mitk::FileWriter::Pointer io = dynamic_cast<mitk::FileWriter *>(i->GetPointer());
     if (io)
     {
       std::string description = std::string("Legacy ") + io->GetNameOfClass() + " Writer";
       mitk::IFileWriter *writer = new mitk::LegacyFileWriterService(io, description);
       m_LegacyWriters.push_back(writer);
     }
     else
     {
       MITK_ERROR << "Error IOWriter override is not of type mitk::FileWriter: " << (*i)->GetNameOfClass() << std::endl;
     }
   }
 }
 
 US_EXPORT_MODULE_ACTIVATOR(MitkCoreActivator)
 
 // Call CppMicroservices initialization code at the end of the file.
 // This especially ensures that VTK object factories have already
 // been registered (VTK initialization code is injected by implicitly
 // include VTK header files at the top of this file).
 US_INITIALIZE_MODULE
diff --git a/Modules/Core/test/mitkIOUtilTest.cpp b/Modules/Core/test/mitkIOUtilTest.cpp
index be4881c0b6..1a7ddd83f3 100644
--- a/Modules/Core/test/mitkIOUtilTest.cpp
+++ b/Modules/Core/test/mitkIOUtilTest.cpp
@@ -1,293 +1,293 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkTestingMacros.h"
 #include <mitkTestFixture.h>
 #include <mitkTestingConfig.h>
 
 #include <mitkIOUtil.h>
 #include <mitkImageGenerator.h>
 #include <mitkIOMetaInformationPropertyConstants.h>
 #include <mitkVersion.h>
 
 #include <itkMetaDataObject.h>
 #include <itkNrrdImageIO.h>
 #include <itksys/SystemTools.hxx>
 
 class mitkIOUtilTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkIOUtilTestSuite);
   MITK_TEST(TestTempMethods);
   MITK_TEST(TestSaveEmptyData);
   MITK_TEST(TestLoadAndSaveImage);
   MITK_TEST(TestNullLoad);
   MITK_TEST(TestNullSave);
   MITK_TEST(TestLoadAndSavePointSet);
   MITK_TEST(TestLoadAndSaveSurface);
   MITK_TEST(TestTempMethodsForUniqueFilenames);
   MITK_TEST(TestTempMethodsForUniqueFilenames);
   MITK_TEST(TestIOMetaInformation);
   CPPUNIT_TEST_SUITE_END();
 
 private:
   std::string m_ImagePath;
   std::string m_SurfacePath;
   std::string m_PointSetPath;
 
 public:
   void setUp() override
   {
     m_ImagePath = GetTestDataFilePath("Pic3D.nrrd");
     m_SurfacePath = GetTestDataFilePath("binary.stl");
     m_PointSetPath = GetTestDataFilePath("pointSet.mps");
   }
 
   void TestSaveEmptyData()
   {
     mitk::Surface::Pointer data = mitk::Surface::New();
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(data, "/tmp/dummy"), mitk::Exception);
   }
 
   void TestTempMethods()
   {
     std::string tmpPath = mitk::IOUtil::GetTempPath();
     CPPUNIT_ASSERT(!tmpPath.empty());
 
     std::ofstream tmpFile;
     std::string tmpFilePath = mitk::IOUtil::CreateTemporaryFile(tmpFile);
     CPPUNIT_ASSERT(tmpFile && tmpFile.is_open());
     CPPUNIT_ASSERT(tmpFilePath.size() > tmpPath.size());
     CPPUNIT_ASSERT(tmpFilePath.substr(0, tmpPath.size()) == tmpPath);
 
     tmpFile.close();
     CPPUNIT_ASSERT(std::remove(tmpFilePath.c_str()) == 0);
 
     std::string programPath = mitk::IOUtil::GetProgramPath();
     CPPUNIT_ASSERT(!programPath.empty());
     std::ofstream tmpFile2;
     std::string tmpFilePath2 = mitk::IOUtil::CreateTemporaryFile(tmpFile2, "my-XXXXXX", programPath);
     CPPUNIT_ASSERT(tmpFile2 && tmpFile2.is_open());
     CPPUNIT_ASSERT(tmpFilePath2.size() > programPath.size());
     CPPUNIT_ASSERT(tmpFilePath2.substr(0, programPath.size()) == programPath);
     tmpFile2.close();
     CPPUNIT_ASSERT(std::remove(tmpFilePath2.c_str()) == 0);
 
     std::ofstream tmpFile3;
     std::string tmpFilePath3 =
       mitk::IOUtil::CreateTemporaryFile(tmpFile3, std::ios_base::binary, "my-XXXXXX.TXT", programPath);
     CPPUNIT_ASSERT(tmpFile3 && tmpFile3.is_open());
     CPPUNIT_ASSERT(tmpFilePath3.size() > programPath.size());
     CPPUNIT_ASSERT(tmpFilePath3.substr(0, programPath.size()) == programPath);
     CPPUNIT_ASSERT(tmpFilePath3.substr(tmpFilePath3.size() - 13, 3) == "my-");
     CPPUNIT_ASSERT(tmpFilePath3.substr(tmpFilePath3.size() - 4) == ".TXT");
     tmpFile3.close();
     // CPPUNIT_ASSERT(std::remove(tmpFilePath3.c_str()) == 0)
 
     std::string tmpFilePath4 = mitk::IOUtil::CreateTemporaryFile();
     std::ofstream file;
     file.open(tmpFilePath4.c_str());
     CPPUNIT_ASSERT_MESSAGE("Testing if file exists after CreateTemporaryFile()", file.is_open());
 
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::CreateTemporaryFile(tmpFile2, "XX"), mitk::Exception);
 
     std::string tmpDir = mitk::IOUtil::CreateTemporaryDirectory();
     CPPUNIT_ASSERT(tmpDir.size() > tmpPath.size());
     CPPUNIT_ASSERT(tmpDir.substr(0, tmpPath.size()) == tmpPath);
     CPPUNIT_ASSERT(itksys::SystemTools::RemoveADirectory(tmpDir.c_str()));
 
     std::string tmpDir2 = mitk::IOUtil::CreateTemporaryDirectory("my-XXXXXX", programPath);
     CPPUNIT_ASSERT(tmpDir2.size() > programPath.size());
     CPPUNIT_ASSERT(tmpDir2.substr(0, programPath.size()) == programPath);
     CPPUNIT_ASSERT(itksys::SystemTools::RemoveADirectory(tmpDir2.c_str()));
   }
 
   void TestTempMethodsForUniqueFilenames()
   {
     int numberOfFiles = 100;
 
     // create 100 empty files
     std::vector<std::string> v100filenames;
     for (int i = 0; i < numberOfFiles; i++)
     {
       v100filenames.push_back(mitk::IOUtil::CreateTemporaryFile());
     }
 
     // check if all of them are unique
     for (int i = 0; i < numberOfFiles; i++)
       for (int j = 0; j < numberOfFiles; j++)
       {
         if (i != j)
         {
           std::stringstream message;
           message << "Checking if file " << i << " and file " << j
                   << " are different, which should be the case because each of them should be unique.";
           CPPUNIT_ASSERT_MESSAGE(message.str(), (v100filenames.at(i) != v100filenames.at(j)));
         }
       }
 
     // delete all the files / clean up
     for (int i = 0; i < numberOfFiles; i++)
     {
       std::remove(v100filenames.at(i).c_str());
     }
   }
 
   void TestLoadAndSaveImage()
   {
     mitk::Image::Pointer img1 = mitk::IOUtil::Load<mitk::Image>(m_ImagePath);
     CPPUNIT_ASSERT(img1.IsNotNull());
 
     std::ofstream tmpStream;
     std::string imagePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "diffpic3d-XXXXXX.nrrd");
     tmpStream.close();
     std::string imagePath2 = mitk::IOUtil::CreateTemporaryFile(tmpStream, "diffpic3d-XXXXXX.nii.gz");
     tmpStream.close();
 
     // the cases where no exception should be thrown
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(img1, imagePath));
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(img1.GetPointer(), imagePath2));
 
     // load data which does not exist
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Load("fileWhichDoesNotExist.nrrd"), mitk::Exception);
 
     // delete the files after the test is done
     std::remove(imagePath.c_str());
     std::remove(imagePath2.c_str());
 
     mitk::Image::Pointer relativImage = mitk::ImageGenerator::GenerateGradientImage<float>(4, 4, 4, 1);
     std::string imagePath3 = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.nrrd");
     tmpStream.close();
     mitk::IOUtil::Save(relativImage, imagePath3);
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Load(imagePath3));
     std::remove(imagePath3.c_str());
   }
 
   /**
   * \brief This method calls all available load methods with a nullpointer and an empty pathand expects an exception
   **/
   void TestNullLoad()
   {
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Load(""), mitk::Exception);
   }
 
   /**
   * \brief This method calls the save method (to which all other convenience save methods reference) with null
   *parameters
   **/
   void TestNullSave()
   {
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(nullptr, mitk::IOUtil::CreateTemporaryFile()), mitk::Exception);
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(mitk::Image::New().GetPointer(), ""), mitk::Exception);
   }
 
   void TestLoadAndSavePointSet()
   {
     mitk::PointSet::Pointer pointset = mitk::IOUtil::Load<mitk::PointSet>(m_PointSetPath);
     CPPUNIT_ASSERT(pointset.IsNotNull());
 
     std::ofstream tmpStream;
     std::string pointSetPath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.mps");
     tmpStream.close();
     std::string pointSetPathWithDefaultExtension = mitk::IOUtil::CreateTemporaryFile(tmpStream, "XXXXXX.mps");
     tmpStream.close();
     std::string pointSetPathWithoutDefaultExtension = mitk::IOUtil::CreateTemporaryFile(tmpStream);
     tmpStream.close();
 
     // the cases where no exception should be thrown
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(pointset, pointSetPathWithDefaultExtension));
 
     // test if defaultextension is inserted if no extension is present
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(pointset, pointSetPathWithoutDefaultExtension.c_str()));
 
     // delete the files after the test is done
     std::remove(pointSetPath.c_str());
     std::remove(pointSetPathWithDefaultExtension.c_str());
     std::remove(pointSetPathWithoutDefaultExtension.c_str());
   }
 
   void TestLoadAndSaveSurface()
   {
     mitk::Surface::Pointer surface = mitk::IOUtil::Load<mitk::Surface>(m_SurfacePath);
     CPPUNIT_ASSERT(surface.IsNotNull());
 
     std::ofstream tmpStream;
     std::string surfacePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "diffsurface-XXXXXX.stl");
 
     // the cases where no exception should be thrown
     CPPUNIT_ASSERT_NO_THROW(mitk::IOUtil::Save(surface, surfacePath));
 
     // test if exception is thrown as expected on unknown extsension
     CPPUNIT_ASSERT_THROW(mitk::IOUtil::Save(surface, "testSurface.xXx"), mitk::Exception);
 
     // delete the files after the test is done
     std::remove(surfacePath.c_str());
   }
 
   std::string GenerateMetaDictKey(const mitk::PropertyKeyPath& propKey)
   {
     auto result = mitk::PropertyKeyPathToPropertyName(propKey);
     std::replace(result.begin(), result.end(), '.', '_');
     return result;
   }
 
   std::string GetValueFromMetaDict(const itk::MetaDataDictionary& dict, const mitk::PropertyKeyPath& propKey)
   {
     auto metaValueBase = dict.Get(GenerateMetaDictKey(propKey));
     auto metaValue = dynamic_cast<const itk::MetaDataObject<std::string>*>(metaValueBase);
     return metaValue->GetMetaDataObjectValue();
   }
 
   void TestIOMetaInformation()
   {
     mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(m_ImagePath);
     CPPUNIT_ASSERT(img.IsNotNull());
     
-    auto value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConsants::READER_DESCRIPTION()).c_str())->GetValueAsString();
+    auto value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_DESCRIPTION()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(std::string("ITK NrrdImageIO"), value);
-    value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConsants::READER_INPUTLOCATION()).c_str())->GetValueAsString();
+    value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_INPUTLOCATION()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(m_ImagePath, value);
-    value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConsants::READER_MIME_CATEGORY()).c_str())->GetValueAsString();
+    value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_MIME_CATEGORY()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(std::string("Images"), value);
-    value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConsants::READER_MIME_NAME()).c_str())->GetValueAsString();
+    value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_MIME_NAME()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(std::string("application/vnd.mitk.image.nrrd"), value);
-    value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConsants::READER_VERSION()).c_str())->GetValueAsString();
+    value = img->GetProperty(mitk::PropertyKeyPathToPropertyName(mitk::IOMetaInformationPropertyConstants::READER_VERSION()).c_str())->GetValueAsString();
     CPPUNIT_ASSERT_EQUAL(std::string(MITK_VERSION_STRING), value);
 
     //check if the information is persistet correctly on save.
     std::ofstream tmpStream;
     std::string imagePath = mitk::IOUtil::CreateTemporaryFile(tmpStream, "ioMeta_XXXXXX.nrrd");
     tmpStream.close();
     mitk::IOUtil::Save(img, imagePath);
 
     auto io = itk::NrrdImageIO::New();
     io->SetFileName(imagePath);
     io->ReadImageInformation();
     auto metaDict = io->GetMetaDataDictionary();
 
-    auto metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConsants::READER_DESCRIPTION());
+    auto metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_DESCRIPTION());
     CPPUNIT_ASSERT_EQUAL(std::string("ITK NrrdImageIO"), metaValue);
-    metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConsants::READER_INPUTLOCATION());
+    metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_INPUTLOCATION());
     CPPUNIT_ASSERT_EQUAL(m_ImagePath, metaValue);
-    metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConsants::READER_MIME_CATEGORY());
+    metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_MIME_CATEGORY());
     CPPUNIT_ASSERT_EQUAL(std::string("Images"), metaValue);
-    metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConsants::READER_MIME_NAME());
+    metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_MIME_NAME());
     CPPUNIT_ASSERT_EQUAL(std::string("application/vnd.mitk.image.nrrd"), metaValue);
-    metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConsants::READER_VERSION());
+    metaValue = GetValueFromMetaDict(metaDict, mitk::IOMetaInformationPropertyConstants::READER_VERSION());
     CPPUNIT_ASSERT_EQUAL(std::string(MITK_VERSION_STRING), metaValue);
 
     // delete the files after the test is done
     std::remove(imagePath.c_str());
   }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkIOUtil)