TestBinningCmd.cpp

Go to the documentation of this file.

 
#include <gtest/gtest.h>
 
#include "Ippl.h"
 
#include "Attributes/Attributes.h"
#include "Structure/BinningCmd.h"
#include "Utilities/OpalException.h"
 
#include <memory>
#include <string>
 
// Test-only helper exposing minimal setters for internal attributes.
class TestableBinningCmd : public BinningCmd {
public:
    void setMaxBins(int value) {
        Attributes::setReal(itsAttr[BINNING::MAXBINS], static_cast<double>(value));
    }
 
    void setDesiredWidth(double value) {
        Attributes::setReal(itsAttr[BINNING::DESIREDWIDTH], value);
    }
 
    void setBinningAlpha(double value) {
        Attributes::setReal(itsAttr[BINNING::BINNINGALPHA], value);
    }
 
    void setBinningBeta(double value) { Attributes::setReal(itsAttr[BINNING::BINNINGBETA], value); }
 
    void setAdaptiveBinning(bool value) {
        Attributes::setBool(itsAttr[BINNING::ADAPTIVEBINNING], value);
    }
 
    void setParameterString(const std::string& value) {
        // PARAMETER is declared as a predefined string; this helper mirrors normal usage.
        Attributes::setPredefinedString(itsAttr[BINNING::PARAMETER], value);
    }
 
    void setDumpBinsFile(const std::string& value) {
        Attributes::setString(itsAttr[BINNING::DUMPBINSFILE], value);
    }
 
    void setDumpBinsFreq(double value) {
        Attributes::setReal(itsAttr[BINNING::DUMPBINSFREQ], value);
    }
 
    void setTablePrintFrequency(double value) {
        Attributes::setReal(itsAttr[BINNING::TABLEPRINTFREQ], value);
    }
};
 
class BinningCmdTest : public ::testing::Test {
protected:
    static void SetUpTestSuite() {
        int argc    = 0;
        char** argv = nullptr;
        ippl::initialize(argc, argv);
    }
 
    static void TearDownTestSuite() { ippl::finalize(); }
};
 
// UpdateAppendsJsonExtensionAndValidatesFreq:
// If DUMPBINSFILE is set without .json, update() appends the extension and
// enforces a valid DUMPBINSFREQ.
TEST_F(BinningCmdTest, UpdateAppendsJsonExtensionAndValidatesFreq) {
    TestableBinningCmd cmd;
 
    // Enable dumping with a filename missing the .json suffix.
    cmd.setDumpBinsFile("bins_output");
    cmd.setDumpBinsFreq(5.0);
 
    cmd.update();
 
    EXPECT_TRUE(cmd.dumpBinsToFile());
    EXPECT_EQ(cmd.getDumpBinsFileName(), "bins_output.json");
    EXPECT_EQ(cmd.getDumpBinsFrequency(), 5);
}
 
// DumpBinsToFileRespectsNoneAndEmpty:
// dumpBinsToFile() should be false for "NONE" or empty, true otherwise.
TEST_F(BinningCmdTest, DumpBinsToFileRespectsNoneAndEmpty) {
    TestableBinningCmd cmd;
 
    // Default is "NONE".
    EXPECT_FALSE(cmd.dumpBinsToFile());
 
    cmd.setDumpBinsFile("");
    EXPECT_FALSE(cmd.dumpBinsToFile());
 
    cmd.setDumpBinsFile("bins.json");
    EXPECT_TRUE(cmd.dumpBinsToFile());
}
 
// InvalidDumpFreqThrowsWhenDumpingEnabled:
// A non-positive DUMPBINSFREQ with an active DUMPBINSFILE must raise.
TEST_F(BinningCmdTest, InvalidDumpFreqThrowsWhenDumpingEnabled) {
    TestableBinningCmd cmd;
 
    cmd.setDumpBinsFile("bins.json");
    cmd.setDumpBinsFreq(0.0);
 
    EXPECT_THROW(cmd.update(), OpalException);
}
 
// InvalidTablePrintFrequencyThrowsWhenNegative:
// Negative TABLEPRINTFREQ values are rejected by update().
TEST_F(BinningCmdTest, InvalidTablePrintFrequencyThrowsWhenNegative) {
    TestableBinningCmd cmd;
 
    cmd.setTablePrintFrequency(-1.0);
    EXPECT_THROW(cmd.update(), OpalException);
}
 
