diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkBandpassFilterTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkBandpassFilterTest.cpp
new file mode 100644
index 0000000000..181e7df0e4
--- /dev/null
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkBandpassFilterTest.cpp
@@ -0,0 +1,138 @@
+/*===================================================================
+
+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 <mitkImage.h>
+#include <mitkImageReadAccessor.h>
+#include <mitkBandpassFilter.h>
+#include <cmath>
+#include <random>
+
+class mitkBandpassFilterTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkBandpassFilterTestSuite);
+  MITK_TEST(testHighPass);
+  MITK_TEST(testLowPass);
+  CPPUNIT_TEST_SUITE_END();
+
+private:
+
+  mitk::BandpassFilter::Pointer m_BandpassFilter;
+  const unsigned int NUM_ITERATIONS = 15;
+  const unsigned int DATA_DIM = 500;
+  const unsigned float TIME_SPACING = 0.0001; // [us]
+  const unsigned float HIGHPASS_FREQENCY = 1.f / TIMESPACING * DATA_DIM * 0.7f; // [Hz]
+  const unsigned float LOWPASS_FREQENCY = 1.f / TIMESPACING * DATA_DIM * 0.3f; // [Hz]
+  const unsigned float ALPHA = 0; // 0 = box, 1 = von Hann; changing this may make the test invalid
+
+public:
+
+  void setUp() override
+  {
+    m_BandpassFilter = mitk::BandpassFilter::New();
+  }
+
+  void test(float signalFreq, float HighPass, float LowPass, float HighPassAlpha, float LowPassAlpha)
+  {
+    std::random_device r;
+    std::default_random_engine randGen(r());
+    std::uniform_real_distribution<float> randDistrHighPass(0, HighPass * 0.9f);
+    std::uniform_real_distribution<float> randDistrLowPass(LowPass * 1.1f, LowPass * 10);
+
+    float* data = new float[DATA_DIM*DATA_DIM*DATA_DIM];
+
+    mitk::Image::Pointer inputImage = mitk::Image::New();
+    unsigned int dimension[3]{ DATA_DIM, DATA_DIM, DATA_DIM };
+    inputImage->Initialize(mitk::MakeScalarPixelType<float>(), 3, dimension);
+    mitk::Vector3D spacing { 1, TIME_SPACING, 1 };
+    inputImage->SetSpacing(spacing);
+
+    for (unsigned int iteration = 0; iteration < NUM_ITERATIONS; ++iteration)
+    {
+      for (unsigned int i = 0; i < DATA_DIM*DATA_DIM*DATA_DIM; ++i)
+      {
+        data[i] = 0;
+      }
+
+      if(HighPass != -1)
+        addFrequency(randDistrHighPass(randGen), TIME_SPACING, data, dimension);
+      if(LowPass != -1)
+        addFrequency(randDistrLowPass(randGen), TIME_SPACING, data, dimension);
+
+      inputImage->SetImportVolume(data, 0, 0, mitk::Image::ImportMemoryManagementType::CopyMemory);
+
+      m_BandpassFilter->SetInput(inputImage);
+
+      m_BandpassFilter->SetHighPass(HighPass);
+      m_BandpassFilter->SetLowPass(LowPass);
+      m_BandpassFilter->SetHighPassAlpha(HighPassAlpha);
+      m_BandpassFilter->SetLowPassAlpha(LowPassAlpha);
+
+      m_BandpassFilter->Update();
+      mitk::Image::Pointer outputImage = m_BandpassFilter->GetOutput();
+
+      mitk::ImageReadAccessor readAccess(outputImage);
+      const float* outputData = (const float*)readAccess.GetData();
+
+      for (unsigned int z = 0; z < DATA_DIM; ++z)
+      {
+        for (unsigned int y = 0; y < DATA_DIM; ++y)
+        {
+          for (unsigned int x = 0; x < DATA_DIM; ++x)
+          {
+            unsigned int outPos = x + y * DATA_DIM + z * DATA_DIM * DATA_DIM;
+            CPPUNIT_ASSERT_MESSAGE(std::string("expected" + "" + "sth but no :(, got " + std::to_string(outputData[outPos])),
+            abs(1) < mitk::eps);
+          }
+        }
+      }
+    }
+
+    delete[] data;
+  }
+
+  void addFrequency(float freq, float timeSpacing, float* data, unsigned int* dim)
+  {
+    for(unsigned int z = 0; z < dim[2]; ++z)
+    {
+      for(unsigned int y = 0; y < dim[2]; ++y)
+      {
+        for(unsigned int x = 0; x < dim[2]; ++x)
+        {
+          data[x + y*dim[0] + z*dim[0]*dim[1]] += std::sin(freq * timeSpacing * y);
+        }
+      }
+    }
+  }
+
+  void testHighPass()
+  {
+    test(HIGHPASS_FREQENCY, -1, ALPHA, 0);
+  }
+
+  void testLowPass()
+  {
+    test(-1, LOWPASS_FREQENCY, 0, ALPHA);
+  }
+
+  void tearDown() override
+  {
+    m_BandpassFilter = nullptr;
+  }
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkBandpassFilterTestSuite)
diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkBeamformingFilterTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkBeamformingFilterTest.cpp
new file mode 100644
index 0000000000..3235037536
--- /dev/null
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkBeamformingFilterTest.cpp
@@ -0,0 +1,82 @@
+/*===================================================================
+
+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 <mitkImage.h>
+#include <mitkImageReadAccessor.h>
+#include <mitkBeamformingFilter.h>
+
+class mitkBeamformingFilterTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkBeamformingFilterTestSuite);
+  MITK_TEST(testBeamformingCPU);
+  MITK_TEST(testBeamformingGPU);
+  CPPUNIT_TEST_SUITE_END();
+
+private:
+
+  mitk::BeamformingFilter::Pointer m_BeamformingFilter;
+  const unsigned int NUM_ITERATIONS = 15;
+  const unsigned int DATA_DIM = 10;
+
+public:
+
+  void setUp() override
+  {
+    m_BeamformingFilter = mitk::BeamformingFilter::New();
+  }
+
+  void test(bool GPU)
+  {
+    float* data = new float[DATA_DIM*DATA_DIM*DATA_DIM];
+
+    for (unsigned int i = 0; i < DATA_DIM*DATA_DIM*DATA_DIM; ++i)
+    {
+      data[i] = 0;
+    }
+
+    mitk::Image::Pointer inputImage = mitk::Image::New();
+    unsigned int dimension[3]{ DATA_DIM, DATA_DIM, DATA_DIM };
+    inputImage->Initialize(mitk::MakeScalarPixelType<TPixelType>(), 3, dimension);
+    inputImage->SetImportVolume(data);
+
+    for (unsigned int iteration = 0; iteration < NUM_ITERATIONS; ++iteration)
+    {
+      m_BeamformingFilter->SetInput(inputImage);
+      m_BeamformingFilter->Update();
+      mitk::Image::Pointer outputImage = m_BeamformingFilter->GetOutput();
+      mitk::ImageReadAccessor readAccess(outputImage);
+      const float* outputData = (const float*)readAccess.GetData();
+      for (unsigned int i = 0; i < DATA_DIM*DATA_DIM*DATA_DIM; ++i)
+      {
+        CPPUNIT_ASSERT_MESSAGE(std::string("expected " + std::to_string(data[i]) + " but was " + std::to_string(outputData[i])), abs(outputData[i] - data[i]) < mitk::eps);
+      }
+    }
+  }
+
+  void testBeamformingCPU()
+  {
+    test(false);
+  }
+
+  void testBeamformingGPU()
+  {
+    test(true);
+  }
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkBeamformingFilterTestSuite)
diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkCropImageFilterTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkCropImageFilterTest.cpp
new file mode 100644
index 0000000000..e3e767af3c
--- /dev/null
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkCropImageFilterTest.cpp
@@ -0,0 +1,123 @@
+/*===================================================================
+
+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 <mitkImage.h>
+#include <mitkImageReadAccessor.h>
+#include <mitkCropImageFilter.h>
+#include <random>
+
+class mitkCropImageFilterTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkCropImageFilterTestSuite);
+  MITK_TEST(testCropImage);
+  CPPUNIT_TEST_SUITE_END();
+
+private:
+
+  mitk::CastToFloatImageFilter::Pointer m_CropImageFilter;
+  const unsigned int NUM_ITERATIONS = 15;
+  const unsigned int DATA_DIM = 20;
+
+public:
+
+  void setUp() override
+  {
+    m_CropImageFilter = mitk::CropImageFilter::New();
+  }
+
+  void test()
+  {
+    std::random_device r;
+    std::default_random_engine randGen(r());
+    std::uniform_int_distribution<int> randDistr(0, DATA_DIM / 2);
+
+    float* data = new float[DATA_DIM*DATA_DIM*DATA_DIM];
+
+    for (unsigned int i = 0; i < DATA_DIM*DATA_DIM*DATA_DIM; ++i)
+    {
+      data[i] = (float)i;
+    }
+
+    mitk::Image::Pointer inputImage = mitk::Image::New();
+    unsigned int dimension[3]{ DATA_DIM, DATA_DIM, DATA_DIM };
+    inputImage->Initialize(mitk::MakeScalarPixelType<float>(), 3, dimension);
+    inputImage->SetImportVolume(data, 0, 0, mitk::Image::ImportMemoryManagementType::CopyMemory);
+
+    for (unsigned int iteration = 0; iteration < NUM_ITERATIONS; ++iteration)
+    {
+      unsigned int XPixelsCropStart = randDistr(randGen);
+      unsigned int YPixelsCropStart = randDistr(randGen);
+      unsigned int ZPixelsCropStart = randDistr(randGen);
+      unsigned int XPixelsCropEnd = randDistr(randGen);
+      unsigned int YPixelsCropEnd = randDistr(randGen);
+      unsigned int ZPixelsCropEnd = randDistr(randGen);
+
+      unsigend int newXDim = DATA_DIM - XPixelsCropStart - XPixelsCropEnd;
+      unsigend int newYDim = DATA_DIM - YPixelsCropStart - YPixelsCropEnd;
+      unsigend int newZDim = DATA_DIM - ZPixelsCropStart - ZPixelsCropEnd;
+
+      m_CropImageFilter->SetInput(inputImage);
+
+      m_CropImageFilter->SetXPixelsCropStart(XPixelsCropStart);
+      m_CropImageFilter->SetYPixelsCropStart(YPixelsCropStart);
+      m_CropImageFilter->SetZPixelsCropStart(ZPixelsCropStart);
+      m_CropImageFilter->SetXPixelsCropEnd(XPixelsCropEnd);
+      m_CropImageFilter->SetYPixelsCropEnd(YPixelsCropEnd);
+      m_CropImageFilter->SetZPixelsCropEnd(ZPixelsCropEnd);
+
+      m_CropImageFilter->Update();
+      mitk::Image::Pointer outputImage = m_CropImageFilter->GetOutput();
+
+      mitk::ImageReadAccessor readAccess(outputImage);
+      const float* outputData = (const float*)readAccess.GetData();
+
+      CPPUNIT_ASSERT_MESSAGE(std::string("expected x size to be" + std::to_string(newXDim) + " but was " + std::to_string(outputImage->GetDimension(0))), newXDim == outputImage->GetDimension(0));
+      CPPUNIT_ASSERT_MESSAGE(std::string("expected y size to be" + std::to_string(newYDim) + " but was " + std::to_string(outputImage->GetDimension(1))), newXDim == outputImage->GetDimension(1));
+      CPPUNIT_ASSERT_MESSAGE(std::string("expected z size to be" + std::to_string(newZDim) + " but was " + std::to_string(outputImage->GetDimension(2))), newXDim == outputImage->GetDimension(2));
+
+      for (unsigned int z = 0; z < newZDim; ++z)
+      {
+        for (unsigned int y = 0; y < newYDim; ++y)
+        {
+          for (unsigned int x = 0; x < newXDim; ++x)
+          {
+            unsigned int origPos = (x + XPixelsCropStart) + (y + YPixelsCropStart) * DATA_DIM + (z + ZPixelsCropStart) * DATA_DIM * DATA_DIM;
+            unsigned int outPos = x + y * newXDim + z * newXDim * newYDim;
+            CPPUNIT_ASSERT_MESSAGE(std::string("expected " + std::to_string(data[origPos])
+            + " but was " + std::to_string(outputData[outPos])),
+            abs(outputData[outPos] - data[origPos]) < mitk::eps);
+          }
+        }
+      }
+    }
+
+    delete[] data;
+  }
+
+  void testCropImage()
+  {
+    test();
+  }
+
+  void tearDown() override
+  {
+    m_CropImageFilter = nullptr;
+  }
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkCropImageFilterTestSuite)
diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
index 281d9ee49d..60408d5d27 100644
--- a/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
@@ -1,111 +1,112 @@
 /*===================================================================
 
 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 <mitkPhotoacousticFilterService.h>
 #include <mitkImage.h>
 #include <mitkImageReadAccessor.h>
 #include <mitkBeamformingSettings.h>
 
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModuleResourceStream.h>
 
 #include <random>
 #include <chrono>
 
 class mitkPAFilterServiceTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkPAFilterServiceTestSuite);
   MITK_TEST(testRunning);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   mitk::PhotoacousticFilterService::Pointer m_PhotoacousticFilterService;
 
 public:
 
   void setUp() override
   {
     m_PhotoacousticFilterService = mitk::PhotoacousticFilterService::New();
   }
 
   mitk::BeamformingSettings::Pointer CreateEmptyBeamformingSettings()
   {
     mitk::BeamformingSettings::Pointer config = mitk::BeamformingSettings::New();
     return config;
   }
 
   mitk::BeamformingSettings::Pointer CreateFunctionalBeamformingSettings()
   {
     mitk::BeamformingSettings::Pointer config = mitk::BeamformingSettings::New();
     return config;
   }
 
   void testRunning()
   {
     int xDim = 3;
     int yDim = 3;
     int length = yDim * xDim;
     float* testArray = new float[length];
     for (int i = 0; i < length; ++i)
     {
       testArray[i] = 0;
     }
 
     unsigned int NUMBER_OF_SPATIAL_DIMENSIONS = 2;
     unsigned int* dimensions = new unsigned int[NUMBER_OF_SPATIAL_DIMENSIONS];
     dimensions[0] = yDim;
     dimensions[1] = xDim;
     mitk::PixelType pixelType = mitk::MakeScalarPixelType<float>();
     mitk::Image::Pointer testImage = mitk::Image::New();
     testImage->Initialize(pixelType, NUMBER_OF_SPATIAL_DIMENSIONS, dimensions);
     testImage->SetImportSlice(testArray, 0, 0, 0, mitk::Image::ImportMemoryManagementType::CopyMemory);
     delete[] testArray;
 
     mitk::ImageReadAccessor readAccessInput(testImage);
     const float* inputArray = (const float*)readAccessInput.GetData();
 
     for (int i = 0; i < length; ++i)
     {
       CPPUNIT_ASSERT_MESSAGE(std::string("Input array already not correct: " + std::to_string(inputArray[i])), abs(inputArray[i]) < 1e-5f);
     }
 
     mitk::BeamformingSettings::Pointer config = CreateEmptyBeamformingSettings();
     auto output = m_PhotoacousticFilterService->ApplyBeamforming(testImage, config);
 
     mitk::ImageReadAccessor readAccess(output);
     const float* outputArray = (const float*)readAccess.GetData();
 
     for (int i = 0; i < length; ++i)
     {
       CPPUNIT_ASSERT_MESSAGE(std::string("Ouput array not correct: " + std::to_string(abs(outputArray[i]))), abs(outputArray[i]) < 1e-5f);
     }
+    delete[] dimensions;
   }
 
   void tearDown() override
   {
     m_PhotoacousticFilterService = nullptr;
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkPAFilterService)