StandardTests.h

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Tests/Functional/Std/StandardTests.h
//! @brief     Provides TEST_F stances that define the BornAgain standard tests.
//!
//!            Each of these stances runs one standard test.
//!            The function run, defined in file Run.cpp, is the same for Core/Py/GUI std tests.
//!            It calls a function checkSimulation that is different for those three test suites.
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************

#ifndef BORNAGAIN_TESTS_FUNCTIONAL_STD_STANDARDTESTS_H
#define BORNAGAIN_TESTS_FUNCTIONAL_STD_STANDARDTESTS_H

#include "Core/Background/ConstantBackground.h"
#include "Core/Simulation/includeSimulations.h"
#include "Sample/ComponentBuilder/FTDistribution2DComponents.h"
#include "Sample/ComponentBuilder/FormFactorComponents.h"
#include "Sample/Multilayer/MultiLayer.h"
#include "Sample/StandardSamples/ExemplarySamples.h"
#include "Tests/Functional/ProStd/MakeSimulations.h"
#include "Tests/GTestWrapper/google_test.h"

#include <iostream>

// By defining DISABLE_DISTRIBUTION_TESTS in the project, tests which contain particle distributions
// can be set do DISABLED. This is useful since the tests in here are the same for Core/Py/GUI, but
// the particle distributions have been removed from GUI.
#ifdef DISABLE_DISTRIBUTION_TESTS
#define DISTRIBUTION_TEST_F(test_fixture, test_name) TEST_F(test_fixture, DISABLED_##test_name)
#else
#define DISTRIBUTION_TEST_F(test_fixture, test_name) TEST_F(test_fixture, test_name)
#endif

class Std : public ::testing::Test {
};

TEST_F(Std, FormFactors)
{
    for (const std::string& ffname : FormFactorComponents().keys()) {
        const IFormFactor* ff = FormFactorComponents().getItem(ffname)->clone();
        ASSERT(ff);
        std::unique_ptr<const MultiLayer> sample(
            ExemplarySamples::createParticleInVacuumWithFF(ff));
        ASSERT(sample);
        auto sim = test::makeSimulation::MiniGISAS(*sample);
        EXPECT_TRUE(run("FormFactors_" + ff->shapeName(), *sim, 2e-10));
    }
}

TEST_F(Std, GISASAbsorptiveSLDLayers)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createLayersWithAbsorptionBySLD());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("GISASAbsorptiveSLDLayers", *sim, 2e-10));
}

TEST_F(Std, CylindersAndPrisms)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersAndPrisms());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("CylindersAndPrisms", *sim, 2e-10));
}

TEST_F(Std, RadialParaCrystal)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRadialParaCrystal());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("RadialParaCrystal", *sim, 2e-10));
}

TEST_F(Std, HardDisk)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createHardDisk());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("HardDisk", *sim, 2e-10));
}

TEST_F(Std, Basic2DParaCrystal)
{
    for (const std::string& pdfname : FTDistribution2DComponents().keys()) {
        const IFTDistribution2D* pdf2 = FTDistribution2DComponents().getItem(pdfname)->clone();
        ASSERT(pdf2);
        std::cout << pdf2->pythonConstructor() << std::endl;
        std::unique_ptr<const MultiLayer> sample(
            ExemplarySamples::createBasic2DParaCrystalWithFTDis(pdf2));
        ASSERT(sample);
        auto sim = test::makeSimulation::MiniGISAS(*sample);
        EXPECT_TRUE(run("Basic2DParaCrystal_" + pdf2->className(), *sim, 2e-10));
    }
}

TEST_F(Std, HexParaCrystal)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createHexParaCrystal());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("HexParaCrystal", *sim, 2e-10));
}

TEST_F(Std, Lattice1D)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createLattice1D());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("Lattice1D", *sim, 2e-10));
}

TEST_F(Std, RectParaCrystal)
{
    // TODO: investigate numeric integration, which has become problematic under Windows
    //       after moving code from Core/Tools to Base/Utils
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRectParaCrystal());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("RectParaCrystal", *sim, 1e-9));
}

TEST_F(Std, CoreShellParticle)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCoreShellParticle());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("CoreShellParticle", *sim, 2e-10));
}

