node_factory.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#include <functional>
#include <variant>
#include <boost/python.hpp>
 
#include <framework/utilities/CutNodes.h>
#include <framework/utilities/TestHelpers.h>
 
#include <gtest/gtest.h>
 
 
using namespace Belle2;
namespace {
  namespace py = boost::python;
  typedef std::variant<double, int, bool> VarVariant;
  struct MockObjectType {
    explicit MockObjectType(const double& d) : m_value{d} {}
    explicit MockObjectType(const int& i) : m_value{i} {}
    explicit MockObjectType(const bool& b) : m_value{b} {}
    VarVariant m_value;
  };

  class MockVariableType {
  public:
    VarVariant function(const MockObjectType* object) const
    {
      return m_function(object);
    }
    explicit MockVariableType(const std::string& name) : m_name{name}
    {
      m_function = [](const MockObjectType * object) -> VarVariant {
        if (object != nullptr)
        {
          return object->m_value;
        } else
        {
          return std::numeric_limits<double>::quiet_NaN();
        }
      };
    }
 
    MockVariableType(const std::string& name, std::function<VarVariant(const MockObjectType*)> function) : m_name{name}, m_function{function}
    {}

    std::string m_name;
    std::function<VarVariant(const MockObjectType*)> m_function;
  };

  class MockVariableManager {
  public:
    using Object = MockObjectType;
    using Var = MockVariableType;
    typedef std::variant<double, int, bool> VarVariant;

    static MockVariableManager& Instance()
    {
      static MockVariableManager instance;
      return instance;
    }

    Var* getVariable(const std::string& name)
    {
      if (name == "mocking_variable") {
        return &m_mocking_variable;
      } else {
        return nullptr;
      }
    }
 
    Var* getVariable(const std::string& functionName, const std::vector<std::string>& functionArguments)
    {
      (void) functionName;
      (void) functionArguments;
      return &m_mocking_variable;
    }

    Var m_mocking_variable{"mocking_variable"};
  };
 
 
  TEST(NodeFactory, FactoryDeathTest)
  {
    Py_Initialize();
    // Make empty tuple
    py::tuple tuple = py::tuple();
    EXPECT_B2FATAL(Belle2::NodeFactory::compile_expression_node<MockVariableManager>(tuple));
 
    // Make UnaryExpressionNode which doesn't have the correct length
    tuple = py::make_tuple(static_cast<int>(NodeType::UnaryExpressionNode));
    EXPECT_B2FATAL(Belle2::NodeFactory::compile_expression_node<MockVariableManager>(tuple));
 
    // Make BinaryExpressionNode which doesn't have the correct length
    tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode));
    EXPECT_B2FATAL(Belle2::NodeFactory::compile_expression_node<MockVariableManager>(tuple));
 
    // Make IntegerNode which doesn't have the correct length
    tuple = py::make_tuple(static_cast<int>(NodeType::IntegerNode));
    EXPECT_B2FATAL(Belle2::NodeFactory::compile_expression_node<MockVariableManager>(tuple));
 
// Make DoubleNode which doesn't have the correct length
    tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode));
    EXPECT_B2FATAL(Belle2::NodeFactory::compile_expression_node<MockVariableManager>(tuple));
 
    // Make BooleanNode which doesn't have the correct length
    tuple = py::make_tuple(static_cast<int>(NodeType::BooleanNode));
    EXPECT_B2FATAL(Belle2::NodeFactory::compile_expression_node<MockVariableManager>(tuple));
 
    // Make IdentifierNode which doesn't have the correct length
    tuple = py::make_tuple(static_cast<int>(NodeType::IdentifierNode));
    EXPECT_B2FATAL(Belle2::NodeFactory::compile_expression_node<MockVariableManager>(tuple));
 
    // Make FunctionNode which doesn't have the correct length
    tuple = py::make_tuple(static_cast<int>(NodeType::FunctionNode));
    EXPECT_B2FATAL(Belle2::NodeFactory::compile_expression_node<MockVariableManager>(tuple));
 
    // Make Identifier Tuple which should trigger a runtime error
    tuple = py::make_tuple(static_cast<int>(NodeType::IdentifierNode), "THISDOESNOTEXIST");
    EXPECT_THROW(Belle2::NodeFactory::compile_expression_node<MockVariableManager>(tuple), std::runtime_error);
 
  }
}