add tests for sina

src/axom/sina/tests/CMakeLists.txt

@@ -0,0 +1,68 @@
+# Copyright (c) 2017-2024, Lawrence Livermore National Security, LLC and
+# other Axom Project Developers. See the top-level LICENSE file for details.
+#
+# SPDX-License-Identifier: (BSD-3-Clause)
+#------------------------------------------------------------------------------
+# Sina unit tests
+#------------------------------------------------------------------------------
+
+#------------------------------------------------------------------------------
+# Specify list of tests
+#------------------------------------------------------------------------------
+
+set(gtest_sina_tests
+    src/sina_ConduitUtil.cpp
+    src/sina_CppBridge.cpp
+    src/sina_Curve.cpp
+    src/sina_CurveSet.cpp
+    src/sina_DataHolder.cpp
+    src/sina_Datum.cpp
+    src/sina_Document.cpp
+    src/sina_File.cpp
+    src/sina_ID.cpp
+    src/sina_Record.cpp
+    src/sina_Relationship.cpp
+    src/sina_Run.cpp
+   )
+
+# Define Sina test utility sources and headers
+set(sina_test_utils_sources
+    src/ConduitTestUtils.cpp
+    src/TestRecord.cpp
+)
+set(sina_test_utils_headers
+    include/ConduitTestUtils.hpp
+    include/TestRecord.hpp
+)
+
+# Define Sina test dependencies
+set(sina_gtests_depends_on sina gtest gmock conduit::conduit)
+
+# Add tests using Adiak if necessary and Adiak dependency
+blt_list_append( TO gtest_sina_tests ELEMENTS src/sina_AdiakWriter.cpp IF AXOM_SINA_USE_ADIAK)
+blt_list_append( TO sina_gtests_depends_on ELEMENTS adiak::adiak IF AXOM_SINA_USE_ADIAK )
+
+# Create a library for the test utilities so they can be used
+axom_add_library(
+    NAME       sina_test_utils
+    SOURCES    ${sina_test_utils_sources}
+    HEADERS    ${sina_test_utils_headers}
+    DEPENDS_ON ${sina_gtests_depends_on}
+    FOLDER     axom/sina/tests)
+
+#------------------------------------------------------------------------------
+# Add gtest C++ tests
+#------------------------------------------------------------------------------
+foreach(test ${gtest_sina_tests})
+    get_filename_component( test_name ${test} NAME_WE )
+    axom_add_executable(NAME ${test_name}_test
+                        SOURCES ${test}
+                        OUTPUT_DIR ${TEST_OUTPUT_DIRECTORY}
+                        DEPENDS_ON sina_test_utils
+                        FOLDER axom/sina/tests
+                        )
+
+    axom_add_test( NAME    ${test_name}
+                   COMMAND ${test_name}_test
+                   )
+endforeach()

src/axom/sina/tests/include/ConduitTestUtils.hpp

@@ -0,0 +1,39 @@
+#ifndef SINA_CONDUITTESTUTILS_HPP
+#define SINA_CONDUITTESTUTILS_HPP
+
+#include <string>
+
+#include "gmock/gmock.h"
+
+#include "conduit.hpp"
+
+namespace axom
+{
+namespace sina
+{
+namespace testing
+{
+
+/**
+ * Parse a JSON value.
+ *
+ * @param valueAsString the value as a string
+ * @return the value as a Conduit node
+ */
+conduit::Node parseJsonValue(std::string const &valueAsString);
+
+// A matcher which verifies that a given Conduit node produces the expected
+// JSON string
+MATCHER_P(MatchesJson, expectedJsonString, "") {
+    conduit::Node expected = parseJsonValue(expectedJsonString);
+    *result_listener << "Given node is " << arg.to_json_default();
+    conduit::Node diff;
+    bool differ = expected.diff(arg, diff);
+    return !differ;
+}
+
+}  // end testing namespace
+}  // end sina namespace
+}  // end axom namespace
+
+#endif //SINA_CONDUITTESTUTILS_HPP

src/axom/sina/tests/include/TestRecord.hpp