TEST_F(Std, CoreShellBoxRotateZandY)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCoreShellBoxRotateZandY());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("CoreShellBoxRotateZandY", *sim, 2e-10));
}

TEST_F(Std, MultiLayerWithRoughness)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMultiLayerWithRoughness());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("MultiLayerWithRoughness", *sim, 2e-10));
}

TEST_F(Std, SquareLattice2D)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSquareLattice2D());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("SquareLattice2D", *sim, 2e-10));
}

TEST_F(Std, CenteredSquareLattice2D)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCenteredSquareLattice2D());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("CenteredSquareLattice2D", *sim, 2e-10));
}

TEST_F(Std, RotatedSquareLattice2D)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRotatedSquareLattice2D());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("RotatedSquareLattice2D", *sim, 2e-10));
}

TEST_F(Std, FiniteSquareLattice2D)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createFiniteSquareLattice2D());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("FiniteSquareLattice2D", *sim, 2e-10));
}

TEST_F(Std, RotatedPyramids)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRotatedPyramids());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("RotatedPyramids", *sim, 2e-10));
}

TEST_F(Std, ThickAbsorptiveSampleWithRoughness)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createThickAbsorptiveSample());
    auto sim = test::makeSimulation::ExtraLongWavelengthGISAS(*sample);
    EXPECT_TRUE(run("ThickAbsorptiveSampleWithRoughness", *sim, 2e-10));
}

TEST_F(Std, ParticleComposition)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createParticleComposition());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("ParticleComposition", *sim, 2e-10));
}

TEST_F(Std, BoxCompositionRotateX)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxCompositionRotateX());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("BoxCompositionRotateX", *sim, 2e-10));
}

TEST_F(Std, BoxCompositionRotateY)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxCompositionRotateY());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("BoxCompositionRotateY", *sim, 2e-10));
}

TEST_F(Std, BoxCompositionRotateZ)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxCompositionRotateZ());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("BoxCompositionRotateZ", *sim, 2e-10));
}

TEST_F(Std, BoxCompositionRotateZandY)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxCompositionRotateZandY());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("BoxCompositionRotateZandY", *sim, 2e-10));
}

TEST_F(Std, BoxStackComposition)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxStackComposition());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("BoxStackComposition", *sim, 2e-10));
}

DISTRIBUTION_TEST_F(Std, CylindersWithSizeDistribution)
{
    std::unique_ptr<const MultiLayer> sample(
        ExemplarySamples::createCylindersWithSizeDistribution());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("CylindersWithSizeDistribution", *sim, 2e-10));
}

DISTRIBUTION_TEST_F(Std, TwoTypesCylindersDistribution)
{
    std::unique_ptr<const MultiLayer> sample(
        ExemplarySamples::createTwoTypesCylindersDistribution());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("TwoTypesCylindersDistribution", *sim, 2e-10));
}

DISTRIBUTION_TEST_F(Std, RotatedPyramidsDistribution)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRotatedPyramidsDistribution());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("RotatedPyramidsDistribution", *sim, 2e-10));
}

DISTRIBUTION_TEST_F(Std, SpheresWithLimitsDistribution)
{
    std::unique_ptr<const MultiLayer> sample(
        ExemplarySamples::createSpheresWithLimitsDistribution());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("SpheresWithLimitsDistribution", *sim, 2e-10));
}

DISTRIBUTION_TEST_F(Std, ConesWithLimitsDistribution)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createConesWithLimitsDistribution());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("ConesWithLimitsDistribution", *sim, 2e-10));
}

DISTRIBUTION_TEST_F(Std, LinkedBoxDistribution)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createLinkedBoxDistribution());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("LinkedBoxDistribution", *sim, 2e-10));
}

TEST_F(Std, MultipleLayout)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMultipleLayout());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("MultipleLayout", *sim, 2e-10));
}

TEST_F(Std, ApproximationDA)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSizeDistributionDAModel());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("ApproximationDA", *sim, 2e-10));
}

TEST_F(Std, ApproximationLMA)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSizeDistributionLMAModel());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("ApproximationLMA", *sim, 2e-10));
}

TEST_F(Std, ApproximationSSCA)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSizeDistributionSSCAModel());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("ApproximationSSCA", *sim, 2e-10));
}

