Implement integration tests for WrapperBase specialisations

Co-authored-by: Matti Kortelainen <[email protected]>

Author: fwyzard

FWCore/Integration/plugins/BuildFile.xml

@@ -33,6 +33,15 @@
     <use name="DataFormats/TestObjects"/>
   </library>
 
+  <library file="WrapperBaseProducer.cc" name="FWCoreIntegrationWrapperBase">
+    <flags EDM_PLUGIN="1"/>
+    <use name="DataFormats/TestObjects"/>
+    <use name="FWCore/Framework"/>
+    <use name="FWCore/ParameterSet"/>
+    <use name="FWCore/Reflection"/>
+    <use name="FWCore/Utilities"/>
+  </library>
+
   <library file="HistProducer.cc" name="TestHistProducer">
     <flags EDM_PLUGIN="1"/>
     <use name="FWCore/Framework"/>

FWCore/Integration/plugins/WrapperBaseProducer.cc

@@ -0,0 +1,227 @@
+#include <cassert>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "DataFormats/Common/interface/WrapperBase.h"
+#include "DataFormats/TestObjects/interface/Thing.h"
+#include "DataFormats/TestObjects/interface/ThingWithDoNotSort.h"
+#include "DataFormats/TestObjects/interface/ThingWithPostInsert.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/WrapperBaseOrphanHandle.h"
+#include "FWCore/Framework/interface/global/EDProducer.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+#include "FWCore/Utilities/interface/EDPutToken.h"
+
+// FIXME for do_post_insert_if_available, remove when no longer needed
+#include "FWCore/Framework/interface/PrincipalGetAdapter.h"
+
+namespace edmtest {
+
+  class WrapperBaseProducer : public edm::global::EDProducer<> {
+  public:
+    explicit WrapperBaseProducer(edm::ParameterSet const& ps);
+
+    void produce(edm::StreamID sid, edm::Event& event, edm::EventSetup const& es) const override;
+
+    static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
+  private:
+    edm::EDPutToken intToken_;
+    edm::EDPutToken floatToken_;
+    edm::EDPutToken stringToken_;
+    edm::EDPutToken vectorToken_;
+    edm::EDPutToken thingToken_;
+    edm::EDPutToken thingWithPostInsertToken_;
+    edm::EDPutToken thingWithDoNotSortToken_;
+    edm::EDPutToken badToken_;
+  };
+
+  template <typename T>
+  static T& unwrap_as(edm::WrapperBase& wrapper) {
+    // throws std::bad_cast on conversion error
+    edm::Wrapper<T>& w = dynamic_cast<edm::Wrapper<T>&>(wrapper);
+
+    // throws an execption if the wrapper is empty
+    if (w.product() == nullptr) {
+      throw cms::Exception("LogicError") << "Empty or invalid wrapper";
+    }
+
+    // return the content of the wrapper
+    return w.bareProduct();
+  }
+
+  template <typename T>
+  static T const& unwrap_as(edm::WrapperBase const& wrapper) {
+    // throws std::bad_cast on conversion error
+    edm::Wrapper<T> const& w = dynamic_cast<edm::Wrapper<T> const&>(wrapper);
+
+    // throws an execption if the wrapper is empty
+    if (w.product() == nullptr) {
+      throw cms::Exception("LogicError") << "Empty or invalid wrapper";
+    }
+
+    // return the content of the wrapper
+    return *w.product();
+  }
+
+  WrapperBaseProducer::WrapperBaseProducer(edm::ParameterSet const& iConfig)
+      : intToken_(produces(edm::TypeID(typeid(int)))),
+        floatToken_(produces(edm::TypeID(typeid(float)))),
+        stringToken_(produces(edm::TypeID(typeid(std::string)))),
+        vectorToken_(produces(edm::TypeID(typeid(std::vector<double>)))),
+        thingToken_(produces(edm::TypeID(typeid(Thing)))),
+        thingWithPostInsertToken_(produces(edm::TypeID(typeid(ThingWithPostInsert)))),
+        thingWithDoNotSortToken_(produces(edm::TypeID(typeid(ThingWithDoNotSort)))),
+        badToken_(produces(edm::TypeID(typeid(int)), "bad")) {}
+
+  void WrapperBaseProducer::produce(edm::StreamID sid, edm::Event& event, edm::EventSetup const& es) const {
+    {
+      // Check that an int can be put into the event via a WrapperBase.
+      int value = 42;
+      // Copy the value into the wrapper
+      std::unique_ptr<edm::WrapperBase> product(
+          std::make_unique<edm::Wrapper<int>>(edm::WrapperBase::Emplace{}, value));
+      // FIXME Wrapper should call post_insert (if available), but that is not implemented yet
+      edm::detail::do_post_insert_if_available(unwrap_as<int>(*product));
+      assert(unwrap_as<int>(*product) == value);
+      // Move the wrapper into the event
+      auto handle = event.put(intToken_, std::move(product));
+      assert(not product);
+      assert(handle.isValid());
+      assert(unwrap_as<int>(*handle) == value);
+    }
+
+    {
+      // Check that a float can be put into the event via a WrapperBase.
+      float value = 3.14159f;
+      // Copy the value into the wrapper
+      std::unique_ptr<edm::WrapperBase> product(new edm::Wrapper<float>(edm::WrapperBase::Emplace{}, value));
+      // FIXME Wrapper should call post_insert (if available), but that is not implemented yet
+      edm::detail::do_post_insert_if_available(unwrap_as<float>(*product));
+      assert(unwrap_as<float>(*product) == value);
+      // Move the wrapper into the event
+      auto handle = event.put(floatToken_, std::move(product));
+      assert(not product);
+      assert(handle.isValid());
+      assert(unwrap_as<float>(*handle) == value);
+    }
+
+    {
+      // Check that a string can be put into the event via a WrapperBase.
+      // With small string optimisation, the underlying buffer should be inside the string object itself.
+      std::string value = "42";
+      // Copy the value into the wrapper
+      std::unique_ptr<edm::WrapperBase> product(new edm::Wrapper<std::string>(edm::WrapperBase::Emplace{}, value));
+      // FIXME Wrapper should call post_insert (if available), but that is not implemented yet
+      edm::detail::do_post_insert_if_available(unwrap_as<std::string>(*product));
+      assert(unwrap_as<std::string>(*product) == value);
+      // Move the wrapper into the event
+      auto handle = event.put(stringToken_, std::move(product));
+      assert(not product);
+      assert(handle.isValid());
+      assert(unwrap_as<std::string>(*handle) == value);
+    }
+
+    {
+      // Check that a vector can be put into the event via a WrapperBase.
+      // The underlying buffer is outside the vector object itself.
+      using Vector = std::vector<double>;
+      Vector value = {1., 1., 2., 3., 5., 8., 11., 19., 30.};
+      // Copy the value into the wrapper
+      std::unique_ptr<edm::WrapperBase> product(new edm::Wrapper<Vector>(edm::WrapperBase::Emplace{}, value));
+      // FIXME Wrapper should call post_insert (if available), but that is not implemented yet
+      edm::detail::do_post_insert_if_available(unwrap_as<Vector>(*product));
+      assert(unwrap_as<Vector>(*product) == value);
+      // Move the wrapper into the event
+      auto handle = event.put(vectorToken_, std::move(product));
+      assert(not product);
+      assert(handle.isValid());
+      assert(unwrap_as<Vector>(*handle) == value);
+    }
+
+    {
+      // Check that a Thing can be put into the event via a WrapperBase.
+      cms_int32_t value = 99;
+      // Copy the value into the wrapper
+      std::unique_ptr<edm::WrapperBase> product(new edm::Wrapper<Thing>(edm::WrapperBase::Emplace{}, value));
+      // FIXME Wrapper should call post_insert (if available), but that is not implemented yet
+      edm::detail::do_post_insert_if_available(unwrap_as<Thing>(*product));
+      assert(unwrap_as<Thing>(*product).a == value);
+      // Move the wrapper into the event
+      auto handle = event.put(thingToken_, std::move(product));
+      assert(not product);
+      assert(handle.isValid());
+      assert(unwrap_as<Thing>(*handle).a == value);
+    }
+
+    {
+      // Check that a ThingWithPostInsert can be put into the event via a WrapperBase,
+      // and that ThingWithPostInsert::post_insert() is called by Wrapper.
+      int32_t value = 2147483647;
+      // Copy the value into the wrapper
+      std::unique_ptr<edm::WrapperBase> product(
+          new edm::Wrapper<ThingWithPostInsert>(edm::WrapperBase::Emplace{}, value));
+      // FIXME Wrapper should call post_insert (if available), but that is not implemented yet
+      assert(not unwrap_as<ThingWithPostInsert>(*product).valid());
+      edm::detail::do_post_insert_if_available(unwrap_as<ThingWithPostInsert>(*product));
+      // end-of-FIXME
+      assert(unwrap_as<ThingWithPostInsert>(*product).value() == value);
+      assert(unwrap_as<ThingWithPostInsert>(*product).valid());
+      // Move the wrapper into the event
+      auto handle = event.put(thingWithPostInsertToken_, std::move(product));
+      assert(not product);
+      assert(handle.isValid());
+      assert(unwrap_as<ThingWithPostInsert>(*handle).value() == value);
+      assert(unwrap_as<ThingWithPostInsert>(*handle).valid());
+    }
+
+    {
+      // Check that a ThingWithDoNotSort can be put into the event via a WrapperBase,
+      // and that ThingWithDoNotSort::post_insert() is *not* called by Wrapper.
+      int32_t value = 2147483647;
+      // Copy the value into the wrapper
+      std::unique_ptr<edm::WrapperBase> product(
+          new edm::Wrapper<ThingWithDoNotSort>(edm::WrapperBase::Emplace{}, value));
+      // FIXME Wrapper should call post_insert (if available), but that is not implemented yet
+      edm::detail::do_post_insert_if_available(unwrap_as<ThingWithDoNotSort>(*product));
+      assert(unwrap_as<ThingWithDoNotSort>(*product).value() == value);
+      // Move the wrapper into the event
+      auto handle = event.put(thingWithDoNotSortToken_, std::move(product));
+      assert(not product);
+      assert(handle.isValid());
+      assert(unwrap_as<ThingWithDoNotSort>(*handle).value() == value);
+    }
+
+    {
+      // Check that mismatches in the type of the token and of the underlying object are caught
+      float value = 3.14159f;
+      // Copy the value into the wrapper
+      std::unique_ptr<edm::WrapperBase> product(new edm::Wrapper<float>(edm::WrapperBase::Emplace{}, value));
+      // FIXME Wrapper should call post_insert (if available), but that is not implemented yet
+      edm::detail::do_post_insert_if_available(unwrap_as<float>(*product));
+      assert(unwrap_as<float>(*product) == value);
+      bool failed = false;
+      try {
+        event.put(badToken_, std::move(product));
+      } catch (edm::Exception const& e) {
+        assert(e.categoryCode() == edm::errors::LogicError);
+        failed = true;
+      }
+      assert(failed);
+    }
+  }
+
+  void WrapperBaseProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+    edm::ParameterSetDescription desc;
+    descriptions.addWithDefaultLabel(desc);
+  }
+
+}  // namespace edmtest
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+using edmtest::WrapperBaseProducer;
+DEFINE_FWK_MODULE(WrapperBaseProducer);

