From 274b39ba869a4dc2886281d3137f2507351a0bfa Mon Sep 17 00:00:00 2001
From: Zach Laine <whatwasthataddress@gmail.com>
Date: Thu, 10 Nov 2016 17:32:56 -0600
Subject: [PATCH] Move more test code to standalone tests.

---
 sketch.cpp                                    | 218 ------------------
 test/CMakeLists.txt                           |   4 +
 test/default_eval.cpp                         |  62 +++++
 test/user_eval_expression_as.cpp              | 106 +++++++++
 test/user_expression_transform.cpp            |   6 +-
 test/user_operator_and_eval_expression_as.cpp | 104 +++++++++
 test/user_operator_eval.cpp                   |  78 +++++++
 7 files changed, 356 insertions(+), 222 deletions(-)
 create mode 100644 test/default_eval.cpp
 create mode 100644 test/user_eval_expression_as.cpp
 create mode 100644 test/user_operator_and_eval_expression_as.cpp
 create mode 100644 test/user_operator_eval.cpp

diff --git a/sketch.cpp b/sketch.cpp
index f01f8b2..b61784a 100644
--- a/sketch.cpp
+++ b/sketch.cpp
@@ -1,12 +1,6 @@
 #define BOOST_PROTO17_CONVERSION_OPERATOR_TEMPLATE
 #include "expression.hpp"
 
-#include <boost/hana/integral_constant.hpp>
-#include <boost/hana/tuple.hpp>
-#include <boost/hana/type.hpp>
-#include <boost/hana/size.hpp>
-
-#include <algorithm>
 #include <iostream>
 #include <string>
 
@@ -952,214 +946,6 @@ void const_term_expr ()
     }
 }
 
