1 // Copyright Louis Dionne 2013-2017
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 #ifndef BOOST_HANA_TEST_AUTO_SLICE_HPP
6 #define BOOST_HANA_TEST_AUTO_SLICE_HPP
7
8 #include <boost/hana/assert.hpp>
9 #include <boost/hana/equal.hpp>
10 #include <boost/hana/integral_constant.hpp>
11 #include <boost/hana/range.hpp>
12 #include <boost/hana/slice.hpp>
13 #include <boost/hana/tuple.hpp>
14
15 #include "test_case.hpp"
16 #include <laws/base.hpp>
17 #include <support/seq.hpp>
18
19 #include <cstddef>
20
21
__anon46cd8c8c0102null22 TestCase test_slice{[]{
23 namespace hana = boost::hana;
24 using hana::test::ct_eq;
25 constexpr auto foldable = ::seq;
26
27 struct undefined { };
28
29 //////////////////////////////////////////////////////////////////////////
30 // Test with arbitrary indices
31 //////////////////////////////////////////////////////////////////////////
32 BOOST_HANA_CONSTANT_CHECK(hana::equal(
33 hana::slice(MAKE_TUPLE(),
34 foldable()),
35 MAKE_TUPLE()
36 ));
37 BOOST_HANA_CONSTANT_CHECK(hana::equal(
38 hana::slice(MAKE_TUPLE(undefined{}),
39 foldable()),
40 MAKE_TUPLE()
41 ));
42 BOOST_HANA_CONSTANT_CHECK(hana::equal(
43 hana::slice(MAKE_TUPLE(undefined{}, undefined{}),
44 foldable()),
45 MAKE_TUPLE()
46 ));
47
48 BOOST_HANA_CONSTANT_CHECK(hana::equal(
49 hana::slice(MAKE_TUPLE(ct_eq<0>{}),
50 foldable(hana::size_c<0>)),
51 MAKE_TUPLE(ct_eq<0>{})
52 ));
53 BOOST_HANA_CONSTANT_CHECK(hana::equal(
54 hana::slice(MAKE_TUPLE(ct_eq<0>{}, undefined{}),
55 foldable(hana::size_c<0>)),
56 MAKE_TUPLE(ct_eq<0>{})
57 ));
58 BOOST_HANA_CONSTANT_CHECK(hana::equal(
59 hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}),
60 foldable(hana::size_c<1>)),
61 MAKE_TUPLE(ct_eq<1>{})
62 ));
63
64 BOOST_HANA_CONSTANT_CHECK(hana::equal(
65 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
66 foldable(hana::size_c<0>, hana::size_c<1>)),
67 MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{})
68 ));
69 BOOST_HANA_CONSTANT_CHECK(hana::equal(
70 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
71 foldable(hana::size_c<1>, hana::size_c<0>)),
72 MAKE_TUPLE(ct_eq<1>{}, ct_eq<0>{})
73 ));
74 BOOST_HANA_CONSTANT_CHECK(hana::equal(
75 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
76 foldable(hana::size_c<0>, hana::size_c<0>)),
77 MAKE_TUPLE(ct_eq<0>{}, ct_eq<0>{})
78 ));
79 BOOST_HANA_CONSTANT_CHECK(hana::equal(
80 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
81 foldable(hana::size_c<1>, hana::size_c<1>)),
82 MAKE_TUPLE(ct_eq<1>{}, ct_eq<1>{})
83 ));
84
85 BOOST_HANA_CONSTANT_CHECK(hana::equal(
86 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
87 foldable(hana::size_c<0>, hana::size_c<1>, hana::size_c<2>)),
88 MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{})
89 ));
90 BOOST_HANA_CONSTANT_CHECK(hana::equal(
91 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
92 foldable(hana::size_c<0>, hana::size_c<2>, hana::size_c<1>)),
93 MAKE_TUPLE(ct_eq<0>{}, ct_eq<2>{}, ct_eq<1>{})
94 ));
95
96 BOOST_HANA_CONSTANT_CHECK(hana::equal(
97 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
98 foldable(hana::size_c<0>, hana::size_c<2>, hana::size_c<1>, hana::size_c<0>)),
99 MAKE_TUPLE(ct_eq<0>{}, ct_eq<2>{}, ct_eq<1>{}, ct_eq<0>{})
100 ));
101
102 BOOST_HANA_CONSTANT_CHECK(hana::equal(
103 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
104 foldable(hana::size_c<0>, hana::size_c<2>, hana::size_c<1>, hana::size_c<0>, hana::size_c<1>)),
105 MAKE_TUPLE(ct_eq<0>{}, ct_eq<2>{}, ct_eq<1>{}, ct_eq<0>{}, ct_eq<1>{})
106 ));
107
108 // Try with a tuple_c
109 BOOST_HANA_CONSTANT_CHECK(hana::equal(
110 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
111 hana::tuple_c<unsigned, 1, 3, 2>),
112 MAKE_TUPLE(ct_eq<1>{}, ct_eq<3>{}, ct_eq<2>{})
113 ));
114
115
116
117 //////////////////////////////////////////////////////////////////////////
118 // Test with a `range` (check the optimization for contiguous indices)
119 //////////////////////////////////////////////////////////////////////////
120 BOOST_HANA_CONSTANT_CHECK(hana::equal(
121 hana::slice(MAKE_TUPLE(),
122 hana::range_c<std::size_t, 0, 0>),
123 MAKE_TUPLE()
124 ));
125 BOOST_HANA_CONSTANT_CHECK(hana::equal(
126 hana::slice(MAKE_TUPLE(undefined{}),
127 hana::range_c<std::size_t, 0, 0>),
128 MAKE_TUPLE()
129 ));
130 BOOST_HANA_CONSTANT_CHECK(hana::equal(
131 hana::slice(MAKE_TUPLE(undefined{}, undefined{}),
132 hana::range_c<std::size_t, 0, 0>),
133 MAKE_TUPLE()
134 ));
135
136 BOOST_HANA_CONSTANT_CHECK(hana::equal(
137 hana::slice(MAKE_TUPLE(ct_eq<0>{}),
138 hana::range_c<std::size_t, 0, 1>),
139 MAKE_TUPLE(ct_eq<0>{})
140 ));
141 BOOST_HANA_CONSTANT_CHECK(hana::equal(
142 hana::slice(MAKE_TUPLE(ct_eq<0>{}, undefined{}),
143 hana::range_c<std::size_t, 0, 1>),
144 MAKE_TUPLE(ct_eq<0>{})
145 ));
146
147 BOOST_HANA_CONSTANT_CHECK(hana::equal(
148 hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}),
149 hana::range_c<std::size_t, 1, 2>),
150 MAKE_TUPLE(ct_eq<1>{})
151 ));
152 BOOST_HANA_CONSTANT_CHECK(hana::equal(
153 hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}, undefined{}),
154 hana::range_c<std::size_t, 1, 2>),
155 MAKE_TUPLE(ct_eq<1>{})
156 ));
157
158 BOOST_HANA_CONSTANT_CHECK(hana::equal(
159 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
160 hana::range_c<std::size_t, 0, 2>),
161 MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{})
162 ));
163 BOOST_HANA_CONSTANT_CHECK(hana::equal(
164 hana::slice(MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, undefined{}),
165 hana::range_c<std::size_t, 0, 2>),
166 MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{})
167 ));
168
169 BOOST_HANA_CONSTANT_CHECK(hana::equal(
170 hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}, ct_eq<2>{}),
171 hana::range_c<std::size_t, 1, 3>),
172 MAKE_TUPLE(ct_eq<1>{}, ct_eq<2>{})
173 ));
174
175 BOOST_HANA_CONSTANT_CHECK(hana::equal(
176 hana::slice(MAKE_TUPLE(undefined{}, ct_eq<1>{}, ct_eq<2>{}, undefined{}),
177 hana::range_c<std::size_t, 1, 3>),
178 MAKE_TUPLE(ct_eq<1>{}, ct_eq<2>{})
179 ));
180 }};
181
182 #endif // !BOOST_HANA_TEST_AUTO_SLICE_HPP
183