diff --git a/Modules/IGT/IO/mitkNavigationToolWriter.cpp b/Modules/IGT/IO/mitkNavigationToolWriter.cpp
index 2b9aed6d9a..1cb2165199 100644
--- a/Modules/IGT/IO/mitkNavigationToolWriter.cpp
+++ b/Modules/IGT/IO/mitkNavigationToolWriter.cpp
@@ -1,151 +1,169 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //Poco headers
 #include <Poco/Zip/Compress.h>
 #include <Poco/Path.h>
 
 //mitk headers
 #include "mitkNavigationToolWriter.h"
 #include <mitkStandaloneDataStorage.h>
 #include <mitkProperties.h>
 #include <mitkSceneIO.h>
 #include <mitkPointSet.h>
 #include <mitkIOUtil.h>
 
 //std headers
 #include <stdio.h>
 
 mitk::NavigationToolWriter::NavigationToolWriter()
   {
 
   }
 
 mitk::NavigationToolWriter::~NavigationToolWriter()
   {
 
   }
 
 bool mitk::NavigationToolWriter::DoWrite(std::string FileName,mitk::NavigationTool::Pointer Tool)
   {
+  //some initial validation checks...
+  if ( Tool.IsNull())
+    {
+    m_ErrorMessage = "Cannot write a navigation tool containing invalid tool data, aborting!";
+    MITK_ERROR << m_ErrorMessage;
+    return false;
+    }
+
+
   // Workaround for a problem: the geometry might be modified if the tool is tracked. If this
   // modified geometry is saved the surface representation is moved by this offset. To avoid
   // this bug, the geometry is set to identity for the saving progress and restored later.
-  mitk::BaseGeometry::Pointer geometryBackup = Tool->GetDataNode()->GetData()->GetGeometry()->Clone();
-  Tool->GetDataNode()->GetData()->GetGeometry()->SetIdentity();
+  mitk::BaseGeometry::Pointer geometryBackup;
+  if (  Tool->GetDataNode().IsNull()
+        || (Tool->GetDataNode()->GetData()==NULL)
+        || (Tool->GetDataNode()->GetData()->GetGeometry()==NULL)
+        )
+      {
+      geometryBackup = Tool->GetDataNode()->GetData()->GetGeometry()->Clone();
+      Tool->GetDataNode()->GetData()->GetGeometry()->SetIdentity();
+      }
+  else {MITK_WARN << "Saving a tool with invalid data node, proceeding but errors might occure!";}
 
   //convert whole data to a mitk::DataStorage
   mitk::StandaloneDataStorage::Pointer saveStorage = mitk::StandaloneDataStorage::New();
   mitk::DataNode::Pointer thisTool = ConvertToDataNode(Tool);
   saveStorage->Add(thisTool);
 
   //use SceneSerialization to save the DataStorage
   std::string DataStorageFileName = mitk::IOUtil::CreateTemporaryDirectory() + Poco::Path::separator() + GetFileWithoutPath(FileName) + ".storage";
   mitk::SceneIO::Pointer mySceneIO = mitk::SceneIO::New();
   mySceneIO->SaveScene(saveStorage->GetAll(),saveStorage,DataStorageFileName);
 
   //now put the DataStorage and the Toolfile in a ZIP-file
   std::ofstream file( FileName.c_str(), std::ios::binary | std::ios::out);
   if (!file.good())
     {
     m_ErrorMessage = "Could not open a zip file for writing: '" + FileName + "'";
+    MITK_ERROR << m_ErrorMessage;
     return false;
     }
   else
     {
     Poco::Zip::Compress zipper( file, true );
     zipper.addFile(DataStorageFileName,GetFileWithoutPath(DataStorageFileName));
     if (Tool->GetCalibrationFile()!="none") zipper.addFile(Tool->GetCalibrationFile(),GetFileWithoutPath(Tool->GetCalibrationFile()));
     zipper.close();
     }
 
   //delete the data storage
   std::remove(DataStorageFileName.c_str());
 
   //restore original geometry
-  Tool->GetDataNode()->GetData()->SetGeometry(geometryBackup);
+  if (geometryBackup.IsNotNull()) {Tool->GetDataNode()->GetData()->SetGeometry(geometryBackup);}
 
   return true;
   }
 
 mitk::DataNode::Pointer mitk::NavigationToolWriter::ConvertToDataNode(mitk::NavigationTool::Pointer Tool)
   {
   mitk::DataNode::Pointer thisTool = mitk::DataNode::New();
   //Name
     if (Tool->GetDataNode().IsNull()) thisTool->SetName("none");
     else thisTool->SetName(Tool->GetDataNode()->GetName().c_str());
   //Identifier
     thisTool->AddProperty("identifier",mitk::StringProperty::New(Tool->GetIdentifier().c_str()));
   //Serial Number
     thisTool->AddProperty("serial number",mitk::StringProperty::New(Tool->GetSerialNumber().c_str()));
   //Tracking Device
     thisTool->AddProperty("tracking device type",mitk::IntProperty::New(Tool->GetTrackingDeviceType()));
   //Tool Type
     thisTool->AddProperty("tracking tool type",mitk::IntProperty::New(Tool->GetType()));
   //Calibration File Name
     thisTool->AddProperty("toolfileName",mitk::StringProperty::New(GetFileWithoutPath(Tool->GetCalibrationFile())));
   //Surface
     if (Tool->GetDataNode().IsNotNull()) if (Tool->GetDataNode()->GetData()!=NULL) thisTool->SetData(Tool->GetDataNode()->GetData());
 
   //Tool Landmarks
     thisTool->AddProperty("ToolRegistrationLandmarks",mitk::StringProperty::New(ConvertPointSetToString(Tool->GetToolRegistrationLandmarks())));
     thisTool->AddProperty("ToolCalibrationLandmarks",mitk::StringProperty::New(ConvertPointSetToString(Tool->GetToolCalibrationLandmarks())));
 
   //Tool Tip
     if (Tool->IsToolTipSet())
     {
       thisTool->AddProperty("ToolTipPosition",mitk::StringProperty::New(ConvertPointToString(Tool->GetToolTipPosition())));
       thisTool->AddProperty("ToolTipOrientation",mitk::StringProperty::New(ConvertQuaternionToString(Tool->GetToolTipOrientation())));
     }
 
   //Material is not needed, to avoid errors in scene serialization we have to do this:
     thisTool->ReplaceProperty("material",NULL);
 
 
   return thisTool;
   }
 
 std::string mitk::NavigationToolWriter::GetFileWithoutPath(std::string FileWithPath)
   {
   Poco::Path myFile(FileWithPath.c_str());
   return myFile.getFileName();
   }
 
 std::string mitk::NavigationToolWriter::ConvertPointSetToString(mitk::PointSet::Pointer pointSet)
   {
   std::stringstream returnValue;
   mitk::PointSet::PointDataIterator it;
   for ( it = pointSet->GetPointSet()->GetPointData()->Begin();it != pointSet->GetPointSet()->GetPointData()->End();it++ )
     {
     mitk::Point3D thisPoint = pointSet->GetPoint(it->Index());
     returnValue << it->Index() << ";" << ConvertPointToString(thisPoint) << "|";
     }
   return returnValue.str();
   }
 
 std::string mitk::NavigationToolWriter::ConvertPointToString(mitk::Point3D point)
 {
 std::stringstream returnValue;
 returnValue << point[0] << ";" << point[1] << ";" << point[2];
 return returnValue.str();
 }
 
 std::string mitk::NavigationToolWriter::ConvertQuaternionToString(mitk::Quaternion quat)
 {
 std::stringstream returnValue;
 returnValue << quat.x() << ";" << quat.y() << ";" << quat.z() << ";" << quat.r();
 return returnValue.str();
 }