-void default_eval ()
-{
-    std::cout << "\ndefault_eva()\n";
-
-    term<double> unity{1.0};
-    int i_ = 42;
-    term<int &&> i{std::move(i_)};
-    bp17::expression<
-        bp17::expr_kind::minus,
-        term<double>,
-        term<int &&>
-    > expr = unity - std::move(i);
-    bp17::expression<
-        bp17::expr_kind::plus,
-        term<double>,
-        bp17::expression<
-            bp17::expr_kind::minus,
-            term<double>,
-            term<int &&>
-        >
-    > unevaluated_expr = unity + std::move(expr);
-
-    {
-        double result = unity;
-        std::cout << "unity=" << result << "\n"; // 1
-    }
-
-    {
-        double result = expr;
-        std::cout << "expr=" << result << "\n"; // -41
-    }
-
-    {
-        double result = unevaluated_expr;
-        std::cout << "unevaluated_expr=" << result << "\n"; // -40
-    }
-
-    {
-        double result = evaluate(unity, 5, 6, 7);
-        std::cout << "evaluate(unity)=" << result << "\n"; // 1
-    }
-
-    {
-        double result = evaluate(expr);
-        std::cout << "evaluate(expr)=" << result << "\n"; // -41
-    }
-
-    {
-        double result = evaluate(unevaluated_expr, std::string("15"));
-        std::cout << "evaluate(unevaluated_expr)=" << result << "\n"; // -40
-    }
-
-    std::cout << "\n";
-}
-
-namespace user {
-
-    struct number
-    {
-        explicit operator double () const { return value; }
-
-        double value;
-    };
-
-    // User-defined binary-plus!  With weird semantics!
-    template <typename A, typename B>
-    inline auto eval_plus (A a, B b)
-    { return number{a.value - b.value}; }
-
-    template <typename E, typename Tuple>
-    constexpr auto eval_expression_as (
-        E const & expr,
-        boost::hana::basic_type<user::number>,
-        Tuple && args)
-    {
-        std::cout << "User eval!  ";
-        return static_cast<user::number>(
-            bp17::detail::default_eval_expr(expr, static_cast<Tuple &&>(args))
-        );
-    }
-
-}
-
-void user_operator_eval ()
-{
-    std::cout << "\nuser_operator_eval()\n";
-
-    term<user::number> unity{{1.0}};
-    double d_ = 42.0;
-    term<user::number> i{{d_}};
-    bp17::expression<
-        bp17::expr_kind::plus,
-        term<user::number>,
-        term<user::number>
-    > expr = unity + std::move(i);
-    bp17::expression<
-        bp17::expr_kind::plus,
-        term<user::number>,
-        bp17::expression<
-            bp17::expr_kind::plus,
-            term<user::number>,
-            term<user::number>
-        >
-    > unevaluated_expr = unity + std::move(expr);
-
-    {
-        double result = unity;
-        std::cout << "unity=" << result << "\n"; // 1
-    }
-
-    {
-        double result = expr;
-        std::cout << "expr=" << result << "\n"; // -41
-    }
-
-    {
-        double result = unevaluated_expr;
-        std::cout << "unevaluated_expr=" << result << "\n"; // 42
-    }
-
-    {
-        double result = (double)evaluate(unity, 5, 6, 7);
-        std::cout << "evaluate(unity)=" << result << "\n"; // 1
-    }
-
-    {
-        double result = (double)evaluate(expr);
-        std::cout << "evaluate(expr)=" << result << "\n"; // -41
-    }
-
-    {
-        double result = (double)evaluate(unevaluated_expr, std::string("15"));
-        std::cout << "evaluate(unevaluated_expr)=" << result << "\n"; // 42
-    }
-
-    std::cout << "\n";
-}
-
-void user_eval_expression_as ()
-{
-    term<user::number> unity{{1.0}};
-    double d_ = 42.0;
-    term<user::number> i{{d_}};
-    bp17::expression<
-        bp17::expr_kind::plus,
-        term<user::number>,
-        term<user::number>
-    > expr = unity + std::move(i);
-    bp17::expression<
-        bp17::expr_kind::plus,
-        term<user::number>,
-        bp17::expression<
-            bp17::expr_kind::plus,
-            term<user::number>,
-            term<user::number>
-        >
-    > unevaluated_expr = unity + std::move(expr);
-
-    std::cout << "\nuser_eval_expression_as()\n";
-
-    {
-        user::number result = unity;
-        std::cout << "unity=" << result.value << "\n"; // 1
-    }
-
-    {
-        user::number result = expr;
-        std::cout << "expr=" << result.value << "\n"; // -41
-    }
-
-    {
-        user::number result = unevaluated_expr;
-        std::cout << "unevaluated_expr=" << result.value << "\n"; // 42
-    }
-
-    {
-        user::number result = evaluate(unity, 5, 6, 7);
-        std::cout << "evaluate(unity)=" << result.value << "\n"; // 1
-    }
-
-    {
-        double result = (double)evaluate(expr);
-        std::cout << "evaluate(expr)=" << result << "\n"; // -41
-    }
-
-    {
-        double result = (double)evaluate(unevaluated_expr, std::string("15"));
-        std::cout << "evaluate(unevaluated_expr)=" << result << "\n"; // 42
-    }
-
-    {
-        user::number result = bp17::evaluate_as<user::number>(unity, 5, 6, 7);
-        std::cout << "evaluate(unity)=" << result.value << "\n"; // 1
-    }
-
-    {
-        user::number result = bp17::evaluate_as<user::number>(expr);
-        std::cout << "evaluate(expr)=" << result.value << "\n"; // -41
-    }
-
-    {
-        user::number result = bp17::evaluate_as<user::number>(unevaluated_expr, std::string("15"));
-        std::cout << "evaluate(unevaluated_expr)=" << result.value << "\n"; // 42
-    }
-
-    std::cout << "\n";
-}
-
 int main ()
 {
     term_plus_x();
@@ -1169,8 +955,4 @@ int main ()
     placeholders();
 
     const_term_expr();
-
-    default_eval();
-    user_eval_expression_as();
-    user_operator_eval();
 }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index ab1fbf0..fae7e08 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -16,6 +16,10 @@ macro(add_test_executable name)
 endmacro()
 
 add_test_executable(print)
