TestSuite: stricter limits for most non-Py tests

Tests/Suite/Common/TestSuite.h

@@ -38,8 +38,15 @@
 #define DISTRIBUTION_TEST(test_fixture, name) TEST(test_fixture, name)
 #endif
 
+#ifndef PYTHON_STD_TEST
+#define eps_direct_vs_python(eps_direct, eps_python) eps_direct
+#else
+#define eps_direct_vs_python(eps_direct, eps_python) eps_python
+#endif
+
 TEST(TESTNAME, FormFactors)
 {
+    const double eps = eps_direct_vs_python(2e-13, 8e-11);
     for (const std::string& ffname : FormFactorComponents().keys()) {
         const IFormFactor* ff = FormFactorComponents().getItem(ffname)->clone();
         ASSERT(ff);
@@ -47,12 +54,13 @@ TEST(TESTNAME, FormFactors)
             ExemplarySamples::createParticleInVacuumWithFF(ff));
         ASSERT(sample);
         auto sim = test::makeSimulation::MiniGISAS(*sample);
-        EXPECT_TRUE(runTest("FormFactors_" + ff->className(), *sim, 8e-11));
+        EXPECT_TRUE(runTest("FormFactors_" + ff->className(), *sim, eps));
     }
 }
 
 TEST(TESTNAME, FormFactorsWithAbsorption)
 {
+    const double eps = eps_direct_vs_python(5e-13, 3e-10);
     for (const std::string& ffname : FormFactorComponents().keys()) {
         const IFormFactor* ff = FormFactorComponents().getItem(ffname)->clone();
         ASSERT(ff);
@@ -60,40 +68,45 @@ TEST(TESTNAME, FormFactorsWithAbsorption)
             ExemplarySamples::createLayersWithAbsorptionWithFF(ff));
         ASSERT(sample);
         auto sim = test::makeSimulation::MiniGISAS_v2(*sample);
-        EXPECT_TRUE(runTest("FormFactorsWithAbsorption_" + ff->className(), *sim, 3e-10));
+        EXPECT_TRUE(runTest("FormFactorsWithAbsorption_" + ff->className(), *sim, eps));
     }
 }
 
 TEST(TESTNAME, GISASAbsorptiveSLDLayers)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createLayersWithAbsorptionBySLD());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("GISASAbsorptiveSLDLayers", *sim, 2e-10));
+    EXPECT_TRUE(runTest("GISASAbsorptiveSLDLayers", *sim, eps));
 }
 
 TEST(TESTNAME, CylindersAndPrisms)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersAndPrisms());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("CylindersAndPrisms", *sim, 2e-10));
+    EXPECT_TRUE(runTest("CylindersAndPrisms", *sim, eps));
 }
 
 TEST(TESTNAME, RadialParacrystal)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRadialParacrystal());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("RadialParacrystal", *sim, 2e-10));
+    EXPECT_TRUE(runTest("RadialParacrystal", *sim, eps));
 }
 
 TEST(TESTNAME, HardDisk)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createHardDisk());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("HardDisk", *sim, 2e-10));
+    EXPECT_TRUE(runTest("HardDisk", *sim, eps));
 }
 
 TEST(TESTNAME, Basic2DParacrystal)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     for (const std::string& pdfname : Profile2DComponents().keys()) {
         const IProfile2D* pdf2 = Profile2DComponents().getItem(pdfname)->clone();
         ASSERT(pdf2);
@@ -102,22 +115,24 @@ TEST(TESTNAME, Basic2DParacrystal)
             ExemplarySamples::createBasic2DParacrystalWithFTDis(pdf2));
         ASSERT(sample);
         auto sim = test::makeSimulation::MiniGISAS(*sample);