@@ -0,0 +1,81 @@
+#ifndef SINA_TESTRECORD_HPP
+#define SINA_TESTRECORD_HPP
+
+#include "axom/sina/include/ConduitUtil.hpp"
+#include "axom/sina/include/Record.hpp"
+
+namespace axom
+{
+namespace sina
+{
+namespace testing
+{
+
+char constexpr TEST_RECORD_VALUE_KEY[] = "testKey";
+
+/**
+ * A TestRecord is a class template that's a subclass of Record and simply
+ * stores a value of a specified type.
+ *
+ * @tparam T the type of the value to store
+ */
+template<typename T>
+class TestRecord : public Record {
+public:
+
+    /**
+     * Create a new TestRecord.
+     *
+     * @param id the ID of the record. It is always a global ID.
+     * @param type the type of the record
+     * @param value the value of the record
+     */
+    TestRecord(std::string id, std::string type, T value);
+
+    /**
+     * Create a new TestRecord from its conduit Node representation.
+     *
+     * NOTE: This needs to be implemented explicitly for each type of value
+     *
+     * @param asValue the record in its Node representation
+     */
+    explicit TestRecord(conduit::Node const &asValue);
+
+    /**
+     * Get the record's value.
+     *
+     * @return the record's value
+     */
+    const T &getValue() const noexcept {
+        return value;
+    }
+
+    conduit::Node toNode() const override;
+
+private:
+    T value;
+};
+
+template<typename T>
+TestRecord<T>::TestRecord(std::string id, std::string type, T value_) :
+        Record{ID{std::move(id), IDType::Global}, std::move(type)},
+        value{std::move(value_)} {}
+
+template<>
+TestRecord<std::string>::TestRecord(conduit::Node const &asNode);
+
+template<>
+TestRecord<int>::TestRecord(conduit::Node const &asJson);
+
+template<typename T>
+conduit::Node TestRecord<T>::toNode() const {
+    auto asJson = Record::toNode();
+    asJson[TEST_RECORD_VALUE_KEY] = value;
+    return asJson;
+}
+
+}  // end testing namespace
+}  // end sina namespace
+}  // end axom namespace
+
+#endif //SINA_TESTRECORD_HPP

src/axom/sina/tests/src/ConduitTestUtils.cpp

@@ -0,0 +1,24 @@
+#include "axom/sina/tests/include/ConduitTestUtils.hpp"
+
+namespace axom
+{
+namespace sina
+{
+namespace testing
+{
+
+conduit::Node parseJsonValue(std::string const &valueAsString) {
+    // If we just try to do node.parse(valueAsString, "json"), then passing
+    // in strings does not work. We need to create a document with a key
+    // so that valueAsString can be parsed as a value.
+    conduit::Node node;
+    std::string fullContents = "{\"TEST_KEY\": ";
+    fullContents += valueAsString;
+    fullContents += "}";
+    node.parse(fullContents, "json");
+    return node.child("TEST_KEY");
+}
+
+}  // end testing namespace
+}  // end sina namespace
+}  // end axom namespace

src/axom/sina/tests/src/TestRecord.cpp

@@ -0,0 +1,23 @@
+#include "axom/sina/tests/include/TestRecord.hpp"
+
+namespace axom
+{
+namespace sina
+{
+namespace testing
+{
+
+template<>
+TestRecord<std::string>::TestRecord(conduit::Node const &asNode) :
+        Record{asNode},
+        value{getRequiredString(TEST_RECORD_VALUE_KEY, asNode, "TestRecord")} {}
+
+template<>
+TestRecord<int>::TestRecord(conduit::Node const &asNode) :
+        Record{asNode},
+        value{getRequiredField(TEST_RECORD_VALUE_KEY, asNode,
+              "TestRecord").as_int()} {}
+
+}  // end testing namespace
+}  // end sina namespace
+}  // end axom namespace

src/axom/sina/tests/src/sina_AdiakWriter.cpp