+add_test_executable(default_eval)
+add_test_executable(user_operator_eval)
+#TODO: Broken! add_test_executable(user_eval_expression_as) 
+add_test_executable(user_operator_and_eval_expression_as) 
 add_test_executable(user_expression_transform)
 add_test_executable(placeholder_eval)
 add_test_executable(call_expr)
diff --git a/test/default_eval.cpp b/test/default_eval.cpp
new file mode 100644
index 0000000..6ee0b20
--- /dev/null
+++ b/test/default_eval.cpp
@@ -0,0 +1,62 @@
+#define BOOST_PROTO17_CONVERSION_OPERATOR_TEMPLATE
+#include "expression.hpp"
+
+#include <gtest/gtest.h>
+
+
+template <typename T>
+using term = boost::proto17::terminal<T>;
+
+namespace bp17 = boost::proto17;
+
+
+TEST(default_eval, default_eval)
+{
+    term<double> unity{1.0};
+    int i_ = 42;
+    term<int &&> i{std::move(i_)};
+    bp17::expression<
+        bp17::expr_kind::minus,
+        term<double>,
+        term<int &&>
+    > expr = unity - std::move(i);
+    bp17::expression<
+        bp17::expr_kind::plus,
+        term<double>,
+        bp17::expression<
+            bp17::expr_kind::minus,
+            term<double>,
+            term<int &&>
+        >
+    > unevaluated_expr = unity + std::move(expr);
+
+    {
+        double result = unity;
+        EXPECT_EQ(result, 1);
+    }
+
+    {
+        double result = expr;
+        EXPECT_EQ(result, -41);
+    }
+
+    {
+        double result = unevaluated_expr;
+        EXPECT_EQ(result, -40);
+    }
+
+    {
+        double result = evaluate(unity, 5, 6, 7);
+        EXPECT_EQ(result, 1);
+    }
+
+    {
+        double result = evaluate(expr);
+        EXPECT_EQ(result, -41);
+    }
+
+    {
+        double result = evaluate(unevaluated_expr, std::string("15"));
+        EXPECT_EQ(result, -40);
+    }
+}
diff --git a/test/user_eval_expression_as.cpp b/test/user_eval_expression_as.cpp
new file mode 100644
index 0000000..6bcf723
--- /dev/null
+++ b/test/user_eval_expression_as.cpp
@@ -0,0 +1,106 @@
+#define BOOST_PROTO17_CONVERSION_OPERATOR_TEMPLATE
+#include "expression.hpp"
+
+#include <gtest/gtest.h>
+
+
+template <typename T>
+using term = boost::proto17::terminal<T>;
+
+namespace bp17 = boost::proto17;
+
+
+namespace user {
+
+    struct number
+    {
+        explicit operator double () const { return value; }
+
+        double value;
+    };
+
+#if 0
+    // User-defined binary-plus!  With weird semantics!
+    template <typename A, typename B>
+    inline auto eval_plus (A a, B b)
+    { return number{a.value - b.value}; }
+#endif
+
+    template <typename E, typename Tuple>
+    constexpr auto eval_expression_as (
+        E const & expr,
+        boost::hana::basic_type<user::number>,
+        Tuple && args)
+    {
+        return static_cast<user::number>(
+            bp17::detail::default_eval_expr(expr, static_cast<Tuple &&>(args))
+        );
+    }
+
+}
+
+TEST(user_eval_expression_as, test_user_eval_expression_as)
+{
+    term<user::number> unity{{1.0}};
+    double d_ = 42.0;
+    term<user::number> i{{d_}};
+    bp17::expression<
+        bp17::expr_kind::plus,
+        term<user::number>,
+        term<user::number>
+    > expr = unity + std::move(i);
+    bp17::expression<
+        bp17::expr_kind::plus,
+        term<user::number>,
+        bp17::expression<
+            bp17::expr_kind::plus,
+            term<user::number>,
+            term<user::number>
+        >
+    > unevaluated_expr = unity + std::move(expr);
+
+    {
+        user::number result = unity;
+        EXPECT_EQ(result.value, 1);
+    }
+
+    {
+        user::number result = expr;
+        EXPECT_EQ(result.value, -41);
+    }
+
+    {
+        user::number result = unevaluated_expr;
+        EXPECT_EQ(result.value, 42);
+    }
+
+    {
+        user::number result = evaluate(unity, 5, 6, 7);
+        EXPECT_EQ(result.value, 1);
+    }
+
+    {
+        double result = (double)evaluate(expr);
+        EXPECT_EQ(result, -41);
+    }
+
+    {
+        double result = (double)evaluate(unevaluated_expr, std::string("15"));
+        EXPECT_EQ(result, 42);
+    }
+
+    {
+        user::number result = bp17::evaluate_as<user::number>(unity, 5, 6, 7);
+        EXPECT_EQ(result.value, 1);
+    }
+
+    {
+        user::number result = bp17::evaluate_as<user::number>(expr);
+        EXPECT_EQ(result.value, -41);
+    }
+
+    {
+        user::number result = bp17::evaluate_as<user::number>(unevaluated_expr, std::string("15"));
+        EXPECT_EQ(result.value, 42);
+    }
+}
diff --git a/test/user_expression_transform.cpp b/test/user_expression_transform.cpp
index 806fdb4..e385072 100644
--- a/test/user_expression_transform.cpp
+++ b/test/user_expression_transform.cpp
@@ -20,7 +20,7 @@ namespace user_2 {
     };
 
     number naxpy (number a, number x, number y)
