DataFormats/Common/test/ref_t.catch2.cc - master - githubmirror/cmssw

DataFormats/Common/test/ref_t.catch2.cc
239 строк8 KB
Chris Jones
Moved tests in DataFormats/Common to catch2
31 мар 2026, 17:34
31 мар 2026, 17:3446bb420
/*
 *  ref_t.cppunit.cc
 *  CMSSW
 *
 *  Created by Chris Jones on 02/11/05.
 *
 */

#include <catch2/catch_all.hpp>
#include <vector>
#include "DataFormats/Common/interface/EDProductGetter.h"
#include "DataFormats/Common/interface/OrphanHandle.h"

#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefProd.h"
#include "DataFormats/Common/interface/RefToBaseProd.h"
#include <iostream>
using namespace edm;

namespace {
  struct Dummy {
    Dummy() {}
    ~Dummy() {}
    bool operator==(Dummy const& iRHS) const { return this == &iRHS; }
    void const* address() const { return this; }
  };

  typedef std::vector<Dummy> DummyCollection;

  struct TestGetter : public edm::EDProductGetter {
    WrapperBase const* hold_;
    WrapperBase const* getIt(ProductID const&) const override { return hold_; }

    unsigned int transitionIndex_() const override { return 0U; }
    TestGetter() : hold_(nullptr) {}
  };

  struct IntValue {
    int value_;
    IntValue(int iValue) : value_(iValue) {}
  };
}  // namespace

