introduce some basic tests of ratequery

Author: mabruzzo

tests/unit/CMakeLists.txt

@@ -67,11 +67,12 @@ add_executable(runVisitorTests test_visitor.cpp)
 target_link_libraries(runVisitorTests testdeps)
 gtest_discover_tests(runVisitorTests)
 
-# one might argue that the following is more of an integration or end-to-end
-# test than a unit-test
-add_executable(runGhostZoneTests test_ghost_zone.cpp)
-target_link_libraries(runGhostZoneTests grtest_utils testdeps)
-gtest_discover_tests(runGhostZoneTests)
+# tests of the API functions
+# -> one might argue that these are better classified as integration or
+#    end-to-end tests than as unit-test
+add_executable(runApiTests test_ghost_zone.cpp test_api_ratequery.cpp)
+target_link_libraries(runApiTests grtest_utils testdeps)
+gtest_discover_tests(runApiTests)
 
 # this target tests that the members of the chemistry_data struct can be
 # accessed through the "dynamic api." The test cases in this target are

tests/unit/grtest_api_fixture.hpp

@@ -23,6 +23,7 @@
 #include <ostream>
 #include <string>
 
+#include "grtest_utils.hpp"
 #include "grackle.h"
 
 namespace grtest {
@@ -42,6 +43,7 @@ enum class ChemPreset {
   primchem1,
   primchem2,
   primchem3,
+  primchem4_dustspecies3
 };
 
 inline std::string to_string(const ChemPreset& preset) {
@@ -56,6 +58,8 @@ inline std::string to_string(const ChemPreset& preset) {
       return "pc=2";
     case ChemPreset::primchem3:
       return "pc=3";
+    case ChemPreset::primchem4_dustspecies3:
+      return "pc=3-dust_species=4";
   }
 }
 
@@ -98,6 +102,14 @@ inline InitStatus setup_chemistry_data_from_preset(chemistry_data* my_chem,
       my_chem->dust_chemistry = 1;
       return InitStatus::success;
     }
+    case ChemPreset::primchem4_dustspecies3: {
+      my_chem->primordial_chemistry = 4;
+      my_chem->dust_chemistry = 1;
+      my_chem->metal_chemistry = 1;
+      my_chem->dust_species = 1;
+      my_chem->use_dust_density_field = 1;
+      return InitStatus::success;
+    }
   }
 }
 