-        EXPECT_TRUE(runTest("Basic2DParacrystal_" + pdf2->className(), *sim, 2e-10));
+        EXPECT_TRUE(runTest("Basic2DParacrystal_" + pdf2->className(), *sim, eps));
     }
 }
 
 TEST(TESTNAME, HexParacrystal)
 {
+    const double eps = eps_direct_vs_python(8e-11, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createHexParacrystal());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("HexParacrystal", *sim, 2e-10));
+    EXPECT_TRUE(runTest("HexParacrystal", *sim, eps));
 }
 
 TEST(TESTNAME, Lattice1D)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createLattice1D());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("Lattice1D", *sim, 2e-10));
+    EXPECT_TRUE(runTest("Lattice1D", *sim, eps));
 }
 
 TEST(TESTNAME, RectParacrystal)
@@ -131,331 +146,377 @@ TEST(TESTNAME, RectParacrystal)
 
 TEST(TESTNAME, CoreShellParticle)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCoreShellParticle());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("CoreShellParticle", *sim, 2e-10));
+    EXPECT_TRUE(runTest("CoreShellParticle", *sim, eps));
 }
 
 TEST(TESTNAME, CoreShellBoxRotateZandY)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCoreShellBoxRotateZandY());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("CoreShellBoxRotateZandY", *sim, 2e-10));
+    EXPECT_TRUE(runTest("CoreShellBoxRotateZandY", *sim, eps));
 }
 
 TEST(TESTNAME, MultiLayerWithRoughness)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMultiLayerWithRoughness());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("MultiLayerWithRoughness", *sim, 2e-10));
+    EXPECT_TRUE(runTest("MultiLayerWithRoughness", *sim, eps));
 }
 
 TEST(TESTNAME, SquareLattice2D)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSquareLattice2D());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("SquareLattice2D", *sim, 2e-10));
+    EXPECT_TRUE(runTest("SquareLattice2D", *sim, eps));
 }
 
 TEST(TESTNAME, CenteredSquareLattice2D)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCenteredSquareLattice2D());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("CenteredSquareLattice2D", *sim, 2e-10));
+    EXPECT_TRUE(runTest("CenteredSquareLattice2D", *sim, eps));
 }
 
 TEST(TESTNAME, RotatedSquareLattice2D)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRotatedSquareLattice2D());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("RotatedSquareLattice2D", *sim, 2e-10));
+    EXPECT_TRUE(runTest("RotatedSquareLattice2D", *sim, eps));
 }
 
 TEST(TESTNAME, FiniteSquareLattice2D)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createFiniteSquareLattice2D());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("FiniteSquareLattice2D", *sim, 2e-10));
+    EXPECT_TRUE(runTest("FiniteSquareLattice2D", *sim, eps));
 }
 
 TEST(TESTNAME, RotatedPyramids)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRotatedPyramids());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("RotatedPyramids", *sim, 2e-10));
+    EXPECT_TRUE(runTest("RotatedPyramids", *sim, eps));
 }
 
 TEST(TESTNAME, ThickAbsorptiveSampleWithRoughness)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createThickAbsorptiveSample());
     auto sim = test::makeSimulation::ExtraLongWavelengthGISAS(*sample);
-    EXPECT_TRUE(runTest("ThickAbsorptiveSampleWithRoughness", *sim, 2e-10));
+    EXPECT_TRUE(runTest("ThickAbsorptiveSampleWithRoughness", *sim, eps));
 }
 
 TEST(TESTNAME, Compound)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCompound());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("Compound", *sim, 2e-10));
+    EXPECT_TRUE(runTest("Compound", *sim, eps));
 }
 
 TEST(TESTNAME, BoxCompositionRotateX)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxCompositionRotateX());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("BoxCompositionRotateX", *sim, 2e-10));
+    EXPECT_TRUE(runTest("BoxCompositionRotateX", *sim, eps));
 }
 
 TEST(TESTNAME, BoxCompositionRotateY)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxCompositionRotateY());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("BoxCompositionRotateY", *sim, 2e-10));
