Histograms/test/metoedmformat_t.cc

0001 // -*- C++ -*-
0002 //
0003 // Package:     Histograms
0004 // Class  :     metoemdformat_t
0005 //
0006 // Implementation:
0007 //     <Notes on implementation>
0008 //
0009 // Original Author:
0010 //         Created:  Tue Jul 21 11:00:06 CDT 2009
0011 //
0012
0013 // system include files
0014 #include <Utilities/Testing/interface/CppUnit_testdriver.icpp>
0015 #include <cppunit/extensions/HelperMacros.h>
0016
0017 // user include files
0018 #include "DataFormats/Histograms/interface/MEtoEDMFormat.h"
0019 #include "TAxis.h"
0020
0021 class TestMEtoEDMFormat : public CppUnit::TestFixture {
0022   CPPUNIT_TEST_SUITE(TestMEtoEDMFormat);
0023   CPPUNIT_TEST(testMergeInt64);
0024   CPPUNIT_TEST(testMergeDouble);
0025   CPPUNIT_TEST(testMergeTString);
0026   CPPUNIT_TEST(testMergeT);
0027   CPPUNIT_TEST_SUITE_END();
0028
0029 public:
0030   void testMergeInt64();
0031   void testMergeDouble();
0032   void testMergeTString();
0033   void testMergeT();
0034   void setUp() override {}
0035   void tearDown() override {}
0036 };
0037
0038 ///registration of the test so that the runner can find it
0039 CPPUNIT_TEST_SUITE_REGISTRATION(TestMEtoEDMFormat);
0040
0041 template <typename T>
0042 bool areEquivalent(const MEtoEDM<T>& iLHS, const MEtoEDM<T>& iRHS) {
0043   if (iLHS.getMEtoEdmObject().size() != iRHS.getMEtoEdmObject().size()) {
0044     std::cout << "areEquivalent failure: sizes are different" << std::endl;
0045     return false;
0046   }
0047   typedef typename MEtoEDM<T>::MEtoEdmObjectVector Vec;
0048   typename Vec::const_iterator itRHS = iRHS.getMEtoEdmObject().begin();
0049   for (typename Vec::const_iterator itLHS = iLHS.getMEtoEdmObject().begin(), itLHSEnd = iLHS.getMEtoEdmObject().end();
0050        itLHS != itLHSEnd;
0051        ++itLHS, ++itRHS) {
0052     if (itLHS->name != itRHS->name || itLHS->tags != itRHS->tags || itLHS->object != itRHS->object) {
0053       std::cout << "areEquivalent failure: elements '" << (itLHS->name) << "' " << (itLHS->object) << " and '"
0054                 << (itRHS->name) << "' " << (itRHS->object) << " are different" << std::endl;
0055       return false;
0056     }
0057   }
0058   return true;
0059 }
0060
0061 void TestMEtoEDMFormat::testMergeInt64() {
0062   MEtoEDM<long long> empty(0);
0063
0064   MEtoEDM<long long> full(3);
0065   full.putMEtoEdmObject("a", 1);
0066   full.putMEtoEdmObject("b", 2);
0067   full.putMEtoEdmObject("c", 3);
0068
0069   MEtoEDM<long long> fullReordered(3);
0070   fullReordered.putMEtoEdmObject("b", 2);
0071   fullReordered.putMEtoEdmObject("a", 1);
0072   fullReordered.putMEtoEdmObject("c", 3);
0073
0074   MEtoEDM<long long> toMerge(full);
0075
0076   //be sure copy constructor worked
0077   CPPUNIT_ASSERT(areEquivalent(toMerge, full));
0078
0079   toMerge.mergeProduct(empty);
0080   CPPUNIT_ASSERT(areEquivalent(toMerge, full));
0081
0082   MEtoEDM<long long> toMerge2(empty);
0083   toMerge2.mergeProduct(full);
0084   CPPUNIT_ASSERT(areEquivalent(toMerge2, full));
0085
0086   MEtoEDM<long long> toMerge3(full);
0087   toMerge3.mergeProduct(fullReordered);
0088   CPPUNIT_ASSERT(areEquivalent(toMerge3, full));
0089
0090   MEtoEDM<long long> part1(2);
0091   part1.putMEtoEdmObject("a", 1);
0092   part1.putMEtoEdmObject("b", 2);
0093   MEtoEDM<long long> part2(1);
0094   part2.putMEtoEdmObject("c", 3);
0095   part1.mergeProduct(part2);
0096   CPPUNIT_ASSERT(areEquivalent(part1, full));
0097
0098   MEtoEDM<long long> specials1(3);
0099   specials1.putMEtoEdmObject("EventInfo/processedEvents", 1);
0100   specials1.putMEtoEdmObject("EventInfo/iEvent", 2);
0101   specials1.putMEtoEdmObject("EventInfo/iLumiSection", 3);
0102
0103   MEtoEDM<long long> specials2(3);
0104   specials2.putMEtoEdmObject("EventInfo/processedEvents", 1);
0105   specials2.putMEtoEdmObject("EventInfo/iEvent", 3);
0106   specials2.putMEtoEdmObject("EventInfo/iLumiSection", 2);
0107
0108   MEtoEDM<long long> specialsTotal(3);
0109   specialsTotal.putMEtoEdmObject("EventInfo/processedEvents", 2);
0110   specialsTotal.putMEtoEdmObject("EventInfo/iEvent", 3);
0111   specialsTotal.putMEtoEdmObject("EventInfo/iLumiSection", 3);
0112   specials1.mergeProduct(specials2);
0113   CPPUNIT_ASSERT(areEquivalent(specials1, specialsTotal));
0114 }
0115
0116 void TestMEtoEDMFormat::testMergeDouble() {
0117   MEtoEDM<double> empty(0);
0118
0119   MEtoEDM<double> full(3);
0120   full.putMEtoEdmObject("a", 1);
0121   full.putMEtoEdmObject("b", 2);
0122   full.putMEtoEdmObject("c", 3);
0123
0124   MEtoEDM<double> fullReordered(3);
0125   fullReordered.putMEtoEdmObject("b", 2);
0126   fullReordered.putMEtoEdmObject("a", 1);
0127   fullReordered.putMEtoEdmObject("c", 3);
0128
0129   MEtoEDM<double> toMerge(full);
0130
0131   //be sure copy constructor worked
0132   CPPUNIT_ASSERT(areEquivalent(toMerge, full));
0133
0134   toMerge.mergeProduct(empty);
0135   CPPUNIT_ASSERT(areEquivalent(toMerge, full));
0136
0137   MEtoEDM<double> toMerge2(empty);
0138   toMerge2.mergeProduct(full);
0139   CPPUNIT_ASSERT(areEquivalent(toMerge2, full));
0140
0141   MEtoEDM<double> toMerge3(full);
0142   toMerge3.mergeProduct(fullReordered);
0143   CPPUNIT_ASSERT(areEquivalent(toMerge3, full));
0144
0145   MEtoEDM<double> part1(2);
0146   part1.putMEtoEdmObject("a", 1);
0147   part1.putMEtoEdmObject("b", 2);
0148   MEtoEDM<double> part2(1);
0149   part2.putMEtoEdmObject("c", 3);
0150   part1.mergeProduct(part2);
0151   CPPUNIT_ASSERT(areEquivalent(part1, full));
0152 }
0153
0154 /*
0155 //NOTE: TString doesn't have a standard comparision operator
0156 bool operator!=(const TString& iLHS, const TString& iRHS) {
0157   return iLHS.CompareTo(iRHS);
0158 }
0159 */
0160
0161 void TestMEtoEDMFormat::testMergeTString() {
0162   MEtoEDM<TString> empty(0);
0163
0164   MEtoEDM<TString> full(3);
0165   full.putMEtoEdmObject("a", "1");
0166   full.putMEtoEdmObject("b", "2");
0167   full.putMEtoEdmObject("c", "3");
0168
0169   MEtoEDM<TString> fullReordered(3);
0170   fullReordered.putMEtoEdmObject("b", "2");
0171   fullReordered.putMEtoEdmObject("a", "1");
0172   fullReordered.putMEtoEdmObject("c", "3");
0173
0174   MEtoEDM<TString> toMerge(full);
0175
0176   //be sure copy constructor worked
0177   CPPUNIT_ASSERT(areEquivalent(toMerge, full));
0178
0179   toMerge.mergeProduct(empty);
0180   CPPUNIT_ASSERT(areEquivalent(toMerge, full));
0181
0182   MEtoEDM<TString> toMerge2(empty);
0183   toMerge2.mergeProduct(full);
0184   CPPUNIT_ASSERT(areEquivalent(toMerge2, full));
0185
0186   MEtoEDM<TString> toMerge3(full);
0187   toMerge3.mergeProduct(fullReordered);
0188   CPPUNIT_ASSERT(areEquivalent(toMerge3, full));
0189
0190   MEtoEDM<TString> part1(2);
0191   part1.putMEtoEdmObject("a", "1");
0192   part1.putMEtoEdmObject("b", "2");
0193   MEtoEDM<TString> part2(1);
0194   part2.putMEtoEdmObject("c", "3");
0195   part1.mergeProduct(part2);
0196   CPPUNIT_ASSERT(areEquivalent(part1, full));
0197 }
0198
0199 namespace {
0200   const TAxis dummy(1.0, 0.0, 1.0);
0201
0202   struct Dummy {
0203     Dummy(int i) : m_i(i) {}
0204     Dummy() : m_i(0) {}
0205     void Add(const Dummy* iOther) {
0206       m_i += iOther->m_i;
0207       //std::cout <<"Dummy Add "<<m_i<<" "<<iOther->m_i<<std::endl;
0208     }
0209
0210     void Add(const Dummy* iOther, float weight = 1.) { m_i += iOther->m_i; }
0211     bool operator!=(const Dummy& iOther) const { return m_i != iOther.m_i; }
0212
0213     int GetNbinsX() const { return 1; }
0214     int GetNbinsY() const { return 1; }
0215     int GetNbinsZ() const { return 1; }
0216
0217     int GetNcells() const { return 9; }
0218     float GetBinContent(int bin) const { return -1.; }
0219     void SetBinContent(int bin, float value) const { return; }
0220     const TClass* IsA() const { return 0; }
0221
0222     const TAxis* GetXaxis() const { return &dummy; }
0223     const TAxis* GetYaxis() const { return &dummy; }
0224     const TAxis* GetZaxis() const { return &dummy; }
0225
0226     bool CanExtendAllAxes() const { return false; }
0227     long long Merge(void*) { return -1; }
0228
0229     int m_i;
0230   };
0231
0232   std::ostream& operator<<(std::ostream& os, const Dummy& iDummy) {
0233     os << iDummy.m_i;
0234     return os;
0235   }
0236
0237 }  // namespace
0238
0239 void TestMEtoEDMFormat::testMergeT() {
0240   MEtoEDM<Dummy> empty(0);
0241
0242   MEtoEDM<Dummy> full(3);
0243   full.putMEtoEdmObject("a", 1);
0244   full.putMEtoEdmObject("b", 2);
0245   full.putMEtoEdmObject("c", 3);
0246
0247   MEtoEDM<Dummy> fullReordered(3);
0248   fullReordered.putMEtoEdmObject("b", 2);
0249   fullReordered.putMEtoEdmObject("a", 1);
0250   fullReordered.putMEtoEdmObject("c", 3);
0251
0252   MEtoEDM<Dummy> doubleFull(3);
0253   doubleFull.putMEtoEdmObject("a", 2 * 1);
0254   doubleFull.putMEtoEdmObject("b", 2 * 2);
0255   doubleFull.putMEtoEdmObject("c", 2 * 3);
0256
0257   MEtoEDM<Dummy> toMerge(full);
0258
0259   //be sure copy constructor worked
0260   CPPUNIT_ASSERT(areEquivalent(toMerge, full));
0261
0262   toMerge.mergeProduct(empty);
0263   CPPUNIT_ASSERT(areEquivalent(toMerge, full));
0264
0265   MEtoEDM<Dummy> toMerge2(empty);
0266   toMerge2.mergeProduct(full);
0267   CPPUNIT_ASSERT(areEquivalent(toMerge2, full));
0268
0269   MEtoEDM<Dummy> toMerge3(full);
0270   toMerge3.mergeProduct(fullReordered);
0271   CPPUNIT_ASSERT(areEquivalent(toMerge3, doubleFull));
0272
0273   MEtoEDM<Dummy> part1(2);
0274   part1.putMEtoEdmObject("a", 1);
0275   part1.putMEtoEdmObject("b", 2);
0276   MEtoEDM<Dummy> part2(1);
0277   part2.putMEtoEdmObject("c", 3);
0278   part1.mergeProduct(part2);
0279   CPPUNIT_ASSERT(areEquivalent(part1, full));
0280 }