]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | //---------------------------------------------------------------------------// |
2 | // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> | |
3 | // | |
4 | // Distributed under the Boost Software License, Version 1.0 | |
5 | // See accompanying file LICENSE_1_0.txt or copy at | |
6 | // http://www.boost.org/LICENSE_1_0.txt | |
7 | // | |
8 | // See http://boostorg.github.com/compute for more information. | |
9 | //---------------------------------------------------------------------------// | |
10 | ||
11 | #define BOOST_TEST_MODULE TestPair | |
12 | #include <boost/test/unit_test.hpp> | |
13 | ||
14 | #include <iostream> | |
15 | ||
16 | #include <boost/compute/algorithm/copy.hpp> | |
17 | #include <boost/compute/algorithm/fill.hpp> | |
18 | #include <boost/compute/algorithm/find.hpp> | |
19 | #include <boost/compute/algorithm/transform.hpp> | |
20 | #include <boost/compute/container/vector.hpp> | |
21 | #include <boost/compute/functional/get.hpp> | |
22 | #include <boost/compute/functional/field.hpp> | |
23 | #include <boost/compute/types/pair.hpp> | |
24 | ||
25 | #include "quirks.hpp" | |
26 | #include "check_macros.hpp" | |
27 | #include "context_setup.hpp" | |
28 | ||
29 | BOOST_AUTO_TEST_CASE(vector_pair_int_float) | |
30 | { | |
31 | boost::compute::vector<std::pair<int, float> > vector(context); | |
32 | vector.push_back(std::make_pair(1, 1.1f), queue); | |
33 | vector.push_back(std::make_pair(2, 2.2f), queue); | |
34 | vector.push_back(std::make_pair(3, 3.3f), queue); | |
b32b8144 | 35 | queue.finish(); |
7c673cae FG |
36 | BOOST_CHECK_EQUAL(vector.size(), size_t(3)); |
37 | BOOST_CHECK(vector[0] == std::make_pair(1, 1.1f)); | |
38 | BOOST_CHECK(vector[1] == std::make_pair(2, 2.2f)); | |
39 | BOOST_CHECK(vector[2] == std::make_pair(3, 3.3f)); | |
40 | } | |
41 | ||
42 | BOOST_AUTO_TEST_CASE(copy_pair_vector) | |
43 | { | |
44 | boost::compute::vector<std::pair<int, float> > input(context); | |
45 | input.push_back(std::make_pair(1, 2.0f), queue); | |
46 | input.push_back(std::make_pair(3, 4.0f), queue); | |
47 | input.push_back(std::make_pair(5, 6.0f), queue); | |
48 | input.push_back(std::make_pair(7, 8.0f), queue); | |
b32b8144 | 49 | queue.finish(); |
7c673cae FG |
50 | BOOST_CHECK_EQUAL(input.size(), size_t(4)); |
51 | ||
52 | boost::compute::vector<std::pair<int, float> > output(4, context); | |
53 | boost::compute::copy(input.begin(), input.end(), output.begin(), queue); | |
54 | queue.finish(); | |
55 | BOOST_CHECK(output[0] == std::make_pair(1, 2.0f)); | |
56 | BOOST_CHECK(output[1] == std::make_pair(3, 4.0f)); | |
57 | BOOST_CHECK(output[2] == std::make_pair(5, 6.0f)); | |
58 | BOOST_CHECK(output[3] == std::make_pair(7, 8.0f)); | |
59 | } | |
60 | ||
61 | BOOST_AUTO_TEST_CASE(fill_pair_vector) | |
62 | { | |
63 | if(bug_in_struct_assignment(device)){ | |
64 | std::cerr << "skipping fill_pair_vector test" << std::endl; | |
65 | return; | |
66 | } | |
67 | ||
68 | boost::compute::vector<std::pair<int, float> > vector(5, context); | |
69 | boost::compute::fill(vector.begin(), vector.end(), std::make_pair(4, 2.0f), queue); | |
70 | queue.finish(); | |
71 | BOOST_CHECK(vector[0] == std::make_pair(4, 2.0f)); | |
72 | BOOST_CHECK(vector[1] == std::make_pair(4, 2.0f)); | |
73 | BOOST_CHECK(vector[2] == std::make_pair(4, 2.0f)); | |
74 | BOOST_CHECK(vector[3] == std::make_pair(4, 2.0f)); | |
75 | BOOST_CHECK(vector[4] == std::make_pair(4, 2.0f)); | |
76 | } | |
77 | ||
78 | BOOST_AUTO_TEST_CASE(fill_char_pair_vector) | |
79 | { | |
80 | if(bug_in_struct_assignment(device)){ | |
81 | std::cerr << "skipping fill_char_pair_vector test" << std::endl; | |
82 | return; | |
83 | } | |
84 | ||
85 | std::pair<char, unsigned char> value('c', static_cast<unsigned char>(127)); | |
86 | boost::compute::vector<std::pair<char, unsigned char> > vector(5, context); | |
87 | boost::compute::fill(vector.begin(), vector.end(), value, queue); | |
88 | queue.finish(); | |
89 | BOOST_CHECK(vector[0] == value); | |
90 | BOOST_CHECK(vector[1] == value); | |
91 | BOOST_CHECK(vector[2] == value); | |
92 | BOOST_CHECK(vector[3] == value); | |
93 | BOOST_CHECK(vector[4] == value); | |
94 | } | |
95 | ||
96 | BOOST_AUTO_TEST_CASE(transform_pair_get) | |
97 | { | |
98 | boost::compute::vector<std::pair<int, float> > input(context); | |
99 | input.push_back(std::make_pair(1, 2.0f), queue); | |
100 | input.push_back(std::make_pair(3, 4.0f), queue); | |
101 | input.push_back(std::make_pair(5, 6.0f), queue); | |
102 | input.push_back(std::make_pair(7, 8.0f), queue); | |
b32b8144 | 103 | queue.finish(); |
7c673cae FG |
104 | |
105 | boost::compute::vector<int> first_output(4, context); | |
106 | boost::compute::transform( | |
107 | input.begin(), | |
108 | input.end(), | |
109 | first_output.begin(), | |
110 | ::boost::compute::get<0>(), | |
111 | queue | |
112 | ); | |
113 | CHECK_RANGE_EQUAL(int, 4, first_output, (1, 3, 5, 7)); | |
114 | ||
115 | boost::compute::vector<float> second_output(4, context); | |
116 | boost::compute::transform( | |
117 | input.begin(), | |
118 | input.end(), | |
119 | second_output.begin(), | |
120 | ::boost::compute::get<1>(), | |
121 | queue | |
122 | ); | |
123 | CHECK_RANGE_EQUAL(float, 4, second_output, (2.0f, 4.0f, 6.0f, 8.0f)); | |
124 | } | |
125 | ||
126 | BOOST_AUTO_TEST_CASE(transform_pair_field) | |
127 | { | |
128 | boost::compute::vector<std::pair<int, float> > input(context); | |
129 | input.push_back(std::make_pair(1, 2.0f), queue); | |
130 | input.push_back(std::make_pair(3, 4.0f), queue); | |
131 | input.push_back(std::make_pair(5, 6.0f), queue); | |
132 | input.push_back(std::make_pair(7, 8.0f), queue); | |
133 | ||
134 | boost::compute::vector<int> first_output(4, context); | |
135 | boost::compute::transform( | |
136 | input.begin(), | |
137 | input.end(), | |
138 | first_output.begin(), | |
139 | boost::compute::field<int>("first"), | |
140 | queue | |
141 | ); | |
142 | CHECK_RANGE_EQUAL(int, 4, first_output, (1, 3, 5, 7)); | |
143 | ||
144 | boost::compute::vector<float> second_output(4, context); | |
145 | boost::compute::transform( | |
146 | input.begin(), | |
147 | input.end(), | |
148 | second_output.begin(), | |
149 | boost::compute::field<float>("second"), | |
150 | queue | |
151 | ); | |
152 | CHECK_RANGE_EQUAL(float, 4, second_output, (2.0f, 4.0f, 6.0f, 8.0f)); | |
153 | } | |
154 | ||
155 | BOOST_AUTO_TEST_CASE(find_vector_pair) | |
156 | { | |
157 | boost::compute::vector<std::pair<int, float> > vector(context); | |
158 | vector.push_back(std::make_pair(1, 1.1f), queue); | |
159 | vector.push_back(std::make_pair(2, 2.2f), queue); | |
160 | vector.push_back(std::make_pair(3, 3.3f), queue); | |
161 | BOOST_CHECK_EQUAL(vector.size(), size_t(3)); | |
162 | ||
163 | BOOST_CHECK( | |
164 | boost::compute::find( | |
165 | boost::compute::make_transform_iterator( | |
166 | vector.begin(), | |
167 | boost::compute::get<0>() | |
168 | ), | |
169 | boost::compute::make_transform_iterator( | |
170 | vector.end(), | |
171 | boost::compute::get<0>() | |
172 | ), | |
173 | int(2), | |
174 | queue | |
175 | ).base() == vector.begin() + 1 | |
176 | ); | |
177 | ||
178 | BOOST_CHECK( | |
179 | boost::compute::find( | |
180 | boost::compute::make_transform_iterator( | |
181 | vector.begin(), | |
182 | boost::compute::get<1>() | |
183 | ), | |
184 | boost::compute::make_transform_iterator( | |
185 | vector.end(), | |
186 | boost::compute::get<1>() | |
187 | ), | |
188 | float(3.3f), | |
189 | queue | |
190 | ).base() == vector.begin() + 2 | |
191 | ); | |
192 | } | |
193 | ||
194 | BOOST_AUTO_TEST_SUITE_END() |