+    EXPECT_TRUE(runTest("BoxCompositionRotateY", *sim, eps));
 }
 
 TEST(TESTNAME, BoxCompositionRotateZ)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxCompositionRotateZ());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("BoxCompositionRotateZ", *sim, 2e-10));
+    EXPECT_TRUE(runTest("BoxCompositionRotateZ", *sim, eps));
 }
 
 TEST(TESTNAME, BoxCompositionRotateZandY)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxCompositionRotateZandY());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("BoxCompositionRotateZandY", *sim, 2e-10));
+    EXPECT_TRUE(runTest("BoxCompositionRotateZandY", *sim, eps));
 }
 
 TEST(TESTNAME, BoxStackComposition)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxStackComposition());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("BoxStackComposition", *sim, 2e-10));
+    EXPECT_TRUE(runTest("BoxStackComposition", *sim, eps));
 }
 
 DISTRIBUTION_TEST(TESTNAME, CylindersWithSizeDistribution)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(
         ExemplarySamples::createCylindersWithSizeDistribution());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("CylindersWithSizeDistribution", *sim, 2e-10));
+    EXPECT_TRUE(runTest("CylindersWithSizeDistribution", *sim, eps));
 }
 
 DISTRIBUTION_TEST(TESTNAME, TwoTypesCylindersDistribution)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(
         ExemplarySamples::createTwoTypesCylindersDistribution());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("TwoTypesCylindersDistribution", *sim, 2e-10));
+    EXPECT_TRUE(runTest("TwoTypesCylindersDistribution", *sim, eps));
 }
 
 DISTRIBUTION_TEST(TESTNAME, RotatedPyramidsDistribution)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRotatedPyramidsDistribution());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("RotatedPyramidsDistribution", *sim, 2e-10));
+    EXPECT_TRUE(runTest("RotatedPyramidsDistribution", *sim, eps));
 }
 
 DISTRIBUTION_TEST(TESTNAME, SpheresWithLimitsDistribution)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(
         ExemplarySamples::createSpheresWithLimitsDistribution());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("SpheresWithLimitsDistribution", *sim, 2e-10));
+    EXPECT_TRUE(runTest("SpheresWithLimitsDistribution", *sim, eps));
 }
 
 DISTRIBUTION_TEST(TESTNAME, ConesWithLimitsDistribution)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createConesWithLimitsDistribution());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("ConesWithLimitsDistribution", *sim, 2e-10));
+    EXPECT_TRUE(runTest("ConesWithLimitsDistribution", *sim, eps));
 }
 
 DISTRIBUTION_TEST(TESTNAME, LinkedBoxDistribution)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createLinkedBoxDistribution());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("LinkedBoxDistribution", *sim, 2e-10));
+    EXPECT_TRUE(runTest("LinkedBoxDistribution", *sim, eps));
 }
 
 TEST(TESTNAME, MultipleLayout)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMultipleLayout());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("MultipleLayout", *sim, 2e-10));
+    EXPECT_TRUE(runTest("MultipleLayout", *sim, eps));
 }
 
 TEST(TESTNAME, ApproximationDA)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSizeDistributionDAModel());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("ApproximationDA", *sim, 2e-10));
+    EXPECT_TRUE(runTest("ApproximationDA", *sim, eps));
 }
 
 TEST(TESTNAME, ApproximationLMA)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSizeDistributionLMAModel());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("ApproximationLMA", *sim, 2e-10));
+    EXPECT_TRUE(runTest("ApproximationLMA", *sim, eps));
 }
 
 TEST(TESTNAME, ApproximationSSCA)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSizeDistributionSSCAModel());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("ApproximationSSCA", *sim, 2e-10));
+    EXPECT_TRUE(runTest("ApproximationSSCA", *sim, eps));
 }
 
 DISTRIBUTION_TEST(TESTNAME, CylindersInSSCA)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInSSCA());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("CylindersInSSCA", *sim, 2e-10));
