diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkPhotoacousticMotionCorrectionFilterTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkPhotoacousticMotionCorrectionFilterTest.cpp
index f0acc0eb92..d44c3ebdd3 100644
--- a/Modules/PhotoacousticsAlgorithms/test/mitkPhotoacousticMotionCorrectionFilterTest.cpp
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkPhotoacousticMotionCorrectionFilterTest.cpp
@@ -1,87 +1,182 @@
 /*===================================================================
 
   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 <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 #include <mitkPhotoacousticMotionCorrectionFilter.h>
 
 class mitkPhotoacousticMotionCorrectionFilterTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkPhotoacousticMotionCorrectionFilterTestSuite);
   MITK_TEST(testSettingFirstInput);
   MITK_TEST(testSettingSecondInput);
-  MITK_TEST(testNoThirdInput);
+  // MITK_TEST(testNoThirdInput);
+  MITK_TEST(testGetFirstEmptyOutput);
+  MITK_TEST(testGetSecondEmptyOutput);
+  MITK_TEST(testSameInOutDimensions);
+  MITK_TEST(testNo3DError);
+  MITK_TEST(testSameInputDimension1);
+  MITK_TEST(testSameInputDimension2);
+  MITK_TEST(testNullPtr1);
+  MITK_TEST(testNullPtr2);
+  MITK_TEST(testNullPtr3);
+  MITK_TEST(testSameInputDimensions);
+  MITK_TEST(testStaticSliceCorrection);
   CPPUNIT_TEST_SUITE_END();
+  
 
 private:
   mitk::PhotoacousticMotionCorrectionFilter::Pointer filter;
-  mitk::Image::Pointer image;
+  mitk::Image::Pointer image, image4d, image2d, image3d1slice;
+  float * data2d;
 
 public:
   void setUp() override {
     // get the filter I need
     filter = mitk::PhotoacousticMotionCorrectionFilter::New();
     // get a 3d mitk image
     image = mitk::Image::New();
-    unsigned int * dimensions = new unsigned int[3] {2, 2, 2,};
+    image2d = mitk::Image::New();
+    image4d = mitk::Image::New();
+    image3d1slice = mitk::Image::New();
+    unsigned int * dimensions = new unsigned int[3] {2, 2, 2};
+    unsigned int * dimensions2 = new unsigned int[3] {2, 2, 1};
+    unsigned int * dim2 = new unsigned int[4] {2, 2, 2, 2};
     mitk::PixelType pt = mitk::MakeScalarPixelType<float>();
+    float * data = new float[8] {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+    float * data4d = new float[16];
+    data2d = new float[4] {1.0, 0.0, 0.0, 0.0};
     image->Initialize(pt, 3, dimensions);
-    delete[] dimensions;
-    double * data = new double[8] {0, 0, 0, 0, 0, 0, 0, 0};
     image->SetVolume(data);
+    image4d->Initialize(pt, 4, dim2);
+    image4d->SetVolume(data4d);
+    image2d->Initialize(pt, 2, dimensions);
+    image2d->SetVolume(data2d);
+    image3d1slice->Initialize(pt, 3, dimensions2);
+    image3d1slice->SetVolume(data);
+    delete[] dimensions;
+    delete[] dimensions2;
     delete[] data;
+    delete[] data4d;
+    delete[] dim2;
   }
 
   void tearDown() override {
+    delete[] data2d;
   }
 
   void testSettingFirstInput() {
     filter->SetInput(0, image);
     mitk::Image::Pointer out = filter->GetInput(0);
     CPPUNIT_ASSERT_EQUAL(image, out);
   }
 
   void testSettingSecondInput() {
     filter->SetInput(1, image);
     mitk::Image::Pointer out = filter->GetInput(1);
     CPPUNIT_ASSERT_EQUAL(image, out);
   }
 
-  void testNoThirdInput() {
-    CPPUNIT_ASSERT_ASSERTION_FAIL(filter->SetInput(2, image));
-    // CPPUNIT_ASSERT(true);
-  }
+  // void testNoThirdInput() {
+  //   CPPUNIT_ASSERT_NO_THROW(filter->SetInput(2, image));
+  //   // CPPUNIT_ASSERT(true);
+  // }
 
   void testGetFirstEmptyOutput() {
-    
+    mitk::Image::Pointer out = filter->GetOutput(0);
+    unsigned int dim = 0;
+    CPPUNIT_ASSERT_EQUAL(dim, out->GetDimension());
   }
 
   void testGetSecondEmptyOutput() {
-
+    mitk::Image::Pointer out = filter->GetOutput(1);
+    unsigned int dim = 0;
+    CPPUNIT_ASSERT_EQUAL(dim, out->GetDimension());
   }
 
   void testSameInOutDimensions() {
-    
+    filter->SetInput(0, image);
+    filter->SetInput(1, image);
+    filter->Update();
+    mitk::Image::Pointer out = filter->GetOutput(0);
+    CPPUNIT_ASSERT_EQUAL(image->GetDimension(), out->GetDimension());
+    out = filter->GetOutput(1);
+    CPPUNIT_ASSERT_EQUAL(image->GetDimension(), out->GetDimension());
+  }
+
+  void testNo3DError() {
+    filter->SetInput(0, image4d);
+    filter->SetInput(1, image4d);
+    CPPUNIT_ASSERT_THROW(filter->Update(), std::invalid_argument);
+  }
+
+  // I only test for dim input0 <= dim input1, because otherwise
+  // itk will throw an error before the program even reaches the
+  // parts I wrote.
+  // Same for testSameInputDimension2
+  void testSameInputDimension1() {
+    filter->SetInput(0, image);
+    filter->SetInput(1, image4d);
+    CPPUNIT_ASSERT_THROW(filter->Update(), std::invalid_argument);
+  }
+
+  // See previous comment
+  void testSameInputDimension2() {
+    filter->SetInput(0, image2d);
+    filter->SetInput(1, image);
+    CPPUNIT_ASSERT_THROW(filter->Update(), std::invalid_argument);
+  }
+
+  // I tried to catch the error myself in the filter, but itk does some magic beforehand
+  void testNullPtr1() {
+    filter->SetInput(0, NULL);
+    filter->SetInput(1, image);
+    CPPUNIT_ASSERT_THROW(filter->Update(), itk::ExceptionObject);
+  }
+
+  // Now I am allowed to catch it myself, because the first input is fine -.-
+  void testNullPtr2() {
+    filter->SetInput(0, image);
+    filter->SetInput(1, NULL);
+    CPPUNIT_ASSERT_THROW(filter->Update(), std::invalid_argument);
+  }
+
+  void testNullPtr3() {
+    filter->SetInput(0, NULL);
+    filter->SetInput(1, NULL);
+    CPPUNIT_ASSERT_THROW(filter->Update(), itk::ExceptionObject);
   }
 
   void testSameInputDimensions() {
-    
+    filter->SetInput(0, image3d1slice);
+    filter->SetInput(1, image);
+    CPPUNIT_ASSERT_THROW(filter->Update(), std::invalid_argument);
   }
 
+  void testStaticSliceCorrection() {
+    // image->SetSlice(data2d, 0);
+    // image->SetSlice(data2d, 1);
+    filter->SetInput(0, image);
+    filter->SetInput(1, image);
+    filter->Update();
+    mitk::Image::Pointer out1 = filter->GetOutput(0);
+    mitk::Image::Pointer out2 = filter->GetOutput(1);
+    MITK_ASSERT_EQUAL(image, out1, "Check that static image does not get changed.");
+  }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkPhotoacousticMotionCorrectionFilter)