diff --git a/Core/Code/DataManagement/mitkTypes.h b/Core/Code/DataManagement/mitkTypes.h
index d8541e7fc5..b9754f6b8f 100644
--- a/Core/Code/DataManagement/mitkTypes.h
+++ b/Core/Code/DataManagement/mitkTypes.h
@@ -1,260 +1,277 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #ifndef MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD
 #define MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD
 
 // this is needed for memcopy in ITK
 // can be removed when fixed in ITK
 #include <cstring>
 
 #include <itkPoint.h>
 #include <float.h>
 #include <itkIndex.h>
 #include <itkContinuousIndex.h>
 #include <itkVector.h>
 #include <itkMatrix.h>
 #include <itkTransform.h>
 #include <vnl/vnl_quaternion.h>
 #include <MitkExports.h>
 
 #include "mitkTypeBasics.h"
 #include "mitkTypedefs.h"
 #include "mitkPoint.h" // TODO SW: should not be included here, maybe generate one "general datatype include" like mitkPrimitives.h
 #include "mitkVector.h"
 #include "mitkMatrix.h"
 
 #include "mitkOldTypeConversions.h"
 
 
 #ifndef DOXYGEN_SKIP
 
 namespace mitk {
 
 
 template <class T, unsigned int NVectorDimension>
   itk::Vector<T, NVectorDimension> operator+(const itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   itk::Vector<T, NVectorDimension> sub;
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     sub[i] = vector[i]+point[i];
   }
   return sub;
 }
 
 template <class T, unsigned int NVectorDimension>
   inline itk::Vector<T, NVectorDimension>& operator+=(itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     vector[i] += point[i];
   }
   return vector;
 }
 
 template <class T, unsigned int NVectorDimension>
   itk::Vector<T, NVectorDimension> operator-(const itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   itk::Vector<T, NVectorDimension> sub;
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     sub[i] = vector[i]-point[i];
   }
   return sub;
 }
 
 template <class T, unsigned int NVectorDimension>
   inline itk::Vector<T, NVectorDimension>& operator-=(itk::Vector<T, NVectorDimension> &vector, const itk::Point<T, NVectorDimension> &point)
 {
   for( unsigned int i=0; i<NVectorDimension; i++)
   {
     vector[i] -= point[i];
   }
   return vector;
 }
 
 /*!
 \brief Check for matrix equality with a user defined accuracy. As an equality metric the root mean squared error (RMS) of all elements is calculated.
 \param matrix1 first vnl matrix
 \param matrix2 second vnl matrix
 \param epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualRMS(const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix1,const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   if ( (matrix1.rows() == matrix2.rows()) && (matrix1.cols() == matrix2.cols()) )
   {
     vnl_matrix_fixed<TCoordRep,NRows,NCols> differenceMatrix = matrix1-matrix2;
     if (differenceMatrix.rms()<epsilon)
     {
       return true;
     }
     else
     {
       return false;
     }
   }
   else
   {
     return false;
   }
 }
 
 /*!
 \brief Check for matrix equality with a user defined accuracy. As an equality metric the root mean squared error (RMS) of all elements is calculated.
 \param matrix1 first itk matrix
 \param matrix2 second itk matrix
 \param epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualRMS(const itk::Matrix<TCoordRep, NRows, NCols>& matrix1,const itk::Matrix<TCoordRep, NRows, NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   return mitk::MatrixEqualRMS(matrix1.GetVnlMatrix(),matrix2.GetVnlMatrix(),epsilon);
 }
 
 /*!
 \brief Check for element-wise matrix equality with a user defined accuracy.
 \param matrix1 first vnl matrix
 \param matrix2 second vnl matrix
 \param epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualElementWise(const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix1,const vnl_matrix_fixed<TCoordRep,NRows,NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   if ( (matrix1.rows() == matrix2.rows()) && (matrix1.cols() == matrix2.cols()) )
   {
     for( unsigned int r=0; r<NRows; r++)
     {
       for( unsigned int c=0; c<NCols; c++ )
       {
         TCoordRep difference =  fabs(matrix1(r,c)-matrix2(r,c));
         if (difference>epsilon)
         {
           return false;
         }
       }
     }
     return true;
   }
   else
   {
     return false;
   }
 }
 
 /*!
 \brief Check for element-wise matrix equality with a user defined accuracy.
 \param matrix1 first itk matrix
 \param matrix2 second itk matrix
 \param epsilon user defined accuracy bounds
 */
 template <typename TCoordRep, unsigned int NRows, unsigned int NCols>
 inline bool MatrixEqualElementWise(const itk::Matrix<TCoordRep, NRows, NCols>& matrix1,const itk::Matrix<TCoordRep, NRows, NCols>& matrix2,mitk::ScalarType epsilon=mitk::eps)
 {
   return mitk::MatrixEqualElementWise(matrix1.GetVnlMatrix(),matrix2.GetVnlMatrix(),epsilon);
 }
 
 template <typename TCoordRep, unsigned int NPointDimension>
 inline bool Equal(const itk::Vector<TCoordRep, NPointDimension>& vector1, const itk::Vector<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps)
 {
   typename itk::Vector<TCoordRep, NPointDimension>::VectorType diff = vector1-vector2;
   for (unsigned int i=0; i<NPointDimension; i++)
       if (diff[i]>eps || diff[i]<-eps)
       return false;
   return true;
 }
 
 template <typename TCoordRep, unsigned int NPointDimension>
   inline bool Equal(const itk::Point<TCoordRep, NPointDimension>& vector1, const itk::Point<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps)
 {
   typename itk::Point<TCoordRep, NPointDimension>::VectorType diff = vector1-vector2;
   for (unsigned int i=0; i<NPointDimension; i++)
     if (diff[i]>eps || diff[i]<-eps)
       return false;
   return true;
 }
 
 inline bool Equal(const mitk::VnlVector& vector1, const mitk::VnlVector& vector2, ScalarType eps=mitk::eps)
 {
   mitk::VnlVector diff = vector1-vector2;
   for (unsigned int i=0; i<diff.size(); i++)
     if (diff[i]>eps || diff[i]<-eps)
       return false;
   return true;
 }
 