TEST_CASE("Ref", "[Ref]") {
  SECTION("construction") {
    Ref<DummyCollection> nulled;
    REQUIRE(!nulled);
    REQUIRE(nulled.isNull());
    REQUIRE(!nulled.isNonnull());

    Ref<DummyCollection> nulledP;
    REQUIRE(!nulledP);
    REQUIRE(nulledP.isNull());
    REQUIRE(!nulledP.isNonnull());

    ProductID const pid(1, 1);

    unsigned int const key = 2;
    Dummy const dummy;
    DummyCollection dummyCollection;
    dummyCollection.push_back(dummy);
    dummyCollection.push_back(dummy);
    dummyCollection.push_back(dummy);
    OrphanHandle<DummyCollection> handle(&dummyCollection, pid);
    Ref<DummyCollection> dummyRef(handle, key);
    RefProd<DummyCollection> dummyRefProd(handle);

    REQUIRE(dummyRef.id() == pid);
    REQUIRE(dummyRefProd.id() == pid);
    REQUIRE(dummyRef.key() == key);
    REQUIRE(&(*dummyRef) == &dummyCollection[key]);
    REQUIRE((dummyRef.operator->()) == &dummyCollection[key]);
    REQUIRE(dummyRef->address() == dummyCollection[key].address());
    REQUIRE(&(*dummyRefProd) == &dummyCollection);
    REQUIRE((dummyRefProd.operator->()) == &dummyCollection);

    Ref<DummyCollection> testRef1(pid, &dummyCollection[key], key, nullptr);
    REQUIRE(testRef1.get() == &dummyCollection[key]);
    REQUIRE(testRef1.key() == key);
    REQUIRE(testRef1.isTransient() == false);
    REQUIRE(testRef1.id() == pid);

    Ref<DummyCollection> testRef2(pid, &dummyCollection[key], key);
    REQUIRE(testRef2.get() == &dummyCollection[key]);
    REQUIRE(testRef2.key() == key);
    REQUIRE(testRef2.isTransient() == false);
    REQUIRE(testRef2.id() == pid);

    Ref<DummyCollection> testRef3(pid, &dummyCollection[key], key, false);
    REQUIRE(testRef3.get() == &dummyCollection[key]);
    REQUIRE(testRef3.key() == key);
    REQUIRE(testRef3.isTransient() == false);
    REQUIRE(testRef3.id() == pid);

    Ref<DummyCollection> testRef4(pid, &dummyCollection[key], key, true);
    REQUIRE(testRef4.get() == &dummyCollection[key]);
    REQUIRE(testRef4.key() == key);
    REQUIRE(testRef4.isTransient() == true);
    REQUIRE(testRef4.id() == pid);

    Ref<DummyCollection> testRef5(&dummyCollection, key);
    REQUIRE(testRef5.get() == &dummyCollection[key]);
    REQUIRE(testRef5.key() == key);
    REQUIRE(testRef5.isTransient() == true);
    REQUIRE(testRef5.id() == edm::ProductID());
  }

  SECTION("comparison") {
    {
      ProductID const pid(1, 1);

      unsigned int const key = 2;
      Dummy const dummy;
      DummyCollection dummyCollection;
      dummyCollection.push_back(dummy);
      OrphanHandle<DummyCollection> handle(&dummyCollection, pid);
      OrphanHandle<DummyCollection> handle2(&dummyCollection, pid);
      Ref<DummyCollection> dummyRef1(handle, key);
      Ref<DummyCollection> dummyRef2(handle2, key);
      RefProd<DummyCollection> dummyRefProd1(handle);
      RefProd<DummyCollection> dummyRefProd2(handle2);

      REQUIRE(dummyRef1 == dummyRef2);
      REQUIRE(!(dummyRef1 != dummyRef2));
      REQUIRE(!(dummyRef1 < dummyRef2));
      REQUIRE(!(dummyRef2 < dummyRef1));
      REQUIRE(!(dummyRef1 < dummyRef1));
      REQUIRE(!(dummyRef2 < dummyRef2));

      REQUIRE(dummyRefProd1 == dummyRefProd2);
      REQUIRE(!(dummyRefProd1 != dummyRefProd2));
      REQUIRE(!(dummyRefProd1 < dummyRefProd2));
      REQUIRE(!(dummyRefProd2 < dummyRefProd1));
      REQUIRE(!(dummyRefProd1 < dummyRefProd1));
      REQUIRE(!(dummyRefProd2 < dummyRefProd2));

      Ref<DummyCollection> dummyRefNewKey(handle, key + 1);
      REQUIRE(!(dummyRef1 == dummyRefNewKey));
      REQUIRE(dummyRef1 != dummyRefNewKey);
      REQUIRE(dummyRef1 < dummyRefNewKey);
      REQUIRE(!(dummyRefNewKey < dummyRef1));

      ProductID const pidOther(1, 4);
      OrphanHandle<DummyCollection> handleNewPID(&dummyCollection, pidOther);
      Ref<DummyCollection> dummyRefNewPID(handleNewPID, key);
      RefProd<DummyCollection> dummyRefProdNewPID(handleNewPID);
      REQUIRE(!(dummyRef1 == dummyRefNewPID));
      REQUIRE(dummyRef1 != dummyRefNewPID);
      REQUIRE(!(dummyRefProd1 == dummyRefProdNewPID));
      REQUIRE(dummyRefProd1 != dummyRefProdNewPID);
      REQUIRE(dummyRefProd1 < dummyRefProdNewPID);
      REQUIRE(!(dummyRefProdNewPID < dummyRefProd1));
    }
    {
      typedef std::map<int, double> DummyCollection2;
      ProductID const pid2(1, 2);
      DummyCollection2 dummyCollection2;
      dummyCollection2.insert(std::make_pair(1, 1.0));
      dummyCollection2.insert(std::make_pair(2, 2.0));
      OrphanHandle<DummyCollection2> handle2(&dummyCollection2, pid2);
      Ref<DummyCollection2> dummyRef21(handle2, 1);
      Ref<DummyCollection2> dummyRef22(handle2, 2);
      REQUIRE(dummyRef21 != dummyRef22);
      REQUIRE(dummyRef21 < dummyRef22);
      REQUIRE(!(dummyRef22 < dummyRef21));

      typedef std::map<int, double, std::greater<int>> DummyCollection3;
      ProductID const pid3(1, 3);
      DummyCollection3 dummyCollection3;
      dummyCollection3.insert(std::make_pair(1, 1.0));
      dummyCollection3.insert(std::make_pair(2, 2.0));
      OrphanHandle<DummyCollection3> handle3(&dummyCollection3, pid3);
      Ref<DummyCollection3> dummyRef31(handle3, 1);
      Ref<DummyCollection3> dummyRef32(handle3, 2);
      REQUIRE(dummyRef31 != dummyRef32);
      REQUIRE(!(dummyRef31 < dummyRef32));
      REQUIRE(dummyRef32 < dummyRef31);
    }
  }

  SECTION("get") {
    typedef std::vector<IntValue> IntCollection;
    auto ptr = std::make_unique<IntCollection>();

    ptr->push_back(0);
    ptr->push_back(1);

    edm::Wrapper<IntCollection> wrapper(std::move(ptr));
    TestGetter tester;
    tester.hold_ = &wrapper;

    ProductID const pid(1, 1);

    IntCollection const* wptr = reinterpret_cast<IntCollection const*>(wrapper.product());

    OrphanHandle<IntCollection> handle(wptr, pid);

    Ref<IntCollection> ref0(pid, 0, &tester);
    REQUIRE(!ref0.hasProductCache());

    Ref<IntCollection> ref1(pid, 1, &tester);

    REQUIRE(0 == ref0->value_);
    REQUIRE(ref0.hasProductCache());
    REQUIRE(1 == ref1->value_);
    REQUIRE(1 == (*ref1).value_);

    Ref<IntCollection> ref0FromHandle(handle, 0);
    REQUIRE(0 == ref0FromHandle->value_);
    Ref<IntCollection> ref1FromHandle(handle, 1);
    REQUIRE(1 == ref1FromHandle->value_);

    RefProd<IntCollection> refProd0(handle);
    refProd0.refCore().setProductGetter(&tester);
    //refProd0.refCore().setProductPtr(0);

    RefProd<IntCollection> refProd2(pid, &tester);

    REQUIRE(0 == (*refProd0)[0].value_);
    REQUIRE(1 == (*refProd0)[1].value_);
    REQUIRE(1 == (*refProd2)[1].value_);

    //std::cerr << ">>> RefToBaseProd from RefProd" << std::endl;
    RefToBaseProd<IntValue> refToBaseProd0(refProd0);
    //std::cerr << ">>> RefToBaseProd from Handle" << std::endl;
    RefToBaseProd<IntValue> refToBaseProd2(handle);
    //std::cerr << ">>> checking View from RefToBaseProd" << std::endl;
    const View<IntValue>& vw = *refToBaseProd0;
    //std::cerr << ">>> checking View not empty" << std::endl;
    REQUIRE(!vw.empty());
    //std::cerr << ">>> checking View size" << std::endl;
    REQUIRE(vw.size() == 2);
    //std::cerr << ">>> checking View element #0" << std::endl;
    REQUIRE(vw[0].value_ == ref0->value_);
    //std::cerr << ">>> checking View element #1" << std::endl;
    REQUIRE(vw[1].value_ == ref1->value_);
    //std::cerr << ">>> RefToBaseProd from View" << std::endl;
  }
}