+    EXPECT_TRUE(runTest("CylindersInSSCA", *sim, eps));
 }
 
 TEST(TESTNAME, CosineRipple)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCosineRipple());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("CosineRipple", *sim, 2e-10));
+    EXPECT_TRUE(runTest("CosineRipple", *sim, eps));
 }
 
 TEST(TESTNAME, TriangularRipple)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createTriangularRipple());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("TriangularRipple", *sim, 2e-10));
+    EXPECT_TRUE(runTest("TriangularRipple", *sim, eps));
 }
 
 TEST(TESTNAME, AsymRipple)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createAsymRipple());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("AsymRipple", *sim, 2e-10));
+    EXPECT_TRUE(runTest("AsymRipple", *sim, eps));
 }
 
 TEST(TESTNAME, Mesocrystal)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMesocrystal());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("Mesocrystal", *sim, 2e-10));
+    EXPECT_TRUE(runTest("Mesocrystal", *sim, eps));
 }
 
 TEST(TESTNAME, CustomMorphology)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCustomMorphology());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("CustomMorphology", *sim, 2e-10));
+    EXPECT_TRUE(runTest("CustomMorphology", *sim, eps));
 }
 
 TEST(TESTNAME, TransformBox)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createTransformBox());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("TransformBox", *sim, 1e-10));
+    EXPECT_TRUE(runTest("TransformBox", *sim, eps));
 }
 
 TEST(TESTNAME, MagneticParticleZeroField)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticParticleZeroField());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("MagneticParticleZeroField", *sim, 2e-10));
+    EXPECT_TRUE(runTest("MagneticParticleZeroField", *sim, eps));
 }
 
 TEST(TESTNAME, SlicedComposition)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSlicedComposition());
     auto sim = test::makeSimulation::MiniGISAS(*sample);
-    EXPECT_TRUE(runTest("SlicedComposition", *sim, 1e-10));
+    EXPECT_TRUE(runTest("SlicedComposition", *sim, eps));
 }
 
 TEST(TESTNAME, MagneticSubstrateZeroField)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticSubstrateZeroField());
     auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PP");
-    EXPECT_TRUE(runTest("MagneticSubstrateZeroField", *sim, 2e-10));
+    EXPECT_TRUE(runTest("MagneticSubstrateZeroField", *sim, eps));
 }
 
 TEST(TESTNAME, MagneticRotation)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticRotation());
     auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PM");
-    EXPECT_TRUE(runTest("MagneticRotationZPM", *sim, 2e-10));
+    EXPECT_TRUE(runTest("MagneticRotationZPM", *sim, eps));
 }
 
 TEST(TESTNAME, MagneticSpheres)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticSpheres());
     auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PM");
-    EXPECT_TRUE(runTest("MagneticSpheres", *sim, 2e-10));
+    EXPECT_TRUE(runTest("MagneticSpheres", *sim, eps));
 }
 
 TEST(TESTNAME, MagneticCylinders)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     for (const std::string polCase : {"PP", "MP", "PM", "MM"}) {
         std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticCylinders());
         auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, polCase);
-        EXPECT_TRUE(runTest("MagneticCylinders" + polCase, *sim, 2e-10));
+        EXPECT_TRUE(runTest("MagneticCylinders" + polCase, *sim, eps));
     }
 }
 
 TEST(TESTNAME, MagneticSpheresInMagLayer)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     for (const std::string polCase : {"PP", "MP"}) {
         std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticLayer());
         auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, polCase);
-        EXPECT_TRUE(runTest("MagneticSpheresInMagLayer" + polCase, *sim, 2e-10));
+        EXPECT_TRUE(runTest("MagneticSpheresInMagLayer" + polCase, *sim, eps));
     }
 }
 
 TEST(TESTNAME, BeamDivergence)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
     auto sim = test::makeSimulation::MiniGISASBeamDivergence(*sample);