DISTRIBUTION_TEST_F(Std, CylindersInSSCA)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInSSCA());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("CylindersInSSCA", *sim, 2e-10));
}

TEST_F(Std, CosineRipple)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCosineRipple());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("CosineRipple", *sim, 2e-10));
}

TEST_F(Std, TriangularRipple)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createTriangularRipple());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("TriangularRipple", *sim, 2e-10));
}

TEST_F(Std, AsymRipple)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createAsymRipple());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("AsymRipple", *sim, 2e-10));
}

TEST_F(Std, MesoCrystal)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMesoCrystal());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("MesoCrystal", *sim, 2e-10));
}

TEST_F(Std, CustomMorphology)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCustomMorphology());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("CustomMorphology", *sim, 2e-10));
}

TEST_F(Std, TransformBox)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createTransformBox());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("TransformBox", *sim, 1e-10));
}

TEST_F(Std, MagneticParticleZeroField)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticParticleZeroField());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("MagneticParticleZeroField", *sim, 2e-10));
}

TEST_F(Std, RotatedCylinder)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createRotatedCylinders());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("RotatedCylinder", *sim, 1e-10));
}

TEST_F(Std, SlicedComposition)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSlicedComposition());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("SlicedComposition", *sim, 1e-10));
}

TEST_F(Std, MagneticSubstrateZeroField)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticSubstrateZeroField());
    auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PP");
    EXPECT_TRUE(run("MagneticSubstrateZeroField", *sim, 2e-10));
}

TEST_F(Std, MagneticRotation)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticRotation());
    auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PM");
    EXPECT_TRUE(run("MagneticRotationZPM", *sim, 2e-10));
}

TEST_F(Std, MagneticSpheres)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticSpheres());
    auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, "PM");
    EXPECT_TRUE(run("MagneticSpheres", *sim, 2e-10));
}

TEST_F(Std, MagneticCylinders)
{
    for (const auto polCase : {"PP", "MP", "PM", "MM"}) {
        std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticCylinders());
        auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, polCase);
        EXPECT_TRUE(run("MagneticCylinders" + polCase, *sim, 2e-10));
    }
}

TEST_F(Std, MagneticSpheresInMagLayer)
{
    for (const auto polCase : {"PP", "MP"}) {
        std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createMagneticLayer());
        auto sim = test::makeSimulation::MiniZPolarizedGISAS(*sample, polCase);
        EXPECT_TRUE(run("MagneticSpheresInMagLayer" + polCase, *sim, 2e-10));
    }
}

TEST_F(Std, BeamDivergence)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
    auto sim = test::makeSimulation::MiniGISASBeamDivergence(*sample);
    EXPECT_TRUE(run("BeamDivergence", *sim, 2e-10));
}

TEST_F(Std, DetectorResolution)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
    auto sim = test::makeSimulation::MiniGISASDetectorResolution(*sample);
    EXPECT_TRUE(run("DetectorResolution", *sim, 2e-10));
}

TEST_F(Std, SimulationWithMasks)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersAndPrisms());
    auto sim = test::makeSimulation::GISASWithMasks(*sample);
    EXPECT_TRUE(run("SimulationWithMasks", *sim, 1e-10));
}

TEST_F(Std, RectDetectorGeneric)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
    auto sim = test::makeSimulation::RectDetectorGeneric(*sample);
    EXPECT_TRUE(run("RectDetectorGeneric", *sim, 1e-10));
}

TEST_F(Std, RectDetectorPerpToSample)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
    auto sim = test::makeSimulation::RectDetectorPerpToSample(*sample);
    EXPECT_TRUE(run("RectDetectorPerpToSample", *sim, 1e-10));
}

TEST_F(Std, RectDetectorPerpToDirectBeam)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
    auto sim = test::makeSimulation::RectDetectorPerpToDirectBeam(*sample);
    EXPECT_TRUE(run("RectDetectorPerpToDirectBeam", *sim, 1e-10));
}

TEST_F(Std, RectDetectorPerpToReflectedBeam)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
    auto sim = test::makeSimulation::RectDetectorPerpToReflectedBeam(*sample);
    EXPECT_TRUE(run("RectDetectorPerpToReflectedBeam", *sim, 1e-10));
}

