stream.cc

#include <framework/utilities/Stream.h>
#include <framework/dataobjects/RelationContainer.h>
#include <framework/dataobjects/RelationElement.h>
#include <framework/datastore/DataStore.h>
#include <framework/gearbox/Gearbox.h>
#include <framework/gearbox/GearDir.h>
 
#include <TVector3.h>
 
#include <fstream>
#include <gtest/gtest.h>
 
using namespace std;
using namespace Belle2;
 
namespace {
  RelationContainer* createObject()
  {
    auto* relCont = new RelationContainer;
    relCont->setFromName("a");
    relCont->setToName("b");
    relCont->setFromDurability(DataStore::c_Event);
    relCont->setToDurability(DataStore::c_Event);
    // cppcheck-suppress constVariable ; cppcheck doesn't understand the weird new placement clonesarry thing
    TClonesArray& relations = relCont->elements();
    //let's make this a bit larger (very small objects are never compressed)
    for (int i = 0; i < 100; i++)
      new(relations.AddrAt(relations.GetLast() + 1)) RelationElement(0, i + 1, 42.0);
 
    return relCont;
  }
 
  void checkObject(const RelationContainer* rel)
  {
    ASSERT_NE(rel, nullptr);
    EXPECT_TRUE(rel->getFromName() == "a");
    EXPECT_TRUE(rel->getToName() == "b");
    EXPECT_EQ(rel->getEntries(), 100);
    for (int i = 0; i < 100; i++) {
      EXPECT_EQ(rel->getElement(i).getToIndex(0), (unsigned int)(i + 1));
      EXPECT_DOUBLE_EQ(rel->getElement(i).getWeight(0), 42.0);
    }
  }
 
  void checkGbContents()
  {
    const Gearbox& gb = Gearbox::getInstance();
 
    checkObject(dynamic_cast<const RelationContainer*>(gb.getTObject("/A/RelationContainer")));
 
    //Access from GearDir should work
    GearDir detector("/A/");
    checkObject(dynamic_cast<const RelationContainer*>(detector.getTObject("RelationContainer")));
  }
 
  TEST(StreamTest, raw)
  {
    TVector3 v(1.0, 2.0, 3.0);
    std::string vStr = Stream::serializeAndEncode(&v);
    //B2INFO(vStr);
 
    //restore
    TObject* obj = Stream::deserializeEncodedRawData(vStr);
    auto* v2 = dynamic_cast<TVector3*>(obj);
    ASSERT_NE(v2, nullptr);
    EXPECT_TRUE(*v2 == v);
 
    //something more complex
    RelationContainer* relCont = createObject();
 
    std::string relStr = Stream::serializeAndEncode(relCont);
    //B2INFO(relStr);
    obj = Stream::deserializeEncodedRawData(relStr);
    checkObject(dynamic_cast<const RelationContainer*>(obj));
 
    //creating file for next test..
    /*
    std::ofstream file("object_base64.xml");
    file << Stream::escapeXML(relStr);
    */
 
    // Given random input, TBase64 will most likely just crash, this specific truncation seems ok.
    // Note that the string length needs to be a multiple of 4 because
    // otherwise TBase64 will definitely access memory it should not as it just
    // assumes multiple of four and then performs an invalid read of a char
    // which it casts to unsigned int.
    std::string truncated = vStr.substr(0, 12);
    TObject* broken_obj = Stream::deserializeEncodedRawData(truncated);
    EXPECT_TRUE(broken_obj == nullptr);
  }
 
  TEST(StreamTest, GearboxRaw)
  {
    Gearbox& gb = Gearbox::getInstance();
    vector<string> backends;
    backends.emplace_back("file:/framework/tests/");
    gb.setBackends(backends);
    gb.open("object_base64.xml");
 
    checkGbContents();
  }
 
}  // namespace