New schema evolution unit test

DataFormats/TestObjects/interface/SchemaEvolutionTestObjects.h

@@ -0,0 +1,337 @@
+#ifndef DataFormats_TestObjects_SchemaEvolutionTestObjects_h
+#define DataFormats_TestObjects_SchemaEvolutionTestObjects_h
+
+#include <vector>
+
+// Don't delete the following comment line.
+// This #define is required when generating data files
+// using the old formats. These data files are saved and used
+// as input in unit tests to verify that ROOT can use schema
+// evolution to read the old formats with a release that has
+// modified formats. When reading this #define should be commented
+// out and it should be commented out in the code repository.
+// Note that the data files are generated manually and this
+// line and classes_def.xml must be manually modified and built
+// when generating new data files. The data files are saved
+// in this repository: https://github.com/cms-data/IOPool-Input.
+//#define DataFormats_TestObjects_USE_OLD
+#if defined DataFormats_TestObjects_USE_OLD
+
+#include <map>
+
+#else
+
+#include <array>
+#include <list>
+#include <memory>
+#include <unordered_map>
+
+#endif
+
+namespace edmtest {
+
+  class SchemaEvolutionChangeOrder {
+  public:
+#if defined DataFormats_TestObjects_USE_OLD
+    SchemaEvolutionChangeOrder() : a_(0), b_(0) {}
+    SchemaEvolutionChangeOrder(int a, int b) : a_(a), b_(b) {}
+    int a_;
+    int b_;
+#else
+    SchemaEvolutionChangeOrder() : b_(0), a_(0) {}
+    SchemaEvolutionChangeOrder(int a, int b) : b_(b), a_(a) {}
+    int b_;
+    int a_;
+#endif
+  };
+
+  class SchemaEvolutionAddMember {
+  public:
+#if defined DataFormats_TestObjects_USE_OLD
+    SchemaEvolutionAddMember() : a_(0), b_(0) {}
+    SchemaEvolutionAddMember(int a, int b, int) : a_(a), b_(b) {}
+    int a_;
+    int b_;
+#else
+    SchemaEvolutionAddMember() : a_(0), b_(0), c_(0) {}
+    SchemaEvolutionAddMember(int a, int b, int c) : a_(a), b_(b), c_(c) {}
+    int a_;
+    int b_;
+    int c_;
+#endif
+  };
+
+  class SchemaEvolutionRemoveMember {
+  public:
+#if defined DataFormats_TestObjects_USE_OLD
+    SchemaEvolutionRemoveMember() : a_(0), b_(0) {}
+    SchemaEvolutionRemoveMember(int a, int b) : a_(a), b_(b) {}
+    int a_;
+    int b_;
+#else
+    SchemaEvolutionRemoveMember() : a_(0) {}
+    SchemaEvolutionRemoveMember(int a, int) : a_(a) {}
+    int a_;
+#endif
+  };
+
+#if defined DataFormats_TestObjects_USE_OLD
+  class SchemaEvolutionBase {
+  public:
+    SchemaEvolutionBase() : d_(0) {}
+    SchemaEvolutionBase(int d) : d_(d) {}
+    int d_;
+  };
+
+  class SchemaEvolutionMoveToBase : public SchemaEvolutionBase {
+  public:
+    SchemaEvolutionMoveToBase() : a_(0), b_(0), c_(0) {}
+    SchemaEvolutionMoveToBase(int a, int b, int c, int d) : SchemaEvolutionBase(d), a_(a), b_(b), c_(c) {}
+    int a_;
+    int b_;
+    int c_;
+  };
+#else
+  class SchemaEvolutionBase {
+  public:
+    SchemaEvolutionBase() : c_(0), d_(0) {}
+    SchemaEvolutionBase(int c, int d) : c_(c), d_(d) {}
+    int c_;
+    int d_;
+  };
+
+  class SchemaEvolutionMoveToBase : public SchemaEvolutionBase {
+  public:
+    SchemaEvolutionMoveToBase() : a_(0), b_(0) {}
+    SchemaEvolutionMoveToBase(int a, int b, int c, int d) : SchemaEvolutionBase(c, d), a_(a), b_(b) {}
+    int a_;
+    int b_;
+  };
+#endif
+
+  class SchemaEvolutionChangeType {
+  public:
+#if defined DataFormats_TestObjects_USE_OLD
+    SchemaEvolutionChangeType() : a_(0), b_(0) {}
+    SchemaEvolutionChangeType(int a, int b) : a_(a), b_(b) {}
+    int a_;
+    int b_;
+#else
+    SchemaEvolutionChangeType() : a_(0.0), b_(0LL) {}
+    SchemaEvolutionChangeType(int a, int b) : a_(a), b_(b) {}
+    double a_;
+    long long b_;
+#endif
+  };
+
+  class SchemaEvolutionBaseA {
+  public:
+    SchemaEvolutionBaseA() : c_(0) {}
+    SchemaEvolutionBaseA(int c) : c_(c) {}
+    int c_;
+  };
+
+#if defined DataFormats_TestObjects_USE_OLD
+  class SchemaEvolutionAddBase {
+  public:
+    SchemaEvolutionAddBase() : a_(0), b_(0) {}
+    SchemaEvolutionAddBase(int a, int b, int) : a_(a), b_(b) {}
+#else
+  class SchemaEvolutionAddBase : public SchemaEvolutionBaseA {
+  public:
+    SchemaEvolutionAddBase() : a_(0), b_(0) {}
+    SchemaEvolutionAddBase(int a, int b, int c) : SchemaEvolutionBaseA(c), a_(a), b_(b) {}
+#endif
+    int a_;
+    int b_;
+  };
+
+  class SchemaEvolutionContained {
+  public:
+    SchemaEvolutionContained() : c_(0) {}
+    SchemaEvolutionContained(int c) : c_(c) {}
+    int c_;
+  };
+
+  class SchemaEvolutionPointerToMember {
+  public:
+#if defined DataFormats_TestObjects_USE_OLD
+    SchemaEvolutionPointerToMember() : a_(0), b_(0), contained_(nullptr) {}
+    SchemaEvolutionPointerToMember(SchemaEvolutionPointerToMember const& other)
+        : a_(other.a_), b_(other.b_), contained_(new SchemaEvolutionContained(other.contained_->c_)) {}
+    SchemaEvolutionPointerToMember(SchemaEvolutionPointerToMember&&) = delete;
+    SchemaEvolutionPointerToMember& operator=(SchemaEvolutionPointerToMember const&) = delete;
+    SchemaEvolutionPointerToMember& operator=(SchemaEvolutionPointerToMember&&) = delete;
+
+    SchemaEvolutionPointerToMember(int a, int b, int c) : a_(a), b_(b), contained_(new SchemaEvolutionContained(c)) {}
+    ~SchemaEvolutionPointerToMember() { delete contained_; }
+    int c() const { return contained_->c_; }
+    int a_;
+    int b_;
+    SchemaEvolutionContained* contained_;
+#else
+    SchemaEvolutionPointerToMember() : a_(0), b_(0) {}
+    SchemaEvolutionPointerToMember(int a, int b, int c) : a_(a), b_(b), contained_(c) {}
+    int c() const { return contained_.c_; }
+    int a_;
+    int b_;
+    SchemaEvolutionContained contained_;
+#endif
+  };
+
+  class SchemaEvolutionPointerToUniquePtr {
+  public:
+    SchemaEvolutionPointerToUniquePtr(SchemaEvolutionPointerToUniquePtr&&) = delete;
+    SchemaEvolutionPointerToUniquePtr& operator=(SchemaEvolutionPointerToUniquePtr const&) = delete;
+    SchemaEvolutionPointerToUniquePtr& operator=(SchemaEvolutionPointerToUniquePtr&&) = delete;
+
+#if defined DataFormats_TestObjects_USE_OLD
+    SchemaEvolutionPointerToUniquePtr() : a_(0), b_(0), contained_(nullptr) {}
+    SchemaEvolutionPointerToUniquePtr(SchemaEvolutionPointerToUniquePtr const& other)
+        : a_(other.a_), b_(other.b_), contained_(new SchemaEvolutionContained(other.contained_->c_)) {}
+
+    SchemaEvolutionPointerToUniquePtr(int a, int b, int c)
+        : a_(a), b_(b), contained_(new SchemaEvolutionContained(c)) {}
+    ~SchemaEvolutionPointerToUniquePtr() { delete contained_; }
+    int a_;
+    int b_;
+    SchemaEvolutionContained* contained_;
+#else
+    SchemaEvolutionPointerToUniquePtr() : a_(0), b_(0) {}
+    SchemaEvolutionPointerToUniquePtr(int a, int b, int c)
+        : a_(a), b_(b), contained_(std::make_unique<SchemaEvolutionContained>(c)) {}
+    SchemaEvolutionPointerToUniquePtr(SchemaEvolutionPointerToUniquePtr const& other)
+        : a_(other.a_), b_(other.b_), contained_(std::make_unique<SchemaEvolutionContained>(other.contained_->c_)) {}
+    int a_;
+    int b_;
+    std::unique_ptr<SchemaEvolutionContained> contained_;
+#endif
+  };
+
+  class SchemaEvolutionCArrayToStdArray {
+  public:
+#if defined DataFormats_TestObjects_USE_OLD
+    SchemaEvolutionCArrayToStdArray() : a_{0, 0, 0} {}
+    SchemaEvolutionCArrayToStdArray(int x, int y, int z) : a_{x, y, z} {}
+    int a_[3];
+#else
+    SchemaEvolutionCArrayToStdArray() : a_{{0, 0, 0}} {}
+    SchemaEvolutionCArrayToStdArray(int x, int y, int z) : a_{{x, y, z}} {}
+    std::array<int, 3> a_;
+#endif
+  };
+
+  class SchemaEvolutionCArrayToStdVector {
+  public:
+#if defined DataFormats_TestObjects_USE_OLD
+    SchemaEvolutionCArrayToStdVector() : a_{new int[fSize_]{0, 0, 0}} {}
+    SchemaEvolutionCArrayToStdVector(int x, int y, int z) : a_{new int[fSize_]{x, y, z}} {}
+    SchemaEvolutionCArrayToStdVector(SchemaEvolutionCArrayToStdVector const& other)
+        : a_(new int[fSize_]{other.a_[0], other.a_[1], other.a_[2]}) {}
+    SchemaEvolutionCArrayToStdVector(SchemaEvolutionCArrayToStdVector&&) = delete;
+    SchemaEvolutionCArrayToStdVector& operator=(SchemaEvolutionCArrayToStdVector const&) = delete;
+    SchemaEvolutionCArrayToStdVector& operator=(SchemaEvolutionCArrayToStdVector&&) = delete;
+    ~SchemaEvolutionCArrayToStdVector() { delete[] a_; }
+
+    int fSize_ = 3;
+    int* a_;  //[fSize_]
+#else
+    SchemaEvolutionCArrayToStdVector() : a_{0, 0, 0} {}
+    SchemaEvolutionCArrayToStdVector(int x, int y, int z) : a_{x, y, z} {}
+    std::vector<int> a_;
+#endif
+  };
+
+  class SchemaEvolutionVectorToList {
+  public:
+    SchemaEvolutionVectorToList() : a_{0, 0, 0} {}
+    SchemaEvolutionVectorToList(int x, int y, int z) : a_{x, y, z} {}
+#if defined DataFormats_TestObjects_USE_OLD
+    std::vector<int> a_;
+#else
+    std::list<int> a_;
+#endif
+  };
+
+  class SchemaEvolutionMapToUnorderedMap {
+  public:
+    SchemaEvolutionMapToUnorderedMap() {
+      a_.insert({0, 0});
+      a_.insert({1, 0});
+      a_.insert({2, 0});
+    }
+    SchemaEvolutionMapToUnorderedMap(int keyX, int x, int keyY, int y, int keyZ, int z) {
+      a_.insert({keyX, x});
+      a_.insert({keyY, y});
+      a_.insert({keyZ, z});
+    }
+#if defined DataFormats_TestObjects_USE_OLD
+    std::map<int, int> a_;
+#else
+    std::unordered_map<int, int> a_;
+#endif
+  };
+
+  class VectorVectorElement {
+  public:
+    VectorVectorElement();
+    VectorVectorElement(int a,
+                        int b,
+                        SchemaEvolutionChangeOrder const&,
+                        SchemaEvolutionAddMember const&,
+                        SchemaEvolutionRemoveMember const&,
+                        SchemaEvolutionMoveToBase const&,
+                        SchemaEvolutionChangeType const&,
+                        SchemaEvolutionAddBase const&,
+                        SchemaEvolutionPointerToMember const&,
+                        SchemaEvolutionPointerToUniquePtr const&,
+                        SchemaEvolutionCArrayToStdArray const&,
+                        // SchemaEvolutionCArrayToStdVector const&,
+                        SchemaEvolutionVectorToList const&,
+                        SchemaEvolutionMapToUnorderedMap const&);
+#if defined DataFormats_TestObjects_USE_OLD
+    int a_;
+    int b_;
+#else
+    int a_;
+    int b_;
+    int c_ = 0;
+#endif
+    SchemaEvolutionChangeOrder changeOrder_;
+    SchemaEvolutionAddMember addMember_;
+    SchemaEvolutionRemoveMember removeMember_;
+    SchemaEvolutionMoveToBase moveToBase_;
+    SchemaEvolutionChangeType changeType_;
+    SchemaEvolutionAddBase addBase_;
+    SchemaEvolutionPointerToMember pointerToMember_;
+    SchemaEvolutionPointerToUniquePtr pointerToUniquePtr_;
+    SchemaEvolutionCArrayToStdArray cArrayToStdArray_;
+    // This one is commented out because it fails reading an old format
+    // input file with an executable built with the modified format.
+    // If the issue in ROOT is ever fixed and this is added back,
+    // it also would need to be added into the constructor above.
+    // SchemaEvolutionCArrayToStdVector cArrayToStdVector_;
+    SchemaEvolutionVectorToList vectorToList_;
+    SchemaEvolutionMapToUnorderedMap mapToUnorderedMap_;
+  };
+
+  class VectorVectorElementNonSplit {
+  public:
+    VectorVectorElementNonSplit();
+    VectorVectorElementNonSplit(int a, int b);
+#if defined DataFormats_TestObjects_USE_OLD
+    // This version of the class is forced to be non-split because
+    // it has only one data member. The unit test this is used by
+    // was developed in response to a ROOT bug in the version of ROOT
+    // associated with CMSSW_13_0_0. This bug only affected non split
+    // classes and this class was necessary to reproduce it.
+    int a_;
+#else
+    int a_;
+    int b_;
+#endif
+  };
+
+}  // namespace edmtest
+
+#endif

DataFormats/TestObjects/interface/VectorVectorTop.h

@@ -0,0 +1,41 @@
+#ifndef DataFormats_TestObjects_VectorVectorTop_h
+#define DataFormats_TestObjects_VectorVectorTop_h
+
+/** \class VectorVectorTop
+
+\author W. David Dagenhart, created 21 July, 2023
+
+*/
+
+#include "DataFormats/TestObjects/interface/SchemaEvolutionTestObjects.h"
+
+#include <vector>
+
+namespace edmtest {
+
+  class VectorVectorMiddle {
+  public:
+    VectorVectorMiddle();
+    std::vector<VectorVectorElement> middleVector_;
+  };
+
+  class VectorVectorTop {
+  public:
+    VectorVectorTop();
+    std::vector<VectorVectorMiddle> outerVector_;
+  };
+
+  class VectorVectorMiddleNonSplit {
+  public:
+    VectorVectorMiddleNonSplit();
+    std::vector<VectorVectorElementNonSplit> middleVector_;
+  };
+
+  class VectorVectorTopNonSplit {
+  public:
+    VectorVectorTopNonSplit();
+    std::vector<VectorVectorMiddleNonSplit> outerVector_;
+  };
+
+}  // namespace edmtest
+#endif