TEST_F(Std, RectDetectorPerpToReflectedBeamDpos)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersInBA());
    auto sim = test::makeSimulation::RectDetectorPerpToReflectedBeamDpos(*sample);
    EXPECT_TRUE(run("RectDetectorPerpToReflectedBeamDpos", *sim, 1e-10));
}

TEST_F(Std, LargeCylindersMonteCarlo)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createLargeCylindersInDWBA());
    auto sim = test::makeSimulation::MiniGISASMonteCarlo(*sample);
    EXPECT_TRUE(run("LargeCylindersMonteCarlo", *sim, 5e-1));
}

TEST_F(Std, SphericalDetWithRoi)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersAndPrisms());
    auto sim = test::makeSimulation::SphericalDetWithRoi(*sample);
    EXPECT_TRUE(run("SphericalDetWithRoi", *sim, 1e-10));
}

TEST_F(Std, RectDetWithRoi)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createCylindersAndPrisms());
    auto sim = test::makeSimulation::RectDetWithRoi(*sample);
    EXPECT_TRUE(run("RectDetWithRoi", *sim, 1e-10));
}

TEST_F(Std, BoxesWithSpecular)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createBoxesSquareLattice2D());
    auto sim = test::makeSimulation::MiniGISASSpecularPeak(*sample);
    EXPECT_TRUE(run("BoxesWithSpecular", *sim, 1e-10));
}

TEST_F(Std, ConstantBackground)
{
    auto sample = ExemplarySamples::createCylindersInBA();
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    sim->setBackground(ConstantBackground(1e3));
    EXPECT_TRUE(run("ConstantBackground", *sim, 1e-10));
}

TEST_F(Std, HomogeneousTiNiSample)
{
    auto sample = ExemplarySamples::createHomogeneousMultilayer();
    auto sim = test::makeSimulation::BasicSpecular(*sample, false);
    EXPECT_TRUE(run("HomogeneousTiNiSample", *sim, 1e-10));
}

TEST_F(Std, HomogeneousTiNiSampleWithAbsorption)
{
    auto sample = ExemplarySamples::createPlainMultiLayerBySLD();
    auto sim = test::makeSimulation::BasicSpecular(*sample, false);
    EXPECT_TRUE(run("HomogeneousTiNiSampleWithAbsorption", *sim, 1e-10));
}

TEST_F(Std, RoughnessInSpecular)
{
    auto sample = ExemplarySamples::createMultiLayerWithRoughness();
    auto sim = test::makeSimulation::BasicSpecular(*sample, false);
    EXPECT_TRUE(run("RoughnessInSpecular", *sim, 2e-9));
}

TEST_F(Std, GaussianBeamFootprint)
{
    auto sample = ExemplarySamples::createHomogeneousMultilayer();
    auto sim = test::makeSimulation::SpecularWithGaussianBeam(*sample);
    EXPECT_TRUE(run("GaussianBeamFootprint", *sim, 1e-10));
}

TEST_F(Std, SquareBeamFootprint)
{
    auto sample = ExemplarySamples::createHomogeneousMultilayer();
    auto sim = test::makeSimulation::SpecularWithSquareBeam(*sample);
    EXPECT_TRUE(run("SquareBeamFootprint", *sim, 1e-10));
}

TEST_F(Std, SpecularDivergentBeam)
{
    auto sample = ExemplarySamples::createHomogeneousMultilayer();
    auto sim = test::makeSimulation::SpecularDivergentBeam(*sample);
    EXPECT_TRUE(run("SpecularDivergentBeam", *sim, 1e-10));
}

//  ************************************************************************************************
//  TODO: broken under GUI
//  ************************************************************************************************

#ifndef GUI_STD_TEST

TEST_F(Std, RelativeResolutionTOF)
{
    auto sample = ExemplarySamples::createPlainMultiLayerBySLD();
    auto sim = test::makeSimulation::TOFRWithRelativeResolution(*sample);
    EXPECT_TRUE(run("RelativeResolutionTOF", *sim, 1e-10));
}

#endif // GUI_STD_TEST

//  ************************************************************************************************
//  TODO: broken under Python
//  ************************************************************************************************