+
 inline bool Equal(ScalarType scalar1, ScalarType scalar2, ScalarType eps=mitk::eps)
 {
   return fabs(scalar1-scalar2) < eps;
 }
 
 template <typename TCoordRep, unsigned int NPointDimension>
   inline bool Equal(const vnl_vector_fixed<TCoordRep, NPointDimension> & vector1, const vnl_vector_fixed<TCoordRep, NPointDimension>& vector2, TCoordRep eps=mitk::eps)
 {
   vnl_vector_fixed<TCoordRep, NPointDimension> diff = vector1-vector2;
   bool returnValue = true;
   for( unsigned int i=0; i<diff.size(); i++)
   {
     if(diff[i]>eps || diff[i]<-eps)
     {
      returnValue = false;
     }
   }
 
   return returnValue;
 }
 
+/**
+ * Compares two ArrayTypes of size size.
+ * ArrayTypes are all Objects/Types who have a [] operator. Pay attention not to set size higher
+ * than the actual size of the ArrayType. For POD arrays like float array[4] this will memory corruption.
+ */
+template <typename TArrayType1, typename TArrayType2>
+  inline bool EqualArray(TArrayType1& arrayType1, TArrayType2& arrayType2, int size, ScalarType eps = mitk::eps)
+{
+  bool isEqual = true;
+  for (int var = 0; var < size; ++var)
+  {
+    isEqual = isEqual && Equal(arrayType1[var], arrayType2[var], eps);
+  }
+  return isEqual;
+}
+
 
 
 } // namespace mitk
 
 #endif //DOXYGEN_SKIP
 
 /*
  * This part of the code has been shifted here to avoid compiler clashes
  * caused by including <itkAffineGeometryFrame.h> before the declaration of
  * the Equal() methods above. This problem occurs when using MSVC and is
  * probably related to a compiler bug.
  */
 
 #include <itkAffineGeometryFrame.h>
 
 namespace mitk
 {
   typedef itk::AffineGeometryFrame<ScalarType, 3>::TransformType AffineTransform3D;
 }
 
 
 #define mitkSetConstReferenceMacro(name,type) \
   virtual void Set##name (const type & _arg) \
   { \
     itkDebugMacro("setting " << #name " to " << _arg ); \
     if (this->m_##name != _arg) \
       { \
       this->m_##name = _arg; \
       this->Modified(); \
       } \
   }
 
 #define mitkSetVectorMacro(name,type) \
   mitkSetConstReferenceMacro(name,type)
 
 #define mitkGetVectorMacro(name,type) \
   itkGetConstReferenceMacro(name,type)
 
 #endif /* MITKVECTOR_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkVector.h b/Core/Code/DataManagement/mitkVector.h
index e63760cffd..51858ff4de 100644
--- a/Core/Code/DataManagement/mitkVector.h
+++ b/Core/Code/DataManagement/mitkVector.h
@@ -1,111 +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.
 
 ===================================================================*/
 
 #ifndef MITKVECTOR_H_
 #define MITKVECTOR_H_
 
 
 #include <itkVector.h>
 #include <vnl/vnl_vector_fixed.h>
 #include <vnl/vnl_vector.h>
 
 #include "mitkTypeBasics.h"
 #include "mitkLogMacros.h"
 
 namespace mitk
 {
 
   template<class TCoordRep, unsigned int NVectorDimension = 3>
   class Vector : public itk::Vector<TCoordRep, NVectorDimension>
   {
   public:
     /** Default constructor has nothing to do. */
     Vector<TCoordRep, NVectorDimension>()
       : itk::Vector<TCoordRep, NVectorDimension>() {}
 
     /**
      * Constructor to convert from mitk::Vector to mitk::Vector.
      * Can convert nonidentical types.
      * E.g. use this to convert from mitk::Vector<float, 3> to mitk::Vector<double,3>
      */
     template <typename TOtherTypeRepresentation>
     Vector<TCoordRep, NVectorDimension>(const Vector<TOtherTypeRepresentation, NVectorDimension>& r)
       : itk::Vector<TCoordRep, NVectorDimension>(r) {}
 
     /**
      * Constructor to convert from itk::Vector to mitk::Vector.
      * Can convert nonidentical types.
      * E.g. use this to convert from itk::Vector<double, 3> to mitk::Vector<float,3>
      */
     template <typename TOtherTypeRepresentation>
     Vector<TCoordRep, NVectorDimension>(const itk::Vector<TOtherTypeRepresentation, NVectorDimension>& r)
       : itk::Vector<TCoordRep, NVectorDimension>(r) {}
 
     Vector<TCoordRep, NVectorDimension>(const TCoordRep r[NVectorDimension])
       : itk::Vector<TCoordRep, NVectorDimension>(r) {}
 
     /**
      * Constructor to initialize entire vector to one value.
      */
-    Vector<TCoordRep, NVectorDimension>(const TCoordRep & v):itk::Vector<TCoordRep, NVectorDimension>(v)
-      {}
+    Vector<TCoordRep, NVectorDimension>(const TCoordRep & v)
+        : itk::Vector<TCoordRep, NVectorDimension>(v) {}
 
     /**
      * Attention: vnlVector should have same size as NVectorDimension, otherwise
      * 1. elements will be lost in case vnlVector is bigger.
      * 2. elements will be set to 0 in case this is bigger.
      * In both cases, MITK_WARN warnings will be issued.
      */
     Vector<TCoordRep, NVectorDimension>(const vnl_vector<ScalarType>& vnlVector)
             : itk::Vector<TCoordRep, NVectorDimension>()
     {
       this->Fill(0);
 
       if (vnlVector.size() < NVectorDimension)
         MITK_WARN << "Attention: conversion of vnl_vector to mitk::Vector:"
                   << "the mitk::Vector has more elements than the vnl_vector. Remaining elements will be set to 0.";
 
       if (NVectorDimension < vnlVector.size())
         MITK_WARN << "Attention: conversion of vnl_vector to mitk::Vector:"
                   << "the vnl_vector has more elements than the mitk::Vector. vnlVector[NVectorDimension .. vnlVector.size()] will be lost.";
 
       for (int var = 0; (var < NVectorDimension) && (var < vnlVector.size()); ++var) {
         this->SetElement(var, vnlVector.get(var));
       }
     };
 
-    Vector<TCoordRep, NVectorDimension>(const vnl_vector_fixed<ScalarType, 3> vnlVectorFixed)
+    /**
+     * Convert a vnl_vector_fixed to a mitk::Vector of the same size and coordinate representation.
+     * TODO SW: allow different coordinate representations.
+     */
+    Vector<TCoordRep, NVectorDimension>(const vnl_vector_fixed<TCoordRep, NVectorDimension> vnlVectorFixed)
         : itk::Vector<TCoordRep, NVectorDimension>(vnlVectorFixed.data_block()){};
 
     /**
      * Warning: Array must have same dimension as Vector
      */
     void CopyToArray(ScalarType array_p[NVectorDimension]) const
     {
       for (int i = 0; i < this->GetVectorDimension(); i++)
         {
           array_p[i] = this->GetElement(i);
         }
     }
-  };
+
+    /**
+     * User defined conversion of mitk::Vector to vnl_vector_fixed
+     */
+    operator vnl_vector_fixed<TCoordRep, NVectorDimension>& () const
+    {
+      vnl_vector_fixed<TCoordRep, NVectorDimension> vnlVectorFixed(this->GetVnlVector());
+      return vnlVectorFixed;
+    }
+
+  }; // end mitk::Vector
 
   typedef Vector<ScalarType,2> Vector2D;
   typedef Vector<ScalarType,3> Vector3D;
   typedef Vector<ScalarType,4> Vector4D;
 
-}
+} // end namespace mitk
 
 #endif /* MITKVECTOR_H_ */
