Add unit tests for the ByteStreamMetadataTool

Test the functionality of the ByteStreamMetadataTool. The tool should do
nothing wihtout complaint for empty input. The tool should transcribes a
ByteStreamMetadata object from input into a container in output. The
tool should transcribe a ByteStreamMetadataContainer from input to
output. Should there already be content in the output, matching content
should be ignored and new content should be appended.

Event/ByteStreamCnvSvc/CMakeLists.txt

@@ -78,6 +78,17 @@ atlas_add_test( ByteStreamConfigTest
    SCRIPT "python -m ByteStreamCnvSvc.ByteStreamConfig"
    POST_EXEC_SCRIPT nopost.sh )
 
+atlas_add_test( ByteStreamMetadataToolTest
+  SOURCES test/ByteStreamMetadataTool_test.cxx
+  LINK_LIBRARIES
+    AthenaKernel
+    AthenaBaseComps
+    ByteStreamData
+    GaudiKernel
+    GoogleTestTools
+    TestTools )
+
+
 # Install files from the package:
 atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} )
 atlas_install_joboptions( share/*.py )

Event/ByteStreamCnvSvc/test/ByteStreamMetadataTool_test.cxx

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ */
+/** Tests for ByteStreamMetadata management.
+ *
+ * The various operations that should be performed by the
+ * ByteStreamMetadataTool when transferring objects from the input to the
+ * metadata store for use by clients.
+ *
+ * @author Frank Berghaus <fberghaus@anl.gov>
+ * @date Dec 4, 2020
+ */
+#include <ostream>
+#include <memory>
+#include <set>
+
+#include "GoogleTestTools/InitGaudiGoogleTest.h"
+#include "TestTools/initGaudi.h"
+
+#include "GaudiKernel/ISvcLocator.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/ToolHandle.h"
+
+#include "AthenaKernel/IMetaDataTool.h"
+#include "StoreGate/StoreGateSvc.h"
+#include "StoreGate/setupStoreGate.h"
+#include "../src/ByteStreamMetadataTool.h"
+#include "ByteStreamData/ByteStreamMetadata.h"
+#include "ByteStreamData/ByteStreamMetadataContainer.h"
+
+
+namespace Athena_test {
+
+  class ByteStreamMetadataToolTest : public InitGaudiGoogleTest {
+   public:
+    ByteStreamMetadataToolTest() : InitGaudiGoogleTest( MSG::INFO ) {}
+
+    void SetUp() override {
+      assert(m_inputStore.retrieve().isSuccess());
+      assert(m_metaStore.retrieve().isSuccess());
+
+      assert(m_tool.retrieve().isSuccess());
+      assert(m_tool->initialize().isSuccess());
+    }
+
+    ToolHandle< IMetaDataTool > m_tool{"ByteStreamMetadataTool"};
+    ServiceHandle< StoreGateSvc > m_inputStore{
+      "StoreGateSvc/InputMetaDataStore", "ByteStreamMetadataToolTest"};
+    ServiceHandle< StoreGateSvc > m_metaStore{
+      "StoreGateSvc/MetaDataStore", "ByteStreamMetadataToolTest"};
+
+    const ByteStreamMetadata testObject{
+      1u,
+      50u,
+      50u,
+      1u,
+      1u,
+      1ul<<31,
+      1ul<<33,
+      1u,
+      6500u,
+      "testObject", // GUID
+      "stream",
+      "project",
+      1u,
+      std::vector<std::string>()};
+
+    const ByteStreamMetadata diffObject{
+      2u,
+      20u,
+      20u,
+      1u,
+      1u,
+      1ul<<30,
+      1ul<<32,
+      1u,
+      6500u,
+      "diffObject", // GUID
+      "stream2",
+      "project",
+      2u,
+      std::vector<std::string>()};
+  };
+
+  /**
+   * An empty input store should not offend the tool and do nothing
+   */
+  TEST_F(ByteStreamMetadataToolTest, emptyInput) {
+    EXPECT_TRUE(m_tool->beginInputFile().isSuccess());
+    EXPECT_TRUE(
+        !m_metaStore->contains< ByteStreamMetadataContainer >(
+            "ByteStreamMetadata"));
+  }
+
+  /**
+   * Test tool with ByteStreamMetadata object in input
+   *
+   * Add a ByteStreamMetadata object to input. Tool should generate a
+   * ByteStreamMetadataContainer that one entry in the output
+   */
+  TEST_F(ByteStreamMetadataToolTest, objectInput) {
+    auto testBSM = std::make_unique< ByteStreamMetadata >(testObject);
+    const ByteStreamMetadata * in = testBSM.get();
+    assert(
+        m_inputStore->record< ByteStreamMetadata >(
+            std::move(testBSM), "Test").isSuccess());
+    EXPECT_TRUE(m_tool->beginInputFile().isSuccess());
+    EXPECT_TRUE(
+        m_metaStore->contains< ByteStreamMetadataContainer >(
+            "Test"));
+    auto bsmc =
+        m_metaStore->tryConstRetrieve< ByteStreamMetadataContainer >("Test");
+    assert(bsmc != nullptr);
+    size_t expectedSize = 1;
+    EXPECT_EQ(bsmc->size(), expectedSize);
+    const ByteStreamMetadata * out = bsmc->at(0);
+    EXPECT_EQ(*in, *out);
+    assert(m_inputStore->clearStore().isSuccess());
+    assert(m_metaStore->clearStore().isSuccess());
+  }
+
+  /**
+   * Test tool with ByteStreamMetadataContainer in input
+   *
+   * Add a ByteStreamMetadataContainer object to input. Tool should generate a
+   * ByteStreamMetadataContainer with equal entries
+   */
+  TEST_F(ByteStreamMetadataToolTest, containerInput) {
+    auto testBSMC = std::make_unique< ByteStreamMetadataContainer >();
+    testBSMC->push_back(std::make_unique< ByteStreamMetadata >(testObject));
+    const ByteStreamMetadataContainer * in = testBSMC.get();
+    assert(
+        m_inputStore->record< ByteStreamMetadataContainer >(
+            std::move(testBSMC), "Test").isSuccess());
+    EXPECT_TRUE(m_tool->beginInputFile().isSuccess());
+    EXPECT_TRUE(
+        m_metaStore->contains< ByteStreamMetadataContainer >(
+            "Test"));
+    auto out =
+        m_metaStore->tryConstRetrieve< ByteStreamMetadataContainer >("Test");
+    assert(out != nullptr);
+    EXPECT_EQ(in->size(), out->size());
+    EXPECT_EQ(*in->at(0), *out->at(0));
+    assert(m_inputStore->clearStore().isSuccess());
+    assert(m_metaStore->clearStore().isSuccess());
+  }
+
+  /**
+   * Test tool with equal object in input and output
+   *
+   * An input object equal to one that already exists in MetaDataStore should
+   * result in no new addition
+   */
+  TEST_F(ByteStreamMetadataToolTest, inputSame) {
+    auto inputBSMC = std::make_unique< ByteStreamMetadataContainer >();
+    inputBSMC->push_back(std::make_unique< ByteStreamMetadata >(testObject));
+    assert(
+        m_inputStore->record< ByteStreamMetadataContainer >(
+            std::move(inputBSMC), "Test").isSuccess());
+
+    auto copyBSMC = std::make_unique< ByteStreamMetadataContainer >();
+    copyBSMC->push_back(std::make_unique< ByteStreamMetadata >(testObject));
+    size_t expectedSize = copyBSMC->size();
+    assert(
+        m_metaStore->record< ByteStreamMetadataContainer >(
+            std::move(copyBSMC), "Test").isSuccess());
+
+    EXPECT_TRUE(m_tool->beginInputFile().isSuccess());
+    EXPECT_TRUE(
+        m_metaStore->contains< ByteStreamMetadataContainer >(
+            "Test"));
+    auto out =
+        m_metaStore->tryConstRetrieve< ByteStreamMetadataContainer >("Test");
+    assert(out != nullptr);
+    EXPECT_EQ(out->size(), expectedSize);
+
+    assert(m_inputStore->clearStore().isSuccess());
+    assert(m_metaStore->clearStore().isSuccess());
+  }
+
+  /**
+   * Test tool adding new objects from input to exisint output
+   *
+   * An input object not equal to one that already exists should result in a
+   * and additional entry in the MetaDataStore container
+   */
+  TEST_F(ByteStreamMetadataToolTest, inputNew) {
+    auto inputBSMC = std::make_unique< ByteStreamMetadataContainer >();
+    inputBSMC->push_back(std::make_unique< ByteStreamMetadata >(testObject));
+    assert(
+        m_inputStore->record< ByteStreamMetadataContainer >(
+            std::move(inputBSMC), "Test").isSuccess());
+
+    auto oldBSMC = std::make_unique< ByteStreamMetadataContainer >();
+    oldBSMC->push_back(std::make_unique< ByteStreamMetadata >(diffObject));
+    size_t expectedSize = 1 + oldBSMC->size();
+    assert(
+        m_metaStore->record< ByteStreamMetadataContainer >(
+            std::move(oldBSMC), "Test").isSuccess());
+
+    EXPECT_TRUE(m_tool->beginInputFile().isSuccess());
+    EXPECT_TRUE(
+        m_metaStore->contains< ByteStreamMetadataContainer >(
+            "Test"));
+    auto out =
+        m_metaStore->tryConstRetrieve< ByteStreamMetadataContainer >("Test");
+    assert(out != nullptr);
+    EXPECT_EQ(out->size(), expectedSize);
+
+    assert(m_inputStore->clearStore().isSuccess());
+    assert(m_metaStore->clearStore().isSuccess());
+  }
+
+}  // namespace Athena_test
+
+int main(int argc, char ** argv) {
+  ISvcLocator * svcLocator = nullptr;
+  if (!Athena_test::initGaudi(svcLocator)) {
+    std::cerr << "This test can not be run" << std::endl;
+    return 1;
+  }
+  assert(svcLocator);
+
+  Athena_test::setupStoreGate(argv[0]);
+  ::testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}

Event/ByteStreamData/ByteStreamData/ByteStreamMetadata.h

@@ -115,6 +115,29 @@ private:
  */
 std::ostream& operator<<(std::ostream& os, const ByteStreamMetadata& bsmd);
 
+/**
+ * Compare ByteStreamMetadata objects for equality
+ *
+ * Implementation of standard comparison operator. Uses the public interface of
+ * @c ByteStreamMetadata to compare GUIDs. It returns true if the GUIDs are
+ * equal, false otherwise.
+ */
+inline bool
+    operator==(const ByteStreamMetadata& lhs, const ByteStreamMetadata& rhs) {
+      return lhs.getGuid() == rhs.getGuid();
+    }
+
+/**
+ * Compare ByteStreamMetadata objects for inequality
+ *
+ * Implementation of standard comparison operator. Uses the public interface of
+ * @c ByteStreamMetadata to compare GUIDs. It returns true if the GUIDs are not
+ * equal, false if they are.
+ */
+inline bool
+    operator!=(const ByteStreamMetadata& lhs, const ByteStreamMetadata& rhs) {
+      return lhs.getGuid() != rhs.getGuid();
+    }
 
 #include "AthenaKernel/CLASS_DEF.h"
 CLASS_DEF(ByteStreamMetadata, 170625359, 1)