-    EXPECT_TRUE(runTest("BeamDivergence", *sim, 2e-10));
+    EXPECT_TRUE(runTest("BeamDivergence", *sim, eps));
 }
 
 TEST(TESTNAME, DetectorResolution)
 {
+    const double eps = eps_direct_vs_python(5e-13, 2e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
     auto sim = test::makeSimulation::MiniGISASDetectorResolution(*sample);
-    EXPECT_TRUE(runTest("DetectorResolution", *sim, 2e-10));
+    EXPECT_TRUE(runTest("DetectorResolution", *sim, eps));
 }
 
 TEST(TESTNAME, SimulationWithMasks)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersAndPrisms());
     auto sim = test::makeSimulation::GISASWithMasks(*sample);
-    EXPECT_TRUE(runTest("SimulationWithMasks", *sim, 1e-10));
+    EXPECT_TRUE(runTest("SimulationWithMasks", *sim, eps));
 }
 
 TEST(TESTNAME, RectDetectorGeneric)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
     auto sim = test::makeSimulation::RectDetectorGeneric(*sample);
-    EXPECT_TRUE(runTest("RectDetectorGeneric", *sim, 1e-10));
+    EXPECT_TRUE(runTest("RectDetectorGeneric", *sim, eps));
 }
 
 TEST(TESTNAME, RectDetectorPerpToSample)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
     auto sim = test::makeSimulation::RectDetectorPerpToSample(*sample);
-    EXPECT_TRUE(runTest("RectDetectorPerpToSample", *sim, 1e-10));
+    EXPECT_TRUE(runTest("RectDetectorPerpToSample", *sim, eps));
 }
 
 TEST(TESTNAME, RectDetectorPerpToDirectBeam)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
     auto sim = test::makeSimulation::RectDetectorPerpToDirectBeam(*sample);
-    EXPECT_TRUE(runTest("RectDetectorPerpToDirectBeam", *sim, 1e-10));
+    EXPECT_TRUE(runTest("RectDetectorPerpToDirectBeam", *sim, eps));
 }
 
 TEST(TESTNAME, RectDetectorPerpToReflectedBeam)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
     auto sim = test::makeSimulation::RectDetectorPerpToReflectedBeam(*sample);
-    EXPECT_TRUE(runTest("RectDetectorPerpToReflectedBeam", *sim, 1e-10));
+    EXPECT_TRUE(runTest("RectDetectorPerpToReflectedBeam", *sim, eps));
 }
 
 TEST(TESTNAME, LargeCylindersMonteCarlo)
@@ -467,45 +528,51 @@ TEST(TESTNAME, LargeCylindersMonteCarlo)
 
 TEST(TESTNAME, SphericalDetWithRoi)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersAndPrisms());
     auto sim = test::makeSimulation::SphericalDetWithRoi(*sample);
-    EXPECT_TRUE(runTest("SphericalDetWithRoi", *sim, 1e-10));
+    EXPECT_TRUE(runTest("SphericalDetWithRoi", *sim, eps));
 }
 
 TEST(TESTNAME, RectDetWithRoi)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersAndPrisms());
     auto sim = test::makeSimulation::RectDetWithRoi(*sample);
-    EXPECT_TRUE(runTest("RectDetWithRoi", *sim, 1e-10));
+    EXPECT_TRUE(runTest("RectDetWithRoi", *sim, eps));
 }
 
 TEST(TESTNAME, BoxesWithSpecular)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxesSquareLattice2D());
     auto sim = test::makeSimulation::MiniGISASSpecularPeak(*sample);
-    EXPECT_TRUE(runTest("BoxesWithSpecular", *sim, 1e-10));
+    EXPECT_TRUE(runTest("BoxesWithSpecular", *sim, eps));
 }
 
 TEST(TESTNAME, ConstantBackground)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     auto* sample = ExemplarySamples::createCylindersInBA();
     auto sim = test::makeSimulation::MiniGISAS(*sample);
     sim->setBackground(ConstantBackground(1e3));