diff --git a/Modules/IGT/Testing/files.cmake b/Modules/IGT/Testing/files.cmake
index daf0b4f348..8a89a47489 100644
--- a/Modules/IGT/Testing/files.cmake
+++ b/Modules/IGT/Testing/files.cmake
@@ -1,64 +1,64 @@
 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.
 
    ################## ON THE FENCE TESTS #################################################
    # none
 
    ################## DISABLED TESTS #####################################################
    # mitkNavigationToolStorageDeserializerTest.cpp # This test was disabled because of bug 17303.
    # mitkNavigationToolStorageSerializerAndDeserializerIntegrationTest.cpp # This test was disabled because of bug 17181.
+   # mitkNavigationToolStorageSerializerTest.cpp # This test was disabled because of bug 18671
 
    ################# RUNNING TESTS #######################################################
    mitkCameraVisualizationTest.cpp
    mitkClaronInterfaceTest.cpp
    mitkClaronToolTest.cpp
    mitkClaronTrackingDeviceTest.cpp
    mitkInternalTrackingToolTest.cpp
    mitkNavigationDataDisplacementFilterTest.cpp
    mitkNavigationDataLandmarkTransformFilterTest.cpp
    mitkNavigationDataObjectVisualizationFilterTest.cpp
    mitkNavigationDataSetTest.cpp
    mitkNavigationDataTest.cpp
    mitkNavigationDataRecorderTest.cpp
    mitkNavigationDataReferenceTransformFilterTest.cpp
    mitkNavigationDataSequentialPlayerTest.cpp
    mitkNavigationDataSetReaderWriterXMLTest.cpp
    mitkNavigationDataSetReaderWriterCSVTest.cpp
    mitkNavigationDataSourceTest.cpp
    mitkNavigationDataToMessageFilterTest.cpp
    mitkNavigationDataToNavigationDataFilterTest.cpp
    mitkNavigationDataToPointSetFilterTest.cpp
    mitkNavigationDataTransformFilterTest.cpp
    mitkNDIPassiveToolTest.cpp
    mitkNDIProtocolTest.cpp
    mitkNDITrackingDeviceTest.cpp
    mitkTimeStampTest.cpp
    mitkTrackingVolumeGeneratorTest.cpp
    mitkTrackingDeviceTest.cpp
    mitkTrackingToolTest.cpp
    mitkVirtualTrackingDeviceTest.cpp
    # mitkNavigationDataPlayerTest.cpp # random fails see bug 16485.
    # We decided to won't fix because of complete restructuring via bug 15959.
    mitkTrackingDeviceSourceTest.cpp
    mitkTrackingDeviceSourceConfiguratorTest.cpp
    mitkNavigationDataEvaluationFilterTest.cpp
    mitkTrackingTypesTest.cpp
    # ------------------ Navigation Tool Management Tests -------------------
    mitkNavigationToolStorageTest.cpp
    mitkNavigationToolTest.cpp
    mitkNavigationToolReaderAndWriterTest.cpp