#ifndef PYTHON_STD_TEST

TEST_F(Std, OffSpecularResonator)
{
    auto sample = ExemplarySamples::createResonator();
    auto sim = test::makeSimulation::MiniOffSpecular(*sample);
    EXPECT_TRUE(run("OffSpecularResonator", *sim, 1e-10));
}

TEST_F(Std, FormFactorsWithAbsorption)
{
    for (const std::string& ffname : FormFactorComponents().keys()) {
        const IFormFactor* ff = FormFactorComponents().getItem(ffname)->clone();
        ASSERT(ff);
        std::unique_ptr<const MultiLayer> sample(
            ExemplarySamples::createLayersWithAbsorptionWithFF(ff));
        ASSERT(sample);
        auto sim = test::makeSimulation::MiniGISAS_v2(*sample);
        EXPECT_TRUE(run("FormFactorsWithAbsorption_" + ff->shapeName(), *sim, 2e-10));
    }
}
#endif // PYTHON_STD_TEST

//  ************************************************************************************************
//  TODO: broken under GUI and Python
//  ************************************************************************************************

#ifndef PYTHON_STD_TEST
#ifndef GUI_STD_TEST

TEST_F(Std, NCRoughnessInSpecular)
{
    auto sample = ExemplarySamples::createMultiLayerWithNCRoughness();
    auto sim = test::makeSimulation::BasicSpecular(*sample, false);
    EXPECT_TRUE(run("NCRoughnessInSpecular", *sim, 2e-9));
}

TEST_F(Std, SuperLattice)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSuperLattice());
    auto sim = test::makeSimulation::MiniGISAS(*sample);
    EXPECT_TRUE(run("SuperLattice", *sim, 2e-10));
}

TEST_F(Std, SpecularWithSlicing1)
{
    // data almost fully agree with SpecularWithSlicing2, as verified by ConsistenceTest
    auto sample = ExemplarySamples::createSlicedCylinders();
    auto sim = test::makeSimulation::BasicSpecular(*sample, false);
    EXPECT_TRUE(run("SpecularWithSlicing1", *sim, 1e-10));
}

TEST_F(Std, SpecularWithSlicing2)
{
    auto sample = ExemplarySamples::createSLDSlicedCylinders();
    auto sim = test::makeSimulation::BasicSpecular(*sample, false);
    EXPECT_TRUE(run("SpecularWithSlicing2", *sim, 1e-10));
    auto simQ = test::makeSimulation::BasicSpecular(*sample, true);
    EXPECT_TRUE(run("SpecularWithSlicing2Q", *simQ, 1e-10));
}

TEST_F(Std, SpecularWithSlicing3)
{
    // data fully agree with SpecularWithSlicing2, as verified by ConsistenceTest
    auto sample = ExemplarySamples::createAveragedSlicedCylinders();
    auto sim = test::makeSimulation::BasicSpecular(*sample, false);
    EXPECT_TRUE(run("SpecularWithSlicing3", *sim, 1e-10));
}

TEST_F(Std, InstrumentDefinitionComparison)
{
    auto sample = ExemplarySamples::createPlainMultiLayerBySLD();
    auto sim = test::makeSimulation::BasicSpecular(*sample, false);
    EXPECT_TRUE(run("InstrumentDefinitionComparison_0", *sim, 1e-10));
    auto simQ = test::makeSimulation::BasicSpecular(*sample, true);
    EXPECT_TRUE(run("InstrumentDefinitionComparison_Q", *simQ, 1e-10));
}

TEST_F(Std, TOFResolutionComparison)
{
    auto sample = ExemplarySamples::createPlainMultiLayerBySLD();
    auto sim1 = test::makeSimulation::TOFRWithRelativeResolution(*sample);
    EXPECT_TRUE(run("TOFResolutionComparison_TR", *sim1, 1e-10));
    auto sim2 = test::makeSimulation::TOFRWithPointwiseResolution(*sample);
    EXPECT_TRUE(run("TOFResolutionComparison_TP", *sim2, 1e-10));
}