-    EXPECT_TRUE(runTest("ConstantBackground", *sim, 1e-10));
+    EXPECT_TRUE(runTest("ConstantBackground", *sim, eps));
 }
 
 TEST(TESTNAME, HomogeneousTiNiSample)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     auto* sample = ExemplarySamples::createHomogeneousMultilayer();
     auto sim = test::makeSimulation::BasicSpecular(*sample, false);
-    EXPECT_TRUE(runTest("HomogeneousTiNiSample", *sim, 1e-10));
+    EXPECT_TRUE(runTest("HomogeneousTiNiSample", *sim, eps));
 }
 
 TEST(TESTNAME, HomogeneousTiNiSampleWithAbsorption)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     auto* sample = ExemplarySamples::createPlainMultiLayerBySLD();
     auto sim = test::makeSimulation::BasicSpecular(*sample, false);
-    EXPECT_TRUE(runTest("HomogeneousTiNiSampleWithAbsorption", *sim, 1e-10));
+    EXPECT_TRUE(runTest("HomogeneousTiNiSampleWithAbsorption", *sim, eps));
 }
 
 TEST(TESTNAME, RoughnessInSpecular)
@@ -517,23 +584,26 @@ TEST(TESTNAME, RoughnessInSpecular)
 
 TEST(TESTNAME, GaussianBeamFootprint)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     auto* sample = ExemplarySamples::createHomogeneousMultilayer();
     auto sim = test::makeSimulation::SpecularWithGaussianBeam(*sample);
-    EXPECT_TRUE(runTest("GaussianBeamFootprint", *sim, 1e-10));
+    EXPECT_TRUE(runTest("GaussianBeamFootprint", *sim, eps));
 }
 
 TEST(TESTNAME, SquareBeamFootprint)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     auto* sample = ExemplarySamples::createHomogeneousMultilayer();
     auto sim = test::makeSimulation::SpecularWithSquareBeam(*sample);
-    EXPECT_TRUE(runTest("SquareBeamFootprint", *sim, 1e-10));
+    EXPECT_TRUE(runTest("SquareBeamFootprint", *sim, eps));
 }
 
 TEST(TESTNAME, SpecularDivergentBeam)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     auto* sample = ExemplarySamples::createHomogeneousMultilayer();
     auto sim = test::makeSimulation::SpecularDivergentBeam(*sample);
-    EXPECT_TRUE(runTest("SpecularDivergentBeam", *sim, 1e-10));
+    EXPECT_TRUE(runTest("SpecularDivergentBeam", *sim, eps));
 }
 
 //  ************************************************************************************************
@@ -544,9 +614,10 @@ TEST(TESTNAME, SpecularDivergentBeam)
 
 TEST(TESTNAME, RelativeResolutionTOF)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     auto* sample = ExemplarySamples::createPlainMultiLayerBySLD();
     auto sim = test::makeSimulation::TOFRWithRelativeResolution(*sample);
-    EXPECT_TRUE(runTest("RelativeResolutionTOF", *sim, 1e-10));
+    EXPECT_TRUE(runTest("RelativeResolutionTOF", *sim, eps));
 }
 
 #endif // GUI_STD_TEST
@@ -559,9 +630,10 @@ TEST(TESTNAME, RelativeResolutionTOF)
 
 TEST(TESTNAME, OffspecResonator)
 {
+    const double eps = eps_direct_vs_python(5e-13, 1e-10);
     auto* sample = ExemplarySamples::createResonator();
     auto sim = test::makeSimulation::MiniOffspec(*sample);
-    EXPECT_TRUE(runTest("OffspecResonator", *sim, 1e-10));
+    EXPECT_TRUE(runTest("OffspecResonator", *sim, eps));
 }
 
 #endif // PYTHON_STD_TEST