1 // Copyright (C) 2016-2018 T. Zachary Laine
2 //
3 // Distributed under the Boost Software License, Version 1.0. (See
4 // accompanying file LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt)
6 #include <boost/yap/expression.hpp>
7
8 #include <boost/mpl/assert.hpp>
9
10 #include <boost/test/minimal.hpp>
11
12 #include <sstream>
13
14
15 template<typename T>
16 using term = boost::yap::terminal<boost::yap::expression, T>;
17
18 template<typename T>
19 using term_ref = boost::yap::expression_ref<boost::yap::expression, term<T> &>;
20
21 template<typename T>
22 using term_cref =
23 boost::yap::expression_ref<boost::yap::expression, term<T> const &>;
24
25 namespace yap = boost::yap;
26 namespace bh = boost::hana;
27
28
29 struct void_callable
30 {
operator ()void_callable31 void operator()() { *called_ = (*call_count_)++; }
32 int * call_count_;
33 int * called_;
34 };
35
36 struct int_callable
37 {
operator ()int_callable38 int operator()()
39 {
40 *called_ = (*call_count_)++;
41 return 42;
42 }
43 int * call_count_;
44 int * called_;
45 };
46
47 struct double_callable
48 {
operator ()double_callable49 double operator()()
50 {
51 *called_ = (*call_count_)++;
52 return 13.0;
53 }
54 int * call_count_;
55 int * called_;
56 };
57
58
test_main(int,char * [])59 int test_main(int, char * [])
60 {
61 {
62 {
63 int call_count = 0;
64 int int_called = -1;
65 int double_called = -1;
66
67 auto int_double_expr =
68 (term<int_callable>{{&call_count, &int_called}}(),
69 term<double_callable>{{&call_count, &double_called}}());
70
71 BOOST_CHECK(evaluate(int_double_expr) == 13.0);
72 BOOST_CHECK(int_called == 0);
73 BOOST_CHECK(double_called == 1);
74 }
75
76 {
77 int call_count = 0;
78 int int_called = -1;
79 int double_called = -1;
80
81 auto double_int_expr =
82 (term<double_callable>{{&call_count, &double_called}}(),
83 term<int_callable>{{&call_count, &int_called}}());
84
85 BOOST_CHECK(evaluate(double_int_expr) == 42);
86 BOOST_CHECK(int_called == 1);
87 BOOST_CHECK(double_called == 0);
88 }
89 }
90
91 {
92 {
93 int call_count = 0;
94 int void_called = -1;
95 int int_called = -1;
96
97 auto void_int_expr =
98 (term<void_callable>{{&call_count, &void_called}}(),
99 term<int_callable>{{&call_count, &int_called}}());
100
101 BOOST_CHECK(evaluate(void_int_expr) == 42);
102 BOOST_CHECK(void_called == 0);
103 BOOST_CHECK(int_called == 1);
104 }
105
106 {
107 int call_count = 0;
108 int void_called = -1;
109 int int_called = -1;
110
111 auto int_void_expr =
112 (term<int_callable>{{&call_count, &int_called}}(),
113 term<void_callable>{{&call_count, &void_called}}());
114
115 using eval_type = decltype(evaluate(int_void_expr));
116 BOOST_MPL_ASSERT(
117 (std::is_same<void, eval_type>));
118
119 evaluate(int_void_expr);
120 BOOST_CHECK(void_called == 1);
121 BOOST_CHECK(int_called == 0);
122 }
123 }
124
125 return 0;
126 }
127