FWCore/Integration/test/BuildFile.xml

@@ -31,6 +31,7 @@
   <test name="CatchCmsExceptiontest" command="CatchCmsExceptiontest.sh"/>
   <test name="TestStdProducts" command="cmsRun ${LOCALTOP}/src/FWCore/Integration/test/testStdProducts_cfg.py"/>
   <test name="TestPostInsertProducer" command="cmsRun ${LOCALTOP}/src/FWCore/Integration/test/testPostInsertProducer_cfg.py"/>
+  <test name="TestWrapperBaseProducer" command="cmsRun ${LOCALTOP}/src/FWCore/Integration/test/testWrapperBaseProducer_cfg.py"/>
 
   <bin file="ProcessConfiguration_t.cpp,ProcessHistory_t.cpp" name="TestIntegrationDataFormatsProvenance">
     <use name="FWCore/ParameterSet"/>

FWCore/Integration/test/testWrapperBaseProducer_cfg.py

@@ -0,0 +1,39 @@
+import FWCore.ParameterSet.Config as cms
+
+process = cms.Process("TEST")
+
+process.source = cms.Source("EmptySource")
+
+process.maxEvents = cms.untracked.PSet(
+    input = cms.untracked.int32(10)
+)
+
+process.producer = cms.EDProducer("WrapperBaseProducer")
+
+process.validateInt = cms.EDAnalyzer("edmtest::GlobalIntAnalyzer",
+    source = cms.InputTag("producer"),
+    expected = cms.int32(42)        # hard-coded in WrapperBaseProducer
+)
+
+process.validateFloat = cms.EDAnalyzer("edmtest::GlobalFloatAnalyzer",
+    source = cms.InputTag("producer"),
+    expected = cms.double(3.14159)  # hard-coded in WrapperBaseProducer
+)
+
+process.validateString = cms.EDAnalyzer("edmtest::GlobalStringAnalyzer",
+    source = cms.InputTag("producer"),
+    expected = cms.string("42")     # hard-coded in WrapperBaseProducer
+)
+
+process.validateVector = cms.EDAnalyzer("edmtest::GlobalVectorAnalyzer",
+    source = cms.InputTag("producer"),
+    expected = cms.vdouble(1., 1., 2., 3., 5., 8., 11., 19., 30.)   # hard-coded in WrapperBaseProducer
+)
+
+process.path = cms.Path(
+    process.producer +
+    process.validateInt +
+    process.validateFloat +
+    process.validateString +
+    process.validateVector
+)