diff --git a/Modules/PhotoacousticsAlgorithms/test/files.cmake b/Modules/PhotoacousticsAlgorithms/test/files.cmake
index 794ef08460..2fe7e9fa64 100644
--- a/Modules/PhotoacousticsAlgorithms/test/files.cmake
+++ b/Modules/PhotoacousticsAlgorithms/test/files.cmake
@@ -1,22 +1,24 @@
 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 #####################################################
 
   ################# RUNNING TESTS #######################################################
 
 
   mitkPAFilterServiceTest.cpp
   mitkCastToFloatImageFilterTest.cpp
-
+  mitkBandpassFilterTest.cpp
+  mitkBeamformingFilterTest.cpp
+  mitkCropImageFilterTest.cpp
 )
 set(RESOURCE_FILES)
diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkBandpassFilterTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkBandpassFilterTest.cpp
index 154435c297..2d85d68c47 100644
--- a/Modules/PhotoacousticsAlgorithms/test/mitkBandpassFilterTest.cpp
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkBandpassFilterTest.cpp
@@ -1,142 +1,145 @@
 /*===================================================================
 
 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
+  const float TIME_SPACING = 0.0001; // [us]
+  const float HIGHPASS_FREQENCY = 1.f / TIME_SPACING * DATA_DIM * 0.7f; // [Hz]
+  const float LOWPASS_FREQENCY = 1.f / TIME_SPACING * DATA_DIM * 0.3f; // [Hz]
+  const 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 };
+    mitk::Vector3D spacing;
+    spacing[0] = 1;
+    spacing[1] = TIME_SPACING;
+    spacing[2] = 1;
     inputImage->SetSpacing(spacing);
 
     for (unsigned int iteration = 0; iteration < NUM_ITERATIONS; ++iteration)
     {
       // fill image with zeros
       for (unsigned int i = 0; i < DATA_DIM*DATA_DIM*DATA_DIM; ++i)
       {
         data[i] = 0;
       }
 
       // write specific frequencies to the image
-      if(HighPass != -1)
+      if (HighPass != -1)
         addFrequency(randDistrHighPass(randGen), TIME_SPACING, data, dimension);
-      if(LowPass != -1)
+      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();
 
       // the resulting image should consist only of zeros, as we filtered the frequencies out
       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);
+            CPPUNIT_ASSERT_MESSAGE(std::string("expected not :(, got " + std::to_string(outputData[outPos])),
+              abs(1) < mitk::eps);
           }
         }
       }
     }
 
     delete[] data;
   }
 
   // write a fixed-frequency signal to the image
   void addFrequency(float freq, float timeSpacing, float* data, unsigned int* dim)
   {
-    for(unsigned int z = 0; z < dim[2]; ++z)
+    for (unsigned int z = 0; z < dim[2]; ++z)
     {
-      for(unsigned int y = 0; y < dim[2]; ++y)
+      for (unsigned int y = 0; y < dim[2]; ++y)
       {
-        for(unsigned int x = 0; x < dim[2]; ++x)
+        for (unsigned int x = 0; x < dim[2]; ++x)
         {
-          data[x + y*dim[0] + z*dim[0]*dim[1]] += std::sin(freq * timeSpacing * y);
+          data[x + y*dim[0] + z*dim[0] * dim[1]] += std::sin(freq * timeSpacing * y);
         }
       }
     }
   }
 
   void testHighPass()
   {
-    test(HIGHPASS_FREQENCY, -1, ALPHA, 0);
+    test(7.5, HIGHPASS_FREQENCY, -1, ALPHA, 0);
   }
 
   void testLowPass()
   {
-    test(-1, LOWPASS_FREQENCY, 0, ALPHA);
+    test(7.5, -1, LOWPASS_FREQENCY, 0, ALPHA);
   }
 
   void tearDown() override
   {
     m_BandpassFilter = nullptr;
   }
 };
 
-MITK_TEST_SUITE_REGISTRATION(mitkBandpassFilterTestSuite)
+MITK_TEST_SUITE_REGISTRATION(mitkBandpassFilter)
diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkBeamformingFilterTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkBeamformingFilterTest.cpp
index 3235037536..0668999780 100644
--- a/Modules/PhotoacousticsAlgorithms/test/mitkBeamformingFilterTest.cpp
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkBeamformingFilterTest.cpp
@@ -1,82 +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();
+    m_BeamformingFilter = mitk::BeamformingFilter::New(nullptr);
   }
 
   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->Initialize(mitk::MakeScalarPixelType<float>(), 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)
+MITK_TEST_SUITE_REGISTRATION(mitkBeamformingFilter)
diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkCropImageFilterTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkCropImageFilterTest.cpp
index e3e767af3c..f2d29e66c4 100644
--- a/Modules/PhotoacousticsAlgorithms/test/mitkCropImageFilterTest.cpp
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkCropImageFilterTest.cpp
@@ -1,123 +1,127 @@
 /*===================================================================
 
 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;
+  mitk::CropImageFilter::Pointer m_CropImageFilter;
+  const unsigned int NUM_ITERATIONS = 5;
+  const unsigned int DATA_DIM = 25;
 
 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);
+    std::uniform_int_distribution<int> randDistr(0, (DATA_DIM / 2) - 1);
 
     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;
+      unsigned int newXDim = DATA_DIM - XPixelsCropStart - XPixelsCropEnd;
+      unsigned int newYDim = DATA_DIM - YPixelsCropStart - YPixelsCropEnd;
+      unsigned 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));
+      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))), newYDim == 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))), newZDim == 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);
+              + " but was " + std::to_string(outputData[outPos])),
+              abs(outputData[outPos] - data[origPos]) < mitk::eps);
           }
         }
       }
     }
 
     delete[] data;
   }
 
   void testCropImage()
   {
-    test();
+    for (int repetition = 0; repetition < 20; ++repetition)
+    {
+      MITK_INFO << "[" << (repetition + 1) << "/20]";
+      test();
+    }
   }
 
   void tearDown() override
   {
     m_CropImageFilter = nullptr;
   }
 };
 
-MITK_TEST_SUITE_REGISTRATION(mitkCropImageFilterTestSuite)
+MITK_TEST_SUITE_REGISTRATION(mitkCropImageFilter)
diff --git a/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp b/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
index 60408d5d27..d04b0c9343 100644
--- a/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
+++ b/Modules/PhotoacousticsAlgorithms/test/mitkPAFilterServiceTest.cpp
@@ -1,112 +1,131 @@
 /*===================================================================
 
 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;
+    return CreateFunctionalBeamformingSettings();
   }
 
   mitk::BeamformingSettings::Pointer CreateFunctionalBeamformingSettings()
   {
-    mitk::BeamformingSettings::Pointer config = mitk::BeamformingSettings::New();
-    return config;
+    mitk::BeamformingSettings::Pointer outputSettings = mitk::BeamformingSettings::New(
+      (float)(0.3 / 1000),
+      (float)(1500),
+      (float)(0.0125 / 1000000),
+      27,
+      true,
+      3000,
+      128,
+      20,
+      false,
+      (unsigned int*) nullptr,
+      (unsigned int*) nullptr,
+      false,
+      mitk::BeamformingSettings::DelayCalc::Spherical,
+      mitk::BeamformingSettings::Apodization::Box,
+      128,
+      mitk::BeamformingSettings::BeamformingAlgorithm::DAS,
+      false,
+      0.0f,
+      0.0f);
+
+    return outputSettings;
   }
 
   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)