adds basic initial test suite for expression_tree_leaf_node

Author: attwoodn

include/attwoodn/expression_tree.hpp

@@ -180,7 +180,12 @@ namespace attwoodn::expression_tree {
                 ~expression_tree_leaf_node() override {};
 
                 bool evaluate(const Obj& obj) override {
-                    if (!member_func_ && !member_var_) {
+                    if (member_func_ && member_var_) {
+                        throw std::runtime_error("expression_tree_leaf_node has both a member function reference " + 
+                            std::string("and member variable reference. Only one is permitted"));
+                    }
+
+                    else if (!member_func_ && !member_var_) {
                         throw std::runtime_error("expression_tree_leaf_node has a nullptr for both member function reference " + 
                             std::string("and member variable reference. At least one is required"));
                     }
@@ -199,7 +204,7 @@ namespace attwoodn::expression_tree {
 
                     else return false;
 
-                    return Op(actual_value, comp_value_);
+                    return logical_op_(actual_value, comp_value_);
                 }
 
             private:

tests/CMakeLists.txt

@@ -1,6 +1,6 @@
 if(BUILD_TESTING) 
-    add_executable( expression_tree_test test.cpp )
-    add_test( expression_tree_test ${EXECUTABLE_OUTPUT_PATH}/expression_tree_test )
+    add_executable( expression_tree_leaf_node_test expression_tree_leaf_node.cpp )
+    add_test( expression_tree_leaf_node_test ${EXECUTABLE_OUTPUT_PATH}/expression_tree_leaf_node_test )
 
     add_executable( operators_test operators.cpp )
     add_test( operators_test ${EXECUTABLE_OUTPUT_PATH}/operators_test )

tests/expression_tree_leaf_node.cpp

@@ -0,0 +1,34 @@
+#include <attwoodn/expression_tree.hpp>
+#include <iostream>
+#include <cassert>
+
+using namespace attwoodn::expression_tree;
+
+struct test_fixture {
+    std::string some_string;
+};
+
+template<class T> struct type_id{typedef T type;}; 
+
+// template<typename Obj, typename CompValue, typename Op = typename type_id<bool (*)(CompValue*, CompValue*)>::type>
+// node::expression_tree_leaf_node<Obj, Op, CompValue>* make_leaf_node( CompValue Obj::* member_var, Op op, CompValue comp_value ) {
+//     return new node::expression_tree_leaf_node<Obj, Op, CompValue>( member_var, op, comp_value );
+// }
+
+template<typename Obj, typename CompValue, typename Op = typename type_id<bool (*)(CompValue, CompValue)>::type>
+node::expression_tree_leaf_node<Obj, Op, CompValue>* make_leaf_node( CompValue Obj::* member_var, Op op, CompValue comp_value ) {
+    return new node::expression_tree_leaf_node<Obj, Op, CompValue>( member_var, op, comp_value );
+}
+
+int main(int argc, char** argv) {
+    test_fixture fixture;
+    fixture.some_string = "hello world!";
+
+    auto node = make_leaf_node(&test_fixture::some_string, &op::equals, std::string("hello world!"));
+    assert(node->evaluate(fixture));
+
+    fixture.some_string = "hey, world!";
+    assert(!node->evaluate(fixture));
+
+    return EXIT_SUCCESS;
+}