-    { return number{a.value * x.value + y.value}; }
+    { return number{a.value * x.value + y.value + 100.0}; }
 
 #if 0
     auto eval_expression_as (
@@ -35,7 +35,6 @@ namespace user_2 {
         > const & expr,
         boost::hana::basic_type<number>)
     {
-        std::cout << "User naxpy!  ";
         using namespace boost::hana::literals;
         return naxpy(
             expr.elements[0_c].elements[0_c].elements[0_c],
@@ -49,7 +48,6 @@ namespace user_2 {
         boost::hana::basic_type<number>,
         boost::hana::tuple<>)
     {
-        std::cout << "User naxpy!  ";
         return naxpy(
             expr.left().left().value(),
             expr.left().right().value(),
@@ -88,5 +86,5 @@ TEST(user_expression_transform, test_user_expression_transform)
 #endif
 
     user_2::number result = expr;
-    EXPECT_EQ(result.value, 45);
+    EXPECT_EQ(result.value, 145);
 }
diff --git a/test/user_operator_and_eval_expression_as.cpp b/test/user_operator_and_eval_expression_as.cpp
new file mode 100644
index 0000000..81e0fb4
--- /dev/null
+++ b/test/user_operator_and_eval_expression_as.cpp
@@ -0,0 +1,104 @@
+#define BOOST_PROTO17_CONVERSION_OPERATOR_TEMPLATE
+#include "expression.hpp"
+
+#include <gtest/gtest.h>
+
+
+template <typename T>
+using term = boost::proto17::terminal<T>;
+
+namespace bp17 = boost::proto17;
+
+
+namespace user {
+
+    struct number
+    {
+        explicit operator double () const { return value; }
+
+        double value;
+    };
+
+    // User-defined binary-plus!  With weird semantics!
+    template <typename A, typename B>
+    inline auto eval_plus (A a, B b)
+    { return number{a.value - b.value}; }
+
+    template <typename E, typename Tuple>
+    constexpr auto eval_expression_as (
+        E const & expr,
+        boost::hana::basic_type<user::number>,
+        Tuple && args)
+    {
+        return static_cast<user::number>(
+            bp17::detail::default_eval_expr(expr, static_cast<Tuple &&>(args))
+        );
+    }
+
+}
+
+TEST(user_eval_expression_as, test_user_eval_expression_as)
+{
+    term<user::number> unity{{1.0}};
+    double d_ = 42.0;
+    term<user::number> i{{d_}};
+    bp17::expression<
+        bp17::expr_kind::plus,
+        term<user::number>,
+        term<user::number>
+    > expr = unity + std::move(i);
+    bp17::expression<
+        bp17::expr_kind::plus,
+        term<user::number>,
+        bp17::expression<
+            bp17::expr_kind::plus,
+            term<user::number>,
+            term<user::number>
+        >
+    > unevaluated_expr = unity + std::move(expr);
+
+    {
+        user::number result = unity;
+        EXPECT_EQ(result.value, 1);
+    }
+
+    {
+        user::number result = expr;
+        EXPECT_EQ(result.value, -41);
+    }
+
+    {
+        user::number result = unevaluated_expr;
+        EXPECT_EQ(result.value, 42);
+    }
+
+    {
+        user::number result = evaluate(unity, 5, 6, 7);
+        EXPECT_EQ(result.value, 1);
+    }
+
+    {
+        double result = (double)evaluate(expr);
+        EXPECT_EQ(result, -41);
+    }
+
+    {
+        double result = (double)evaluate(unevaluated_expr, std::string("15"));
+        EXPECT_EQ(result, 42);
+    }
+
+    {
+        user::number result = bp17::evaluate_as<user::number>(unity, 5, 6, 7);
+        EXPECT_EQ(result.value, 1);
+    }
+
+    {
+        user::number result = bp17::evaluate_as<user::number>(expr);
+        EXPECT_EQ(result.value, -41);
+    }
+
+    {
+        user::number result = bp17::evaluate_as<user::number>(unevaluated_expr, std::string("15"));
+        EXPECT_EQ(result.value, 42);
+    }
+}
diff --git a/test/user_operator_eval.cpp b/test/user_operator_eval.cpp
new file mode 100644
index 0000000..4bc2f9a
--- /dev/null
+++ b/test/user_operator_eval.cpp
@@ -0,0 +1,78 @@
+#define BOOST_PROTO17_CONVERSION_OPERATOR_TEMPLATE
+#include "expression.hpp"
+
+#include <gtest/gtest.h>
+
+
+template <typename T>
+using term = boost::proto17::terminal<T>;
+
+namespace bp17 = boost::proto17;
+
+
+namespace user {
+
+    struct number
+    {
+        explicit operator double () const { return value; }
+
+        double value;
+    };
+
+    // User-defined binary-plus!  With weird semantics!
+    template <typename A, typename B>
+    inline auto eval_plus (A a, B b)
+    { return number{a.value - b.value}; }
+
+}
+
+TEST(user_operator_eval, test_user_operator_eval)
+{
+    term<user::number> unity{{1.0}};
+    double d_ = 42.0;
+    term<user::number> i{{d_}};
+    bp17::expression<
+        bp17::expr_kind::plus,
+        term<user::number>,
+        term<user::number>
+    > expr = unity + std::move(i);
+    bp17::expression<
+        bp17::expr_kind::plus,
+        term<user::number>,
+        bp17::expression<
+            bp17::expr_kind::plus,
+            term<user::number>,
+            term<user::number>
+        >
+    > unevaluated_expr = unity + std::move(expr);
+
+    {
+        double result = unity;
+        EXPECT_EQ(result, 1);
+    }
+
+    {
+        double result = expr;
+        EXPECT_EQ(result, -41);
+    }
+
+    {
+        double result = unevaluated_expr;
+        EXPECT_EQ(result, 42);
+    }
+
+    {
+        double result = (double)evaluate(unity, 5, 6, 7);
+        EXPECT_EQ(result, 1);
+    }
+
+    {
+        double result = (double)evaluate(expr);
+        EXPECT_EQ(result, -41);
+    }
+
+    {
+        double result = (double)evaluate(unevaluated_expr, std::string("15"));
+        EXPECT_EQ(result, 42);
+    }
+}