diff --git a/Core/Code/Testing/mitkTypeVectorConversionTest.cpp b/Core/Code/Testing/mitkTypeVectorConversionTest.cpp
index f9186aaea8..61a07a2ae9 100644
--- a/Core/Code/Testing/mitkTypeVectorConversionTest.cpp
+++ b/Core/Code/Testing/mitkTypeVectorConversionTest.cpp
@@ -1,225 +1,208 @@
 /*===================================================================
 
 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 <iostream>
 
 #include "itkVector.h"
 
 #include <vnl/vnl_vector_ref.h>
 #include <vnl/vnl_vector_fixed_ref.h>
 #include "vnl/vnl_math.h"
 
 #include "mitkTestingMacros.h"
 #include "mitkTypeBasics.h"
 #include "mitkVector.h"
 #include "mitkTypes.h" // for Equals
 
 using namespace mitk;
 
 /**
  * these private variables are used in the test functions
  *
  * The variable which should be copied into is set to its original value.
  * The value which should be copied is set to valuesToCopy.
  *
  * Then the copying takes place. The test is successful, if the variable which
  * should be copied into holds the valuesToCopy afterwards and is equal to the
  * vector which should be copied.
  */
 static const ScalarType originalValues[]      =  {1.123456789987, 2.789456321456, 3.123654789987456};
 static const float      originalValuesFloat[] =  {1.123456789987, 2.789456321456, 3.123654789987456};
 
 static const ScalarType valuesToCopy[]        =  {4.654789123321, 5.987456789321, 6.321654987789546};
 static const float      valuesToCopyFloat[]   =  {4.654789123321, 5.987456789321, 6.321654987789546};
 
 
 
 static void Test_mitk2mitk_DifferntTypeCompatibility(void)
 {
   mitk::Vector<float, 3>  floatVector3D  = originalValuesFloat;
   mitk::Vector<double, 3> doubleVector3D = valuesToCopy;
 
   floatVector3D = doubleVector3D;
 
   MITK_TEST_CONDITION(floatVector3D == doubleVector3D, "mitk double vector assigned to mitk float vector")
-
-  // test for correct values needs a little more love than in other cases
-  // since Equal cannot compare arrays/vectors of different type
-  bool correctValuesAssigned = true;
-  for (int var = 0; var < 3; ++var) {
-      correctValuesAssigned = correctValuesAssigned
-          && Equal(floatVector3D[var], valuesToCopy[var], vnl_math::float_eps * 10.0);
-  }
-  MITK_TEST_CONDITION(correctValuesAssigned, "correct values were assigned within float accuracy")
+  MITK_TEST_CONDITION(EqualArray(floatVector3D, valuesToCopy, 3, vnl_math::float_eps * 10.), "correct values were assigned within float accuracy")
 }
 
 static void Test_itk2mitk_Compatibility(void)
 {
   Vector3D vector3D = originalValues;
   itk::Vector<ScalarType, 3> itkVector = valuesToCopy;
 
   vector3D = itkVector;
 
   MITK_TEST_CONDITION(vector3D == itkVector, "itk vector assigned to mitk vector")
   MITK_TEST_CONDITION(vector3D == valuesToCopy, "correct values were assigned")
 }
 
 static void Test_itk2mitk_floatCompatibility(void)
 {
   Vector3D vector3D = originalValues;
   itk::Vector<float, 3> itkVector = valuesToCopyFloat;
 
   vector3D = itkVector;
 
   MITK_TEST_CONDITION(vector3D == itkVector, "itk float vector assigned to mitk double vector")
-
-  // test for correct values needs a little more love than in other cases
-  // since Equal cannot compare arrays/vectors of different type
-  bool correctValuesAssigned = true;
-  for (int var = 0; var < 3; ++var) {
-      correctValuesAssigned = correctValuesAssigned
-          && Equal(vector3D[var], valuesToCopyFloat[var]);
-  }
-  MITK_TEST_CONDITION(correctValuesAssigned, "correct values were assigned")
+  MITK_TEST_CONDITION(EqualArray(vector3D, valuesToCopyFloat, 3), "correct values were assigned")
 }
 
 static void Test_mitk2itk_Compatibility(void)
 {
   Vector3D vector3D = valuesToCopy;
   itk::Vector<ScalarType, 3> itkVector = originalValues;
 
   itkVector = vector3D;
 
   MITK_TEST_CONDITION(vector3D == itkVector, "mitk vector assigned to itk vector")
   MITK_TEST_CONDITION(itkVector == valuesToCopy, "correct values were assigned")
 }
 
 static void Test_mitk2itk_floatCompatibility(void)
 {
   itk::Vector<double,3> itkDoubleVector = originalValues;
   mitk::Vector<float, 3> mitkFloatVector = valuesToCopyFloat;
 
   itkDoubleVector = mitkFloatVector;
 
   MITK_TEST_CONDITION(itkDoubleVector == mitkFloatVector, "mitk float vector assigned to itk double vector")
-
-  // test for correct values needs a little more love than in other cases
-  // since Equal cannot compare arrays/vectors of different type
-  bool correctValuesAssigned = true;
-  for (int var = 0; var < 3; ++var) {
-      correctValuesAssigned = correctValuesAssigned
-          && Equal(itkDoubleVector[var], valuesToCopyFloat[var]);
-  }
-  MITK_TEST_CONDITION(correctValuesAssigned, "correct values were assigned")
+  MITK_TEST_CONDITION(EqualArray(itkDoubleVector, valuesToCopyFloat, 3), "correct values were assigned")
 }
 
 
