tboudreaux/SERiF
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(serif): updated tests to reflect new serif namespaces

Browse Source
This commit is contained in:
Emily Boudreaux
2025-06-11 14:49:26 -04:00
parent 6e4ff1ece9
commit aae590399c
13 changed files with 99 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
tests/composition/compositionTest.cpp
View File

@@ -25,13 +25,13 @@ TEST_F(compositionTest, isotopeMasses) {
}
TEST_F(compositionTest, constructor) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
EXPECT_NO_THROW(composition::Composition comp);
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
EXPECT_NO_THROW(serif::composition::Composition comp);
}
TEST_F(compositionTest, registerSymbol) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp;
EXPECT_NO_THROW(comp.registerSymbol("H-1"));
EXPECT_NO_THROW(comp.registerSymbol("He-4"));
EXPECT_THROW(comp.registerSymbol("H-19"), std::runtime_error);
@@ -45,8 +45,8 @@ TEST_F(compositionTest, registerSymbol) {
}
TEST_F(compositionTest, setGetComposition) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp;
comp.registerSymbol("H-1");
comp.registerSymbol("He-4");
@@ -71,8 +71,8 @@ TEST_F(compositionTest, setGetComposition) {
}
TEST_F(compositionTest, setGetNumberFraction) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp;
comp.registerSymbol("H-1", false);
comp.registerSymbol("He-4", false);
@@ -88,8 +88,8 @@ TEST_F(compositionTest, setGetNumberFraction) {
}
TEST_F(compositionTest, subset) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp;
comp.registerSymbol("H-1");
comp.registerSymbol("He-4");
comp.setMassFraction("H-1", 0.6);
@@ -97,14 +97,14 @@ TEST_F(compositionTest, subset) {
EXPECT_NO_THROW(comp.finalize());
std::vector<std::string> symbols = {"H-1"};
composition::Composition subsetComp = comp.subset(symbols, "norm");
serif::composition::Composition subsetComp = comp.subset(symbols, "norm");
EXPECT_TRUE(subsetComp.finalize());
EXPECT_DOUBLE_EQ(subsetComp.getMassFraction("H-1"), 1.0);
}
TEST_F(compositionTest, finalizeWithNormalization) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp;
comp.registerSymbol("H-1");
comp.registerSymbol("He-4");
comp.setMassFraction("H-1", 0.3);
@@ -115,8 +115,8 @@ TEST_F(compositionTest, finalizeWithNormalization) {
}
TEST_F(compositionTest, finalizeWithoutNormalization) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp;
comp.registerSymbol("H-1");
comp.registerSymbol("He-4");
comp.setMassFraction("H-1", 0.5);
@@ -127,8 +127,8 @@ TEST_F(compositionTest, finalizeWithoutNormalization) {
}
TEST_F(compositionTest, getComposition) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp;
comp.registerSymbol("H-1");
comp.registerSymbol("He-4");
comp.setMassFraction("H-1", 0.6);
@@ -142,8 +142,8 @@ TEST_F(compositionTest, getComposition) {
}
TEST_F(compositionTest, setCompositionMode) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp;
comp.registerSymbol("H-1");
comp.registerSymbol("He-4");
comp.setMassFraction("H-1", 0.6);
@@ -164,8 +164,8 @@ TEST_F(compositionTest, setCompositionMode) {
}
TEST_F(compositionTest, hasSymbol) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp;
comp.registerSymbol("H-1");
comp.registerSymbol("He-4");
comp.setMassFraction("H-1", 0.6);
@@ -179,27 +179,27 @@ TEST_F(compositionTest, hasSymbol) {
}
TEST_F(compositionTest, mix) {
Config::getInstance().loadConfig(EXAMPLE_FILENAME);
composition::Composition comp1;
serif::config::Config::getInstance().loadConfig(EXAMPLE_FILENAME);
serif::composition::Composition comp1;
comp1.registerSymbol("H-1");
comp1.registerSymbol("He-4");
comp1.setMassFraction("H-1", 0.6);
comp1.setMassFraction("He-4", 0.4);
EXPECT_NO_THROW(comp1.finalize());
composition::Composition comp2;
serif::composition::Composition comp2;
comp2.registerSymbol("H-1");
comp2.registerSymbol("He-4");
comp2.setMassFraction("H-1", 0.4);
comp2.setMassFraction("He-4", 0.6);
EXPECT_NO_THROW(comp2.finalize());
composition::Composition mixedComp = comp1 + comp2;
serif::composition::Composition mixedComp = comp1 + comp2;
EXPECT_TRUE(mixedComp.finalize());
EXPECT_DOUBLE_EQ(mixedComp.getMassFraction("H-1"), 0.5);
EXPECT_DOUBLE_EQ(mixedComp.getMassFraction("He-4"), 0.5);
composition::Composition mixedComp2 = comp1.mix(comp2, 0.25);
serif::composition::Composition mixedComp2 = comp1.mix(comp2, 0.25);
EXPECT_TRUE(mixedComp2.finalize());
EXPECT_DOUBLE_EQ(mixedComp2.getMassFraction("H-1"), 0.45);
EXPECT_DOUBLE_EQ(mixedComp2.getMassFraction("He-4"), 0.55);

8
tests/composition_sandbox/comp.cpp
View File

@@ -9,8 +9,8 @@ int main(int argv, char* argc[]) {
} else {
pathToConfigFile = "config.json";
}
Config::getInstance().loadConfig(pathToConfigFile);
composition::Composition comp;
serif::config::Config::getInstance().loadConfig(pathToConfigFile);
serif::composition::Composition comp;
std::vector<std::string> symbols = {"H-1", "He-4"};
comp.registerSymbol(symbols);
comp.setMassFraction("H-1", 0.7);
@@ -25,7 +25,7 @@ int main(int argv, char* argc[]) {
std::cout << "\tMass Frac Sum: " << comp.getMassFraction("H-1") + comp.getMassFraction("He-4") << std::endl;
std::cout << "\tNumber Frac Sum: " << comp.getNumberFraction("H-1") + comp.getNumberFraction("He-4") << std::endl;
composition::Composition comp2;
serif::composition::Composition comp2;
comp2.registerSymbol(symbols, false);
comp2.setNumberFraction("H-1", comp.getNumberFraction("H-1"));
comp2.setNumberFraction("He-4", comp.getNumberFraction("He-4"));
@@ -73,7 +73,7 @@ int main(int argv, char* argc[]) {
0.0004,
0.00006
};
composition::Composition comp3(symbols3, mass_fractions, true);
serif::composition::Composition comp3(symbols3, mass_fractions, true);
std::cout << "=== Mass Fraction Mode ===" << std::endl;
double massFracSum = 0.0;
double numberFracSum = 0.0;

30
tests/config/configTest.cpp
View File

@@ -15,23 +15,23 @@ std::string EXAMPLE_FILENAME = std::string(getenv("MESON_SOURCE_ROOT")) + "/test
class configTestPrivateAccessor {
public:
static bool callIsKeyInCache(Config& config, const std::string& key) {
static bool callIsKeyInCache(serif::config::Config& config, const std::string& key) {
return config.isKeyInCache(key);
}
static int callCacheSize(Config& config) {
static int callCacheSize(serif::config::Config& config) {
return config.configMap.size();
}
static void callAddToCache(Config& config, const std::string& key, const YAML::Node& node) {
static void callAddToCache(serif::config::Config& config, const std::string& key, const YAML::Node& node) {
config.addToCache(key, node);
}
static void callRegisterKeyNotFound(Config& config, const std::string& key) {
static void callRegisterKeyNotFound(serif::config::Config& config, const std::string& key) {
config.registerUnknownKey(key);
}
static bool CheckIfKeyUnknown(Config& config, const std::string& key) {
static bool CheckIfKeyUnknown(serif::config::Config& config, const std::string& key) {
if (std::find(config.unknownKeys.begin(), config.unknownKeys.end(), key) == config.unknownKeys.end()) {
return false;
}
@@ -48,22 +48,22 @@ class configTest : public ::testing::Test {};
* @brief Test the constructor of the Config class.
*/
TEST_F(configTest, constructor) {
EXPECT_NO_THROW(Config::getInstance());
EXPECT_NO_THROW(serif::config::Config::getInstance());
}
TEST_F(configTest, loadConfig) {
Config& config = Config::getInstance();
serif::config::Config& config = serif::config::Config::getInstance();
EXPECT_TRUE(config.loadConfig(EXAMPLE_FILENAME));
}
TEST_F(configTest, singletonTest) {
Config& config1 = Config::getInstance();
Config& config2 = Config::getInstance();
serif::config::Config& config1 = serif::config::Config::getInstance();
serif::config::Config& config2 = serif::config::Config::getInstance();
EXPECT_EQ(&config1, &config2);
}
TEST_F(configTest, getTest) {
Config& config = Config::getInstance();
serif::config::Config& config = serif::config::Config::getInstance();
config.loadConfig(EXAMPLE_FILENAME);
int maxIter = config.get<int>("opac:lowTemp:numeric:maxIter", 10);
EXPECT_EQ(maxIter, 100);
@@ -82,19 +82,19 @@ TEST_F(configTest, getTest) {
}
TEST_F(configTest, secondSingletonTest) {
Config& config = Config::getInstance();
serif::config::Config& config = serif::config::Config::getInstance();
EXPECT_EQ(config.get<int>("opac:lowTemp:numeric:maxIter", 10), 100);
}
TEST_F(configTest, isKeyInCacheTest) {
Config& config = Config::getInstance();
serif::config::Config& config = serif::config::Config::getInstance();
config.loadConfig(EXAMPLE_FILENAME);
EXPECT_TRUE(configTestPrivateAccessor::callIsKeyInCache(config, "opac:lowTemp:numeric:maxIter"));
EXPECT_FALSE(configTestPrivateAccessor::callIsKeyInCache(config, "opac:lowTemp:numeric:maxIter2"));
}
TEST_F(configTest, cacheSize) {
Config& config = Config::getInstance();
serif::config::Config& config = serif::config::Config::getInstance();
config.loadConfig(EXAMPLE_FILENAME);
EXPECT_EQ(configTestPrivateAccessor::callCacheSize(config), 3);
EXPECT_NE(configTestPrivateAccessor::callCacheSize(config), 4);
@@ -103,9 +103,9 @@ TEST_F(configTest, cacheSize) {
}
TEST_F(configTest, unknownKeyTest) {
Config& config = Config::getInstance();
serif::config::Config& config = serif::config::Config::getInstance();
config.loadConfig(EXAMPLE_FILENAME);
config.get<int>("opac:lowTemp:numeric:random", 10);
EXPECT_FALSE(configTestPrivateAccessor::CheckIfKeyUnknown(config, "opac:lowTemp:numeric:maxIter"));
EXPECT_TRUE(configTestPrivateAccessor::CheckIfKeyUnknown(config, "opac:lowTemp:numeric:random"));
}
}

16
tests/const/constTest.cpp
View File

@@ -17,7 +17,7 @@
class constTest : public ::testing::Test {
protected:
void SetUp() override {
Constants::getInstance();
serif::constant::Constants::getInstance();
}
};
@@ -25,7 +25,7 @@ protected:
* @test Verify default constructor initializes correctly.
*/
TEST_F(constTest, DefaultConstructor) {
EXPECT_NO_THROW(Constants::getInstance());
EXPECT_NO_THROW(serif::constant::Constants::getInstance());
}
/**
@@ -33,14 +33,14 @@ TEST_F(constTest, DefaultConstructor) {
*/
TEST_F(constTest, isLoaded) {
EXPECT_NO_THROW(Constants::getInstance().isLoaded());
EXPECT_NO_THROW(serif::constant::Constants::getInstance().isLoaded());
}
/**
* @test Verify get method returns the correct constant.
*/
TEST_F(constTest, GetMethod) {
Constants& obj = Constants::getInstance();
serif::constant::Constants& obj = serif::constant::Constants::getInstance();
EXPECT_DOUBLE_EQ(obj.get("c").value, 2.99792458e10);
EXPECT_EQ(obj.get("c").unit, "cm / s");
EXPECT_DOUBLE_EQ(obj.get("c").uncertainty, 0.0);
@@ -51,7 +51,7 @@ TEST_F(constTest, GetMethod) {
* @test Verify [] opperators returns the correct constant.
*/
TEST_F(constTest, SubscriptOperator) {
Constants& obj = Constants::getInstance();
serif::constant::Constants& obj = serif::constant::Constants::getInstance();
EXPECT_DOUBLE_EQ(obj["c"].value, 2.99792458e10);
EXPECT_EQ(obj["c"].unit, "cm / s");
EXPECT_DOUBLE_EQ(obj["c"].uncertainty, 0.0);
@@ -62,7 +62,7 @@ TEST_F(constTest, SubscriptOperator) {
* @test Verify that the has method returns the correct values
*/
TEST_F(constTest, HasMethod) {
Constants& obj = Constants::getInstance();
serif::constant::Constants& obj = serif::constant::Constants::getInstance();
EXPECT_TRUE(obj.has("c"));
EXPECT_FALSE(obj.has("c4"));
@@ -70,7 +70,7 @@ TEST_F(constTest, HasMethod) {
}
TEST_F(constTest, KeysMethod) {
Constants& obj = Constants::getInstance();
serif::constant::Constants& obj = serif::constant::Constants::getInstance();
std::set<std::string> checkKeys;
checkKeys.insert("c");
checkKeys.insert("wienK");
@@ -99,7 +99,7 @@ TEST_F(constTest, KeysMethod) {
}
TEST_F(constTest, StreamOperator) {
Constants& obj = Constants::getInstance();
serif::constant::Constants& obj = serif::constant::Constants::getInstance();
std::ostringstream os;
os << obj.get("c");

2
tests/const/meson.build
View File

@@ -12,7 +12,7 @@ foreach test_file : test_sources
exe_name,
test_file,
dependencies: [gtest_dep, const_dep, gtest_main],
include_directories: include_directories('../../src/const/public'),
include_directories: include_directories('../../src/constants/public'),
link_with: libconst, # Link the dobj library
install_rpath: '@loader_path/../../src' # Ensure runtime library path resolves correctly
)

19
tests/eos/eosTest.cpp
View File

@@ -25,22 +25,21 @@ std::string TEST_CONFIG = std::string(getenv("MESON_SOURCE_ROOT")) + "/tests/tes
*/
TEST_F(eosTest, read_helm_table) {
Config::getInstance().loadConfig(TEST_CONFIG);
ResourceManager& rm = ResourceManager::getInstance();
auto& eos = std::get<std::unique_ptr<EosIO>>(rm.getResource("eos:helm"));
serif::config::Config::getInstance().loadConfig(TEST_CONFIG);
serif::resource::ResourceManager& rm = serif::resource::ResourceManager::getInstance();
auto& eos = std::get<std::unique_ptr<serif::eos::EosIO>>(rm.getResource("eos:helm"));
auto& table = eos->getTable();
auto& helmTable = *std::get<std::unique_ptr<helmholtz::HELMTable>>(table);
auto& helmTable = *std::get<std::unique_ptr<serif::eos::helmholtz::HELMTable>>(table);
std::stringstream ss;
ss << helmTable;
EXPECT_EQ(ss.str(), "HELMTable Data:\n imax: 541, jmax: 201\n Temperature Range: [1000, 1e+13]\n Density Range: [1e-12, 1e+15]\n");
}
TEST_F(eosTest, get_helm_EOS) {
using namespace helmholtz;
const int nel=3;
double xmass[nel], aion[nel], zion[nel];
EOSInput eos1;
serif::eos::helmholtz::EOSInput eos1;
xmass[0] = 0.75; aion[0] = 1.0; zion[0] = 1.0;
xmass[1] = 0.23; aion[1] = 4.0; zion[1] = 2.0;
@@ -58,11 +57,11 @@ TEST_F(eosTest, get_helm_EOS) {
eos1.abar = 1.0/asum;
eos1.zbar = eos1.abar*zsum;
ResourceManager& rm = ResourceManager::getInstance();
auto& eos = std::get<std::unique_ptr<EosIO>>(rm.getResource("eos:helm"));
serif::resource::ResourceManager& rm = serif::resource::ResourceManager::getInstance();
auto& eos = std::get<std::unique_ptr<serif::eos::EosIO>>(rm.getResource("eos:helm"));
auto& table = eos->getTable();
auto& helmTable = *std::get<std::unique_ptr<helmholtz::HELMTable>>(table);
EOS helmEos = get_helm_EOS(eos1, helmTable);
auto& helmTable = *std::get<std::unique_ptr<serif::eos::helmholtz::HELMTable>>(table);
serif::eos::helmholtz::EOS helmEos = get_helm_EOS(eos1, helmTable);
const double absErr = 1e-12;

8
tests/meshIO/meshIOTest.cpp
View File

@@ -19,16 +19,16 @@ double ComputeMeshVolume(mfem::Mesh &mesh)
class meshIOTest : public ::testing::Test {};
TEST_F(meshIOTest, DefaultConstructor) {
EXPECT_NO_THROW(MeshIO meshIO(EXAMPLE_FILENAME));
EXPECT_NO_THROW(serif::mesh::MeshIO meshIO(EXAMPLE_FILENAME));
}
TEST_F(meshIOTest, IsLoaded) {
MeshIO meshIO(EXAMPLE_FILENAME);
serif::mesh::MeshIO meshIO(EXAMPLE_FILENAME);
EXPECT_EQ(meshIO.IsLoaded(), true);
}
TEST_F(meshIOTest, GetMesh) {
MeshIO meshIO(EXAMPLE_FILENAME);
serif::mesh::MeshIO meshIO(EXAMPLE_FILENAME);
mfem::Mesh& mesh = meshIO.GetMesh();
EXPECT_EQ(mesh.GetNE(), 18351);
EXPECT_EQ(mesh.GetNV(), 3768);
@@ -37,7 +37,7 @@ TEST_F(meshIOTest, GetMesh) {
}
TEST_F(meshIOTest, LinearRescale) {
MeshIO meshIO(EXAMPLE_FILENAME, 5);
serif::mesh::MeshIO meshIO(EXAMPLE_FILENAME, 5);
mfem::Mesh& mesh = meshIO.GetMesh();
double volume = ComputeMeshVolume(mesh);
EXPECT_DOUBLE_EQ(volume, 520.06455669116463);

2
tests/meson.build
View File

@@ -4,7 +4,6 @@ gtest_main = dependency('gtest_main', required: true)
gtest_nomain_dep = dependency('gtest', main: false, required : true)
# Subdirectories for unit and integration tests
subdir('dobj')
subdir('const')
subdir('meshIO')
subdir('probe')
@@ -16,6 +15,5 @@ subdir('composition')
subdir('poly')
# Subdirectories for sandbox tests
subdir('dobj_sandbox')
subdir('composition_sandbox')

16
tests/network/approx8Test.cpp
View File

@@ -14,13 +14,13 @@ class approx8Test : public ::testing::Test {};
* @brief Test the constructor of the Config class.
*/
TEST_F(approx8Test, constructor) {
Config& config = Config::getInstance();
serif::config::Config& config = serif::config::Config::getInstance();
config.loadConfig(TEST_CONFIG);
EXPECT_NO_THROW(nnApprox8::Approx8Network());
EXPECT_NO_THROW(serif::network::approx8::Approx8Network());
}
TEST_F(approx8Test, setStiff) {
nnApprox8::Approx8Network network;
serif::network::approx8::Approx8Network network;
EXPECT_NO_THROW(network.setStiff(true));
EXPECT_TRUE(network.isStiff());
EXPECT_NO_THROW(network.setStiff(false));
@@ -28,8 +28,8 @@ TEST_F(approx8Test, setStiff) {
}
TEST_F(approx8Test, evaluate) {
nnApprox8::Approx8Network network;
nuclearNetwork::NetIn netIn;
serif::network::approx8::Approx8Network network;
serif::network::NetIn netIn;
std::vector<double> comp = {0.708, 2.94e-5, 0.276, 0.003, 0.0011, 9.62e-3, 1.62e-3, 5.16e-4};
@@ -41,10 +41,10 @@ TEST_F(approx8Test, evaluate) {
netIn.tmax = 3.15e17;
netIn.dt0 = 1e12;
nuclearNetwork::NetOut netOut;
serif::network::NetOut netOut;
EXPECT_NO_THROW(netOut = network.evaluate(netIn));
EXPECT_DOUBLE_EQ(netOut.composition[nnApprox8::Net::ih1], 0.50166260916650918);
EXPECT_DOUBLE_EQ(netOut.composition[nnApprox8::Net::ihe4],0.48172270591286032);
EXPECT_DOUBLE_EQ(netOut.composition[serif::network::approx8::Net::ih1], 0.50166260916650918);
EXPECT_DOUBLE_EQ(netOut.composition[serif::network::approx8::Net::ihe4],0.48172270591286032);
EXPECT_DOUBLE_EQ(netOut.energy, 1.6433049870528356e+18);
}

6
tests/poly/polyTest.cpp
View File

@@ -33,9 +33,11 @@ std::string CONFIG_FILENAME = std::string(getenv("MESON_SOURCE_ROOT")) + "/tests
class polyTest : public ::testing::Test {};
TEST_F(polyTest, Solve) {
Config& config = Config::getInstance();
using namespace serif::polytrope;
serif::config::Config& config = serif::config::Config::getInstance();
config.loadConfig(CONFIG_FILENAME);
Probe::LogManager& logManager = Probe::LogManager::getInstance();
serif::probe::LogManager& logManager = serif::probe::LogManager::getInstance();
quill::Logger* logger = logManager.getLogger("log");

18
tests/probe/probeTest.cpp
View File

@@ -41,21 +41,21 @@ std::string stripTimestamps(const std::string& logLine) {
class probeTest : public ::testing::Test {};
TEST_F(probeTest, DefaultConstructorTest) {
Config::getInstance().loadConfig(TEST_CONFIG);
EXPECT_NO_THROW(Probe::LogManager::getInstance());
serif::config::Config::getInstance().loadConfig(TEST_CONFIG);
EXPECT_NO_THROW(serif::probe::LogManager::getInstance());
}
TEST_F(probeTest, waitTest) {
auto start = std::chrono::high_resolution_clock::now();
Probe::wait(1);
serif::probe::wait(1);
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = end - start;
EXPECT_LE(elapsed.count(), 1.1);
}
TEST_F(probeTest, getLoggerTest) {
Config::getInstance().loadConfig(TEST_CONFIG);
Probe::LogManager& logManager = Probe::LogManager::getInstance();
serif::config::Config::getInstance().loadConfig(TEST_CONFIG);
serif::probe::LogManager& logManager = serif::probe::LogManager::getInstance();
const std::string loggerName = "testLog";
const std::string filename = "test.log";
quill::Logger* logger = logManager.newFileLogger(filename, loggerName);
@@ -70,8 +70,8 @@ TEST_F(probeTest, getLoggerTest) {
}
TEST_F(probeTest, newFileLoggerTest) {
Config::getInstance().loadConfig(TEST_CONFIG);
Probe::LogManager& logManager = Probe::LogManager::getInstance();
serif::config::Config::getInstance().loadConfig(TEST_CONFIG);
serif::probe::LogManager& logManager = serif::probe::LogManager::getInstance();
const std::string loggerName = "newLog";
const std::string filename = "newLog.log";
quill::Logger* logger = logManager.newFileLogger(filename, loggerName);
@@ -86,8 +86,8 @@ TEST_F(probeTest, newFileLoggerTest) {
}
TEST_F(probeTest, getLoggerNames) {
Config::getInstance().loadConfig(TEST_CONFIG);
Probe::LogManager& logManager = Probe::LogManager::getInstance();
serif::config::Config::getInstance().loadConfig(TEST_CONFIG);
serif::probe::LogManager& logManager = serif::probe::LogManager::getInstance();
std::vector<std::string> loggerNames = logManager.getLoggerNames();
EXPECT_EQ(loggerNames.size(), 4);
EXPECT_EQ(loggerNames.at(0), "log");

2
tests/resource/meson.build
View File

@@ -11,7 +11,7 @@ foreach test_file : test_sources
test_exe = executable(
exe_name,
test_file,
dependencies: [gtest_dep, resourceManager_dep, gtest_main, macros_dep],
dependencies: [gtest_dep, resourceManager_dep, gtest_main, macros_dep, opatio_dep],
include_directories: include_directories('../../src/resource/public'),
install_rpath: '@loader_path/../../src' # Ensure runtime library path resolves correctly
)

20
tests/resource/resourceManagerTest.cpp
View File

@@ -28,13 +28,13 @@ class resourceManagerTest : public ::testing::Test {};
* @brief Test the constructor of the resourceManager class.
*/
TEST_F(resourceManagerTest, constructor) {
Config::getInstance().loadConfig(TEST_CONFIG);
EXPECT_NO_THROW(ResourceManager::getInstance());
serif::config::Config::getInstance().loadConfig(TEST_CONFIG);
EXPECT_NO_THROW(serif::resource::ResourceManager::getInstance());
}
TEST_F(resourceManagerTest, getAvaliableResources) {
Config::getInstance().loadConfig(TEST_CONFIG);
ResourceManager& rm = ResourceManager::getInstance();
serif::config::Config::getInstance().loadConfig(TEST_CONFIG);
serif::resource::ResourceManager& rm = serif::resource::ResourceManager::getInstance();
std::vector<std::string> resources = rm.getAvaliableResources();
std::set<std::string> expected = {"eos:helm", "mesh:sphere"};
std::set<std::string> actual(resources.begin(), resources.end());
@@ -42,17 +42,17 @@ TEST_F(resourceManagerTest, getAvaliableResources) {
}
TEST_F(resourceManagerTest, getResource) {
Config::getInstance().loadConfig(TEST_CONFIG);
ResourceManager& rm = ResourceManager::getInstance();
serif::config::Config::getInstance().loadConfig(TEST_CONFIG);
serif::resource::ResourceManager& rm = serif::resource::ResourceManager::getInstance();
std::string name = "eos:helm";
const Resource &r = rm.getResource(name);
const serif::resource::types::Resource &r = rm.getResource(name);
// BREAKPOINT();
const auto &eos = std::get<std::unique_ptr<EosIO>>(r);
const auto &eos = std::get<std::unique_ptr<serif::eos::EosIO>>(r);
EXPECT_EQ("helm", eos->getFormat());
EOSTable &table = eos->getTable();
serif::eos::EOSTable &table = eos->getTable();
// -- Extract the Helm table from the EOSTable
helmholtz::HELMTable &helmTable = *std::get<std::unique_ptr<helmholtz::HELMTable>>(table);
serif::eos::helmholtz::HELMTable &helmTable = *std::get<std::unique_ptr<serif::eos::helmholtz::HELMTable>>(table);
EXPECT_DOUBLE_EQ(helmTable.f[0][0], -1692098915534.8142);
EXPECT_THROW(rm.getResource("opac:GS98:high:doesNotExist"), std::runtime_error);