-   mitkNavigationToolStorageSerializerTest.cpp
    # -----------------------------------------------------------------------
 )
 
 set(MODULE_CUSTOM_TESTS
   mitkNDIAuroraHardwareTest.cpp
   mitkNDIPolarisHardwareTest.cpp
   mitkClaronTrackingDeviceHardwareTest.cpp
 )
diff --git a/Modules/IGT/Testing/mitkNavigationToolReaderAndWriterTest.cpp b/Modules/IGT/Testing/mitkNavigationToolReaderAndWriterTest.cpp
index 28f6d740c1..70ad72db64 100644
--- a/Modules/IGT/Testing/mitkNavigationToolReaderAndWriterTest.cpp
+++ b/Modules/IGT/Testing/mitkNavigationToolReaderAndWriterTest.cpp
@@ -1,198 +1,224 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //Poco headers
 #include "Poco/Path.h"
 
 //mitk headers
 #include "mitkNavigationToolWriter.h"
 #include "mitkCommon.h"
 #include "mitkTestingMacros.h"
 #include "mitkNavigationTool.h"
 #include "mitkBaseData.h"
 #include "mitkDataNode.h"
 #include "mitkSurface.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkDataStorage.h"
 #include "mitkNavigationToolReader.h"
 #include "mitkIGTConfig.h"
 #include <mitkIOUtil.h>
 
 #include <sstream>
 #include <fstream>
 
 mitk::Surface::Pointer m_testSurface;
 
 static void TestInstantiation()
 {
   // let's create an object of our class
   mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
   MITK_TEST_CONDITION_REQUIRED(myWriter.IsNotNull(),"Testing instantiation")
 }
 
 static void TestWrite()
 {
   //testcase with first test tool: a claron tool
 
   //create a NavigationTool which we can write on the harddisc
   std::string toolFileName(MITK_IGT_DATA_DIR);
   toolFileName.append("/ClaronTool");
   mitk::NavigationTool::Pointer myNavigationTool = mitk::NavigationTool::New();
   myNavigationTool->SetCalibrationFile(toolFileName);
 
   mitk::DataNode::Pointer myNode = mitk::DataNode::New();
   myNode->SetName("ClaronTool");
 
   std::string surfaceFileName(MITK_IGT_DATA_DIR);
   surfaceFileName.append("/ClaronTool.stl");
   m_testSurface = mitk::IOUtil::LoadSurface( surfaceFileName );
   myNode->SetData(m_testSurface);
 
   myNavigationTool->SetDataNode(myNode);
   myNavigationTool->SetIdentifier("ClaronTool#1");
   myNavigationTool->SetSerialNumber("0815");
   myNavigationTool->SetTrackingDeviceType(mitk::ClaronMicron);
   myNavigationTool->SetType(mitk::NavigationTool::Fiducial);
 
   //now create a writer and write it to the harddisc
   mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
   std::string filename = "TestTool.tool";
 
   MITK_TEST_OUTPUT(<<"---- Testing navigation tool writer with first test tool (claron tool) ----");
   bool test = myWriter->DoWrite(filename,myNavigationTool);
   MITK_TEST_CONDITION_REQUIRED(test,"OK");
 }
 
 static void TestRead()
 {
   mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
   mitk::NavigationTool::Pointer readTool = myReader->DoRead("TestTool.tool");
   MITK_TEST_OUTPUT(<<"---- Testing navigation tool reader with first test tool (claron tool) ----");
 
   //Test if the surfaces do have the same number of vertexes (it would be better to test for real equality of the surfaces!)
   MITK_TEST_CONDITION_REQUIRED(dynamic_cast<mitk::Surface*>(readTool->GetDataNode()->GetData())->GetSizeOfPolyDataSeries()==m_testSurface->GetSizeOfPolyDataSeries(),"Test if surface was restored correctly ...");
 
   MITK_TEST_CONDITION_REQUIRED(readTool->GetType()==mitk::NavigationTool::Fiducial,"Testing Tool Type");
 
   MITK_TEST_CONDITION_REQUIRED(readTool->GetTrackingDeviceType()==mitk::ClaronMicron,"Testing Tracking Device Type");
 
   MITK_TEST_CONDITION_REQUIRED(readTool->GetSerialNumber()=="0815","Testing Serial Number");
 
   std::ifstream TestFile(readTool->GetCalibrationFile().c_str());
   MITK_TEST_CONDITION_REQUIRED(TestFile,"Testing If Calibration File Exists");
 
 }
 
 static void TestWrite2()
 {
   //testcase with second test tool: an aurora tool
   //create a NavigationTool which we can write on the harddisc
   mitk::NavigationTool::Pointer myNavigationTool = mitk::NavigationTool::New();
 
   mitk::DataNode::Pointer myNode = mitk::DataNode::New();
   myNode->SetName("AuroraTool");
 
   std::string surfaceFileName(MITK_IGT_DATA_DIR);
   surfaceFileName.append("/EMTool.stl");
   m_testSurface = mitk::IOUtil::LoadSurface( surfaceFileName );
   myNode->SetData(m_testSurface);
 
   myNavigationTool->SetDataNode(myNode);
   myNavigationTool->SetIdentifier("AuroraTool#1");
   myNavigationTool->SetSerialNumber("0816");
   myNavigationTool->SetTrackingDeviceType(mitk::NDIAurora);
   myNavigationTool->SetType(mitk::NavigationTool::Instrument);
 
   //now create a writer and write it to the harddisc
   mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
   std::string filename = "TestTool2.tool";
 
   MITK_TEST_OUTPUT(<<"---- Testing navigation tool writer with second tool (aurora tool) ----");
   bool test = myWriter->DoWrite(filename,myNavigationTool);
   MITK_TEST_CONDITION_REQUIRED(test,"OK");
 }
 
 static void TestRead2()
 {
   mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
   mitk::NavigationTool::Pointer readTool = myReader->DoRead("TestTool2.tool");
   MITK_TEST_OUTPUT(<<"---- Testing navigation tool reader  with second tool (aurora tool) ----");
 
   //Test if the surfaces do have the same number of vertexes (it would be better to test for real equality of the surfaces!)
   MITK_TEST_CONDITION_REQUIRED(dynamic_cast<mitk::Surface*>(readTool->GetDataNode()->GetData())->GetSizeOfPolyDataSeries()==m_testSurface->GetSizeOfPolyDataSeries(),"Test if surface was restored correctly ...");
 
   //Test if the tool type is the same
   MITK_TEST_CONDITION_REQUIRED(readTool->GetType()==mitk::NavigationTool::Instrument,"Testing Tool Type");
 
   MITK_TEST_CONDITION_REQUIRED(readTool->GetTrackingDeviceType()==mitk::NDIAurora,"Testing Tracking Device Type");
 
   MITK_TEST_CONDITION_REQUIRED(readTool->GetSerialNumber()=="0816","Testing Serial Number");
 
   MITK_TEST_CONDITION_REQUIRED(readTool->GetCalibrationFile()=="none","Testing Calibration File");
 
 }
 
 static void CleanUp()
 {
   std::remove("TestTool.tool");
   std::remove("TestTool2.tool");
 }
 
 static void TestReadInvalidData()
 {
   mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
   mitk::NavigationTool::Pointer readTool = myReader->DoRead("invalidTool");
 
   MITK_TEST_CONDITION_REQUIRED(readTool.IsNull(), "Testing return value if filename is invalid");
   MITK_TEST_CONDITION_REQUIRED(myReader->GetErrorMessage() == "Cannot open 'invalidTool' for reading", "Testing error message in this case");
 }
 
