]>
Commit | Line | Data |
---|---|---|
b32b8144 | 1 | // Copyright Louis Dionne 2013-2017 |
7c673cae FG |
2 | // Distributed under the Boost Software License, Version 1.0. |
3 | // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) | |
4 | ||
5 | #include "minimal.hpp" | |
6 | ||
7 | #include <boost/hana/and.hpp> | |
8 | #include <boost/hana/equal.hpp> | |
9 | #include <boost/hana/eval_if.hpp> | |
10 | #include <boost/hana/if.hpp> | |
11 | #include <boost/hana/not.hpp> | |
12 | #include <boost/hana/not_equal.hpp> | |
13 | #include <boost/hana/or.hpp> | |
14 | #include <boost/hana/tuple.hpp> | |
15 | #include <boost/hana/while.hpp> | |
16 | ||
17 | #include <laws/base.hpp> | |
18 | #include <laws/logical.hpp> | |
19 | namespace hana = boost::hana; | |
20 | ||
21 | ||
22 | struct invalid { }; | |
23 | ||
24 | int main() { | |
25 | constexpr auto bools = hana::make_tuple( | |
26 | minimal_constant<bool, false>{}, | |
27 | minimal_constant<bool, true>{} | |
28 | ); | |
29 | ||
30 | hana::test::TestLogical<minimal_constant_tag<bool>>{bools}; | |
31 | ||
32 | ||
33 | constexpr auto true_ = minimal_constant<bool, true>{}; | |
34 | constexpr auto false_ = minimal_constant<bool, false>{}; | |
35 | ||
36 | // not_ | |
37 | { | |
38 | BOOST_HANA_CONSTANT_CHECK(hana::equal(hana::not_(true_), false_)); | |
39 | BOOST_HANA_CONSTANT_CHECK(hana::equal(hana::not_(false_), true_)); | |
40 | } | |
41 | ||
42 | // and_ | |
43 | { | |
44 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
45 | hana::and_(true_), | |
46 | true_ | |
47 | )); | |
48 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
49 | hana::and_(false_), | |
50 | false_ | |
51 | )); | |
52 | ||
53 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
54 | hana::and_(true_, true_), | |
55 | true_ | |
56 | )); | |
57 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
58 | hana::and_(true_, false_), | |
59 | false_ | |
60 | )); | |
61 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
62 | hana::and_(false_, invalid{}), | |
63 | false_ | |
64 | )); | |
65 | ||
66 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
67 | hana::and_(true_, true_, true_), | |
68 | true_ | |
69 | )); | |
70 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
71 | hana::and_(true_, true_, false_), | |
72 | false_ | |
73 | )); | |
74 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
75 | hana::and_(true_, false_, invalid{}), | |
76 | false_ | |
77 | )); | |
78 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
79 | hana::and_(false_, invalid{}, invalid{}), | |
80 | false_ | |
81 | )); | |
82 | } | |
83 | ||
84 | // or_ | |
85 | { | |
86 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
87 | hana::or_(true_), | |
88 | true_ | |
89 | )); | |
90 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
91 | hana::or_(false_), | |
92 | false_ | |
93 | )); | |
94 | ||
95 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
96 | hana::or_(false_, false_), | |
97 | false_ | |
98 | )); | |
99 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
100 | hana::or_(false_, true_), | |
101 | true_ | |
102 | )); | |
103 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
104 | hana::or_(true_, invalid{}), | |
105 | true_ | |
106 | )); | |
107 | ||
108 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
109 | hana::or_(false_, false_, false_), | |
110 | false_ | |
111 | )); | |
112 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
113 | hana::or_(false_, false_, true_), | |
114 | true_ | |
115 | )); | |
116 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
117 | hana::or_(false_, true_, invalid{}), | |
118 | true_ | |
119 | )); | |
120 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
121 | hana::or_(true_, invalid{}, invalid{}), | |
122 | true_ | |
123 | )); | |
124 | } | |
125 | ||
126 | // if_ | |
127 | { | |
128 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
129 | hana::if_(true_, hana::test::ct_eq<3>{}, hana::test::ct_eq<4>{}), | |
130 | hana::test::ct_eq<3>{} | |
131 | )); | |
132 | ||
133 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
134 | hana::if_(false_, hana::test::ct_eq<3>{}, hana::test::ct_eq<4>{}), | |
135 | hana::test::ct_eq<4>{} | |
136 | )); | |
137 | } | |
138 | ||
139 | // eval_if | |
140 | { | |
141 | auto t = [](auto) { return hana::test::ct_eq<2>{}; }; | |
142 | auto e = [](auto) { return hana::test::ct_eq<3>{}; }; | |
143 | ||
144 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
145 | hana::eval_if(true_, t, invalid{}), | |
146 | hana::test::ct_eq<2>{} | |
147 | )); | |
148 | ||
149 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
150 | hana::eval_if(false_, invalid{}, e), | |
151 | hana::test::ct_eq<3>{} | |
152 | )); | |
153 | } | |
154 | ||
155 | // while_ | |
156 | { | |
157 | hana::test::_injection<0> f{}; | |
158 | ||
159 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
160 | hana::while_(hana::not_equal.to(hana::test::ct_eq<0>{}), hana::test::ct_eq<0>{}, invalid{}), | |
161 | hana::test::ct_eq<0>{} | |
162 | )); | |
163 | ||
164 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
165 | hana::while_(hana::not_equal.to(f(hana::test::ct_eq<0>{})), hana::test::ct_eq<0>{}, f), | |
166 | f(hana::test::ct_eq<0>{}) | |
167 | )); | |
168 | ||
169 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
170 | hana::while_(hana::not_equal.to(f(f(hana::test::ct_eq<0>{}))), hana::test::ct_eq<0>{}, f), | |
171 | f(f(hana::test::ct_eq<0>{})) | |
172 | )); | |
173 | ||
174 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
175 | hana::while_(hana::not_equal.to(f(f(f(hana::test::ct_eq<0>{})))), hana::test::ct_eq<0>{}, f), | |
176 | f(f(f(hana::test::ct_eq<0>{}))) | |
177 | )); | |
178 | ||
179 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
180 | hana::while_(hana::not_equal.to(f(f(f(f(hana::test::ct_eq<0>{}))))), hana::test::ct_eq<0>{}, f), | |
181 | f(f(f(f(hana::test::ct_eq<0>{})))) | |
182 | )); | |
183 | ||
184 | // Make sure it can be called with an lvalue state: | |
185 | auto state = hana::test::ct_eq<0>{}; | |
186 | BOOST_HANA_CONSTANT_CHECK(hana::equal( | |
187 | hana::while_(hana::not_equal.to(f(f(f(f(hana::test::ct_eq<0>{}))))), state, f), | |
188 | f(f(f(f(hana::test::ct_eq<0>{})))) | |
189 | )); | |
190 | } | |
191 | } |