@@ -0,0 +1,154 @@
+#include "axom/sina/include/AdiakWriter.hpp"
+
+#ifdef AXOM_SINA_USE_ADIAK
+
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include "adiak.hpp"
+extern "C" {
+#include "adiak_tool.h"
+#include "adiak.h"
+}
+
+#include "axom/sina/include/Datum.hpp"
+#include "axom/sina/include/ID.hpp"
+#include "axom/sina/include/Run.hpp"
+
+namespace axom
+{
+namespace sina
+{
+namespace testing
+{
+namespace
+{
+
+using ::testing::HasSubstr;
+using ::testing::DoubleEq;
+using ::testing::ElementsAre;
+
+char const EXPECTED_DATA_KEY[] = "data";
+char const EXPECTED_FILES_KEY[] = "files";
+
+class AdiakWriterTest : public ::testing::Test {
+
+ protected:
+  static void SetUpTestCase() {
+    adiak::init(nullptr);
+    adiak_register_cb(1, adiak_category_all, AdiakWriterTest::callbackWrapper, 0, &current_test);
+  }
+
+  void SetUp() override {
+     current_test=this;
+  }
+
+  static void callbackWrapper(const char *name, adiak_category_t category, const char *subcategory, adiak_value_t *val, adiak_datatype_t *adiak_type, void *adiakwriter){
+    auto test = static_cast<AdiakWriterTest**>(adiakwriter);
+    adiakSinaCallback(name, category, subcategory, val, adiak_type, &((*test)->record));
+  }
+
+  axom::sina::Record record{axom::sina::ID{"test_run", axom::sina::IDType::Local}, "test_type"};
+  static AdiakWriterTest *current_test;
+};
+
+AdiakWriterTest *AdiakWriterTest::current_test;
+
+TEST_F(AdiakWriterTest, basic_assignment) {
+  //adiak::init(nullptr);
+  //adiak_register_cb(1, adiak_category_all, sina::adiakSinaCallback, 0, callback_record_ptr);
+  std::string name1 = "name1";
+  std::string value1 = "value1";
+  std::vector<std::string> tags1 = {"string"};
+  std::string name2 = "name2";
+  int value2 = 2;
+  std::vector<std::string> tags2 = {"int"};
+  auto result1 = adiak::value(name1, value1);
+  auto result2 = adiak::value(name2, value2);
+  EXPECT_TRUE(result1 && result2);
+  auto asNode = record.toNode();
+  EXPECT_EQ(value1, asNode[EXPECTED_DATA_KEY][name1]["value"].as_string());
+  EXPECT_EQ(value2, int(asNode[EXPECTED_DATA_KEY][name2]["value"].as_double()));
+  EXPECT_EQ(tags1[0], asNode[EXPECTED_DATA_KEY][name1]["tags"][0].as_string());
+  EXPECT_EQ(tags2[0], asNode[EXPECTED_DATA_KEY][name2]["tags"][0].as_string());
+}
+
+TEST_F(AdiakWriterTest, scalar_types) {
+  std::string name1 = "my_long";
+  long value1 = 0;
+  std::string name2 = "my_double";
+  double value2 = 3.14;
+  auto result1 = adiak::value(name1, value1);
+  auto result2 = adiak::value(name2, value2);
+  EXPECT_TRUE(result1 && result2);
+  auto asNode = record.toNode();
+  EXPECT_EQ(value1, asNode[EXPECTED_DATA_KEY][name1]["value"].as_float64());
+  EXPECT_EQ(value2, asNode[EXPECTED_DATA_KEY][name2]["value"].as_double());
+}
+
+// No extra test for string_types (besides date) as they're handled identically
+TEST_F(AdiakWriterTest, date_type) {
+  std::string name1 = "my_date";
+  auto result = adiak::value(name1, adiak::date(1568397849));
+  EXPECT_TRUE(result);
+  auto toNode = record.toNode();
+  EXPECT_EQ("Fri, 13 Sep 2019 11:04:09 -0700", toNode[EXPECTED_DATA_KEY][name1]["value"].as_string());
+}
+
+TEST_F(AdiakWriterTest, list_types) {
+  std::string name1 = "my_scalar_list";
+  std::vector<double> value1{4.5, 0, 5.12, 42};
+  std::string name2 = "my_string_list";
+  std::set<std::string> value2{"spam", "egg and bacon", "egg and spam"};
+  auto result1 = adiak::value(name1, value1);
+  auto result2 = adiak::value(name2, value2);
+  EXPECT_TRUE(result1 && result2);
+  auto asNode = record.toNode();
+  auto doub_array = asNode[EXPECTED_DATA_KEY][name1]["value"].as_double_ptr();
+  std::vector<double>scal_child_vals(doub_array, doub_array+asNode[EXPECTED_DATA_KEY][name1]["value"].dtype().number_of_elements());
+  EXPECT_EQ(value1, scal_child_vals);
+  std::set<std::string> node_vals;
+  auto val_itr = asNode[EXPECTED_DATA_KEY][name2]["value"].children();
+  while(val_itr.has_next())
+      node_vals.insert(val_itr.next().as_string());
+  EXPECT_EQ(value2, node_vals);
+}
+
+TEST_F(AdiakWriterTest, files) {
+  std::string name1 = "my_bash";
+  std::string value1 = "/bin/bash";
+  std::string name2 = "my_cat_pics";
+  std::string value2 = "~/pictures/neighbor_cat.png";
+  std::vector<std::string> tags2{name2};
+  auto result1 = adiak::value(name1, adiak::path(value1));
+  auto result2 = adiak::value(name2, adiak::path(value2));
+  EXPECT_TRUE(result1 && result2);
+  auto asNode = record.toNode();
+  EXPECT_FALSE(asNode[EXPECTED_FILES_KEY].child(value1).dtype().is_empty());
+  EXPECT_EQ(1, asNode[EXPECTED_FILES_KEY].child(value2)["tags"].number_of_children());
+  EXPECT_EQ(tags2[0], asNode[EXPECTED_FILES_KEY].child(value2)["tags"][0].as_string());
+}
+
+TEST_F(AdiakWriterTest, files_list){
+  std::string fileListName = "my_gecko_pics";
+  std::string fileListVal1 = "~/pictures/spike.png";
+  std::string fileListVal2 = "~/pictures/sandy.png";
+  std::vector<adiak::path> fileListAdiak{adiak::path(fileListVal1), adiak::path(fileListVal2)};
+  std::vector<std::string> tags = {"string"};
+  EXPECT_TRUE(adiak::value(fileListName, fileListAdiak));
+  auto asNode = record.toNode();
+  EXPECT_FALSE(asNode[EXPECTED_FILES_KEY].child(fileListVal1).dtype().is_empty());
+  EXPECT_EQ(1, asNode[EXPECTED_FILES_KEY].child(fileListVal2)["tags"].number_of_children());
+  EXPECT_EQ(fileListName, asNode[EXPECTED_FILES_KEY].child(fileListVal2)["tags"][0].as_string());
+}
+
+}  // end nameless namespace
+}  // end testing namespace
+}  // end sina namespace
+}  // end axom namespace
+
+#endif // AXOM_SINA_USE_ADIAK