-static void TestWriteInvalidData()
+static void TestWriteInvalidFilename()
 {
+  //create a test navigation tool
   mitk::NavigationTool::Pointer myNavigationTool = mitk::NavigationTool::New();
-  myNavigationTool->SetIdentifier("ClaronTool#1");
-  myNavigationTool->SetSerialNumber("0815");
-  myNavigationTool->SetTrackingDeviceType(mitk::ClaronMicron);
-  myNavigationTool->SetType(mitk::NavigationTool::Fiducial);
+  mitk::DataNode::Pointer myNode = mitk::DataNode::New();
+  myNode->SetName("AuroraTool");
+  std::string surfaceFileName(MITK_IGT_DATA_DIR);
+  surfaceFileName.append("/EMTool.stl");
+  m_testSurface = mitk::IOUtil::LoadSurface( surfaceFileName );
+  myNode->SetData(m_testSurface);
+  myNavigationTool->SetDataNode(myNode);
+  myNavigationTool->SetIdentifier("AuroraTool#1");
+  myNavigationTool->SetSerialNumber("0816");
+  myNavigationTool->SetTrackingDeviceType(mitk::NDIAurora);
+  myNavigationTool->SetType(mitk::NavigationTool::Instrument);
 
   //now create a writer and write it to the harddisc
   mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
   std::string filename = "NH:/sfdsfsdsf.&%%%";
 
   MITK_TEST_OUTPUT(<<"---- Testing write invalid file ----");
   bool test = myWriter->DoWrite(filename,myNavigationTool);
   MITK_TEST_CONDITION_REQUIRED(!test,"testing write");
   MITK_TEST_CONDITION_REQUIRED(myWriter->GetErrorMessage() == "Could not open a zip file for writing: 'NH:/sfdsfsdsf.&%%%'","testing error message");
 }
 
+static void TestWriteInvalidData()
+{
+  mitk::NavigationTool::Pointer myNavigationTool;
+  //tool is invalid because no data note is created
+
+  //now create a writer and write it to the harddisc
+  mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
+  std::string filename = "NH:/sfdsfsdsf.&%%%";
+
+  MITK_TEST_OUTPUT(<<"---- Testing write invalid tool ----");
+  bool test = myWriter->DoWrite(filename,myNavigationTool);
+  MITK_TEST_CONDITION_REQUIRED(!test,"testing write");
+  MITK_TEST_CONDITION_REQUIRED(myWriter->GetErrorMessage() == "Cannot write a navigation tool containing invalid tool data, aborting!","testing error message");
+}
+
+
+
 /** This function is testing the TrackingVolume class. */
 int mitkNavigationToolReaderAndWriterTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("NavigationToolWriter")
 
   TestInstantiation();
   TestWrite();
   TestRead();
   TestWrite2();
   TestRead2();
   TestReadInvalidData();
   TestWriteInvalidData();
+  TestWriteInvalidFilename();
   CleanUp();
 
   MITK_TEST_END()
 }