// ConstructionDefaults:
// Verify that a freshly constructed exemplar has the documented defaults.
TEST_F(BinningCmdTest, ConstructionDefaults) {
    BinningCmd cmd;
 
    EXPECT_EQ(cmd.getMaxBins(), 128);
    EXPECT_DOUBLE_EQ(cmd.getDesiredWidth(), 0.1);
    EXPECT_DOUBLE_EQ(cmd.getBinningAlpha(), 1.0);
    EXPECT_DOUBLE_EQ(cmd.getBinningBeta(), 1.5);
    EXPECT_TRUE(cmd.getAdaptiveBinning());
 
    EXPECT_EQ(cmd.getParameter(), "VELOCITYZ");
    EXPECT_EQ(cmd.getParameterType(), BinningParameter::VELOCITYZ);
 
    EXPECT_EQ(cmd.getTablePrintFrequency(), 10);
}
 
// GettersReflectAttributes:
// Changing the underlying attributes via the helper should be reflected by the getters.
TEST_F(BinningCmdTest, GettersReflectAttributes) {
    TestableBinningCmd cmd;
 
    cmd.setMaxBins(42);
    cmd.setDesiredWidth(0.25);
    cmd.setBinningAlpha(0.5);
    cmd.setBinningBeta(1.75);
    cmd.setAdaptiveBinning(false);
    cmd.setParameterString("PZ");
    cmd.setTablePrintFrequency(3.0);
 
    // update() refreshes the internal cached parameter string.
    cmd.update();
 
    EXPECT_EQ(cmd.getMaxBins(), 42);
    EXPECT_DOUBLE_EQ(cmd.getDesiredWidth(), 0.25);
    EXPECT_DOUBLE_EQ(cmd.getBinningAlpha(), 0.5);
    EXPECT_DOUBLE_EQ(cmd.getBinningBeta(), 1.75);
    EXPECT_FALSE(cmd.getAdaptiveBinning());
 
    EXPECT_EQ(cmd.getParameter(), "PZ");
 
    EXPECT_EQ(cmd.getTablePrintFrequency(), 3);
}
 
// ExecuteMapsKnownParameters:
// For each supported PARAMETER option, execute() should set the correct enum.
TEST_F(BinningCmdTest, ExecuteMapsKnownParameters) {
    struct Case {
        const char* name;
        BinningParameter expected;
    } cases[] = {
            {"VELOCITYZ", BinningParameter::VELOCITYZ},
            {"POSITIONZ", BinningParameter::POSITIONZ},
            {"PZ", BinningParameter::PZ},
            {"GAMMAZ", BinningParameter::GAMMAZ}};
 
    for (const auto& c : cases) {
        TestableBinningCmd cmd;
        cmd.setParameterString(c.name);
 
        // execute() calls setParameterType() and then update().
        cmd.execute();
 
        EXPECT_EQ(cmd.getParameter(), std::string(c.name));
        EXPECT_EQ(cmd.getParameterType(), c.expected);
    }
}
 
// ExecuteThrowsOnUnknownParameter:
// An unsupported PARAMETER string should surface as an OpalException
// when setParameterType() (via execute()) cannot map it.
TEST_F(BinningCmdTest, ExecuteThrowsOnUnknownParameter) {
    TestableBinningCmd cmd;
 
    // This value is not present in the BinningParameter mapping table.
    cmd.setParameterString("FOO");
 
    EXPECT_THROW(cmd.execute(), OpalException);
}
 
// CloneCopiesState:
// clone(name) should copy attribute state and cached parameter type/name.
TEST_F(BinningCmdTest, CloneCopiesState) {
    TestableBinningCmd original;
    original.setMaxBins(7);
    original.setDesiredWidth(0.3);
    original.setBinningAlpha(0.8);
    original.setBinningBeta(1.2);
    original.setAdaptiveBinning(false);
    original.setParameterString("POSITIONZ");
 
    original.execute();  // ensure parameterType_m is updated
 
    std::unique_ptr<BinningCmd> copy(original.clone("BINNING_COPY"));
 
    ASSERT_NE(copy, nullptr);
    EXPECT_EQ(copy->getOpalName(), "BINNING_COPY");
 
    EXPECT_EQ(copy->getMaxBins(), original.getMaxBins());
    EXPECT_DOUBLE_EQ(copy->getDesiredWidth(), original.getDesiredWidth());
    EXPECT_DOUBLE_EQ(copy->getBinningAlpha(), original.getBinningAlpha());
    EXPECT_DOUBLE_EQ(copy->getBinningBeta(), original.getBinningBeta());
    EXPECT_EQ(copy->getAdaptiveBinning(), original.getAdaptiveBinning());
 
    EXPECT_EQ(copy->getParameter(), original.getParameter());
    EXPECT_EQ(copy->getParameterType(), original.getParameterType());
}
 
// PrintInfoDoesNotThrow:
// Smoke test that printInfo can be called without throwing.
TEST_F(BinningCmdTest, PrintInfoDoesNotThrow) {
    BinningCmd cmd;
 
    // Inform is defined in Ippl; using a simple instance here is sufficient
    // to exercise the printing path.
    Inform os("BinningCmd::printInfo");
 
    EXPECT_NO_THROW({ cmd.printInfo(os); });
}