TEST_F(Std, BasicSpecular)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSimpleMagneticLayer());
    for (const auto polCase : {"PP", "MM"}) {
        auto sim = test::makeSimulation::BasicYPolarizedSpecular(*sample, polCase, false);
        EXPECT_TRUE(run("BasicSpecular" + polCase, *sim, 1e-10));
    }
}

TEST_F(Std, PolarizedQAngleReflectivity)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createSimpleMagneticLayer());
    for (const auto polKey : {"PP", "MM"}) {
        auto sim = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
        EXPECT_TRUE(run("PolarizedQAngleReflectivity" + polKey + "_Q", *sim, 1e-10));
    }
}

TEST_F(Std, MagneticRotationReflectivity)
{
    for (const auto roughnessKey : {"Flat", "Tanh", "NevotCroce"}) {
        std::unique_ptr<const MultiLayer> sample(
            ExemplarySamples::createSimpleMagneticRotationWithRoughness(roughnessKey));
        for (const auto polKey : {"PP", "PM", "MP", "MM"}) {
            auto sim = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
            EXPECT_TRUE(
                run("MagneticRotationReflectivity" + polKey + "_" + roughnessKey, *sim, 1e-10));
        }
    }
}

TEST_F(Std, PolarizedFeNiBilayer)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createFeNiBilayer());
    for (const auto polKey : {"PP", "MM"}) {
        auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
        EXPECT_TRUE(run("PolarizedFeNiBilayer" + polKey, *sim1, 1e-7));
        auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
        EXPECT_TRUE(run("PolarizedFeNiBilayer" + polKey + "_Q", *sim2, 1e-7));
    }
}

TEST_F(Std, PolarizedFeNiBilayerTanh)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createFeNiBilayerTanh());
    for (const auto polKey : {"PP", "MM"}) {
        auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
        EXPECT_TRUE(run("PolarizedFeNiBilayerTanh" + polKey, *sim1, 1e-7));
        auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
        EXPECT_TRUE(run("PolarizedFeNiBilayerTanh" + polKey + "_Q", *sim2, 1e-7));
    }
}

TEST_F(Std, PolarizedFeNiBilayerNC)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createFeNiBilayerNC());
    for (const auto polKey : {"PP", "MM"}) {
        auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
        EXPECT_TRUE(run("PolarizedFeNiBilayerNC" + polKey, *sim1, 1e-7));
        auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
        EXPECT_TRUE(run("PolarizedFeNiBilayerNC" + polKey + "_Q", *sim2, 1e-7));
    }
}

TEST_F(Std, PolarizedFeNiBilayerSpinFlip)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createFeNiBilayerSpinFlip());
    for (const auto polKey : {"PP", "PM", "MP", "MM"}) {
        auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlip" + polKey, *sim1, 1e-7));
        auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlip" + polKey + "_Q", *sim2, 1e-7));
    }
}

TEST_F(Std, PolarizedFeNiBilayerSpinFlipTanh)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createFeNiBilayerSpinFlipTanh());
    for (const auto polKey : {"PP", "PM", "MP", "MM"}) {
        auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanh" + polKey, *sim1, 1e-7));
        auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipTanh" + polKey + "_Q", *sim2, 1e-7));
    }
}

TEST_F(Std, PolarizedFeNiBilayerSpinFlipNC)
{
    std::unique_ptr<const MultiLayer> sample(ExemplarySamples::createFeNiBilayerSpinFlipNC());
    for (const auto polKey : {"PP", "PM", "MP", "MM"}) {
        auto sim1 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, false);
        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNC" + polKey, *sim1, 1e-7));
        auto sim2 = test::makeSimulation::BasicYPolarizedSpecular(*sample, polKey, true);
        EXPECT_TRUE(run("PolarizedFeNiBilayerSpinFlipNC" + polKey + "_Q", *sim2, 1e-7));
    }
}

TEST_F(Std, DepthProbeTest)
{
    auto sample = ExemplarySamples::createHomogeneousMultilayer();
    auto sim = test::makeSimulation::BasicDepthProbe(*sample);
    EXPECT_TRUE(run("DepthProbeTest", *sim, 1e-10));
}

#endif // GUI_STD_TEST
#endif // PYTHON_STD_TEST

#endif // BORNAGAIN_TESTS_FUNCTIONAL_STD_STANDARDTESTS_H