1/*=============================================================================
2 Copyright (c) 2017 Paul Fultz II
3 placeholders.cpp
4 Distributed under the Boost Software License, Version 1.0. (See accompanying
5 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6==============================================================================*/
7#include <boost/hof/placeholders.hpp>
8#include "test.hpp"
9#include <sstream>
10
11// TODO: Test assign operators
12
13#if BOOST_HOF_HAS_STATIC_TEST_CHECK
14#define BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR constexpr
15#else
16#define BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR
17#endif
18
19struct square
20{
21 template<class T>
22 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto operator()(T x) const BOOST_HOF_RETURNS(x*x);
23};
24
25#define CHECK_DEFAULT_CONSTRUCTION_OP(op, name) \
26 static_assert(boost::hof::detail::is_default_constructible<boost::hof::operators::name>::value, "Operator not default constructible");
27
28#if BOOST_HOF_HAS_NOEXCEPT_DEDUCTION
29#define PLACEHOLDER_CHECK(...) \
30 BOOST_HOF_STATIC_TEST_CHECK(__VA_ARGS__); \
31 BOOST_HOF_TEST_CHECK(__VA_ARGS__); \
32 static_assert(noexcept(__VA_ARGS__), "noexcept placeholders")
33#else
34#define PLACEHOLDER_CHECK(...) \
35 BOOST_HOF_STATIC_TEST_CHECK(__VA_ARGS__); \
36 BOOST_HOF_TEST_CHECK(__VA_ARGS__)
37#endif
38
39BOOST_HOF_TEST_CASE()
40{
41 static_assert(boost::hof::detail::is_default_constructible<boost::hof::placeholder<1>>::value, "Placeholder not default constructible");
42 static_assert(boost::hof::detail::is_default_constructible<boost::hof::placeholder<2>>::value, "Placeholder not default constructible");
43 static_assert(boost::hof::detail::is_default_constructible<boost::hof::placeholder<3>>::value, "Placeholder not default constructible");
44
45 BOOST_HOF_FOREACH_BINARY_OP(CHECK_DEFAULT_CONSTRUCTION_OP)
46 BOOST_HOF_FOREACH_ASSIGN_OP(CHECK_DEFAULT_CONSTRUCTION_OP)
47 BOOST_HOF_FOREACH_UNARY_OP(CHECK_DEFAULT_CONSTRUCTION_OP)
48}
49
50BOOST_HOF_TEST_CASE()
51{
52 auto simple_print = boost::hof::reveal(std::ref(t&: std::cout) << boost::hof::_);
53 simple_print("Hello");
54}
55
56BOOST_HOF_TEST_CASE()
57{
58 std::stringstream ss;
59 auto simple_print = boost::hof::reveal(std::ref(t&: ss) << boost::hof::_);
60 simple_print("Hello");
61 BOOST_HOF_TEST_CHECK(ss.str() == "Hello");
62}
63
64BOOST_HOF_TEST_CASE()
65{
66 const auto x_square_add = 2 + (4*4);
67 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_square_add = boost::hof::_1 + boost::hof::lazy(square())(boost::hof::_2);
68#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
69 static_assert(std::is_copy_constructible<decltype(f_square_add)>::value, "Not copyable");
70#endif
71 PLACEHOLDER_CHECK(f_square_add(2, 4) == x_square_add);
72}
73
74BOOST_HOF_TEST_CASE()
75{
76 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_invoke_2 = boost::hof::_1(3);
77#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
78 static_assert(std::is_copy_constructible<decltype(f_invoke_2)>::value, "Not copyable");
79#endif
80 PLACEHOLDER_CHECK(f_invoke_2(square()) == 9);
81}
82
83BOOST_HOF_TEST_CASE()
84{
85 const auto x_add = 2 + 1;
86 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_add = boost::hof::_1 + boost::hof::_2;
87#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
88 static_assert(std::is_copy_constructible<decltype(f_add)>::value, "Not copyable");
89#endif
90 static_assert(boost::hof::detail::is_default_constructible<decltype(f_add)>::value, "Not default constructible");
91 PLACEHOLDER_CHECK(f_add(2, 1) == x_add);
92
93 const auto x_subtract = 2 - 1;
94 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_subtract = boost::hof::_1 - boost::hof::_2;
95#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
96 static_assert(std::is_copy_constructible<decltype(f_subtract)>::value, "Not copyable");
97#endif
98 static_assert(boost::hof::detail::is_default_constructible<decltype(f_subtract)>::value, "Not default constructible");
99 PLACEHOLDER_CHECK(f_subtract(2, 1) == x_subtract);
100
101 const auto x_multiply = 2 * 1;
102 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_multiply = boost::hof::_1 * boost::hof::_2;
103#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
104 static_assert(std::is_copy_constructible<decltype(f_multiply)>::value, "Not copyable");
105#endif
106 static_assert(boost::hof::detail::is_default_constructible<decltype(f_multiply)>::value, "Not default constructible");
107 PLACEHOLDER_CHECK(f_multiply(2, 1) == x_multiply);
108
109 const auto x_divide = 2 / 1;
110 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_divide = boost::hof::_1 / boost::hof::_2;
111#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
112 static_assert(std::is_copy_constructible<decltype(f_divide)>::value, "Not copyable");
113#endif
114 static_assert(boost::hof::detail::is_default_constructible<decltype(f_divide)>::value, "Not default constructible");
115 PLACEHOLDER_CHECK(f_divide(2, 1) == x_divide);
116
117 const auto x_remainder = 2 % 1;
118 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_remainder = boost::hof::_1 % boost::hof::_2;
119#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
120 static_assert(std::is_copy_constructible<decltype(f_remainder)>::value, "Not copyable");
121#endif
122 static_assert(boost::hof::detail::is_default_constructible<decltype(f_remainder)>::value, "Not default constructible");
123 PLACEHOLDER_CHECK(f_remainder(2, 1) == x_remainder);
124
125 const auto x_shift_right = 2 >> 1;
126 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_right = boost::hof::_1 >> boost::hof::_2;
127#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
128 static_assert(std::is_copy_constructible<decltype(f_shift_right)>::value, "Not copyable");
129#endif
130 static_assert(boost::hof::detail::is_default_constructible<decltype(f_shift_right)>::value, "Not default constructible");
131 PLACEHOLDER_CHECK(f_shift_right(2, 1) == x_shift_right);
132
133 const auto x_shift_left = 2 << 1;
134 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_left = boost::hof::_1 << boost::hof::_2;
135#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
136 static_assert(std::is_copy_constructible<decltype(f_shift_left)>::value, "Not copyable");
137#endif
138 static_assert(boost::hof::detail::is_default_constructible<decltype(f_shift_left)>::value, "Not default constructible");
139 PLACEHOLDER_CHECK(f_shift_left(2, 1) == x_shift_left);
140
141 const auto x_greater_than = 2 > 1;
142 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than = boost::hof::_1 > boost::hof::_2;
143#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
144 static_assert(std::is_copy_constructible<decltype(f_greater_than)>::value, "Not copyable");
145#endif
146 static_assert(boost::hof::detail::is_default_constructible<decltype(f_greater_than)>::value, "Not default constructible");
147 PLACEHOLDER_CHECK(f_greater_than(2, 1) == x_greater_than);
148
149 const auto x_less_than = 2 < 1;
150 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than = boost::hof::_1 < boost::hof::_2;
151#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
152 static_assert(std::is_copy_constructible<decltype(f_less_than)>::value, "Not copyable");
153#endif
154 static_assert(boost::hof::detail::is_default_constructible<decltype(f_less_than)>::value, "Not default constructible");
155 PLACEHOLDER_CHECK(f_less_than(2, 1) == x_less_than);
156
157 const auto x_less_than_equal = 2 <= 1;
158 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than_equal = boost::hof::_1 <= boost::hof::_2;
159#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
160 static_assert(std::is_copy_constructible<decltype(f_less_than_equal)>::value, "Not copyable");
161#endif
162 static_assert(boost::hof::detail::is_default_constructible<decltype(f_less_than_equal)>::value, "Not default constructible");
163 PLACEHOLDER_CHECK(f_less_than_equal(2, 1) == x_less_than_equal);
164
165 const auto x_greater_than_equal = 2 >= 1;
166 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than_equal = boost::hof::_1 >= boost::hof::_2;
167#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
168 static_assert(std::is_copy_constructible<decltype(f_greater_than_equal)>::value, "Not copyable");
169#endif
170 static_assert(boost::hof::detail::is_default_constructible<decltype(f_greater_than_equal)>::value, "Not default constructible");
171 PLACEHOLDER_CHECK(f_greater_than_equal(2, 1) == x_greater_than_equal);
172
173 const auto x_equal = 2 == 1;
174 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_equal = boost::hof::_1 == boost::hof::_2;
175#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
176 static_assert(std::is_copy_constructible<decltype(f_equal)>::value, "Not copyable");
177#endif
178 static_assert(boost::hof::detail::is_default_constructible<decltype(f_equal)>::value, "Not default constructible");
179 PLACEHOLDER_CHECK(f_equal(2, 1) == x_equal);
180
181 const auto x_not_equal = 2 != 1;
182 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_equal = boost::hof::_1 != boost::hof::_2;
183#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
184 static_assert(std::is_copy_constructible<decltype(f_not_equal)>::value, "Not copyable");
185#endif
186 static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_equal)>::value, "Not default constructible");
187 PLACEHOLDER_CHECK(f_not_equal(2, 1) == x_not_equal);
188
189 const auto x_bit_and = 2 & 1;
190 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_and = boost::hof::_1 & boost::hof::_2;
191#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
192 static_assert(std::is_copy_constructible<decltype(f_bit_and)>::value, "Not copyable");
193#endif
194 static_assert(boost::hof::detail::is_default_constructible<decltype(f_bit_and)>::value, "Not default constructible");
195 PLACEHOLDER_CHECK(f_bit_and(2, 1) == x_bit_and);
196
197 const auto x_xor_ = 2 ^ 1;
198 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_xor_ = boost::hof::_1 ^ boost::hof::_2;
199#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
200 static_assert(std::is_copy_constructible<decltype(f_xor_)>::value, "Not copyable");
201#endif
202 static_assert(boost::hof::detail::is_default_constructible<decltype(f_xor_)>::value, "Not default constructible");
203 PLACEHOLDER_CHECK(f_xor_(2, 1) == x_xor_);
204
205 const auto x_bit_or = 2 | 1;
206 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_or = boost::hof::_1 | boost::hof::_2;
207#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
208 static_assert(std::is_copy_constructible<decltype(f_bit_or)>::value, "Not copyable");
209#endif
210 static_assert(boost::hof::detail::is_default_constructible<decltype(f_bit_or)>::value, "Not default constructible");
211 PLACEHOLDER_CHECK(f_bit_or(2, 1) == x_bit_or);
212
213 const auto x_and_ = true && false;
214 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_and_ = boost::hof::_1 && boost::hof::_2;
215#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
216 static_assert(std::is_copy_constructible<decltype(f_and_)>::value, "Not copyable");
217#endif
218 static_assert(boost::hof::detail::is_default_constructible<decltype(f_and_)>::value, "Not default constructible");
219 PLACEHOLDER_CHECK(f_and_(true, false) == x_and_);
220
221 const auto x_or_ = true;
222 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_or_ = boost::hof::_1 || boost::hof::_2;
223#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
224 static_assert(std::is_copy_constructible<decltype(f_or_)>::value, "Not copyable");
225#endif
226 static_assert(boost::hof::detail::is_default_constructible<decltype(f_or_)>::value, "Not default constructible");
227 PLACEHOLDER_CHECK(f_or_(true, false) == x_or_);
228}
229
230BOOST_HOF_TEST_CASE()
231{
232
233 const auto x_not_ = !false;
234 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_ = !boost::hof::_1;
235#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
236 static_assert(std::is_copy_constructible<decltype(f_not_)>::value, "Not copyable");
237#endif
238 static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_)>::value, "Not default constructible");
239 PLACEHOLDER_CHECK(f_not_(false) == x_not_);
240
241 const auto x_not_0 = !0;
242 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_0 = !boost::hof::_1;
243#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
244 static_assert(std::is_copy_constructible<decltype(f_not_0)>::value, "Not copyable");
245#endif
246 static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_0)>::value, "Not default constructible");
247 PLACEHOLDER_CHECK(f_not_0(0) == x_not_0);
248
249 const auto x_compl_ = ~2;
250 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_compl_ = ~boost::hof::_1;
251#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
252 static_assert(std::is_copy_constructible<decltype(f_compl_)>::value, "Not copyable");
253#endif
254 static_assert(boost::hof::detail::is_default_constructible<decltype(f_compl_)>::value, "Not default constructible");
255 PLACEHOLDER_CHECK(f_compl_(2) == x_compl_);
256
257 const auto x_unary_plus = +2;
258 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_unary_plus = +boost::hof::_1;
259#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
260 static_assert(std::is_copy_constructible<decltype(f_unary_plus)>::value, "Not copyable");
261#endif
262 static_assert(boost::hof::detail::is_default_constructible<decltype(f_unary_plus)>::value, "Not default constructible");
263 PLACEHOLDER_CHECK(f_unary_plus(2) == x_unary_plus);
264
265 const auto x_unary_subtract = -2;
266 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_unary_subtract = -boost::hof::_1;
267#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
268 static_assert(std::is_copy_constructible<decltype(f_unary_subtract)>::value, "Not copyable");
269#endif
270 static_assert(boost::hof::detail::is_default_constructible<decltype(f_unary_subtract)>::value, "Not default constructible");
271 PLACEHOLDER_CHECK(f_unary_subtract(2) == x_unary_subtract);
272
273 const auto x_dereference = 2;
274 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_dereference = *boost::hof::_1;
275#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
276 static_assert(std::is_copy_constructible<decltype(f_dereference)>::value, "Not copyable");
277#endif
278 static_assert(boost::hof::detail::is_default_constructible<decltype(f_dereference)>::value, "Not default constructible");
279 PLACEHOLDER_CHECK(f_dereference(&x_dereference) == x_dereference);
280
281 // TODO: Test BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR increment and decrement
282#ifndef _MSC_VER
283 auto x_increment = 2;
284 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_increment = ++boost::hof::_1;
285#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
286 static_assert(std::is_copy_constructible<decltype(f_increment)>::value, "Not copyable");
287#endif
288 static_assert(boost::hof::detail::is_default_constructible<decltype(f_increment)>::value, "Not default constructible");
289 f_increment(x_increment);
290 BOOST_HOF_TEST_CHECK(x_increment == 3);
291
292 auto x_decrement = 2;
293 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_decrement = --boost::hof::_1;
294#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
295 static_assert(std::is_copy_constructible<decltype(f_decrement)>::value, "Not copyable");
296#endif
297 static_assert(boost::hof::detail::is_default_constructible<decltype(f_decrement)>::value, "Not default constructible");
298 f_decrement(x_decrement);
299 BOOST_HOF_TEST_CHECK(x_decrement == 1);
300#endif
301
302 // TODO: Test post increment and decrement
303}
304
305
306BOOST_HOF_TEST_CASE()
307{
308 const auto x_add = 2 + 1;
309 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_add = boost::hof::_ + boost::hof::_;
310#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
311 static_assert(std::is_copy_constructible<decltype(f_add)>::value, "Not copyable");
312#endif
313 static_assert(boost::hof::detail::is_default_constructible<decltype(f_add)>::value, "Not default constructible");
314 PLACEHOLDER_CHECK(f_add(2, 1) == x_add);
315
316 const auto x_subtract = 2 - 1;
317 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_subtract = boost::hof::_ - boost::hof::_;
318#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
319 static_assert(std::is_copy_constructible<decltype(f_subtract)>::value, "Not copyable");
320#endif
321 static_assert(boost::hof::detail::is_default_constructible<decltype(f_subtract)>::value, "Not default constructible");
322 PLACEHOLDER_CHECK(f_subtract(2, 1) == x_subtract);
323
324 const auto x_multiply = 2 * 1;
325 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_multiply = boost::hof::_ * boost::hof::_;
326#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
327 static_assert(std::is_copy_constructible<decltype(f_multiply)>::value, "Not copyable");
328#endif
329 static_assert(boost::hof::detail::is_default_constructible<decltype(f_multiply)>::value, "Not default constructible");
330 PLACEHOLDER_CHECK(f_multiply(2, 1) == x_multiply);
331
332 const auto x_divide = 2 / 1;
333 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_divide = boost::hof::_ / boost::hof::_;
334#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
335 static_assert(std::is_copy_constructible<decltype(f_divide)>::value, "Not copyable");
336#endif
337 static_assert(boost::hof::detail::is_default_constructible<decltype(f_divide)>::value, "Not default constructible");
338 PLACEHOLDER_CHECK(f_divide(2, 1) == x_divide);
339
340 const auto x_remainder = 2 % 1;
341 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_remainder = boost::hof::_ % boost::hof::_;
342#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
343 static_assert(std::is_copy_constructible<decltype(f_remainder)>::value, "Not copyable");
344#endif
345 static_assert(boost::hof::detail::is_default_constructible<decltype(f_remainder)>::value, "Not default constructible");
346 PLACEHOLDER_CHECK(f_remainder(2, 1) == x_remainder);
347
348 const auto x_shift_right = 2 >> 1;
349 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_right = boost::hof::_ >> boost::hof::_;
350#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
351 static_assert(std::is_copy_constructible<decltype(f_shift_right)>::value, "Not copyable");
352#endif
353 static_assert(boost::hof::detail::is_default_constructible<decltype(f_shift_right)>::value, "Not default constructible");
354 PLACEHOLDER_CHECK(f_shift_right(2, 1) == x_shift_right);
355
356 const auto x_shift_left = 2 << 1;
357 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_left = boost::hof::_ << boost::hof::_;
358#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
359 static_assert(std::is_copy_constructible<decltype(f_shift_left)>::value, "Not copyable");
360#endif
361 static_assert(boost::hof::detail::is_default_constructible<decltype(f_shift_left)>::value, "Not default constructible");
362 PLACEHOLDER_CHECK(f_shift_left(2, 1) == x_shift_left);
363
364 const auto x_greater_than = 2 > 1;
365 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than = boost::hof::_ > boost::hof::_;
366#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
367 static_assert(std::is_copy_constructible<decltype(f_greater_than)>::value, "Not copyable");
368#endif
369 static_assert(boost::hof::detail::is_default_constructible<decltype(f_greater_than)>::value, "Not default constructible");
370 PLACEHOLDER_CHECK(f_greater_than(2, 1) == x_greater_than);
371
372 const auto x_less_than = 2 < 1;
373 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than = boost::hof::_ < boost::hof::_;
374#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
375 static_assert(std::is_copy_constructible<decltype(f_less_than)>::value, "Not copyable");
376#endif
377 static_assert(boost::hof::detail::is_default_constructible<decltype(f_less_than)>::value, "Not default constructible");
378 PLACEHOLDER_CHECK(f_less_than(2, 1) == x_less_than);
379
380 const auto x_less_than_equal = 2 <= 1;
381 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than_equal = boost::hof::_ <= boost::hof::_;
382#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
383 static_assert(std::is_copy_constructible<decltype(f_less_than_equal)>::value, "Not copyable");
384#endif
385 static_assert(boost::hof::detail::is_default_constructible<decltype(f_less_than_equal)>::value, "Not default constructible");
386 PLACEHOLDER_CHECK(f_less_than_equal(2, 1) == x_less_than_equal);
387
388 const auto x_greater_than_equal = 2 >= 1;
389 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than_equal = boost::hof::_ >= boost::hof::_;
390#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
391 static_assert(std::is_copy_constructible<decltype(f_greater_than_equal)>::value, "Not copyable");
392#endif
393 static_assert(boost::hof::detail::is_default_constructible<decltype(f_greater_than_equal)>::value, "Not default constructible");
394 PLACEHOLDER_CHECK(f_greater_than_equal(2, 1) == x_greater_than_equal);
395
396 const auto x_equal = 2 == 1;
397 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_equal = boost::hof::_ == boost::hof::_;
398#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
399 static_assert(std::is_copy_constructible<decltype(f_equal)>::value, "Not copyable");
400#endif
401 static_assert(boost::hof::detail::is_default_constructible<decltype(f_equal)>::value, "Not default constructible");
402 PLACEHOLDER_CHECK(f_equal(2, 1) == x_equal);
403
404 const auto x_not_equal = 2 != 1;
405 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_equal = boost::hof::_ != boost::hof::_;
406#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
407 static_assert(std::is_copy_constructible<decltype(f_not_equal)>::value, "Not copyable");
408#endif
409 static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_equal)>::value, "Not default constructible");
410 PLACEHOLDER_CHECK(f_not_equal(2, 1) == x_not_equal);
411
412 const auto x_bit_and = 2 & 1;
413 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_and = boost::hof::_ & boost::hof::_;
414#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
415 static_assert(std::is_copy_constructible<decltype(f_bit_and)>::value, "Not copyable");
416#endif
417 static_assert(boost::hof::detail::is_default_constructible<decltype(f_bit_and)>::value, "Not default constructible");
418 PLACEHOLDER_CHECK(f_bit_and(2, 1) == x_bit_and);
419
420 const auto x_xor_ = 2 ^ 1;
421 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_xor_ = boost::hof::_ ^ boost::hof::_;
422#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
423 static_assert(std::is_copy_constructible<decltype(f_xor_)>::value, "Not copyable");
424#endif
425 static_assert(boost::hof::detail::is_default_constructible<decltype(f_xor_)>::value, "Not default constructible");
426 PLACEHOLDER_CHECK(f_xor_(2, 1) == x_xor_);
427
428 const auto x_bit_or = 2 | 1;
429 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_or = boost::hof::_ | boost::hof::_;
430#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
431 static_assert(std::is_copy_constructible<decltype(f_bit_or)>::value, "Not copyable");
432#endif
433 static_assert(boost::hof::detail::is_default_constructible<decltype(f_bit_or)>::value, "Not default constructible");
434 PLACEHOLDER_CHECK(f_bit_or(2, 1) == x_bit_or);
435
436 const auto x_and_ = true && false;
437 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_and_ = boost::hof::_ && boost::hof::_;
438#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
439 static_assert(std::is_copy_constructible<decltype(f_and_)>::value, "Not copyable");
440#endif
441 static_assert(boost::hof::detail::is_default_constructible<decltype(f_and_)>::value, "Not default constructible");
442 PLACEHOLDER_CHECK(f_and_(true, false) == x_and_);
443
444 const auto x_or_ = true;
445 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_or_ = boost::hof::_ || boost::hof::_;
446#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
447 static_assert(std::is_copy_constructible<decltype(f_or_)>::value, "Not copyable");
448#endif
449 static_assert(boost::hof::detail::is_default_constructible<decltype(f_or_)>::value, "Not default constructible");
450 PLACEHOLDER_CHECK(f_or_(true, false) == x_or_);
451}
452
453BOOST_HOF_TEST_CASE()
454{
455 const auto x_add = 2 + 1;
456 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_add = 2 + boost::hof::_;
457#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
458 static_assert(std::is_copy_constructible<decltype(f_add)>::value, "Not copyable");
459#endif
460 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_add)>::value, "default constructible");
461 PLACEHOLDER_CHECK(f_add(1) == x_add);
462
463 const auto x_subtract = 2 - 1;
464 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_subtract = 2 - boost::hof::_;
465#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
466 static_assert(std::is_copy_constructible<decltype(f_subtract)>::value, "Not copyable");
467#endif
468 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_subtract)>::value, "default constructible");
469 PLACEHOLDER_CHECK(f_subtract(1) == x_subtract);
470
471 const auto x_multiply = 2 * 1;
472 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_multiply = 2 * boost::hof::_;
473#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
474 static_assert(std::is_copy_constructible<decltype(f_multiply)>::value, "Not copyable");
475#endif
476 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_multiply)>::value, "default constructible");
477 PLACEHOLDER_CHECK(f_multiply(1) == x_multiply);
478
479 const auto x_divide = 2 / 1;
480 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_divide = 2 / boost::hof::_;
481#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
482 static_assert(std::is_copy_constructible<decltype(f_divide)>::value, "Not copyable");
483#endif
484 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_divide)>::value, "default constructible");
485 PLACEHOLDER_CHECK(f_divide(1) == x_divide);
486
487 const auto x_remainder = 2 % 1;
488 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_remainder = 2 % boost::hof::_;
489#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
490 static_assert(std::is_copy_constructible<decltype(f_remainder)>::value, "Not copyable");
491#endif
492 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_remainder)>::value, "default constructible");
493 PLACEHOLDER_CHECK(f_remainder(1) == x_remainder);
494
495 const auto x_shift_right = 2 >> 1;
496 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_right = 2 >> boost::hof::_;
497#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
498 static_assert(std::is_copy_constructible<decltype(f_shift_right)>::value, "Not copyable");
499#endif
500 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_shift_right)>::value, "default constructible");
501 PLACEHOLDER_CHECK(f_shift_right(1) == x_shift_right);
502
503 const auto x_shift_left = 2 << 1;
504 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_left = 2 << boost::hof::_;
505#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
506 static_assert(std::is_copy_constructible<decltype(f_shift_left)>::value, "Not copyable");
507#endif
508 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_shift_left)>::value, "default constructible");
509 PLACEHOLDER_CHECK(f_shift_left(1) == x_shift_left);
510
511 const auto x_greater_than = 2 > 1;
512 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than = 2 > boost::hof::_;
513#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
514 static_assert(std::is_copy_constructible<decltype(f_greater_than)>::value, "Not copyable");
515#endif
516 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_greater_than)>::value, "default constructible");
517 PLACEHOLDER_CHECK(f_greater_than(1) == x_greater_than);
518
519 const auto x_less_than = 2 < 1;
520 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than = 2 < boost::hof::_;
521#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
522 static_assert(std::is_copy_constructible<decltype(f_less_than)>::value, "Not copyable");
523#endif
524 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_less_than)>::value, "default constructible");
525 PLACEHOLDER_CHECK(f_less_than(1) == x_less_than);
526
527 const auto x_less_than_equal = 2 <= 1;
528 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than_equal = 2 <= boost::hof::_;
529#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
530 static_assert(std::is_copy_constructible<decltype(f_less_than_equal)>::value, "Not copyable");
531#endif
532 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_less_than_equal)>::value, "default constructible");
533 PLACEHOLDER_CHECK(f_less_than_equal(1) == x_less_than_equal);
534
535 const auto x_greater_than_equal = 2 >= 1;
536 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than_equal = 2 >= boost::hof::_;
537#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
538 static_assert(std::is_copy_constructible<decltype(f_greater_than_equal)>::value, "Not copyable");
539#endif
540 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_greater_than_equal)>::value, "default constructible");
541 PLACEHOLDER_CHECK(f_greater_than_equal(1) == x_greater_than_equal);
542
543 const auto x_equal = 2 == 1;
544 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_equal = 2 == boost::hof::_;
545#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
546 static_assert(std::is_copy_constructible<decltype(f_equal)>::value, "Not copyable");
547#endif
548 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_equal)>::value, "default constructible");
549 PLACEHOLDER_CHECK(f_equal(1) == x_equal);
550
551 const auto x_not_equal = 2 != 1;
552 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_equal = 2 != boost::hof::_;
553#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
554 static_assert(std::is_copy_constructible<decltype(f_not_equal)>::value, "Not copyable");
555#endif
556 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_not_equal)>::value, "default constructible");
557 PLACEHOLDER_CHECK(f_not_equal(1) == x_not_equal);
558
559 const auto x_bit_and = 2 & 1;
560 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_and = 2 & boost::hof::_;
561#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
562 static_assert(std::is_copy_constructible<decltype(f_bit_and)>::value, "Not copyable");
563#endif
564 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_bit_and)>::value, "default constructible");
565 PLACEHOLDER_CHECK(f_bit_and(1) == x_bit_and);
566
567 const auto x_xor_ = 2 ^ 1;
568 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_xor_ = 2 ^ boost::hof::_;
569#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
570 static_assert(std::is_copy_constructible<decltype(f_xor_)>::value, "Not copyable");
571#endif
572 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_xor_)>::value, "default constructible");
573 PLACEHOLDER_CHECK(f_xor_(1) == x_xor_);
574
575 const auto x_bit_or = 2 | 1;
576 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_or = 2 | boost::hof::_;
577#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
578 static_assert(std::is_copy_constructible<decltype(f_bit_or)>::value, "Not copyable");
579#endif
580 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_bit_or)>::value, "default constructible");
581 PLACEHOLDER_CHECK(f_bit_or(1) == x_bit_or);
582
583 const auto x_and_ = true && false;
584 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_and_ = true && boost::hof::_;
585#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
586 static_assert(std::is_copy_constructible<decltype(f_and_)>::value, "Not copyable");
587#endif
588 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_and_)>::value, "default constructible");
589 PLACEHOLDER_CHECK(f_and_(false) == x_and_);
590
591 const auto x_or_ = true;
592 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_or_ = true || boost::hof::_;
593#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
594 static_assert(std::is_copy_constructible<decltype(f_or_)>::value, "Not copyable");
595#endif
596 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_or_)>::value, "default constructible");
597 PLACEHOLDER_CHECK(f_or_(false) == x_or_);
598}
599
600BOOST_HOF_TEST_CASE()
601{
602 const auto x_add = 2 + 1;
603 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_add = boost::hof::_ + 1;
604#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
605 static_assert(std::is_copy_constructible<decltype(f_add)>::value, "Not copyable");
606#endif
607 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_add)>::value, "default constructible");
608 PLACEHOLDER_CHECK(f_add(2) == x_add);
609
610 const auto x_subtract = 2 - 1;
611 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_subtract = boost::hof::_ - 1;
612#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
613 static_assert(std::is_copy_constructible<decltype(f_subtract)>::value, "Not copyable");
614#endif
615 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_subtract)>::value, "default constructible");
616 PLACEHOLDER_CHECK(f_subtract(2) == x_subtract);
617
618 const auto x_multiply = 2 * 1;
619 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_multiply = boost::hof::_ * 1;
620#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
621 static_assert(std::is_copy_constructible<decltype(f_multiply)>::value, "Not copyable");
622#endif
623 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_multiply)>::value, "default constructible");
624 PLACEHOLDER_CHECK(f_multiply(2) == x_multiply);
625
626 const auto x_divide = 2 / 1;
627 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_divide = boost::hof::_ / 1;
628#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
629 static_assert(std::is_copy_constructible<decltype(f_divide)>::value, "Not copyable");
630#endif
631 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_divide)>::value, "default constructible");
632 PLACEHOLDER_CHECK(f_divide(2) == x_divide);
633
634 const auto x_remainder = 2 % 1;
635 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_remainder = boost::hof::_ % 1;
636#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
637 static_assert(std::is_copy_constructible<decltype(f_remainder)>::value, "Not copyable");
638#endif
639 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_remainder)>::value, "default constructible");
640 PLACEHOLDER_CHECK(f_remainder(2) == x_remainder);
641
642 const auto x_shift_right = 2 >> 1;
643 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_right = boost::hof::_ >> 1;
644#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
645 static_assert(std::is_copy_constructible<decltype(f_shift_right)>::value, "Not copyable");
646#endif
647 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_shift_right)>::value, "default constructible");
648 PLACEHOLDER_CHECK(f_shift_right(2) == x_shift_right);
649
650 const auto x_shift_left = 2 << 1;
651 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_shift_left = boost::hof::_ << 1;
652#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
653 static_assert(std::is_copy_constructible<decltype(f_shift_left)>::value, "Not copyable");
654#endif
655 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_shift_left)>::value, "default constructible");
656 PLACEHOLDER_CHECK(f_shift_left(2) == x_shift_left);
657
658 const auto x_greater_than = 2 > 1;
659 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than = boost::hof::_ > 1;
660#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
661 static_assert(std::is_copy_constructible<decltype(f_greater_than)>::value, "Not copyable");
662#endif
663 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_greater_than)>::value, "default constructible");
664 PLACEHOLDER_CHECK(f_greater_than(2) == x_greater_than);
665
666 const auto x_less_than = 2 < 1;
667 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than = boost::hof::_ < 1;
668#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
669 static_assert(std::is_copy_constructible<decltype(f_less_than)>::value, "Not copyable");
670#endif
671 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_less_than)>::value, "default constructible");
672 PLACEHOLDER_CHECK(f_less_than(2) == x_less_than);
673
674 const auto x_less_than_equal = 2 <= 1;
675 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_less_than_equal = boost::hof::_ <= 1;
676#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
677 static_assert(std::is_copy_constructible<decltype(f_less_than_equal)>::value, "Not copyable");
678#endif
679 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_less_than_equal)>::value, "default constructible");
680 PLACEHOLDER_CHECK(f_less_than_equal(2) == x_less_than_equal);
681
682 const auto x_greater_than_equal = 2 >= 1;
683 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_greater_than_equal = boost::hof::_ >= 1;
684#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
685 static_assert(std::is_copy_constructible<decltype(f_greater_than_equal)>::value, "Not copyable");
686#endif
687 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_greater_than_equal)>::value, "default constructible");
688 PLACEHOLDER_CHECK(f_greater_than_equal(2) == x_greater_than_equal);
689
690 const auto x_equal = 2 == 1;
691 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_equal = boost::hof::_ == 1;
692#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
693 static_assert(std::is_copy_constructible<decltype(f_equal)>::value, "Not copyable");
694#endif
695 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_equal)>::value, "default constructible");
696 PLACEHOLDER_CHECK(f_equal(2) == x_equal);
697
698 const auto x_not_equal = 2 != 1;
699 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_equal = boost::hof::_ != 1;
700#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
701 static_assert(std::is_copy_constructible<decltype(f_not_equal)>::value, "Not copyable");
702#endif
703 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_not_equal)>::value, "default constructible");
704 PLACEHOLDER_CHECK(f_not_equal(2) == x_not_equal);
705
706 const auto x_bit_and = 2 & 1;
707 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_and = boost::hof::_ & 1;
708#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
709 static_assert(std::is_copy_constructible<decltype(f_bit_and)>::value, "Not copyable");
710#endif
711 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_bit_and)>::value, "default constructible");
712 PLACEHOLDER_CHECK(f_bit_and(2) == x_bit_and);
713
714 const auto x_xor_ = 2 ^ 1;
715 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_xor_ = boost::hof::_ ^ 1;
716#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
717 static_assert(std::is_copy_constructible<decltype(f_xor_)>::value, "Not copyable");
718#endif
719 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_xor_)>::value, "default constructible");
720 PLACEHOLDER_CHECK(f_xor_(2) == x_xor_);
721
722 const auto x_bit_or = 2 | 1;
723 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_bit_or = boost::hof::_ | 1;
724#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
725 static_assert(std::is_copy_constructible<decltype(f_bit_or)>::value, "Not copyable");
726#endif
727 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_bit_or)>::value, "default constructible");
728 PLACEHOLDER_CHECK(f_bit_or(2) == x_bit_or);
729
730 const auto x_and_ = true && false;
731 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_and_ = boost::hof::_ && false;
732#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
733 static_assert(std::is_copy_constructible<decltype(f_and_)>::value, "Not copyable");
734#endif
735 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_and_)>::value, "default constructible");
736 PLACEHOLDER_CHECK(f_and_(true) == x_and_);
737
738 const auto x_or_ = true;
739 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_or_ = boost::hof::_ || false;
740#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
741 static_assert(std::is_copy_constructible<decltype(f_or_)>::value, "Not copyable");
742#endif
743 static_assert(!boost::hof::detail::is_default_constructible<decltype(f_or_)>::value, "default constructible");
744 PLACEHOLDER_CHECK(f_or_(true) == x_or_);
745}
746
747BOOST_HOF_TEST_CASE()
748{
749
750 const auto x_not_ = !false;
751 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_not_ = !boost::hof::_;
752#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
753 static_assert(std::is_copy_constructible<decltype(f_not_)>::value, "Not copyable");
754#endif
755 static_assert(boost::hof::detail::is_default_constructible<decltype(f_not_)>::value, "Not default constructible");
756 PLACEHOLDER_CHECK(f_not_(false) == x_not_);
757
758 const auto x_compl_ = ~2;
759 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_compl_ = ~boost::hof::_;
760#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
761 static_assert(std::is_copy_constructible<decltype(f_compl_)>::value, "Not copyable");
762#endif
763 static_assert(boost::hof::detail::is_default_constructible<decltype(f_compl_)>::value, "Not default constructible");
764 PLACEHOLDER_CHECK(f_compl_(2) == x_compl_);
765
766 const auto x_unary_plus = +2;
767 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_unary_plus = +boost::hof::_;
768#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
769 static_assert(std::is_copy_constructible<decltype(f_unary_plus)>::value, "Not copyable");
770#endif
771 static_assert(boost::hof::detail::is_default_constructible<decltype(f_unary_plus)>::value, "Not default constructible");
772 PLACEHOLDER_CHECK(f_unary_plus(2) == x_unary_plus);
773
774 const auto x_unary_subtract = -2;
775 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_unary_subtract = -boost::hof::_;
776#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
777 static_assert(std::is_copy_constructible<decltype(f_unary_subtract)>::value, "Not copyable");
778#endif
779 static_assert(boost::hof::detail::is_default_constructible<decltype(f_unary_subtract)>::value, "Not default constructible");
780 PLACEHOLDER_CHECK(f_unary_subtract(2) == x_unary_subtract);
781
782 const auto x_dereference = 2;
783 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_dereference = *boost::hof::_;
784#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
785 static_assert(std::is_copy_constructible<decltype(f_dereference)>::value, "Not copyable");
786#endif
787 static_assert(boost::hof::detail::is_default_constructible<decltype(f_dereference)>::value, "Not default constructible");
788 PLACEHOLDER_CHECK(f_dereference(&x_dereference) == x_dereference);
789
790 // TODO: Test constexpr increment and decrement
791#ifndef _MSC_VER
792 auto x_increment = 2;
793 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_increment = ++boost::hof::_;
794#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
795 static_assert(std::is_copy_constructible<decltype(f_increment)>::value, "Not copyable");
796#endif
797 static_assert(boost::hof::detail::is_default_constructible<decltype(f_increment)>::value, "Not default constructible");
798 f_increment(x_increment);
799 BOOST_HOF_TEST_CHECK(x_increment == 3);
800
801 auto x_decrement = 2;
802 BOOST_HOF_PLACEHOLDER_TEST_CONSTEXPR auto f_decrement = --boost::hof::_;
803#if defined(__GNUC__) && !defined (__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ > 6
804 static_assert(std::is_copy_constructible<decltype(f_decrement)>::value, "Not copyable");
805#endif
806 static_assert(boost::hof::detail::is_default_constructible<decltype(f_decrement)>::value, "Not default constructible");
807 f_decrement(x_decrement);
808 BOOST_HOF_TEST_CHECK(x_decrement == 1);
809#endif
810
811 // TODO: Test post increment and decrement
812}
813
814

source code of boost/libs/hof/test/placeholders.cpp