Belle II Software light-2509-fornax
cutNodes.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8#include <functional>
9#include <variant>
10#include <iostream>
11#include <cmath>
12#include <boost/python.hpp>
13
14#include <framework/utilities/CutNodes.h>
15#include <framework/utilities/TestHelpers.h>
16#include <framework/utilities/Conversion.h>
17
18#include <gtest/gtest.h>
19
20
21using namespace Belle2;
22namespace {
23 namespace py = boost::python;
25 typedef std::variant<double, int, bool> VarVariant;
27 struct MockObjectType {
29 explicit MockObjectType(const double& d) : m_value{d} {}
30 explicit MockObjectType(const int& i) : m_value{i} {}
31 explicit MockObjectType(const bool& b) : m_value{b} {}
32 VarVariant m_value;
33 };
35 std::function<VarVariant(const MockObjectType*)> mockMetaVariable(const std::vector<std::string>& arguments);
36
42 class MockVariableType {
43 public:
45 VarVariant function(const MockObjectType* object) const
46 {
47 return m_function(object);
48 }
49 explicit MockVariableType(const std::string& name) : m_name{name}
50 {
51 m_function = [](const MockObjectType * object) -> VarVariant {
52 if (object != nullptr)
53 {
54 return object->m_value;
55 } else
56 {
57 return std::numeric_limits<double>::quiet_NaN();
58 }
59 };
60 }
61
62 MockVariableType(const std::string& name, std::function<VarVariant(const MockObjectType*)> function) : m_name{name}, m_function{function}
63 {}
64
66 std::string m_name;
67 std::function<VarVariant(const MockObjectType*)> m_function;
68 };
69
74 class MockVariableManager {
75 public:
77 using Object = MockObjectType;
79 using Var = MockVariableType;
81 typedef std::variant<double, int, bool> VarVariant;
82
84 static MockVariableManager& Instance()
85 {
86 static MockVariableManager instance;
87 return instance;
88 }
89
91 Var* getVariable(const std::string& name)
92 {
93 if (name == "mocking_variable") {
94 return &m_mocking_variable;
95 } else {
96 return nullptr;
97 }
98 }
99
100 Var* getVariable(const std::string& functionName, const std::vector<std::string>& functionArguments)
101 {
102 auto function = mockMetaVariable(functionArguments);
103 m_mocking_metavariable = MockVariableType(functionName, function);
104 return &m_mocking_metavariable;
105 }
106
108 Var m_mocking_variable{"mocking_variable"};
109 Var m_mocking_metavariable{""};
110 };
111
112
113// Mock sum metavariable
114 std::function<VarVariant(const MockObjectType*)> mockMetaVariable(const std::vector<std::string>& arguments)
115 {
116 const MockVariableType* var = MockVariableManager::Instance().getVariable(arguments[0]);
117 if (var == nullptr) {
118 throw std::runtime_error("Variable could not be found.");
119 }
120 auto func = [var, arguments](const MockObjectType * object) -> VarVariant {
121 double sum = 0.0;
122 if (std::holds_alternative<int>(var->function(object)))
123 {
124 sum += std::get<int>(var->function(object));
125 } else if (std::holds_alternative<double>(var->function(object)))
126 {
127 sum += std::get<double>(var->function(object));
128 } else
129 {
130 sum += std::get<bool>(var->function(object));
131 }
132 for (size_t i = 1; i < arguments.size(); i++)
133 {
134 sum += Belle2::convertString<double>(arguments[i]);
135 }
136 return sum;
137 };
138 return func;
139 }
140
144 TEST(CutNodesTest, TupleLength)
145 {
146 Py_Initialize();
147 py::tuple tuple = py::tuple();
148 EXPECT_B2FATAL(NodeFactory::compile_boolean_node<MockVariableManager>(tuple));
149 EXPECT_B2FATAL(NodeFactory::compile_expression_node<MockVariableManager>(tuple));
150
151 tuple = py::make_tuple(static_cast<int>(NodeType::UnaryBooleanNode));
152 EXPECT_B2FATAL(NodeFactory::compile_boolean_node<MockVariableManager>(tuple));
153
154 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryBooleanNode));
155 EXPECT_B2FATAL(NodeFactory::compile_boolean_node<MockVariableManager>(tuple));
156
157 tuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode));
158 EXPECT_B2FATAL(NodeFactory::compile_boolean_node<MockVariableManager>(tuple));
159
160 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode));
161 EXPECT_B2FATAL(NodeFactory::compile_boolean_node<MockVariableManager>(tuple));
162
163 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode));
164 EXPECT_B2FATAL(NodeFactory::compile_boolean_node<MockVariableManager>(tuple));
165
166 tuple = py::make_tuple(static_cast<int>(NodeType::UnaryExpressionNode));
167 EXPECT_B2FATAL(NodeFactory::compile_expression_node<MockVariableManager>(tuple));
168
169 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode));
170 EXPECT_B2FATAL(NodeFactory::compile_expression_node<MockVariableManager>(tuple));
171
172 tuple = py::make_tuple(static_cast<int>(NodeType::BooleanNode));
173 EXPECT_B2FATAL(NodeFactory::compile_expression_node<MockVariableManager>(tuple));
174
175 tuple = py::make_tuple(static_cast<int>(NodeType::IntegerNode));
176 EXPECT_B2FATAL(NodeFactory::compile_expression_node<MockVariableManager>(tuple));
177
178 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode));
179 EXPECT_B2FATAL(NodeFactory::compile_expression_node<MockVariableManager>(tuple));
180
181 tuple = py::make_tuple(static_cast<int>(NodeType::IdentifierNode));
182 EXPECT_B2FATAL(NodeFactory::compile_expression_node<MockVariableManager>(tuple));
183
184 tuple = py::make_tuple(static_cast<int>(NodeType::FunctionNode));
185 EXPECT_B2FATAL(NodeFactory::compile_expression_node<MockVariableManager>(tuple));
186
187 }
188
189
191 TEST(CutNodesTest, unaryBooleanNode)
192 {
193 Py_Initialize();
194 // Create two BooleanNode tuples with values true and false.
195 const py::tuple booleanTuple_true = py::make_tuple(static_cast<int>(NodeType::BooleanNode), true);
196 const py::tuple booleanTuple_false = py::make_tuple(static_cast<int>(NodeType::BooleanNode), false);
197 // Compile BooleanNodes and check evaluation
198 auto booleanNode_true = NodeFactory::compile_expression_node<MockVariableManager>(booleanTuple_true);
199 auto booleanNode_false = NodeFactory::compile_expression_node<MockVariableManager>(booleanTuple_false);
200 EXPECT_TRUE(std::get<bool>(booleanNode_true->evaluate(nullptr)));
201 EXPECT_FALSE(std::get<bool>(booleanNode_false->evaluate(nullptr)));
202
203 // Create two UnaryRelationalNodes tuples with each BooleanNode tuple as child.
204 const py::tuple uRelTuple_true = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), booleanTuple_true);
205 const py::tuple uRelTuple_false = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), booleanTuple_false);
206 // Compile UnaryExpressionNodes and check evaluation
207 auto uRelNode_true = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple_true);
208 auto uRelNode_false = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple_false);
209 EXPECT_TRUE(uRelNode_true->check(nullptr));
210 EXPECT_FALSE(uRelNode_false->check(nullptr));
211
212 // Create all tuple combinations of true/false children and flags
213 // True child
214 const py::tuple uBoolTuple_true = py::make_tuple(static_cast<int>(NodeType::UnaryBooleanNode), uRelTuple_true, false, false);
215 const py::tuple uBoolTuple_true_brack = py::make_tuple(static_cast<int>(NodeType::UnaryBooleanNode), uRelTuple_true, false, true);
216 const py::tuple uBoolTuple_true_neg = py::make_tuple(static_cast<int>(NodeType::UnaryBooleanNode), uRelTuple_true, true, false);
217 const py::tuple uBoolTuple_true_neg_brack = py::make_tuple(static_cast<int>(NodeType::UnaryBooleanNode), uRelTuple_true, true,
218 true);
219
220 auto uBoolNode_true = NodeFactory::compile_boolean_node<MockVariableManager>(uBoolTuple_true);
221 EXPECT_TRUE(uBoolNode_true->check(nullptr));
222 EXPECT_EQ(uBoolNode_true->decompile(), "true");
223
224 auto uBoolNode_true_brack = NodeFactory::compile_boolean_node<MockVariableManager>(uBoolTuple_true_brack);
225 EXPECT_TRUE(uBoolNode_true_brack->check(nullptr));
226 EXPECT_EQ(uBoolNode_true_brack->decompile(), "[true]");
227
228 auto uBoolNode_true_neg = NodeFactory::compile_boolean_node<MockVariableManager>(uBoolTuple_true_neg);
229 EXPECT_FALSE(uBoolNode_true_neg->check(nullptr));
230 EXPECT_EQ(uBoolNode_true_neg->decompile(), "not true");
231
232 auto uBoolNode_true_neg_brack = NodeFactory::compile_boolean_node<MockVariableManager>(uBoolTuple_true_neg_brack);
233 EXPECT_FALSE(uBoolNode_true_neg_brack->check(nullptr));
234 EXPECT_EQ(uBoolNode_true_neg_brack->decompile(), "not [true]");
235
236 // False child
237 const py::tuple uBoolTuple_false = py::make_tuple(static_cast<int>(NodeType::UnaryBooleanNode), uRelTuple_false, false, false);
238 const py::tuple uBoolTuple_false_brack = py::make_tuple(static_cast<int>(NodeType::UnaryBooleanNode), uRelTuple_false, false, true);
239 const py::tuple uBoolTuple_false_neg = py::make_tuple(static_cast<int>(NodeType::UnaryBooleanNode), uRelTuple_false, true, false);
240 const py::tuple uBoolTuple_false_neg_brack = py::make_tuple(static_cast<int>(NodeType::UnaryBooleanNode), uRelTuple_false, true,
241 true);
242
243 auto uBoolNode_false = NodeFactory::compile_boolean_node<MockVariableManager>(uBoolTuple_false);
244 EXPECT_FALSE(uBoolNode_false->check(nullptr));
245 EXPECT_EQ(uBoolNode_false->decompile(), "false");
246
247 auto uBoolNode_false_brack = NodeFactory::compile_boolean_node<MockVariableManager>(uBoolTuple_false_brack);
248 EXPECT_FALSE(uBoolNode_false_brack->check(nullptr));
249 EXPECT_EQ(uBoolNode_false_brack->decompile(), "[false]");
250
251 auto uBoolNode_false_neg = NodeFactory::compile_boolean_node<MockVariableManager>(uBoolTuple_false_neg);
252 EXPECT_TRUE(uBoolNode_false_neg->check(nullptr));
253 EXPECT_EQ(uBoolNode_false_neg->decompile(), "not false");
254
255 auto uBoolNode_false_neg_brack = NodeFactory::compile_boolean_node<MockVariableManager>(uBoolTuple_false_neg_brack);
256 EXPECT_TRUE(uBoolNode_false_neg_brack->check(nullptr));
257 EXPECT_EQ(uBoolNode_false_neg_brack->decompile(), "not [false]");
258
259 }
261 TEST(CutNodesTest, binaryBooleanNode)
262 {
263 // Create two BooleanNode tuples with values true and false.
264 const py::tuple booleanTuple_true = py::make_tuple(static_cast<int>(NodeType::BooleanNode), true);
265 const py::tuple booleanTuple_false = py::make_tuple(static_cast<int>(NodeType::BooleanNode), false);
266
267 // Create two UnaryRelationalNodes tuples with each BooleanNode tuple as child.
268 const py::tuple uRelTuple_true = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), booleanTuple_true);
269 const py::tuple uRelTuple_false = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), booleanTuple_false);
270
271 // Create all tuple combinations of children and BooleanOperators
272 const py::tuple binBoolTuple_AND_true_true = py::make_tuple(static_cast<int>(NodeType::BinaryBooleanNode), uRelTuple_true,
273 uRelTuple_true, static_cast<int>(BooleanOperator::AND));
274 const py::tuple binBoolTuple_AND_false_true = py::make_tuple(static_cast<int>(NodeType::BinaryBooleanNode), uRelTuple_false,
275 uRelTuple_true, static_cast<int>(BooleanOperator::AND));
276 const py::tuple binBoolTuple_AND_true_false = py::make_tuple(static_cast<int>(NodeType::BinaryBooleanNode), uRelTuple_true,
277 uRelTuple_false, static_cast<int>(BooleanOperator::AND));
278 const py::tuple binBoolTuple_AND_false_false = py::make_tuple(static_cast<int>(NodeType::BinaryBooleanNode), uRelTuple_false,
279 uRelTuple_false, static_cast<int>(BooleanOperator::AND));
280
281 const py::tuple binBoolTuple_OR_true_true = py::make_tuple(static_cast<int>(NodeType::BinaryBooleanNode), uRelTuple_true,
282 uRelTuple_true, static_cast<int>(BooleanOperator::OR));
283 const py::tuple binBoolTuple_OR_false_true = py::make_tuple(static_cast<int>(NodeType::BinaryBooleanNode), uRelTuple_false,
284 uRelTuple_true, static_cast<int>(BooleanOperator::OR));
285 const py::tuple binBoolTuple_OR_true_false = py::make_tuple(static_cast<int>(NodeType::BinaryBooleanNode), uRelTuple_true,
286 uRelTuple_false, static_cast<int>(BooleanOperator::OR));
287 const py::tuple binBoolTuple_OR_false_false = py::make_tuple(static_cast<int>(NodeType::BinaryBooleanNode), uRelTuple_false,
288 uRelTuple_false, static_cast<int>(BooleanOperator::OR));
289
290
291 auto binBoolNode_AND_true_true = NodeFactory::compile_boolean_node<MockVariableManager>(binBoolTuple_AND_true_true);
292 auto binBoolNode_AND_false_true = NodeFactory::compile_boolean_node<MockVariableManager>(binBoolTuple_AND_false_true);
293 auto binBoolNode_AND_true_false = NodeFactory::compile_boolean_node<MockVariableManager>(binBoolTuple_AND_true_false);
294 auto binBoolNode_AND_false_false = NodeFactory::compile_boolean_node<MockVariableManager>(binBoolTuple_AND_false_false);
295
296 auto binBoolNode_OR_true_true = NodeFactory::compile_boolean_node<MockVariableManager>(binBoolTuple_OR_true_true);
297 auto binBoolNode_OR_false_true = NodeFactory::compile_boolean_node<MockVariableManager>(binBoolTuple_OR_false_true);
298 auto binBoolNode_OR_true_false = NodeFactory::compile_boolean_node<MockVariableManager>(binBoolTuple_OR_true_false);
299 auto binBoolNode_OR_false_false = NodeFactory::compile_boolean_node<MockVariableManager>(binBoolTuple_OR_false_false);
300
301 EXPECT_TRUE(binBoolNode_AND_true_true->check(nullptr));
302 EXPECT_FALSE(binBoolNode_AND_false_true->check(nullptr));
303 EXPECT_FALSE(binBoolNode_AND_true_false->check(nullptr));
304 EXPECT_FALSE(binBoolNode_AND_false_false->check(nullptr));
305
306 EXPECT_TRUE(binBoolNode_OR_true_true->check(nullptr));
307 EXPECT_TRUE(binBoolNode_OR_false_true->check(nullptr));
308 EXPECT_TRUE(binBoolNode_OR_true_false->check(nullptr));
309 EXPECT_FALSE(binBoolNode_OR_false_false->check(nullptr));
310
311 }
313 TEST(CutNodesTest, unaryRelationalNode)
314 {
315 Py_Initialize();
316 // Get main module
317 py::object main = py::import("__main__");
318 py::object pyfloat = main.attr("__builtins__").attr("float");
319
320 // Test IntegerNode
321 py::tuple tuple = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 1337);
322 py::tuple uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
323 auto node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
324 EXPECT_TRUE(node->check(nullptr));
325
326 tuple = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 0);
327 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
328 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
329 EXPECT_FALSE(node->check(nullptr));
330
331 tuple = py::make_tuple(static_cast<int>(NodeType::IntegerNode), -0);
332 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
333 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
334 EXPECT_FALSE(node->check(nullptr));
335
336 tuple = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 1);
337 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
338 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
339 EXPECT_TRUE(node->check(nullptr));
340
341 tuple = py::make_tuple(static_cast<int>(NodeType::IntegerNode), -1);
342 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
343 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
344 EXPECT_TRUE(node->check(nullptr));
345
346 // Test DoubleNode
347 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 0.0);
348 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
349 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
350 EXPECT_FALSE(node->check(nullptr));
351
352 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode), -0.0);
353 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
354 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
355 EXPECT_FALSE(node->check(nullptr));
356
357 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 1.0);
358 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
359 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
360 EXPECT_TRUE(node->check(nullptr));
361
362 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode), -1.0);
363 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
364 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
365 EXPECT_TRUE(node->check(nullptr));
366
367 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 1.1);
368 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
369 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
370 EXPECT_TRUE(node->check(nullptr));
371
372 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode), -1.1);
373 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
374 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
375 EXPECT_TRUE(node->check(nullptr));
376
377 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("nan"));
378 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
379 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
380 EXPECT_FALSE(node->check(nullptr));
381
382 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("inf"));
383 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
384 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
385 EXPECT_TRUE(node->check(nullptr));
386
387
388 tuple = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("-inf"));
389 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
390 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
391 EXPECT_TRUE(node->check(nullptr));
392
393 // Test BooleanNodes
394 tuple = py::make_tuple(static_cast<int>(NodeType::BooleanNode), true);
395 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
396 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
397 EXPECT_TRUE(node->check(nullptr));
398
399 tuple = py::make_tuple(static_cast<int>(NodeType::BooleanNode), false);
400 uRelTuple = py::make_tuple(static_cast<int>(NodeType::UnaryRelationalNode), tuple);
401 node = NodeFactory::compile_boolean_node<MockVariableManager>(uRelTuple);
402 EXPECT_FALSE(node->check(nullptr));
403
404 }
406 TEST(CutNodesTest, binaryRelationalNode)
407 {
408 Py_Initialize();
409 // Get main module
410 py::object main = py::import("__main__");
411 py::object pyfloat = main.attr("__builtins__").attr("float");
412
413 py::tuple child1 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 1337);
414 py::tuple child2 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 1337);
415 py::tuple bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
416 static_cast<int>(ComparisonOperator::EQUALEQUAL));
417 auto node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
418 EXPECT_TRUE(node->check(nullptr));
419
420 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 1337.0);
421 child2 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 1337);
422 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
423 static_cast<int>(ComparisonOperator::EQUALEQUAL));
424 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
425 EXPECT_TRUE(node->check(nullptr));
426
427 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child2, child1,
428 static_cast<int>(ComparisonOperator::EQUALEQUAL));
429 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
430 EXPECT_TRUE(node->check(nullptr));
431
432 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 1337.0);
433 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 1337.0);
434 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
435 static_cast<int>(ComparisonOperator::EQUALEQUAL));
436 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
437 EXPECT_TRUE(node->check(nullptr));
438
439 // NaN with NaN comparisons
440 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("nan"));
441 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("nan"));
442 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
443 static_cast<int>(ComparisonOperator::EQUALEQUAL));
444 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
445 EXPECT_TRUE(node->check(nullptr));
446
447 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
448 static_cast<int>(ComparisonOperator::GREATEREQUAL));
449 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
450 EXPECT_FALSE(node->check(nullptr));
451
452 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
453 static_cast<int>(ComparisonOperator::LESSEQUAL));
454 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
455 EXPECT_FALSE(node->check(nullptr));
456
457 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
458 static_cast<int>(ComparisonOperator::GREATER));
459 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
460 EXPECT_FALSE(node->check(nullptr));
461
462 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
463 static_cast<int>(ComparisonOperator::LESS));
464 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
465 EXPECT_FALSE(node->check(nullptr));
466
467 // NaN != NaN yields true
468 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
469 static_cast<int>(ComparisonOperator::NOTEQUAL));
470 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
471 EXPECT_FALSE(node->check(nullptr));
472
473 // Compare nan with a numerical value
474 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("nan"));
475 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 0.0);
476 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
477 static_cast<int>(ComparisonOperator::EQUALEQUAL));
478 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
479 EXPECT_FALSE(node->check(nullptr));
480
481 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
482 static_cast<int>(ComparisonOperator::GREATEREQUAL));
483 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
484 EXPECT_FALSE(node->check(nullptr));
485
486 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
487 static_cast<int>(ComparisonOperator::LESSEQUAL));
488 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
489 EXPECT_FALSE(node->check(nullptr));
490
491 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
492 static_cast<int>(ComparisonOperator::GREATER));
493 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
494 EXPECT_FALSE(node->check(nullptr));
495
496 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
497 static_cast<int>(ComparisonOperator::LESS));
498 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
499 EXPECT_FALSE(node->check(nullptr));
500
501 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
502 static_cast<int>(ComparisonOperator::NOTEQUAL));
503 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
504 EXPECT_TRUE(node->check(nullptr));
505
506 // Compare nan with -inf
507 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("nan"));
508 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("inf"));
509 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
510 static_cast<int>(ComparisonOperator::EQUALEQUAL));
511 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
512 EXPECT_FALSE(node->check(nullptr));
513
514 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
515 static_cast<int>(ComparisonOperator::GREATEREQUAL));
516 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
517 EXPECT_FALSE(node->check(nullptr));
518
519 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
520 static_cast<int>(ComparisonOperator::LESSEQUAL));
521 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
522 EXPECT_FALSE(node->check(nullptr));
523
524 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
525 static_cast<int>(ComparisonOperator::GREATER));
526 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
527 EXPECT_FALSE(node->check(nullptr));
528
529 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
530 static_cast<int>(ComparisonOperator::LESS));
531 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
532 EXPECT_FALSE(node->check(nullptr));
533
534 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
535 static_cast<int>(ComparisonOperator::NOTEQUAL));
536 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
537 EXPECT_TRUE(node->check(nullptr));
538
539 // Compare nan with -inf
540 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("nan"));
541 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("-inf"));
542 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
543 static_cast<int>(ComparisonOperator::EQUALEQUAL));
544 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
545 EXPECT_FALSE(node->check(nullptr));
546
547 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
548 static_cast<int>(ComparisonOperator::GREATEREQUAL));
549 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
550 EXPECT_FALSE(node->check(nullptr));
551
552 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
553 static_cast<int>(ComparisonOperator::LESSEQUAL));
554 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
555 EXPECT_FALSE(node->check(nullptr));
556
557 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
558 static_cast<int>(ComparisonOperator::GREATER));
559 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
560 EXPECT_FALSE(node->check(nullptr));
561
562 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
563 static_cast<int>(ComparisonOperator::LESS));
564 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
565 EXPECT_FALSE(node->check(nullptr));
566
567 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
568 static_cast<int>(ComparisonOperator::NOTEQUAL));
569 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
570 EXPECT_TRUE(node->check(nullptr));
571
572 // Compare inf with numerical value
573 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("inf"));
574 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 0.0);
575 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
576 static_cast<int>(ComparisonOperator::EQUALEQUAL));
577 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
578 EXPECT_FALSE(node->check(nullptr));
579
580 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
581 static_cast<int>(ComparisonOperator::GREATEREQUAL));
582 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
583 EXPECT_TRUE(node->check(nullptr));
584
585 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
586 static_cast<int>(ComparisonOperator::LESSEQUAL));
587 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
588 EXPECT_FALSE(node->check(nullptr));
589
590 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
591 static_cast<int>(ComparisonOperator::GREATER));
592 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
593 EXPECT_TRUE(node->check(nullptr));
594
595 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
596 static_cast<int>(ComparisonOperator::LESS));
597 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
598 EXPECT_FALSE(node->check(nullptr));
599
600 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
601 static_cast<int>(ComparisonOperator::NOTEQUAL));
602 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
603 EXPECT_TRUE(node->check(nullptr));
604
605 // Compare inf with inf
606 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("inf"));
607 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("inf"));
608 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
609 static_cast<int>(ComparisonOperator::EQUALEQUAL));
610 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
611 EXPECT_TRUE(node->check(nullptr));
612
613 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
614 static_cast<int>(ComparisonOperator::GREATEREQUAL));
615 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
616 EXPECT_TRUE(node->check(nullptr));
617
618 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
619 static_cast<int>(ComparisonOperator::LESSEQUAL));
620 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
621 EXPECT_TRUE(node->check(nullptr));
622
623 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
624 static_cast<int>(ComparisonOperator::GREATER));
625 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
626 EXPECT_FALSE(node->check(nullptr));
627
628 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
629 static_cast<int>(ComparisonOperator::LESS));
630 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
631 EXPECT_FALSE(node->check(nullptr));
632
633 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
634 static_cast<int>(ComparisonOperator::NOTEQUAL));
635 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
636 EXPECT_FALSE(node->check(nullptr));
637
638 // Compare inf with -inf
639 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("inf"));
640 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("-inf"));
641 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
642 static_cast<int>(ComparisonOperator::EQUALEQUAL));
643 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
644 EXPECT_FALSE(node->check(nullptr));
645
646 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
647 static_cast<int>(ComparisonOperator::GREATEREQUAL));
648 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
649 EXPECT_TRUE(node->check(nullptr));
650
651 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
652 static_cast<int>(ComparisonOperator::LESSEQUAL));
653 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
654 EXPECT_FALSE(node->check(nullptr));
655
656 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
657 static_cast<int>(ComparisonOperator::GREATER));
658 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
659 EXPECT_TRUE(node->check(nullptr));
660
661 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
662 static_cast<int>(ComparisonOperator::LESS));
663 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
664 EXPECT_FALSE(node->check(nullptr));
665
666 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
667 static_cast<int>(ComparisonOperator::NOTEQUAL));
668 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
669 EXPECT_TRUE(node->check(nullptr));
670
671 // Check double precision
672 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 3.141592653589793);
673 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 3.141592653589792);
674 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
675 static_cast<int>(ComparisonOperator::EQUALEQUAL));
676 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
677 EXPECT_FALSE(node->check(nullptr));
678
679 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
680 static_cast<int>(ComparisonOperator::GREATEREQUAL));
681 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
682 EXPECT_TRUE(node->check(nullptr));
683
684 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
685 static_cast<int>(ComparisonOperator::LESSEQUAL));
686 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
687 EXPECT_FALSE(node->check(nullptr));
688
689 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
690 static_cast<int>(ComparisonOperator::GREATER));
691 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
692 EXPECT_TRUE(node->check(nullptr));
693
694 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
695 static_cast<int>(ComparisonOperator::LESS));
696 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
697 EXPECT_FALSE(node->check(nullptr));
698
699 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
700 static_cast<int>(ComparisonOperator::NOTEQUAL));
701 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
702 EXPECT_TRUE(node->check(nullptr));
703
704 // Check almost equal doubles
705 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 3.1415926535897931234567890);
706 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 3.1415926535897931234567891);
707 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
708 static_cast<int>(ComparisonOperator::EQUALEQUAL));
709 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
710 EXPECT_TRUE(node->check(nullptr));
711
712 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
713 static_cast<int>(ComparisonOperator::GREATEREQUAL));
714 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
715 EXPECT_TRUE(node->check(nullptr));
716
717 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
718 static_cast<int>(ComparisonOperator::LESSEQUAL));
719 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
720 EXPECT_TRUE(node->check(nullptr));
721
722 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
723 static_cast<int>(ComparisonOperator::GREATER));
724 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
725 EXPECT_FALSE(node->check(nullptr));
726
727 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
728 static_cast<int>(ComparisonOperator::LESS));
729 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
730 EXPECT_FALSE(node->check(nullptr));
731
732 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
733 static_cast<int>(ComparisonOperator::NOTEQUAL));
734 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
735 EXPECT_FALSE(node->check(nullptr));
736
737 // Check almost equal comparison for doubles and integers
738 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 3.0000000000000000000000001);
739 child2 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 3);
740 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
741 static_cast<int>(ComparisonOperator::EQUALEQUAL));
742 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
743 EXPECT_TRUE(node->check(nullptr));
744
745 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
746 static_cast<int>(ComparisonOperator::GREATEREQUAL));
747 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
748 EXPECT_TRUE(node->check(nullptr));
749
750 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
751 static_cast<int>(ComparisonOperator::LESSEQUAL));
752 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
753 EXPECT_TRUE(node->check(nullptr));
754
755 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
756 static_cast<int>(ComparisonOperator::GREATER));
757 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
758 EXPECT_FALSE(node->check(nullptr));
759
760 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
761 static_cast<int>(ComparisonOperator::LESS));
762 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
763 EXPECT_FALSE(node->check(nullptr));
764
765 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
766 static_cast<int>(ComparisonOperator::NOTEQUAL));
767 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
768 EXPECT_FALSE(node->check(nullptr));
769
770 // Note: almostEqualDouble does not work if one input is exactly 0.0
771 // and the other input is almost equal to 0.0
772 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 0.0);
773 child2 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 0);
774 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
775 static_cast<int>(ComparisonOperator::EQUALEQUAL));
776 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
777 EXPECT_TRUE(node->check(nullptr));
778
779 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
780 static_cast<int>(ComparisonOperator::GREATEREQUAL));
781 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
782 EXPECT_TRUE(node->check(nullptr));
783
784 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
785 static_cast<int>(ComparisonOperator::LESSEQUAL));
786 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
787 EXPECT_TRUE(node->check(nullptr));
788
789 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
790 static_cast<int>(ComparisonOperator::GREATER));
791 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
792 EXPECT_FALSE(node->check(nullptr));
793
794 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
795 static_cast<int>(ComparisonOperator::LESS));
796 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
797 EXPECT_FALSE(node->check(nullptr));
798
799 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
800 static_cast<int>(ComparisonOperator::NOTEQUAL));
801 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
802 EXPECT_FALSE(node->check(nullptr));
803
804 // Check double and int that are not almost equal but notequal 0.0
805 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 3.00000000000001);
806 child2 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 3);
807 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
808 static_cast<int>(ComparisonOperator::EQUALEQUAL));
809 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
810 EXPECT_FALSE(node->check(nullptr));
811
812 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
813 static_cast<int>(ComparisonOperator::GREATEREQUAL));
814 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
815 EXPECT_TRUE(node->check(nullptr));
816
817 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
818 static_cast<int>(ComparisonOperator::LESSEQUAL));
819 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
820 EXPECT_FALSE(node->check(nullptr));
821
822 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
823 static_cast<int>(ComparisonOperator::GREATER));
824 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
825 EXPECT_TRUE(node->check(nullptr));
826
827 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
828 static_cast<int>(ComparisonOperator::LESS));
829 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
830 EXPECT_FALSE(node->check(nullptr));
831
832 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
833 static_cast<int>(ComparisonOperator::NOTEQUAL));
834 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
835 EXPECT_TRUE(node->check(nullptr));
836
837 // Check almost equal comparison for double and bool
838 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 1.0000000000000001);
839 child2 = py::make_tuple(static_cast<int>(NodeType::BooleanNode), true);
840 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
841 static_cast<int>(ComparisonOperator::EQUALEQUAL));
842 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
843 // Uses almostEqualDouble and should evaluate to true
844 EXPECT_TRUE(node->check(nullptr));
845
846 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
847 static_cast<int>(ComparisonOperator::GREATEREQUAL));
848 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
849 EXPECT_TRUE(node->check(nullptr));
850
851 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
852 static_cast<int>(ComparisonOperator::LESSEQUAL));
853 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
854 EXPECT_TRUE(node->check(nullptr));
855
856 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
857 static_cast<int>(ComparisonOperator::GREATER));
858 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
859 EXPECT_FALSE(node->check(nullptr));
860
861 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
862 static_cast<int>(ComparisonOperator::LESS));
863 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
864 EXPECT_FALSE(node->check(nullptr));
865
866 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
867 static_cast<int>(ComparisonOperator::NOTEQUAL));
868 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
869 // Uses almostEqualDouble and should evaluate to false
870 EXPECT_FALSE(node->check(nullptr));
871
872 // Note: almostEqualDouble does not work if one input is exactly 0.0
873 // and the other input is almost equal to 0.0
874 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 0.0);
875 child2 = py::make_tuple(static_cast<int>(NodeType::BooleanNode), false);
876 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
877 static_cast<int>(ComparisonOperator::EQUALEQUAL));
878 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
879 EXPECT_TRUE(node->check(nullptr));
880
881 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
882 static_cast<int>(ComparisonOperator::GREATEREQUAL));
883 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
884 EXPECT_TRUE(node->check(nullptr));
885
886 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
887 static_cast<int>(ComparisonOperator::LESSEQUAL));
888 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
889 EXPECT_TRUE(node->check(nullptr));
890
891 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
892 static_cast<int>(ComparisonOperator::GREATER));
893 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
894 EXPECT_FALSE(node->check(nullptr));
895
896 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
897 static_cast<int>(ComparisonOperator::LESS));
898 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
899 EXPECT_FALSE(node->check(nullptr));
900
901 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
902 static_cast<int>(ComparisonOperator::NOTEQUAL));
903 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
904 EXPECT_FALSE(node->check(nullptr));
905
906
907 // Check double and bool that are not almost equal
908 child1 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 1.00000000000001);
909 child2 = py::make_tuple(static_cast<int>(NodeType::BooleanNode), true);
910 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
911 static_cast<int>(ComparisonOperator::EQUALEQUAL));
912 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
913 EXPECT_FALSE(node->check(nullptr));
914
915 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
916 static_cast<int>(ComparisonOperator::GREATEREQUAL));
917 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
918 EXPECT_TRUE(node->check(nullptr));
919
920 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
921 static_cast<int>(ComparisonOperator::LESSEQUAL));
922 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
923 EXPECT_FALSE(node->check(nullptr));
924
925 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
926 static_cast<int>(ComparisonOperator::GREATER));
927 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
928 EXPECT_TRUE(node->check(nullptr));
929
930 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
931 static_cast<int>(ComparisonOperator::LESS));
932 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
933 EXPECT_FALSE(node->check(nullptr));
934
935 bRelTuple = py::make_tuple(static_cast<int>(NodeType::BinaryRelationalNode), child1, child2,
936 static_cast<int>(ComparisonOperator::NOTEQUAL));
937 node = NodeFactory::compile_boolean_node<MockVariableManager>(bRelTuple);
938 EXPECT_TRUE(node->check(nullptr));
939
940 }
942 TEST(CutNodesTest, ternaryRelationalNode)
943 {
944 Py_Initialize();
945 // Get main module
946 py::object main = py::import("__main__");
947 py::object pyfloat = main.attr("__builtins__").attr("float");
948
949 auto child1 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 1);
950 auto child2 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 2);
951 auto child3 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 3);
952 auto tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child2, child3,
953 static_cast<int>(ComparisonOperator::LESS), static_cast<int>(ComparisonOperator::LESS));
954
955 auto node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
956 EXPECT_TRUE(node->check(nullptr));
957 EXPECT_EQ(node->decompile(), "1 < 2 < 3");
958
959 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child1,
960 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::EQUALEQUAL));
961 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
962 EXPECT_TRUE(node->check(nullptr));
963 EXPECT_EQ(node->decompile(), "1 == 1 == 1");
964
965
966 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child1,
967 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::LESSEQUAL));
968 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
969 EXPECT_TRUE(node->check(nullptr));
970 EXPECT_EQ(node->decompile(), "1 == 1 <= 1");
971
972
973 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child2,
974 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::LESSEQUAL));
975 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
976 EXPECT_TRUE(node->check(nullptr));
977 EXPECT_EQ(node->decompile(), "1 == 1 <= 2");
978
979
980 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child2,
981 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::LESS));
982 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
983 EXPECT_TRUE(node->check(nullptr));
984 EXPECT_EQ(node->decompile(), "1 == 1 < 2");
985
986 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child2,
987 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::NOTEQUAL));
988 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
989 EXPECT_TRUE(node->check(nullptr));
990 EXPECT_EQ(node->decompile(), "1 == 1 != 2");
991
992 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child1,
993 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::GREATEREQUAL));
994 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
995 EXPECT_TRUE(node->check(nullptr));
996 EXPECT_EQ(node->decompile(), "1 == 1 >= 1");
997
998 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child2,
999 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::GREATER));
1000 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1001 EXPECT_FALSE(node->check(nullptr));
1002 EXPECT_EQ(node->decompile(), "1 == 1 > 2");
1003
1004 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child1,
1005 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::NOTEQUAL));
1006 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1007 EXPECT_FALSE(node->check(nullptr));
1008 EXPECT_EQ(node->decompile(), "1 == 1 != 1");
1009
1010
1011 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child2,
1012 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::LESSEQUAL));
1013 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1014 EXPECT_TRUE(node->check(nullptr));
1015 EXPECT_EQ(node->decompile(), "1 == 1 <= 2");
1016
1017 // Create new double tuple
1018 child3 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 3.141);
1019
1020 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child1, child3,
1021 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::LESSEQUAL));
1022 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1023 EXPECT_TRUE(node->check(nullptr));
1024 EXPECT_EQ(node->decompile(), "1 == 1 <= 3.141");
1025
1026 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child1, child3, child3,
1027 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::LESSEQUAL));
1028 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1029 EXPECT_FALSE(node->check(nullptr));
1030 EXPECT_EQ(node->decompile(), "1 == 3.141 <= 3.141");
1031
1032
1033 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child3,
1034 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::LESSEQUAL));
1035 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1036 EXPECT_TRUE(node->check(nullptr));
1037 EXPECT_EQ(node->decompile(), "3.141 == 3.141 <= 3.141");
1038
1039
1040 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child3,
1041 static_cast<int>(ComparisonOperator::NOTEQUAL), static_cast<int>(ComparisonOperator::LESSEQUAL));
1042 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1043 EXPECT_FALSE(node->check(nullptr));
1044 EXPECT_EQ(node->decompile(), "3.141 != 3.141 <= 3.141");
1045
1046 child3 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("nan"));
1047
1048 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child3,
1049 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::EQUALEQUAL));
1050 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1051 EXPECT_TRUE(node->check(nullptr));
1052 EXPECT_EQ(node->decompile(), "nan == nan == nan");
1053
1054 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child2,
1055 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::EQUALEQUAL));
1056 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1057 EXPECT_FALSE(node->check(nullptr));
1058 EXPECT_EQ(node->decompile(), "nan == nan == 2");
1059
1060
1061 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child2,
1062 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::NOTEQUAL));
1063 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1064 EXPECT_TRUE(node->check(nullptr));
1065 EXPECT_EQ(node->decompile(), "nan == nan != 2");
1066
1067 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child3,
1068 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::NOTEQUAL));
1069 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1070 EXPECT_FALSE(node->check(nullptr));
1071 EXPECT_EQ(node->decompile(), "nan == nan != nan");
1072
1073 child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), pyfloat("inf"));
1074
1075 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child2,
1076 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::NOTEQUAL));
1077 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1078 EXPECT_TRUE(node->check(nullptr));
1079 EXPECT_EQ(node->decompile(), "nan == nan != inf");
1080
1081
1082 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child2,
1083 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::EQUALEQUAL));
1084 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1085 EXPECT_FALSE(node->check(nullptr));
1086 EXPECT_EQ(node->decompile(), "nan == nan == inf");
1087
1088 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child2,
1089 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::LESS));
1090 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1091 EXPECT_FALSE(node->check(nullptr));
1092 EXPECT_EQ(node->decompile(), "nan == nan < inf");
1093
1094 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child2,
1095 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::LESSEQUAL));
1096 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1097 EXPECT_FALSE(node->check(nullptr));
1098 EXPECT_EQ(node->decompile(), "nan == nan <= inf");
1099
1100 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child2,
1101 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::GREATER));
1102 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1103 EXPECT_FALSE(node->check(nullptr));
1104 EXPECT_EQ(node->decompile(), "nan == nan > inf");
1105
1106 tuple = py::make_tuple(static_cast<int>(NodeType::TernaryRelationalNode), child3, child3, child2,
1107 static_cast<int>(ComparisonOperator::EQUALEQUAL), static_cast<int>(ComparisonOperator::GREATEREQUAL));
1108 node = NodeFactory::compile_boolean_node<MockVariableManager>(tuple);
1109 EXPECT_FALSE(node->check(nullptr));
1110 EXPECT_EQ(node->decompile(), "nan == nan >= inf");
1111
1112 }
1114 TEST(CutNodesTest, unaryExpressionNode)
1115 {
1116 Py_Initialize();
1117 auto child1 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 1);
1118 auto tuple = py::make_tuple(static_cast<int>(NodeType::UnaryExpressionNode), child1, false, false);
1119 auto node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1120 EXPECT_EQ(std::get<int>(node->evaluate(nullptr)), 1);
1121
1122 // Check docompiling
1123 EXPECT_EQ(node->decompile(), "1");
1124
1125 tuple = py::make_tuple(static_cast<int>(NodeType::UnaryExpressionNode), child1, true, false);
1126 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1127 EXPECT_EQ(std::get<int>(node->evaluate(nullptr)), -1);
1128
1129 // Check docompiling
1130 EXPECT_EQ(node->decompile(), "-1");
1131
1132 tuple = py::make_tuple(static_cast<int>(NodeType::UnaryExpressionNode), child1, true, true);
1133 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1134 EXPECT_EQ(std::get<int>(node->evaluate(nullptr)), -1);
1135
1136 // Check docompiling
1137 EXPECT_EQ(node->decompile(), "-( 1 )");
1138
1139 tuple = py::make_tuple(static_cast<int>(NodeType::UnaryExpressionNode), child1, false, true);
1140 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1141 EXPECT_EQ(std::get<int>(node->evaluate(nullptr)), 1);
1142
1143 // Check docompiling
1144 EXPECT_EQ(node->decompile(), "( 1 )");
1145
1146 }
1148 TEST(CutNodesTest, binaryExpressionNode)
1149 {
1150 Py_Initialize();
1151 auto child1 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 1);
1152 auto child2 = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 2.5);
1153 auto tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child1, child1,
1154 static_cast<int>(ArithmeticOperation::PLUS));
1155 auto node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1156 EXPECT_EQ(std::get<int>(node->evaluate(nullptr)), 2);
1157
1158 // Check docompiling
1159 EXPECT_EQ(node->decompile(), "1 + 1");
1160
1161 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child1, child2,
1162 static_cast<int>(ArithmeticOperation::PLUS));
1163 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1164 EXPECT_EQ(std::get<double>(node->evaluate(nullptr)), 3.5);
1165 EXPECT_EQ(node->decompile(), "1 + 2.5");
1166
1167 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child1, child2,
1168 static_cast<int>(ArithmeticOperation::MINUS));
1169 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1170 EXPECT_EQ(std::get<double>(node->evaluate(nullptr)), -1.5);
1171 EXPECT_EQ(node->decompile(), "1 - 2.5");
1172
1173
1174 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child1, child2,
1175 static_cast<int>(ArithmeticOperation::PRODUCT));
1176 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1177 EXPECT_EQ(std::get<double>(node->evaluate(nullptr)), 2.5);
1178 EXPECT_EQ(node->decompile(), "1 * 2.5");
1179
1180
1181 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child1, child2,
1182 static_cast<int>(ArithmeticOperation::DIVISION));
1183 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1184 EXPECT_EQ(std::get<double>(node->evaluate(nullptr)), 0.4);
1185 EXPECT_EQ(node->decompile(), "1 / 2.5");
1186
1187
1188 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child1, child1,
1189 static_cast<int>(ArithmeticOperation::POWER));
1190 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1191 EXPECT_EQ(std::get<double>(node->evaluate(nullptr)), 1.0);
1192 EXPECT_EQ(node->decompile(), "1 ** 1");
1193
1194 child1 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 2);
1195 child2 = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 3);
1196
1197 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child1, child2,
1198 static_cast<int>(ArithmeticOperation::POWER));
1199 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1200 EXPECT_EQ(std::get<double>(node->evaluate(nullptr)), 8.0);
1201 EXPECT_EQ(node->decompile(), "2 ** 3");
1202
1203 child2 = py::make_tuple(static_cast<int>(NodeType::IdentifierNode), "mocking_variable");
1204 MockObjectType part{10};
1205 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child1, child2,
1206 static_cast<int>(ArithmeticOperation::POWER));
1207 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1208 EXPECT_EQ(std::get<double>(node->evaluate(&part)), 1024);
1209 EXPECT_EQ(node->decompile(), "2 ** mocking_variable");
1210
1211
1212 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child2, child2,
1213 static_cast<int>(ArithmeticOperation::PLUS));
1214 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1215 EXPECT_EQ(std::get<int>(node->evaluate(&part)), 20);
1216 EXPECT_EQ(node->decompile(), "mocking_variable + mocking_variable");
1217
1218 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child2, child2,
1219 static_cast<int>(ArithmeticOperation::MINUS));
1220 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1221 EXPECT_EQ(std::get<int>(node->evaluate(&part)), 0);
1222 EXPECT_EQ(node->decompile(), "mocking_variable - mocking_variable");
1223
1224 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child2, child2,
1225 static_cast<int>(ArithmeticOperation::PRODUCT));
1226 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1227 EXPECT_EQ(std::get<int>(node->evaluate(&part)), 100);
1228 EXPECT_EQ(node->decompile(), "mocking_variable * mocking_variable");
1229
1230
1231 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child2, child2,
1232 static_cast<int>(ArithmeticOperation::DIVISION));
1233 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1234 EXPECT_EQ(std::get<double>(node->evaluate(&part)), 1);
1235 EXPECT_EQ(node->decompile(), "mocking_variable / mocking_variable");
1236
1237
1238 part = MockObjectType{20};
1239 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child1, child2,
1240 static_cast<int>(ArithmeticOperation::DIVISION));
1241 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1242 EXPECT_EQ(std::get<double>(node->evaluate(&part)), 0.1);
1243 EXPECT_EQ(node->decompile(), "2 / mocking_variable");
1244
1245 part = MockObjectType{0.1};
1246 tuple = py::make_tuple(static_cast<int>(NodeType::BinaryExpressionNode), child2, child1,
1247 static_cast<int>(ArithmeticOperation::DIVISION));
1248 node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1249 EXPECT_EQ(std::get<double>(node->evaluate(&part)), 0.05);
1250 EXPECT_EQ(node->decompile(), "mocking_variable / 2");
1251
1252
1253 }
1255 TEST(CutNodesTest, identifierNode)
1256 {
1257 Py_Initialize();
1258 MockObjectType part{4.2};
1259 auto tuple = py::make_tuple(static_cast<int>(NodeType::IdentifierNode), "mocking_variable");
1260 auto node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1261 EXPECT_EQ(std::get<double>(node->evaluate(&part)), 4.2);
1262
1263 tuple = py::make_tuple(static_cast<int>(NodeType::IdentifierNode), "THISDOESNOTEXIST");
1264 EXPECT_THROW(NodeFactory::compile_expression_node<MockVariableManager>(tuple), std::runtime_error);
1265
1266 // Check nested runtime_error
1267 tuple = py::make_tuple(static_cast<int>(NodeType::UnaryExpressionNode), tuple, false, false);
1268 EXPECT_THROW(NodeFactory::compile_expression_node<MockVariableManager>(tuple), std::runtime_error);
1269
1270 }
1272 TEST(CutNodesTest, functionNode)
1273 {
1274 Py_Initialize();
1275 MockObjectType part{4};
1276 auto tuple = py::make_tuple(
1277 static_cast<int>(NodeType::FunctionNode),
1278 "sum",
1279 "mocking_variable, 2, 1"
1280 );
1281 auto node = NodeFactory::compile_expression_node<MockVariableManager>(tuple);
1282 EXPECT_EQ(std::get<double>(node->evaluate(&part)), 7);
1283 EXPECT_EQ(node->decompile(), "sum(mocking_variable, 2, 1)");
1284 part = MockObjectType{4.2};
1285 EXPECT_EQ(std::get<double>(node->evaluate(&part)), 7.2);
1286 part = MockObjectType{false};
1287 EXPECT_EQ(std::get<double>(node->evaluate(&part)), 3.0);
1288 part = MockObjectType{true};
1289 EXPECT_EQ(std::get<double>(node->evaluate(&part)), 4.0);
1290
1291 }
1293 TEST(CutNodesTest, integerNode)
1294 {
1295 Py_Initialize();
1296 // Get main module
1297 py::object main = py::import("__main__");
1298
1299 // Create IntegerNode tuples.
1300 const py::tuple iTuple_val = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 1337);
1301 const py::tuple iTuple_val_neg = py::make_tuple(static_cast<int>(NodeType::IntegerNode), -1337);
1302 const py::tuple iTuple_val_zero = py::make_tuple(static_cast<int>(NodeType::IntegerNode), 0);
1303
1304 // Check overflow management
1305 const py::tuple iTuple_max = py::make_tuple(static_cast<int>(NodeType::IntegerNode),
1306 main.attr("__builtins__").attr("int")("2147483647"));
1307 const py::tuple iTuple_min = py::make_tuple(static_cast<int>(NodeType::IntegerNode),
1308 main.attr("__builtins__").attr("int")("-2147483648"));
1309 const py::tuple iTuple_pos_overflow = py::make_tuple(static_cast<int>(NodeType::IntegerNode),
1310 main.attr("__builtins__").attr("int")("2147483648"));
1311 const py::tuple iTuple_neg_overflow = py::make_tuple(static_cast<int>(NodeType::IntegerNode),
1312 main.attr("__builtins__").attr("int")("-2147483649"));
1313
1314 // Compile IntegerNodes and check evaluation
1315 auto iNode_val = NodeFactory::compile_expression_node<MockVariableManager>(iTuple_val);
1316 auto iNode_val_neg = NodeFactory::compile_expression_node<MockVariableManager>(iTuple_val_neg);
1317 auto iNode_val_zero = NodeFactory::compile_expression_node<MockVariableManager>(iTuple_val_zero);
1318 // Compile overflow management
1319 auto iNode_max = NodeFactory::compile_expression_node<MockVariableManager>(iTuple_max);
1320 auto iNode_min = NodeFactory::compile_expression_node<MockVariableManager>(iTuple_min);
1321 auto iNode_pos_overflow = NodeFactory::compile_expression_node<MockVariableManager>(iTuple_pos_overflow);
1322 auto iNode_neg_overflow = NodeFactory::compile_expression_node<MockVariableManager>(iTuple_neg_overflow);
1323
1324 // test evaluation
1325 EXPECT_EQ(std::get<int>(iNode_val->evaluate(nullptr)), 1337);
1326 EXPECT_EQ(std::get<int>(iNode_val_neg->evaluate(nullptr)), -1337);
1327 EXPECT_EQ(std::get<int>(iNode_val_zero->evaluate(nullptr)), 0);
1328 EXPECT_EQ(std::get<int>(iNode_max->evaluate(nullptr)), 2147483647);
1329 EXPECT_EQ(std::get<int>(iNode_min->evaluate(nullptr)), -2147483648);
1330 // test overflowing node evaluation (returned as double)
1331 EXPECT_EQ(std::get<double>(iNode_pos_overflow->evaluate(nullptr)), 2147483648.);
1332 EXPECT_EQ(std::get<double>(iNode_neg_overflow->evaluate(nullptr)), -2147483649.);
1333
1334 // test decompiling
1335 EXPECT_EQ(iNode_val->decompile(), "1337");
1336 EXPECT_EQ(iNode_val_neg->decompile(), "-1337");
1337 EXPECT_EQ(iNode_val_zero->decompile(), "0");
1338 EXPECT_EQ(iNode_max->decompile(), "2147483647");
1339 EXPECT_EQ(iNode_min->decompile(), "-2147483648");
1340 // test overflowing node decompiling
1341 EXPECT_EQ(iNode_pos_overflow->decompile(), "2.14748e+09");
1342 EXPECT_EQ(iNode_neg_overflow->decompile(), "-2.14748e+09");
1343 }
1345 TEST(CutNodesTest, booleanNode)
1346 {
1347 Py_Initialize();
1348 // Create two BooleanNode tuples with values true and false.
1349 const py::tuple booleanTuple_true = py::make_tuple(static_cast<int>(NodeType::BooleanNode), true);
1350 const py::tuple booleanTuple_false = py::make_tuple(static_cast<int>(NodeType::BooleanNode), false);
1351 // Compile BooleanNodes and check evaluation
1352 auto booleanNode_true = NodeFactory::compile_expression_node<MockVariableManager>(booleanTuple_true);
1353 auto booleanNode_false = NodeFactory::compile_expression_node<MockVariableManager>(booleanTuple_false);
1354 // test evaluation
1355 EXPECT_TRUE(std::get<bool>(booleanNode_true->evaluate(nullptr)));
1356 EXPECT_FALSE(std::get<bool>(booleanNode_false->evaluate(nullptr)));
1357 // test decompiling
1358 EXPECT_EQ(booleanNode_true->decompile(), "true");
1359 EXPECT_EQ(booleanNode_false->decompile(), "false");
1360 }
1362 TEST(CutNodesTest, doubleNode)
1363 {
1364 Py_Initialize();
1365 // Get main module
1366 py::object main = py::import("__main__");
1367
1368 // Value tuples
1369 const py::tuple tuple_val = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 3.141);
1370 const py::tuple tuple_val_neg = py::make_tuple(static_cast<int>(NodeType::DoubleNode), -3.141);
1371 const py::tuple tuple_val_zero = py::make_tuple(static_cast<int>(NodeType::DoubleNode), 0.0);
1372 // Infinity tuples
1373 const py::tuple tuple_inf = py::make_tuple(static_cast<int>(NodeType::DoubleNode), main.attr("__builtins__").attr("float")("inf"));
1374 const py::tuple tuple_neg_inf = py::make_tuple(static_cast<int>(NodeType::DoubleNode),
1375 main.attr("__builtins__").attr("float")("-inf"));
1376 // nan tuple
1377 const py::tuple tuple_nan = py::make_tuple(static_cast<int>(NodeType::DoubleNode), main.attr("__builtins__").attr("float")("nan"));
1378
1379 // Value nodes
1380 auto doubleNode_val = NodeFactory::compile_expression_node<MockVariableManager>(tuple_val);
1381 auto doubleNode_val_neg = NodeFactory::compile_expression_node<MockVariableManager>(tuple_val_neg);
1382 auto doubleNode_val_zero = NodeFactory::compile_expression_node<MockVariableManager>(tuple_val_zero);
1383
1384 // Infinity nodes
1385 auto doubleNode_inf = NodeFactory::compile_expression_node<MockVariableManager>(tuple_inf);
1386 auto doubleNode_neg_inf = NodeFactory::compile_expression_node<MockVariableManager>(tuple_neg_inf);
1387 // NaN nodes
1388 auto doubleNode_nan = NodeFactory::compile_expression_node<MockVariableManager>(tuple_nan);
1389
1390 // test value evaluation
1391 EXPECT_EQ(std::get<double>(doubleNode_val->evaluate(nullptr)), 3.141);
1392 EXPECT_EQ(std::get<double>(doubleNode_val_neg->evaluate(nullptr)), -3.141);
1393 EXPECT_EQ(std::get<double>(doubleNode_val_zero->evaluate(nullptr)), 0);
1394
1395 // test infinity evaluation
1396 EXPECT_EQ(std::get<double>(doubleNode_inf->evaluate(nullptr)), std::numeric_limits<double>::infinity());
1397 EXPECT_EQ(std::get<double>(doubleNode_neg_inf->evaluate(nullptr)), -1 * std::numeric_limits<double>::infinity());
1398
1399 // test NaN evaluation
1400 EXPECT_TRUE(std::isnan(std::get<double>(doubleNode_nan->evaluate(nullptr))));
1401
1402 // test value decompiling
1403 EXPECT_EQ(doubleNode_val->decompile(), "3.141");
1404 EXPECT_EQ(doubleNode_val_neg->decompile(), "-3.141");
1405 EXPECT_EQ(doubleNode_val_zero->decompile(), "0");
1406 // test infinity decompiling
1407 EXPECT_EQ(doubleNode_inf->decompile(), "inf");
1408 EXPECT_EQ(doubleNode_neg_inf->decompile(), "-inf");
1409 // test nan decompiling
1410 EXPECT_EQ(doubleNode_nan->decompile(), "nan");
1411 }
1412} // namespace
Belle2::NodeFactory::compile_expression_node
static std::unique_ptr< const AbstractExpressionNode< AVariableManager > > compile_expression_node(Nodetuple tuple)
This template function creates a ExpressionNode from a boost::python::tuple The Python Parser encodes...
Definition NodeFactory.h:141
Belle2::NodeFactory::compile_boolean_node
static std::unique_ptr< const AbstractBooleanNode< AVariableManager > > compile_boolean_node(Nodetuple tuple)
This template function creates a boolean node from a boost::python::tuple The Python Parser encodes t...
Definition NodeFactory.h:80
Belle2::convertString
T convertString(const std::string &str)
Converts a string to type T (one of float, double, long double, int, long int, unsigned long int).
Belle2
Abstract base class for different kinds of events.
Definition ClusterUtils.h:26