ColumnarMemoryTest.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
#ifndef COLUMNAR_TEST_FIXTURES__COLUMNAR_MEMORY_TEST_H
#define COLUMNAR_TEST_FIXTURES__COLUMNAR_MEMORY_TEST_H
 
#include <AsgTools/AsgTool.h>
#include <ColumnarInterfaces/ColumnInfo.h>
#include <ColumnarInterfaces/IColumnarTool.h>
#include <ColumnarTestFixtures/ToolWrapper.h>
#include <ColumnarTestFixtures/ManualColumnData.h>
#include <PATInterfaces/ISystematicsTool.h>
 
#include <gtest/gtest.h>
 
#include <optional>
 
namespace columnar
{
  namespace TestUtils
  {
    class ColumnarTestToolHandle;
    struct ColumnMapType;
  }
 
  struct ColumnarMemoryTest : public testing::Test
  {
    ColumnarMemoryTest ();
 
    std::string makeUniqueName ();
 
    static bool checkMode ();
 
    using ColumnMapType = TestUtils::ColumnMapType;
    using ColumnarTestToolHandle = TestUtils::ColumnarTestToolHandle;
  };
 
 
 
  namespace TestUtils
  {
 
    class ColumnarTestToolHandle final
    {
 
    public:
 
      explicit ColumnarTestToolHandle (asg::AsgTool& val_tool);
 
      void renameContainers (const std::vector<std::pair<std::string,std::string>>& renames);
 
      void initialize ();
 
      void applySystematicVariation (const std::string& sysName);
 
      [[nodiscard]] std::vector<ColumnInfo> getColumnInfo () const;
 
      std::vector<std::string> getColumnNames () const;
 
      std::vector<std::string> getRecommendedSystematics () const;
 
      [[nodiscard]] ToolColumnVectorMap& getToolWrapper ();
      [[nodiscard]] const ToolColumnVectorMap& getToolWrapper () const;
 
      [[nodiscard]] const ColumnVectorHeader& getColumnHeader () const {
        return *m_columnHeader;}
 
      [[nodiscard]] IColumnarTool* getTool ();
 
 
 
 
    private:
 
      IColumnarTool* m_tool = nullptr;
      CP::ISystematicsTool* m_systTool = nullptr;
 
      std::shared_ptr<ColumnVectorHeader> m_columnHeader;
      std::shared_ptr<ToolColumnVectorMap> m_toolWrapper;
    };
 
 
 
    struct ColumnMapType final
    {
      ColumnMapType (ColumnarTestToolHandle& val_toolHandle);
 
      void addColumn (const std::string& name, std::vector<std::any> data);
 
      std::size_t columnSize (const std::string& name);
 
      void setExpectation (const std::string& name, std::vector<std::any> values);
 
      void connectColumnsToTool ();
 
      void call ();
 
      void checkExpectations ();
 
      template<typename T> void addTypedColumn (const std::string& name, std::vector<T> data)
      {
        addColumn (name, std::vector<std::any> (data.begin(), data.end()));
      }
 
    private:
 
      ColumnarTestToolHandle* m_toolHandle = nullptr;
 
      std::unique_ptr<ColumnVectorData> m_columnData;
 
      struct MyColumnData final
      {
        std::optional<ColumnInfo> info;
        std::optional<ManualColumnData> input;
        std::optional<ManualColumnData> expectation;
      };
      std::unordered_map<std::string,MyColumnData> m_userColumns;
    };
  }
}
 
#endif