@@ -195,9 +207,11 @@ class GrackleCtxPack {
   bool is_initialized() const { return this->my_chemistry_ != nullptr; }
 
   // getter functions
-  const code_units& initial_units() const { return this->initial_units_; }
-  chemistry_data* my_chemistry() { return this->my_chemistry_.get(); }
-  chemistry_data_storage* my_rates() { return this->my_rates_.get(); }
+  const code_units& initial_units() const { return initial_units_; }
+  chemistry_data* my_chemistry() { return my_chemistry_.get(); }
+  const chemistry_data* my_chemistry() const { return my_chemistry_.get(); }
+  chemistry_data_storage* my_rates() { return my_rates_.get(); }
+  const chemistry_data_storage* my_rates() const { return my_rates_.get(); }
 
   /// create an initialized instance from a preset
   static GrackleCtxPack create(const FullConfPreset& preset,
@@ -231,25 +245,62 @@ class GrackleCtxPack {
   }
 };
 
-/// defines a parameterized test-fixture that can used to run a parametrized
+/// test-fixture that can used to run one or more tests with a chemsitry data
+/// configuration intialized from a given chemistry presets.
+///
+/// This sets up a GrackleCtxPack (where the contents are configured with
+/// appropriate presets) and deallocates that memory at the end of the test.
+///
+/// How To Use
+/// ==========
+/// To make use of this fixture in a test-suite called `MyFeatureTest`, you
+/// need to either:
+/// 1. make a type alias (via `using` or `typedef`), named `MyFeatureTest`, of
+///    the relevant instantiation of this class template, OR
+/// 2. make a subclass, named `MyFeatureTest`, of the relevant instantiation of
+///    this class template
+template <ChemPreset chem_preset, InitialUnitPreset unit_preset>
+class ConfigPresetFixture : public testing::Test {
+protected:
+  void SetUp() override {
+    // called immediately after the constructor (but before the test-case)
+
+    grtest::InitStatus status;
+    pack = GrackleCtxPack::create(FullConfPreset{chem_preset, unit_preset},
+                                  &status);
+    if (!pack.is_initialized()) {
+      if (status == InitStatus::datafile_notfound) {
+        GTEST_SKIP() << "something went wrong with finding the data file";
+      } else {
+        FAIL() << "Error in initialize_chemistry_data.";
+      }
+    }
+  }
+
+  GrackleCtxPack pack;
+};
+
+/// defines a parameterized test-fixture that can be used to run a parametrized
 /// set of tests that are initialized with different chemistry data presets.
 ///
 /// This sets up a GrackleCtxPack (where the contents are configured with
 /// appropriate presets) and deallocates that memory at the end of the test.
 ///
 /// How To Use
 /// ==========
-/// To make use of this, you might create a subclass of this type that is named
-/// for the test suite. I don't love this strategy, but it seems to be the
-/// standard way to do things. We can revisit this in the future.
+/// To make use of this fixture in a test-suite called `MyFeatureTest`, you
+/// need to either:
+/// 1. make a type alias (via `using` or `typedef`), named `MyFeatureTest`, of
+///    this class, OR
+/// 2. make a subclass, named `MyFeatureTest`, of this class
 class ParametrizedConfigPresetFixture
     : public testing::TestWithParam<FullConfPreset> {
 protected:
   void SetUp() override {
     // called immediately after the constructor (but before the test-case)
     grtest::InitStatus status;
-    pack_ = GrackleCtxPack::create(GetParam(), &status);
-    if (!pack_.is_initialized()) {
+    pack = GrackleCtxPack::create(GetParam(), &status);
+    if (!pack.is_initialized()) {
       if (status == InitStatus::datafile_notfound) {
         GTEST_SKIP() << "something went wrong with finding the data file";
       } else {
@@ -258,7 +309,7 @@ class ParametrizedConfigPresetFixture
     }
   }
 
-  GrackleCtxPack pack_;
+  GrackleCtxPack pack;
 };
 
 }  // namespace grtest

tests/unit/test_api_ratequery.cpp

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// See the LICENSE file for license and copyright information
+// SPDX-License-Identifier: NCSA AND BSD-3-Clause
+//
+//===----------------------------------------------------------------------===//
+///
+/// @file
+/// Define some basic tests of the experimental ratequery API
+///
+//===----------------------------------------------------------------------===//
+
+#include <limits>
+#include <gtest/gtest.h>
+#include "grtest_api_fixture.hpp"
+
+#include "grackle.h"
+
+/// returns the rateid used to denote invalid rate names
+grunstable_rateid_type get_invalid_rateid(const grtest::GrackleCtxPack& pack) {
+  // although we don't use pack, yet a forthcoming refactor requires it
+  return grunstable_ratequery_id(nullptr);
+}
+
+using SimpleRateQueryTest =
+    grtest::ConfigPresetFixture<grtest::ChemPreset::primchem4_dustspecies3,
+                                grtest::InitialUnitPreset::simple_z0>;
+
+TEST_F(SimpleRateQueryTest, InvalidIthRate) {
+  const char* name = grunstable_ith_rate(
+      std::numeric_limits<unsigned long long>::max(), nullptr);
+  EXPECT_EQ(name, nullptr);
+}
+
+TEST_F(SimpleRateQueryTest, EmptyNameQuery) {
+  grunstable_rateid_type rateid = grunstable_ratequery_id("");
+  EXPECT_EQ(rateid, get_invalid_rateid(pack));
+}
+
+TEST_F(SimpleRateQueryTest, InvalidNameQuery) {
+  grunstable_rateid_type rateid = grunstable_ratequery_id("NotAValidName");
+  EXPECT_EQ(rateid, get_invalid_rateid(pack));
+}
+
+TEST_F(SimpleRateQueryTest, PtrInvalidRateId) {
+  double* ptr =
+      grunstable_ratequery_get_ptr(pack.my_rates(), get_invalid_rateid(pack));
+  EXPECT_EQ(ptr, nullptr);
+}

tests/unit/test_ghost_zone.cpp

@@ -249,16 +249,14 @@ bool equal_ghost_values(val_vec_map_t& ref, val_vec_map_t& actual,
   return true;
 }
 
-class APIGhostZoneTest: public grtest::ParametrizedConfigPresetFixture
-{};
+using APIGhostZoneTest = grtest::ParametrizedConfigPresetFixture;
 
 TEST_P(APIGhostZoneTest, GridZoneStartEnd) {
 
   grid_props my_grid_props = {{5,6,7}, {1,0,2}};
 
-  // alias the pack_ attribute tracked by the fixture
-  grtest::GrackleCtxPack& pack = pack_;
-  code_units my_units = pack_.initial_units();
+  // the pack attribute holds grtest::GrackleCtxPack
+  code_units my_units = pack.initial_units();
 
   // initialize pseudo random number generator
   std::uint32_t seed = 1379069008;