-
-
 static void Test_vnl2mitk_VectorFixedCompatibility()
 {
-
   mitk::Vector3D vector3D = originalValues;
   vnl_vector_fixed<ScalarType, 3> vnlVectorFixed(valuesToCopy);
 
   vector3D = vnlVectorFixed;
 
   MITK_TEST_CONDITION( vector3D.GetVnlVector() == vnlVectorFixed, "vnl_vector_fixed assigned to mitk vector")
   MITK_TEST_CONDITION( vector3D == valuesToCopy, "correct values were assigned" )
 }
 
+
+static void Test_mitk2vnl_VectorFixedCompatibility()
+{
+  vnl_vector_fixed<ScalarType, 3> vnlVectorFixed(originalValues);
+  mitk::Vector3D vector3D = valuesToCopy;
+
+  vnlVectorFixed = vector3D;
+
+  MITK_TEST_CONDITION( vnlVectorFixed == vector3D.GetVnlVector(), "mitk vector assigned to vnl_vector_fixed")
+  MITK_TEST_CONDITION( EqualArray(vnlVectorFixed, valuesToCopy, 3), "correct values were assigned" )
+}
+
+
 static void Test_vnl2mitk_VectorCompatibility()
 {
 
   mitk::Vector3D vector3D = originalValues;
   vnl_vector<ScalarType> vnlVector(3);
   vnlVector.set(valuesToCopy);
 
   vector3D = vnlVector;
 
   MITK_TEST_CONDITION( vector3D.GetVnlVector() == vnlVector, "vnl_vector assigned to mitk vector")
   MITK_TEST_CONDITION( vector3D == valuesToCopy, "correct values were assigned" )
 }
 
 /**
- * tests if constructing a mitk::Vector using a shorter in size vnl_vector is handled properly
+ * tests if constructing a mitk::Vector using a shorter in size vnl_vector is handled properly.
+ * Attention:
+ * say you have a mitk::Vector holding {1, 2, 3}.
+ * Now you assign a vnl_vector holdin {4, 5}.
+ *
+ * The result will be {4, 5, 0}, not {4, 5, 3}
  */
