adds unit test for complex expression tree

Author: attwoodn

tests/expression_tree.cpp

@@ -8,12 +8,14 @@ void test_simple_expression_tree();
 void test_complex_expression_tree();
 void test_moved_expression_tree();
 void test_copied_expression_tree();
+void test_user_defined_operator();
 
 int main(int argc, char** argv) {
     test_simple_expression_tree();
     test_complex_expression_tree();
     test_moved_expression_tree();
     test_copied_expression_tree();
+    test_user_defined_operator();
 
     return EXIT_SUCCESS;
 }
@@ -57,6 +59,140 @@ void test_simple_expression_tree() {
 
 void test_complex_expression_tree() {
 
+    // expression: (uint > 0 AND (some_string > "a" AND some_string < "z")) OR (some_string > "0" AND some_string < "9")
+    expression_tree<test_fixture> expr {
+        (make_expr(&test_fixture::is_some_uint_greater_than_zero, op::equals, true)
+            ->AND((make_expr(&test_fixture::some_string, op::greater_than, std::string("a"))
+                ->AND(make_expr(&test_fixture::some_string, op::less_than, std::string("z")))
+            ))
+        )
+        ->OR((make_expr(&test_fixture::some_string, op::greater_than, std::string("0"))
+                ->AND(make_expr(&test_fixture::some_string, op::less_than, std::string("9")))
+            )
+        )
+    };
+
+    test_fixture fixture;
+
+    fixture.some_uint = 0;
+
+    // test left-hand side of the expression tree when some_uint is 0
+    {
+        fixture.some_string = "a";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "aaa";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "c";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "yyyyy";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "B";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "ZZZ";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "/";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "red";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "                              ";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "tree fiddy";
+        assert(!expr.evaluate(fixture));
+    }
+
+    // test right-hand side of the expression tree when some_uint is 0
+    {
+        fixture.some_string = "000";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "00";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "0";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "12345";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "7";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "89999";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "9";
+        assert(!expr.evaluate(fixture));
+    }
+
+    fixture.some_uint = 1;
+    
+    // test left-hand side of the expression tree when some_uint is 0
+    {
+        fixture.some_string = "a";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "aaa";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "c";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "yyyyy";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "B";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "ZZZ";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "/";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "red";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "                              ";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "tree fiddy";
+        assert(expr.evaluate(fixture));
+    }
+
+    // test right-hand side of the expression tree when some_uint is 1
+    {
+        fixture.some_string = "000";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "00";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "0";
+        assert(!expr.evaluate(fixture));
+
+        fixture.some_string = "12345";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "7";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "89999";
+        assert(expr.evaluate(fixture));
+
+        fixture.some_string = "9";
+        assert(!expr.evaluate(fixture));
+    }
+
+
 }
 
 void test_moved_expression_tree() {
@@ -90,7 +226,7 @@ void test_moved_expression_tree() {
     };
     test_procedure(expr);
 
-    expression_tree<test_fixture> move_constructed_expr( std::move(expr) );
+    expression_tree<test_fixture> move_constructed_expr(std::move(expr));
     test_procedure(move_constructed_expr);
 
     expression_tree<test_fixture> move_assigned_expr = std::move(move_constructed_expr);
@@ -128,7 +264,7 @@ void test_copied_expression_tree() {
     };
     test_procedure(expr);
 
-    expression_tree<test_fixture> copy_constructed_expr( expr );
+    expression_tree<test_fixture> copy_constructed_expr(expr);
     test_procedure(copy_constructed_expr);
 
     expression_tree<test_fixture> copy_assigned_expr = copy_constructed_expr;
@@ -137,4 +273,8 @@ void test_copied_expression_tree() {
     // ensure both of the old copied versions still work after copying
     test_procedure(expr);
     test_procedure(copy_constructed_expr);
+}
+
+void test_user_defined_operator() {
+
 }

tests/test_utils.hpp

@@ -15,4 +15,18 @@ struct test_fixture {
     bool is_some_uint_greater_than_zero() const {
         return some_uint;
     }
+};
+
+struct packet_payload {
+    const uint16_t error_code; 
+    std::string data;
+
+    uint64_t payload_size() const {
+        return data.size();
+    }
+};
+
+class data_packet {
+    const uint32_t sender_id;
+    packet_payload payload;
 };