]>
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); | |
35 | BOOST_CHECK_EQUAL(vector.size(), size_t(3)); | |
36 | BOOST_CHECK(vector[0] == std::make_pair(1, 1.1f)); | |
37 | BOOST_CHECK(vector[1] == std::make_pair(2, 2.2f)); | |
38 | BOOST_CHECK(vector[2] == std::make_pair(3, 3.3f)); | |
39 | } | |
40 | ||
41 | BOOST_AUTO_TEST_CASE(copy_pair_vector) | |
42 | { | |
43 | boost::compute::vector<std::pair<int, float> > input(context); | |
44 | input.push_back(std::make_pair(1, 2.0f), queue); | |
45 | input.push_back(std::make_pair(3, 4.0f), queue); | |
46 | input.push_back(std::make_pair(5, 6.0f), queue); | |
47 | input.push_back(std::make_pair(7, 8.0f), queue); | |
48 | BOOST_CHECK_EQUAL(input.size(), size_t(4)); | |
49 | ||
50 | boost::compute::vector<std::pair<int, float> > output(4, context); | |
51 | boost::compute::copy(input.begin(), input.end(), output.begin(), queue); | |
52 | queue.finish(); | |
53 | BOOST_CHECK(output[0] == std::make_pair(1, 2.0f)); | |
54 | BOOST_CHECK(output[1] == std::make_pair(3, 4.0f)); | |
55 | BOOST_CHECK(output[2] == std::make_pair(5, 6.0f)); | |
56 | BOOST_CHECK(output[3] == std::make_pair(7, 8.0f)); | |
57 | } | |
58 | ||
59 | BOOST_AUTO_TEST_CASE(fill_pair_vector) | |
60 | { | |
61 | if(bug_in_struct_assignment(device)){ | |
62 | std::cerr << "skipping fill_pair_vector test" << std::endl; | |
63 | return; | |
64 | } | |
65 | ||
66 | boost::compute::vector<std::pair<int, float> > vector(5, context); | |
67 | boost::compute::fill(vector.begin(), vector.end(), std::make_pair(4, 2.0f), queue); | |
68 | queue.finish(); | |
69 | BOOST_CHECK(vector[0] == std::make_pair(4, 2.0f)); | |
70 | BOOST_CHECK(vector[1] == std::make_pair(4, 2.0f)); | |
71 | BOOST_CHECK(vector[2] == std::make_pair(4, 2.0f)); | |
72 | BOOST_CHECK(vector[3] == std::make_pair(4, 2.0f)); | |
73 | BOOST_CHECK(vector[4] == std::make_pair(4, 2.0f)); | |
74 | } | |
75 | ||
76 | BOOST_AUTO_TEST_CASE(fill_char_pair_vector) | |
77 | { | |
78 | if(bug_in_struct_assignment(device)){ | |
79 | std::cerr << "skipping fill_char_pair_vector test" << std::endl; | |
80 | return; | |
81 | } | |
82 | ||
83 | std::pair<char, unsigned char> value('c', static_cast<unsigned char>(127)); | |
84 | boost::compute::vector<std::pair<char, unsigned char> > vector(5, context); | |
85 | boost::compute::fill(vector.begin(), vector.end(), value, queue); | |
86 | queue.finish(); | |
87 | BOOST_CHECK(vector[0] == value); | |
88 | BOOST_CHECK(vector[1] == value); | |
89 | BOOST_CHECK(vector[2] == value); | |
90 | BOOST_CHECK(vector[3] == value); | |
91 | BOOST_CHECK(vector[4] == value); | |
92 | } | |
93 | ||
94 | BOOST_AUTO_TEST_CASE(transform_pair_get) | |
95 | { | |
96 | boost::compute::vector<std::pair<int, float> > input(context); | |
97 | input.push_back(std::make_pair(1, 2.0f), queue); | |
98 | input.push_back(std::make_pair(3, 4.0f), queue); | |
99 | input.push_back(std::make_pair(5, 6.0f), queue); | |
100 | input.push_back(std::make_pair(7, 8.0f), queue); | |
101 | ||
102 | boost::compute::vector<int> first_output(4, context); | |
103 | boost::compute::transform( | |
104 | input.begin(), | |
105 | input.end(), | |
106 | first_output.begin(), | |
107 | ::boost::compute::get<0>(), | |
108 | queue | |
109 | ); | |
110 | CHECK_RANGE_EQUAL(int, 4, first_output, (1, 3, 5, 7)); | |
111 | ||
112 | boost::compute::vector<float> second_output(4, context); | |
113 | boost::compute::transform( | |
114 | input.begin(), | |
115 | input.end(), | |
116 | second_output.begin(), | |
117 | ::boost::compute::get<1>(), | |
118 | queue | |
119 | ); | |
120 | CHECK_RANGE_EQUAL(float, 4, second_output, (2.0f, 4.0f, 6.0f, 8.0f)); | |
121 | } | |
122 | ||
123 | BOOST_AUTO_TEST_CASE(transform_pair_field) | |
124 | { | |
125 | boost::compute::vector<std::pair<int, float> > input(context); | |
126 | input.push_back(std::make_pair(1, 2.0f), queue); | |
127 | input.push_back(std::make_pair(3, 4.0f), queue); | |
128 | input.push_back(std::make_pair(5, 6.0f), queue); | |
129 | input.push_back(std::make_pair(7, 8.0f), queue); | |
130 | ||
131 | boost::compute::vector<int> first_output(4, context); | |
132 | boost::compute::transform( | |
133 | input.begin(), | |
134 | input.end(), | |
135 | first_output.begin(), | |
136 | boost::compute::field<int>("first"), | |
137 | queue | |
138 | ); | |
139 | CHECK_RANGE_EQUAL(int, 4, first_output, (1, 3, 5, 7)); | |
140 | ||
141 | boost::compute::vector<float> second_output(4, context); | |
142 | boost::compute::transform( | |
143 | input.begin(), | |
144 | input.end(), | |
145 | second_output.begin(), | |
146 | boost::compute::field<float>("second"), | |
147 | queue | |
148 | ); | |
149 | CHECK_RANGE_EQUAL(float, 4, second_output, (2.0f, 4.0f, 6.0f, 8.0f)); | |
150 | } | |
151 | ||
152 | BOOST_AUTO_TEST_CASE(find_vector_pair) | |
153 | { | |
154 | boost::compute::vector<std::pair<int, float> > vector(context); | |
155 | vector.push_back(std::make_pair(1, 1.1f), queue); | |
156 | vector.push_back(std::make_pair(2, 2.2f), queue); | |
157 | vector.push_back(std::make_pair(3, 3.3f), queue); | |
158 | BOOST_CHECK_EQUAL(vector.size(), size_t(3)); | |
159 | ||
160 | BOOST_CHECK( | |
161 | boost::compute::find( | |
162 | boost::compute::make_transform_iterator( | |
163 | vector.begin(), | |
164 | boost::compute::get<0>() | |
165 | ), | |
166 | boost::compute::make_transform_iterator( | |
167 | vector.end(), | |
168 | boost::compute::get<0>() | |
169 | ), | |
170 | int(2), | |
171 | queue | |
172 | ).base() == vector.begin() + 1 | |
173 | ); | |
174 | ||
175 | BOOST_CHECK( | |
176 | boost::compute::find( | |
177 | boost::compute::make_transform_iterator( | |
178 | vector.begin(), | |
179 | boost::compute::get<1>() | |
180 | ), | |
181 | boost::compute::make_transform_iterator( | |
182 | vector.end(), | |
183 | boost::compute::get<1>() | |
184 | ), | |
185 | float(3.3f), | |
186 | queue | |
187 | ).base() == vector.begin() + 2 | |
188 | ); | |
189 | } | |
190 | ||
191 | BOOST_AUTO_TEST_SUITE_END() |