-static void Test_vnl2mitk_ShortVectorCompatibility()
+static void Test_vnl2mitk_ShorterVectorCompatibility()
 {
   ScalarType shorterValuesToCopy[] = {4.12345678910, 5.10987654321};
   mitk::Vector3D vector3D = originalValues;
   vnl_vector<ScalarType> vnlVector(2);
   vnlVector.set(shorterValuesToCopy);
 
   vector3D = vnlVector;
 
-  bool correctValuesInVector3D = true;
-  for (int var = 0; var < 2; ++var) {
-    correctValuesInVector3D = correctValuesInVector3D &&
-        (vector3D[var] && shorterValuesToCopy[var]);
-  }
-  correctValuesInVector3D = correctValuesInVector3D && (vector3D[2] == 0.0);
+  bool firstTwoElementsCopied = EqualArray(vector3D, vnlVector, 2);
+  bool lastElementIs0 = (vector3D[2] == 0.0);
 
-  MITK_TEST_CONDITION(correctValuesInVector3D, "shorter vnl vector correctly assigned to mitk vector" )
+  MITK_TEST_CONDITION(
+      firstTwoElementsCopied && lastElementIs0, "shorter vnl vector correctly assigned to mitk vector" )
 }
 
 /**
  * tests if constructing a mitk::Vector using a large in size vnl_vector is handled properly
  */
