TestTasks.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

#include "FairTask.h"
#include "FairTimeStamp.h"

#include "PndConstContainer.h"
#include "PndMutableContainer.h"
// #include "PndPersistencyTask.h" // for PndPersistencyTask
#include "PndSTDMutableContainer.h"
#include "PndTCAMutableContainer.h"

#include "gtest/gtest.h" // for AssertHelper, EXPECT_EQ, EXPECT_TRUE

//______________________________________________________________________________
class TestInTask : public FairTask {
  PndConstContainer<FairTimeStamp> fInCont;
  Int_t fgNumber{111};
  TString fBranchName;

 public:
  TestInTask(const TString &t_branch = "TestBranch") : FairTask(), fBranchName(t_branch){};
  virtual ~TestInTask(){};

  PndTCAConstContainer<FairTimeStamp> *GetTCA(const TString &t_branchname)
  {
    PndTCAConstContainer<FairTimeStamp> *container{nullptr};

    if (FairRootManager::Instance()->CheckBranch(t_branchname) ==
        0) { // This test is required here, as you get a segmentation violation if you try to access a not existing branch t_branchname via std
      return container;
    }
    container = new PndTCAConstContainer<FairTimeStamp>{};
    container->SetBranchName(t_branchname);
    container->SetTCA(dynamic_cast<TClonesArray *>(FairRootManager::Instance()->GetObject(t_branchname)));
    return container;
  }

  PndSTDConstContainer<FairTimeStamp> *GetSTD(const TString &t_branchname)
  {
    PndSTDConstContainer<FairTimeStamp> *container{nullptr};
    if (FairRootManager::Instance()->CheckBranch(t_branchname) ==
        0) { // This test is required here, as you get a segmentation violation if you try to access a not existing branch t_branchname via std
      return container;
    }
    std::vector<FairTimeStamp> const *data = FairRootManager::Instance()->InitObjectAs<std::vector<FairTimeStamp> const *>(t_branchname);
    if (data != nullptr) {
      container = new PndSTDConstContainer<FairTimeStamp>{};
      container->SetBranchName(t_branchname);
      container->SetData(data);
    }

    return container;
  }

  virtual InitStatus Init() /*override*/ final
  {
    fInCont.SetBranchName(fBranchName);
    PndConstContainerI<FairTimeStamp> *container = GetTCA(fBranchName);
    if (container != nullptr) {
      fInCont.SetConstContainer(container);
      return kSUCCESS;
    }
    container = GetSTD(fBranchName);
    if (container != nullptr) {
      fInCont.SetConstContainer(container);
      return kSUCCESS;
    }
    return kFATAL;
  };

  virtual void Exec(Option_t * /*option*/) /*override*/
  {
    ASSERT_EQ(fInCont.GetSize(), 1);
    EXPECT_EQ(fInCont.GetConstElementPtr(0)->GetTimeStamp(), fgNumber--);
  };

 private:
  // ClassDef(TestInTask, 1);
};

//______________________________________________________________________________
class TestOutTask : public FairTask {
  PndTCAMutableContainer<FairTimeStamp> fOutCont;
  Int_t fgNumber{111};
  TString fBranchName;

 public:
  TestOutTask(const TString &t_branch = "TestBranch") : FairTask(), fBranchName(t_branch) {}
  virtual ~TestOutTask() {}

  virtual InitStatus Init() /*override*/ final
  {
    fOutCont.SetBranchName(fBranchName);
    fOutCont.SetTCA(dynamic_cast<TClonesArray *>(FairRootManager::Instance()->Register(fBranchName, "FairTimeStamp", "Test", kTRUE)));
    return kSUCCESS;
  }

  virtual void Exec(Option_t * /*option*/) /*override*/
  {
    fOutCont.Reset();
    FairTimeStamp stamp;
    stamp.SetTimeStamp(fgNumber--);
    fOutCont.CreateCopy(stamp);
  }
  // ClassDef(TestOutTask, 1);
};

//______________________________________________________________________________
class TestOutWithSTDTask : public FairTask {
  PndSTDMutableContainer<FairTimeStamp> fOutCont;
  Int_t fgNumber{111};
  TString fBranchName;

 public:
  TestOutWithSTDTask(const TString &t_branch = "TestBranch") : FairTask(), fBranchName(t_branch) {}
  virtual ~TestOutWithSTDTask() {}

  virtual InitStatus Init() /*override*/ final
  {
    fOutCont.SetBranchName(fBranchName);
    auto *data = new std::vector<FairTimeStamp>{};
    FairRootManager::Instance()->RegisterAny(fBranchName, data, kTRUE);
    fOutCont.SetData(data);

    return kSUCCESS;
  }

  virtual void Exec(Option_t * /*option*/) /*override*/
  {
    fOutCont.Reset();
    FairTimeStamp stamp;
    stamp.SetTimeStamp(fgNumber--);
    fOutCont.CreateCopy(stamp);
  }
  // ClassDef(TestOutWithSTDTask, 1);
};

//______________________________________________________________________________
class TestOutWithTCATask : public FairTask {
  PndTCAMutableContainer<FairTimeStamp> fOutCont;
  Int_t fgNumber{111};
  TString fBranchName;

 public:
  TestOutWithTCATask(const TString &t_branch = "TestBranch") : FairTask(), fBranchName(t_branch) {}

  virtual ~TestOutWithTCATask() {}

  virtual InitStatus Init() /*override*/ final
  {
    fOutCont.SetBranchName(fBranchName);
    fOutCont.SetTCA(dynamic_cast<TClonesArray *>(FairRootManager::Instance()->Register(fBranchName, "FairTimeStamp", "Test", kTRUE)));

    return kSUCCESS;
  }

  virtual void Exec(Option_t * /*option*/) /*override*/
  {
    fOutCont.Reset();
    FairTimeStamp stamp;
    stamp.SetTimeStamp(fgNumber--);
    fOutCont.CreateCopy(stamp);
  }
  // ClassDef(TestOutWithTCATask, 1);
};