Belle II Software  release-05-01-25
datastore.cc
1 #include <framework/dataobjects/EventMetaData.h>
2 #include <framework/dataobjects/ProfileInfo.h>
3 #include <framework/datastore/StoreArray.h>
4 #include <framework/datastore/StoreObjPtr.h>
5 #include <framework/datastore/RelationsObject.h>
6 #include <framework/utilities/TestHelpers.h>
7 
8 #include <gtest/gtest.h>
9 
10 #include <algorithm>
11 
12 using namespace std;
13 using namespace Belle2;
14 
15 namespace {
17  class DataStoreTest : public ::testing::Test {
18  protected:
20  void SetUp() override
21  {
22  StoreObjPtr<EventMetaData> evtPtr;
23  StoreArray<EventMetaData> evtData;
24  StoreArray<EventMetaData> evtDataDifferentName("EventMetaDatas_2");
25  StoreArray<EventMetaData> evtDataEmpty("Empty");
26  StoreArray<EventMetaData> evtDataDifferentDurability("", DataStore::c_Persistent);
27  StoreArray<ProfileInfo> profileInfo;
28 
29  DataStore::Instance().setInitializeActive(true);
30  evtPtr.registerInDataStore();
31  evtData.registerInDataStore();
32  evtDataDifferentName.registerInDataStore();
33  evtDataEmpty.registerInDataStore();
34  evtDataDifferentDurability.registerInDataStore();
35  profileInfo.registerInDataStore();
36  DataStore::Instance().setInitializeActive(false);
37 
38  evtPtr.create();
39  evtPtr->setEvent(42);
40 
41 
42  ProfileInfo profileInfoObject(128, 64, 60.0);
43  for (int i = 0; i < 10; ++i) {
44  //direct construction
45  EventMetaData* newobj = evtData.appendNew();
46  newobj->setEvent(10 + i);
47 
48  //copy-construction
49  EventMetaData newObj2;
50  newObj2.setEvent(20 + i);
51  evtDataDifferentName.appendNew(newObj2);
52 
53  //fancy constructors
54  newobj = evtDataDifferentDurability.appendNew(30 + i);
55  ASSERT_TRUE(newobj != nullptr);
56 
57  //copy-construct ProfileInfo objects
58  profileInfo.appendNew(profileInfoObject);
59  }
60  }
61 
63  void TearDown() override
64  {
65  DataStore::Instance().reset();
66  }
67 
69  static void verifyContents()
70  {
71  StoreObjPtr<EventMetaData> evtPtr;
72  EXPECT_TRUE(evtPtr.isValid());
73  EXPECT_EQ(evtPtr->getEvent(), (unsigned long)42);
74 
75  StoreArray<EventMetaData> evtData;
76  StoreArray<EventMetaData> evtDataDifferentName("EventMetaDatas_2");
77  StoreArray<EventMetaData> evtDataDifferentDurability("", DataStore::c_Persistent);
78  StoreArray<ProfileInfo> profileInfo;
79  EXPECT_EQ(evtData.getEntries(), 10);
80  EXPECT_EQ(evtDataDifferentName.getEntries(), 10);
81  EXPECT_EQ(evtDataDifferentDurability.getEntries(), 10);
82  EXPECT_EQ(profileInfo.getEntries(), 10);
83  for (int i = 0; i < 10; ++i) {
84  EXPECT_EQ((int)evtData[i]->getEvent(), 10 + i);
85  EXPECT_EQ((int)evtDataDifferentName[i]->getEvent(), 20 + i);
86  EXPECT_EQ((int)evtDataDifferentDurability[i]->getEvent(), 30 + i);
87 
88  EXPECT_EQ(profileInfo[i]->getVirtualMemory(), 128u);
89  EXPECT_FLOAT_EQ(profileInfo[i]->getTimeInSec(), 60.0);
90  }
91  }
92 
93  };
94 
95  TEST_F(DataStoreTest, EntryNames)
96  {
97  EXPECT_EQ("JustSomeStuff", DataStore::defaultObjectName("JustSomeStuff"));
98  EXPECT_EQ("JustSomeStuff", DataStore::defaultObjectName("Belle2::Foo::JustSomeStuff"));
99  EXPECT_EQ("JustSomeStuffs", DataStore::defaultArrayName("Belle2::Foo::JustSomeStuff"));
100 
101  EXPECT_EQ("MyOwnName", DataStore::arrayName<TObject>("MyOwnName"));
102  EXPECT_EQ("MyOwnName", DataStore::arrayName(TObject::Class(), "MyOwnName"));
103  EXPECT_EQ("TObjects", DataStore::arrayName<TObject>(""));
104  EXPECT_EQ("TObjects", DataStore::arrayName(TObject::Class(), ""));
105 
106  EXPECT_EQ("MyOwnName", DataStore::objectName<TObject>("MyOwnName"));
107  EXPECT_EQ("MyOwnName", DataStore::objectName(TObject::Class(), "MyOwnName"));
108 
109  EXPECT_EQ("TObject", DataStore::objectName<TObject>(""));
110  EXPECT_EQ("TObject", DataStore::objectName(TObject::Class(), ""));
111 
112  EXPECT_EQ("EventMetaDatas", DataStore::arrayName<EventMetaData>(""));
113  EXPECT_EQ("GF2Track", DataStore::defaultObjectName("genfit::Track"));
114 
115  EXPECT_EQ("AToB", DataStore::relationName("A", "B"));
116  auto relname = DataStore::defaultRelationName<EventMetaData, ProfileInfo>();
117  EXPECT_EQ("EventMetaDatasToProfileInfos", relname);
118  }
119 
120  TEST_F(DataStoreTest, GetTClass)
121  {
122  EXPECT_EQ(Belle2::EventMetaData::Class(), DataStore::getTClassFromDefaultObjectName("Belle2::EventMetaData"));
123  EXPECT_EQ(Belle2::EventMetaData::Class(), DataStore::getTClassFromDefaultObjectName("EventMetaData"));
124 
125  EXPECT_EQ(Belle2::EventMetaData::Class(), DataStore::getTClassFromDefaultArrayName("Belle2::EventMetaDatas"));
126  EXPECT_EQ(Belle2::EventMetaData::Class(), DataStore::getTClassFromDefaultArrayName("EventMetaDatas"));
127  }
128 
129 
131  TEST_F(DataStoreTest, AttachTest)
132  {
133  StoreObjPtr<EventMetaData> evtPtr;
134  EXPECT_TRUE(evtPtr);
135 
136  StoreArray<EventMetaData> evtData;
137  EXPECT_TRUE(evtData);
138  StoreArray<EventMetaData> evtDataDifferentName("EventMetaDatas_2");
139  EXPECT_TRUE(evtDataDifferentName);
140  StoreArray<EventMetaData> evtDataDifferentDurability("", DataStore::c_Persistent);
141  EXPECT_TRUE(evtDataDifferentDurability);
142  StoreArray<ProfileInfo> profileInfo;
143  EXPECT_TRUE(profileInfo);
144  }
145 
147  TEST_F(DataStoreTest, TypeTest)
148  {
149  //attach with incompatible type
150  EXPECT_B2FATAL(StoreArray<ProfileInfo>("EventMetaDatas").isValid());
151  EXPECT_B2FATAL(StoreObjPtr<ProfileInfo>("EventMetaData").isValid());
152 
153  //attaching objects to array and vice versa shouldn't work
154  //neither should the store allow objects with same name/durability
155  //as existing arrays
156  EXPECT_B2FATAL(StoreArray<EventMetaData>("EventMetaData").isValid());
157  EXPECT_B2FATAL(StoreObjPtr<EventMetaData>("EventMetaDatas").isValid());
158 
159  //getting a base class is OK
160  EXPECT_TRUE(StoreArray<TObject>("EventMetaDatas").isValid());
161  StoreObjPtr<TObject> emd("EventMetaData");
162  EXPECT_TRUE(emd.isValid());
163  EXPECT_EQ(std::string("Belle2::EventMetaData"), std::string(emd->GetName()));
164  }
165 
167  TEST_F(DataStoreTest, MetaDataTest)
168  {
169  StoreObjPtr<EventMetaData> evtPtr;
170  EXPECT_EQ(evtPtr.getDurability(), DataStore::c_Event);
171  EXPECT_TRUE(evtPtr.getName() == "EventMetaData");
172  EXPECT_FALSE(evtPtr.isArray());
173  EXPECT_TRUE(evtPtr.getClass() == EventMetaData::Class());
174 
175  StoreArray<EventMetaData> evtData;
176  StoreArray<EventMetaData> evtData2("EventMetaDatas");
177  StoreArray<EventMetaData> evtDataDifferentName("EventMetaDatas_2");
178  StoreArray<EventMetaData> evtDataDifferentDurability("", DataStore::c_Persistent);
179  EXPECT_TRUE(evtData.getName() == "EventMetaDatas");
180  EXPECT_TRUE(evtData.isArray());
181  EXPECT_TRUE(evtData.getClass() == EventMetaData::Class());
182  EXPECT_EQ(evtData.getDurability(), DataStore::c_Event);
183  EXPECT_TRUE(evtData == evtData2);
184  EXPECT_FALSE(evtData != evtData2);
185  EXPECT_FALSE(evtData == evtDataDifferentName);
186  EXPECT_FALSE(evtData == evtDataDifferentDurability);
187 
188  //different type
189  StoreArray<ProfileInfo> profileInfo;
190  EXPECT_FALSE(profileInfo == evtData);
191  EXPECT_TRUE(profileInfo != evtData);
192  //note: EXPECT_NE/EQ do things I don't understand. this doesn't work:
193  //EXPECT_NE(profileInfo, evtData);
194  }
195 
197  TEST_F(DataStoreTest, ReadOnlyAttach)
198  {
199  StoreObjPtr<EventMetaData> a("", DataStore::c_Event);
200  EXPECT_TRUE(a);
201  EXPECT_EQ(a->getEvent(), (unsigned long)42);
202  StoreObjPtr<EventMetaData> b("nonexisting", DataStore::c_Event);
203  EXPECT_FALSE(b);
204  StoreObjPtr<EventMetaData> c("", DataStore::c_Persistent);
205  EXPECT_FALSE(c);
206  StoreObjPtr<EventMetaData> d("", DataStore::c_Persistent);
207  EXPECT_FALSE(d);
208 
209  //check we didn't insert a new object with 'd'
210  StoreObjPtr<EventMetaData> e("", DataStore::c_Persistent);
211  EXPECT_FALSE(e);
212  }
213 
215  TEST_F(DataStoreTest, VerifyContents)
216  {
217  verifyContents();
218 
219  //test removing data
220  StoreArray<EventMetaData> evtData;
221  evtData.clear();
222  EXPECT_TRUE(evtData.isValid());
223  EXPECT_EQ(evtData.getEntries(), 0);
224 
225  StoreObjPtr<EventMetaData> evtPtr;
226  evtPtr.clear(); //resets to default-constructed object
227  EXPECT_TRUE(evtPtr.isValid());
228  EXPECT_EQ(evtPtr->getEvent(), 1);
229  }
230  TEST_F(DataStoreTest, InvalidAccessor)
231  {
232  StoreArray<EventMetaData> none("doesntexist");
233  EXPECT_FALSE(none.isValid());
234  EXPECT_THROW(none.getPtr(), std::runtime_error);
235  EXPECT_THROW(none.appendNew(), std::runtime_error);
236  none.clear();
237  EXPECT_THROW(none.getPtr(), std::runtime_error);
238  EXPECT_EQ(0, none.getEntries());
239 
240  StoreObjPtr<EventMetaData> noobj("doesntexist");
241  EXPECT_FALSE(noobj.isValid());
242  EXPECT_THROW(*noobj, std::runtime_error);
243  EXPECT_THROW(noobj->getEvent(), std::runtime_error);
244 
245  }
246  TEST_F(DataStoreTest, RawAccess)
247  {
248  StoreArray<EventMetaData> evtData;
249  EXPECT_TRUE(evtData.getPtr() != nullptr);
250  }
251 
253  TEST_F(DataStoreTest, ArrayConsistency)
254  {
255  StoreArray<EventMetaData> evtData;
256  StoreArray<EventMetaData> evtDataDifferentName("EventMetaDatas_2");
257  StoreArray<EventMetaData> evtDataDifferentDurability("", DataStore::c_Persistent);
258  StoreArray<ProfileInfo> profileInfo;
259  EXPECT_EQ((int)evtData.getPtr()->GetEntries(), 10);
260  EXPECT_EQ((int)evtDataDifferentName.getPtr()->GetEntries(), 10);
261  EXPECT_EQ((int)evtDataDifferentDurability.getPtr()->GetEntries(), 10);
262  EXPECT_EQ((int)profileInfo.getPtr()->GetEntries(), 10);
263  }
264 
266  TEST_F(DataStoreTest, RangeCheck)
267  {
268  StoreArray<EventMetaData> evtData;
269  EXPECT_TRUE(evtData[0] != nullptr);
270  EXPECT_THROW(evtData[-1], std::out_of_range);
271  EXPECT_THROW(evtData[10], std::out_of_range);
272  }
273 
275  TEST_F(DataStoreTest, ClearMaps)
276  {
277  StoreObjPtr<EventMetaData> evtPtr;
278  EXPECT_EQ(evtPtr->getEvent(), (unsigned long)42);
279 
280  //clear event map (evtPtr is now invalid!)
281  DataStore::Instance().invalidateData(DataStore::c_Event);
282 
283  //right now this is NULL, since no object was actually created yet
284  StoreObjPtr<EventMetaData> a;
285  EXPECT_FALSE(a);
286 
287  StoreObjPtr<EventMetaData> b;
288  EXPECT_FALSE(b);
289 
290  //create() should produce a default constructed object
291  b.create();
292  EXPECT_TRUE(*b == EventMetaData());
293  //since a should attach to same object...
294  EXPECT_TRUE(*a == *b);
295 
296  a->setEvent(42);
297  //don't replace existing object
298  a.create(false);
299  EXPECT_EQ(a->getEvent(), (unsigned long)42);
300  //replace existing object
301  a.create(true);
302  EXPECT_NE(a->getEvent(), (unsigned long)42);
303 
304 
305  //cleared arrays must be empty
306  StoreArray<EventMetaData> evtData;
307  StoreArray<EventMetaData> evtDataDifferentName("EventMetaDatas_2");
308  StoreArray<ProfileInfo> profileInfo;
309  EXPECT_EQ(evtData.getEntries(), 0);
310  EXPECT_EQ(evtDataDifferentName.getEntries(), 0);
311  EXPECT_EQ(profileInfo.getEntries(), 0);
312 
313  //run durability, should be unaffected
314  StoreArray<EventMetaData> evtDataDifferentDurability("", DataStore::c_Persistent);
315  EXPECT_EQ(evtDataDifferentDurability.getEntries(), 10);
316  }
317 
319  TEST_F(DataStoreTest, RequireObjects)
320  {
321  DataStore::Instance().setInitializeActive(true);
322  EXPECT_TRUE(StoreObjPtr<EventMetaData>().isRequired());
323  EXPECT_FALSE(StoreObjPtr<EventMetaData>("", DataStore::c_Persistent).isRequired());
324  EXPECT_FALSE(StoreObjPtr<EventMetaData>("nonexisting2").isRequired());
325  EXPECT_FALSE(StoreObjPtr<EventMetaData>("", DataStore::c_Persistent).isRequired());
326  //check we didn't create one...
327  EXPECT_FALSE(StoreObjPtr<EventMetaData>("nonexisting2").isRequired());
328 
329  EXPECT_TRUE(StoreArray<EventMetaData>().isRequired());
330  EXPECT_TRUE(StoreArray<EventMetaData>("EventMetaDatas_2").isRequired());
331  EXPECT_TRUE(StoreArray<EventMetaData>("", DataStore::c_Persistent).isRequired());
332  EXPECT_FALSE(StoreArray<EventMetaData>("blah").isRequired());
333  EXPECT_FALSE(StoreArray<EventMetaData>("blah").isRequired());
334  EXPECT_TRUE(StoreArray<ProfileInfo>().isRequired());
335  //check we didn't create one...
336  EXPECT_FALSE(StoreArray<EventMetaData>("blah").isRequired());
337  DataStore::Instance().setInitializeActive(false);
338 
339  EXPECT_B2FATAL(StoreObjPtr<EventMetaData>().isRequired());
340  }
341 
343  TEST_F(DataStoreTest, StoreArrayIteration)
344  {
345  const StoreArray<EventMetaData> evtData;
346  StoreArray<EventMetaData> evtDataNonConst;
347  //array syntax
348  for (int i = 0; i < evtData.getEntries(); i++) {
349  EXPECT_TRUE(evtData[i] != nullptr);
350  }
351 
352  //basic iterator features
353  {
354  //input iterator:
355  StoreArray<EventMetaData>::iterator it = evtDataNonConst.begin();
356  StoreArray<EventMetaData>::iterator it2(it);
357  it2 = it;
358 
359  //equality/inequality
360  EXPECT_TRUE(it == it2);
361  EXPECT_FALSE(it != it2);
362 
363  //test postfix
364  EXPECT_TRUE((it++) == it2);
365  ++it2;
366 
367  //test prefix
368  EXPECT_TRUE(it != (++it2));
369 
370  //rvalue deref
371  EventMetaData ev = *it;
372  it->getEvent();
373  it2 = it;
374 
375  //output iterator:
376  //lvalue deref (just overwrite with same object)
377  *it = ev;
378  *it++ = ev;
379 
380  EXPECT_TRUE(ev == *it2);
381  EXPECT_TRUE(it2 != it); //was incremented
382  EXPECT_TRUE(ev != *it); //was incremented
383 
384  //forward iterator (default constructor and multi-pass):
385  StoreArray<EventMetaData>::iterator it3;
386  it3 = it;
387  ev = *it++;
388  EXPECT_TRUE(ev == *it3);
389  }
390 
391  //algorithm stuff
392  {
393  StoreArray<EventMetaData> evtDataDifferentName("EventMetaDatas_2");
394  EXPECT_EQ((int)evtDataNonConst[0]->getEvent(), 10);
395  EXPECT_EQ((int)evtDataDifferentName[0]->getEvent(), 20);
396  //swap all members of evtDataNonConst ande evtDataDifferentName (same length!)
397  std::swap_ranges(evtDataNonConst.begin(), evtDataNonConst.end(), evtDataDifferentName.begin());
398  EXPECT_EQ((int)evtDataDifferentName[9]->getEvent(), 19);
399  EXPECT_EQ((int)evtDataNonConst[9]->getEvent(), 29);
400 
401  //undo
402  std::swap_ranges(evtDataDifferentName.begin(), evtDataDifferentName.end(), evtDataNonConst.begin());
403  EXPECT_EQ((int)evtDataNonConst[9]->getEvent(), 19);
404  EXPECT_EQ((int)evtDataDifferentName[9]->getEvent(), 29);
405  }
406 
407  int i = 0;
408  for (StoreArray<EventMetaData>::iterator it = evtDataNonConst.begin(); it != evtDataNonConst.end(); ++it) {
409  EXPECT_TRUE(&(*it) == evtData[i]);
410  EXPECT_EQ((int)it->getEvent(), 10 + i);
411  i++;
412  }
413  EXPECT_EQ(i, evtData.getEntries());
414 
415  //range-based for
416  i = 0;
417  for (EventMetaData& emd : evtDataNonConst) {
418  EXPECT_TRUE(&emd == evtData[i]);
419  i++;
420  }
421  EXPECT_EQ(i, evtData.getEntries());
422 
423  //range-based for (const)
424  i = 0;
425  for (const EventMetaData& emd : evtData) {
426  EXPECT_TRUE(&emd == evtData[i]);
427  i++;
428  }
429  EXPECT_EQ(i, evtData.getEntries());
430 
431  //iteration over registered, but empty array
432  i = 0;
433  StoreArray<EventMetaData> evtDataEmpty("Empty");
434  for (const EventMetaData& emd : evtDataEmpty) {
435  (void)emd;
436  i++;
437  }
438  EXPECT_EQ(i, 0);
439  //iteration over non-existing array
440  i = 0;
441  StoreArray<EventMetaData> nonExistant("doesntexist");
442  for (const EventMetaData& emd : nonExistant) {
443  (void)emd;
444  i++;
445  }
446  EXPECT_EQ(i, 0);
447  }
448 
450  TEST_F(DataStoreTest, DataStoreRegistration)
451  {
452  //emulate Module::initialize()
453  DataStore::Instance().setInitializeActive(true);
454 
455  StoreObjPtr<EventMetaData> evtPtr("abc123");
456  StoreArray<EventMetaData> evtArray("abc123array");
457 
458  //verify that they aren't registered right now
459  EXPECT_FALSE(evtPtr.isOptional());
460  EXPECT_FALSE(evtArray.isOptional());
461  EXPECT_FALSE(evtPtr.isRequired());
462  EXPECT_FALSE(evtArray.isRequired());
463  EXPECT_FALSE(evtPtr.isValid());
464  EXPECT_FALSE(evtArray.isValid());
465  EXPECT_FALSE(StoreObjPtr<EventMetaData>(evtPtr.getName()).isRequired());
466  EXPECT_FALSE(StoreArray<EventMetaData>(evtArray.getName()).isRequired());
467 
468  EXPECT_TRUE(evtPtr.registerInDataStore());
469  EXPECT_TRUE(evtArray.registerInDataStore(DataStore::c_DontWriteOut));
470 
471  //already registered, ok by default
472  EXPECT_TRUE(evtPtr.registerInDataStore());
473  EXPECT_TRUE(evtArray.registerInDataStore(DataStore::c_DontWriteOut));
474 
475  //test c_ErrorIfAlreadyRegistered (return code=false + B2ERROR)
476  EXPECT_B2ERROR(EXPECT_FALSE(evtPtr.registerInDataStore(DataStore::c_ErrorIfAlreadyRegistered)));
477  EXPECT_B2ERROR(EXPECT_FALSE(evtArray.registerInDataStore(DataStore::c_DontWriteOut | DataStore::c_ErrorIfAlreadyRegistered)));
478 
479  //now they should be available:
480  EXPECT_TRUE(evtPtr.isOptional());
481  EXPECT_TRUE(evtArray.isOptional());
482  EXPECT_TRUE(evtPtr.isRequired());
483  EXPECT_TRUE(evtArray.isRequired());
484  EXPECT_FALSE(evtPtr.isValid()); // not valid until created
485  EXPECT_TRUE(evtArray.isValid());
486  EXPECT_TRUE(StoreObjPtr<EventMetaData>(evtPtr.getName()).isRequired());
487  EXPECT_TRUE(StoreArray<EventMetaData>(evtArray.getName()).isRequired());
488  DataStore::Instance().setInitializeActive(false);
489  }
490 
491  TEST_F(DataStoreTest, RegistrationOutsideOfInitializeShouldFail)
492  {
493  //outside initialize(), registration results in an error
494  EXPECT_B2ERROR(StoreArray<EventMetaData>().registerInDataStore("someothernewname"));
495  EXPECT_B2ERROR(StoreArray<EventMetaData>().registerInDataStore("someothernewname", DataStore::c_DontWriteOut));
496  EXPECT_FALSE(StoreArray<EventMetaData>().isOptional("someothernewname"));
497 
498  //accessing unregistered things doesn't work.
499  StoreArray<EventMetaData> someothernewname("someothernewname");
500  EXPECT_FALSE(someothernewname.isValid());
501  }
502 
503  TEST_F(DataStoreTest, ConstructedBeforeInitializeButWithNonDefaultName)
504  {
505  //as a class member, the classes get constructed before initialize(), but we may not have the name yet
506  StoreArray<EventMetaData> events;
507  StoreObjPtr<ProfileInfo> profile;
508  StoreArray<EventMetaData> eventsMetaDatas2;
509 
510  //inialize(), use names from module paramateres
511  DataStore::Instance().setInitializeActive(true);
512  {
513  EXPECT_TRUE(events.registerInDataStore("ThisBeInterestingNameForEvents"));
514  EXPECT_TRUE(profile.registerInDataStore("MyProfileInfoName", DataStore::c_DontWriteOut));
515 
516  //also should work with optional / required
517  EXPECT_TRUE(eventsMetaDatas2.isOptional("EventMetaDatas_2"));
518  EXPECT_TRUE(eventsMetaDatas2.isRequired("EventMetaDatas_2"));
519  }
520  DataStore::Instance().setInitializeActive(false);
521 
522  //ok, our objects should now know their name
523  EXPECT_EQ("ThisBeInterestingNameForEvents", events.getName());
524  EXPECT_TRUE(profile.getName() == "MyProfileInfoName");
525  EXPECT_TRUE(profile.notWrittenOut());
526  EXPECT_TRUE(eventsMetaDatas2.getName() == "EventMetaDatas_2");
527 
528  //accessing data
529  EXPECT_EQ(0, events.getEntries());
530  EXPECT_FALSE(profile.isValid());
531  EXPECT_EQ(10, eventsMetaDatas2.getEntries());
532 
533  //saving data
534  profile.create();
535  EXPECT_TRUE(profile.isValid());
536  StoreObjPtr<ProfileInfo> profileAttachAgain("MyProfileInfoName");
537  EXPECT_TRUE(profileAttachAgain.isValid());
538 
539  events.appendNew();
540  EXPECT_EQ(1, events.getEntries());
541  StoreArray<EventMetaData> eventsAttachAgain("ThisBeInterestingNameForEvents");
542  EXPECT_EQ(1, eventsAttachAgain.getEntries());
543  }
544 
545  TEST_F(DataStoreTest, ArrayList)
546  {
547  std::vector<std::string> arrayList = StoreArray<EventMetaData>::getArrayList();
548  std::vector<std::string> exparrayList = {"Empty", "EventMetaDatas", "EventMetaDatas_2"};
549  EXPECT_EQ(exparrayList, arrayList);
550  }
551 
552  TEST_F(DataStoreTest, ReplaceData)
553  {
554  StoreObjPtr<EventMetaData> evtPtr;
555  StoreObjPtr<EventMetaData> evtPtrB("abc123");
556  StoreArray<EventMetaData> evtData;
557  StoreArray<EventMetaData> evtDataB("otherArray");
558  DataStore::Instance().setInitializeActive(true);
559  evtPtrB.registerInDataStore(DataStore::c_DontWriteOut);
560  evtDataB.registerInDataStore(DataStore::c_DontWriteOut);
561  DataStore::Instance().setInitializeActive(false);
562 
563  {
564  //objects
565  EXPECT_EQ(42, evtPtr->getEvent());
566  EXPECT_FALSE(evtPtrB.isValid());
567  EXPECT_FALSE(evtPtr.notWrittenOut());
568  EXPECT_TRUE(evtPtrB.notWrittenOut());
569 
570  DataStore::Instance().replaceData(evtPtr, evtPtrB);
571  EXPECT_EQ(42, evtPtrB->getEvent());
572  EXPECT_FALSE(evtPtr.isValid());
573 
574  //metadata unchanged
575  EXPECT_FALSE(evtPtr.notWrittenOut());
576  EXPECT_TRUE(evtPtrB.notWrittenOut());
577 
578  //move null object into existing one
579  DataStore::Instance().replaceData(evtPtr, evtPtrB);
580  EXPECT_FALSE(evtPtr.isValid());
581  EXPECT_FALSE(evtPtrB.isValid());
582 
583  //null object to null object
584  DataStore::Instance().replaceData(evtPtr, evtPtrB);
585  EXPECT_FALSE(evtPtr.isValid());
586  EXPECT_FALSE(evtPtrB.isValid());
587  }
588 
589  {
590  //arrays
591  EXPECT_EQ(10, evtData.getEntries());
592  EXPECT_EQ(0, evtDataB.getEntries());
593 
594  DataStore::Instance().replaceData(evtData, evtDataB);
595  EXPECT_EQ(0, evtData.getEntries());
596  EXPECT_EQ(10, evtDataB.getEntries());
597 
598  DataStore::Instance().replaceData(evtData, evtDataB);
599  EXPECT_EQ(0, evtData.getEntries());
600  EXPECT_EQ(0, evtDataB.getEntries());
601 
602  DataStore::Instance().replaceData(evtData, evtDataB);
603  EXPECT_EQ(0, evtData.getEntries());
604  EXPECT_EQ(0, evtDataB.getEntries());
605  }
606  }
607 
608  TEST_F(DataStoreTest, SwitchDataStore)
609  {
610  EXPECT_TRUE("" == DataStore::Instance().currentID());
611  //not created yet
612  EXPECT_THROW(DataStore::Instance().copyContentsTo("foo"), std::out_of_range);
613 
614  //create new DS ID
615  DataStore::Instance().createNewDataStoreID("foo");
616  EXPECT_TRUE("" == DataStore::Instance().currentID());
617  DataStore::Instance().copyContentsTo("foo");
618  EXPECT_TRUE("" == DataStore::Instance().currentID());
619  verifyContents();
620  DataStore::Instance().switchID("foo");
621  EXPECT_TRUE("foo" == DataStore::Instance().currentID());
622  verifyContents(); //still unmodified
623 
624  //change something
625  StoreObjPtr<EventMetaData> a;
626  a->setEvent(1234567);
627 
628  //and restore
629  DataStore::Instance().switchID("");
630  EXPECT_TRUE("" == DataStore::Instance().currentID());
631  verifyContents(); //back to normal
632 
633  //register another object in ""
634  //and try copying (this catches insufficient checks during copying)
635  StoreArray<EventMetaData> evtDataB("otherArray");
636  DataStore::Instance().setInitializeActive(true);
637  evtDataB.registerInDataStore();
638  DataStore::Instance().copyContentsTo("foo");
639  }
640 
641  TEST_F(DataStoreTest, FindStoreEntry)
642  {
643  DataStore::StoreEntry* entry = nullptr;
644  int index = -1;
645 
646  //test TObject-derived arrays
647  StoreArray<EventMetaData> evtData;
648  StoreArray<EventMetaData> evtDataDifferentName("EventMetaDatas_2");
649 
650  EXPECT_TRUE(DataStore::Instance().findStoreEntry(evtData[5], entry, index));
651  EXPECT_EQ(index, 5);
652  EXPECT_EQ(entry->name, evtData.getName());
653 
654  //entry and index are already correct, should return quickly
655  EXPECT_TRUE(DataStore::Instance().findStoreEntry(evtData[5], entry, index));
656  EXPECT_EQ(index, 5);
657  EXPECT_EQ(entry->name, evtData.getName());
658 
659  //not resetting entry, index here. this should not usually happen, but ought to be harmless
660  EXPECT_TRUE(DataStore::Instance().findStoreEntry(evtDataDifferentName[7], entry, index));
661  EXPECT_EQ(index, 7);
662  EXPECT_EQ(entry->name, evtDataDifferentName.getName());
663 
664  entry = nullptr; index = -1;
665  EXPECT_TRUE(DataStore::Instance().findStoreEntry(evtDataDifferentName[7], entry, index));
666  EXPECT_EQ(index, 7);
667  EXPECT_EQ(entry->name, evtDataDifferentName.getName());
668 
669  entry = nullptr; index = -1;
670  EventMetaData localObj;
671  EXPECT_FALSE(DataStore::Instance().findStoreEntry(&localObj, entry, index));
672  EXPECT_EQ(index, -1);
673  EXPECT_EQ(entry, nullptr);
674 
675 
676  //test RelationsObjects (caches used)
677  StoreArray<RelationsObject> relObjs;
678  StoreArray<RelationsObject> relObjs2("relobs2");
679  DataStore::Instance().setInitializeActive(true);
680  relObjs.registerInDataStore();
681  relObjs2.registerInDataStore();
682  DataStore::Instance().setInitializeActive(false);
683  for (int i = 0; i < 6; i++) {
684  relObjs.appendNew();
685  relObjs2.appendNew();
686  }
687 
688  entry = nullptr; index = -1;
689  EXPECT_TRUE(DataStore::Instance().findStoreEntry(relObjs[5], entry, index));
690  EXPECT_EQ(index, 5);
691  EXPECT_EQ(entry->name, relObjs.getName());
692 
693  //should use cache now
694  entry = nullptr; index = -1;
695  EXPECT_TRUE(DataStore::Instance().findStoreEntry(relObjs[5], entry, index));
696  EXPECT_EQ(index, 5);
697  EXPECT_EQ(entry->name, relObjs.getName());
698 
699  entry = nullptr; index = -1;
700  EXPECT_TRUE(DataStore::Instance().findStoreEntry(relObjs2[2], entry, index));
701  EXPECT_EQ(index, 2);
702  EXPECT_EQ(entry->name, relObjs2.getName());
703 
704  //and caches again
705  entry = nullptr; index = -1;
706  EXPECT_TRUE(DataStore::Instance().findStoreEntry(relObjs2[2], entry, index));
707  EXPECT_EQ(index, 2);
708  EXPECT_EQ(entry->name, relObjs2.getName());
709 
710  //test finding storeobjptr (not implemented, so nothing found)
711  StoreObjPtr<EventMetaData> evtPtr;
712  entry = nullptr; index = -1;
713  EXPECT_FALSE(DataStore::Instance().findStoreEntry(&(*evtPtr), entry, index));
714  EXPECT_EQ(index, -1);
715  EXPECT_EQ(entry, nullptr);
716 
717  //searching for nullptr is allowed
718  EXPECT_FALSE(DataStore::Instance().findStoreEntry(nullptr, entry, index));
719  }
720 
721  TEST_F(DataStoreTest, ListEntries)
722  {
723  StoreArray<EventMetaData> evtData;
724  EXPECT_EQ(0, DataStore::Instance().getListOfRelatedArrays(evtData).size());
725 
726  DataStore::Instance().setInitializeActive(true);
727  StoreArray<ProfileInfo> profileInfo;
728  evtData.registerRelationTo(profileInfo);
729  DataStore::Instance().setInitializeActive(false);
730 
731  EXPECT_TRUE(DataStore::Instance().hasRelation(evtData, profileInfo, DataStore::c_Event, ""));
732  EXPECT_FALSE(DataStore::Instance().hasRelation(profileInfo, evtData, DataStore::c_Event, ""));
733  EXPECT_FALSE(DataStore::Instance().hasRelation(evtData, profileInfo, DataStore::c_Event, "SOMENONSENSE"));
734  EXPECT_FALSE(DataStore::Instance().hasRelation(evtData, profileInfo, DataStore::c_Persistent, ""));
735  EXPECT_FALSE(DataStore::Instance().hasRelation(profileInfo, evtData, DataStore::c_Persistent, ""));
736 
737  EXPECT_EQ(1, DataStore::Instance().getListOfRelatedArrays(evtData).size());
738  EXPECT_EQ(1, DataStore::Instance().getListOfRelatedArrays(profileInfo).size());
739 
740  EXPECT_EQ(1, DataStore::Instance().getListOfArrays(ProfileInfo::Class(), DataStore::c_Event).size());
741  EXPECT_EQ(0, DataStore::Instance().getListOfArrays(ProfileInfo::Class(), DataStore::c_Persistent).size());
742  EXPECT_EQ(1, DataStore::Instance().getListOfArrays(EventMetaData::Class(), DataStore::c_Persistent).size());
743  EXPECT_EQ(3, DataStore::Instance().getListOfArrays(EventMetaData::Class(), DataStore::c_Event).size());
744 
745  EXPECT_EQ(1, DataStore::Instance().getListOfArrays(TObject::Class(), DataStore::c_Persistent).size());
746  EXPECT_EQ(4, DataStore::Instance().getListOfArrays(TObject::Class(), DataStore::c_Event).size());
747 
748  EXPECT_EQ(1, DataStore::Instance().getListOfObjects(EventMetaData::Class(), DataStore::c_Event).size());
749  EXPECT_EQ(0, DataStore::Instance().getListOfObjects(EventMetaData::Class(), DataStore::c_Persistent).size());
750  EXPECT_EQ(1, DataStore::Instance().getListOfObjects(TObject::Class(), DataStore::c_Event).size());
751  EXPECT_EQ(0, DataStore::Instance().getListOfObjects(TObject::Class(), DataStore::c_Persistent).size());
752  }
753 
754  TEST_F(DataStoreTest, Assign)
755  {
756  StoreArray<EventMetaData> evtData;
757  EXPECT_FALSE(evtData.assign(new EventMetaData(), true));
758  EXPECT_FALSE(evtData.assign(new EventMetaData(), false));
759 
760  EXPECT_TRUE(evtData.isValid());
761  EXPECT_EQ(evtData.getEntries(), 10);
762 
763  StoreObjPtr<EventMetaData> evtPtr;
764  auto* newobj = new EventMetaData();
765  newobj->setEvent(123);
766  EXPECT_FALSE(evtPtr.assign(new EventMetaData(), false));
767  EXPECT_FALSE(evtPtr.assign(new ProfileInfo(), true));
768  EXPECT_EQ(evtPtr->getEvent(), 42);
769  EXPECT_TRUE(evtPtr.assign(newobj, true));
770  EXPECT_EQ(evtPtr->getEvent(), 123);
771  }
772 } // namespace
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:256
Belle2::ProfileInfo
Store execution time and memory usage.
Definition: ProfileInfo.h:32
Belle2::StoreArray::registerRelationTo
bool registerRelationTo(const StoreArray< TO > &toArray, DataStore::EDurability durability=DataStore::c_Event, DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut, const std::string &namedRelation="") const
Register a relation to the given StoreArray.
Definition: StoreArray.h:150
prepareAsicCrosstalkSimDB.e
e
aux.
Definition: prepareAsicCrosstalkSimDB.py:53
Belle2::EventMetaData::setEvent
void setEvent(unsigned int event)
Event Setter.
Definition: EventMetaData.h:65
Belle2::ObjArrayIterator
Optimizes class to iterate over TObjArray and classes inheriting from it.
Definition: ArrayIterator.h:25
Belle2::StoreEntry
Wraps a stored array/object, stored under unique (name, durability) key.
Definition: StoreEntry.h:15
Belle2::TrackFindingCDC::NForwardBackward::isValid
bool isValid(EForwardBackward eForwardBackward)
Check whether the given enum instance is one of the valid values.
Definition: EForwardBackward.h:55
Belle2::StoreEntry::name
std::string name
Name of the entry.
Definition: StoreEntry.h:46
Belle2::StoreArray::clear
void clear() override
Delete all entries in this array.
Definition: StoreArray.h:217
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: ParticleList.h:33
Belle2::TEST_F
TEST_F(GlobalLabelTest, LargeNumberOfTimeDependentParameters)
Test large number of time-dep params for registration and retrieval.
Definition: globalLabel.cc:65
Belle2::StoreArray::begin
iterator begin()
Return iterator to first entry.
Definition: StoreArray.h:328
Belle2::StoreArray::isValid
bool isValid() const
Check wether the array was registered.
Definition: StoreArray.h:298
Belle2::StoreArray::end
iterator end()
Return iterator to last entry +1.
Definition: StoreArray.h:330
Belle2::StoreArray::getPtr
TClonesArray * getPtr() const
Raw access to the underlying TClonesArray.
Definition: StoreArray.h:321
Belle2::EventMetaData
Store event, run, and experiment numbers.
Definition: EventMetaData.h:43
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: ECLMatchingPerformanceExpertModule.h:33
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:226
Belle2::StoreObjPtr::isValid
bool isValid() const
Check whether the object was created.
Definition: StoreObjPtr.h:120