-static void Test_vnl2mitk_LargeVectorCompatibility()
+static void Test_vnl2mitk_LargerVectorCompatibility()
 {
   ScalarType largerValuesToCopy[] = {4.12345678910, 5.10987654321, 6.123456789132456, 7.123456987789456};
   mitk::Vector3D vector3D = originalValues;
   vnl_vector<ScalarType> vnlVector(4);
   vnlVector.set(largerValuesToCopy);
 
   vector3D = vnlVector;
 
-  bool correctValuesInVector3D = true;
-  for (int var = 0; var < 3; ++var) {
-    correctValuesInVector3D = correctValuesInVector3D &&
-        (vector3D[var] && largerValuesToCopy[var]);
-  }
-
-  MITK_TEST_CONDITION(correctValuesInVector3D, "larger vnl vector correctly assigned to mitk vector" )
+  MITK_TEST_CONDITION(EqualArray(vector3D, largerValuesToCopy, 3), "larger vnl vector correctly assigned to mitk vector" )
 }
 
 
 /**
 * Test the conversions from and to the mitk vector type
 */
 int mitkTypeVectorConversionTest(int /*argc*/ , char* /*argv*/[])
 {
   // always start with this!
   MITK_TEST_BEGIN("VectorConversionTest")
 
   Test_mitk2mitk_DifferntTypeCompatibility();
 
   Test_itk2mitk_Compatibility();
   Test_itk2mitk_floatCompatibility();
 
   Test_mitk2itk_Compatibility();
   Test_mitk2itk_floatCompatibility();
 
   Test_vnl2mitk_VectorFixedCompatibility();
+  Test_mitk2vnl_VectorFixedCompatibility();
 
   Test_vnl2mitk_VectorCompatibility();
-  Test_vnl2mitk_ShortVectorCompatibility();
-  Test_vnl2mitk_LargeVectorCompatibility();
+  Test_vnl2mitk_ShorterVectorCompatibility();
+  Test_vnl2mitk_LargerVectorCompatibility();
 
   MITK_TEST_END()
 
 }