1 #include <unittest/unittest.h>
2 #include <thrust/sequence.h>
3 #include <thrust/device_malloc_allocator.h>
4 #include <vector>
5 #include <list>
6 #include <limits>
7 #include <utility>
8
9 template <class Vector>
TestVectorZeroSize(void)10 void TestVectorZeroSize(void)
11 {
12 Vector v;
13 ASSERT_EQUAL(v.size(), 0lu);
14 ASSERT_EQUAL((v.begin() == v.end()), true);
15 }
16 DECLARE_VECTOR_UNITTEST(TestVectorZeroSize);
17
18
TestVectorBool(void)19 void TestVectorBool(void)
20 {
21 thrust::host_vector<bool> h(3);
22 thrust::device_vector<bool> d(3);
23
24 h[0] = true; h[1] = false; h[2] = true;
25 d[0] = true; d[1] = false; d[2] = true;
26
27 ASSERT_EQUAL(h[0], true);
28 ASSERT_EQUAL(h[1], false);
29 ASSERT_EQUAL(h[2], true);
30
31 ASSERT_EQUAL(d[0], true);
32 ASSERT_EQUAL(d[1], false);
33 ASSERT_EQUAL(d[2], true);
34 }
35 DECLARE_UNITTEST(TestVectorBool);
36
37
38 template <class Vector>
TestVectorFrontBack(void)39 void TestVectorFrontBack(void)
40 {
41 typedef typename Vector::value_type T;
42
43 Vector v(3);
44 v[0] = 0; v[1] = 1; v[2] = 2;
45
46 ASSERT_EQUAL(v.front(), T(0));
47 ASSERT_EQUAL(v.back(), T(2));
48 }
49 DECLARE_VECTOR_UNITTEST(TestVectorFrontBack);
50
51
52 template <class Vector>
TestVectorData(void)53 void TestVectorData(void)
54 {
55 Vector v(3);
56 v[0] = 0; v[1] = 1; v[2] = 2;
57
58 ASSERT_EQUAL(0, *v.data());
59 ASSERT_EQUAL(1, *(v.data() + 1));
60 ASSERT_EQUAL(2, *(v.data() + 2));
61 ASSERT_EQUAL(&v.front(), v.data());
62 ASSERT_EQUAL(&*v.begin(), v.data());
63 ASSERT_EQUAL(&v[0], v.data());
64
65 const Vector &c_v = v;
66
67 ASSERT_EQUAL(0, *c_v.data());
68 ASSERT_EQUAL(1, *(c_v.data() + 1));
69 ASSERT_EQUAL(2, *(c_v.data() + 2));
70 ASSERT_EQUAL(&c_v.front(), c_v.data());
71 ASSERT_EQUAL(&*c_v.begin(), c_v.data());
72 ASSERT_EQUAL(&c_v[0], c_v.data());
73 }
74 DECLARE_VECTOR_UNITTEST(TestVectorData);
75
76
77 template <class Vector>
TestVectorElementAssignment(void)78 void TestVectorElementAssignment(void)
79 {
80 Vector v(3);
81
82 v[0] = 0; v[1] = 1; v[2] = 2;
83
84 ASSERT_EQUAL(v[0], 0);
85 ASSERT_EQUAL(v[1], 1);
86 ASSERT_EQUAL(v[2], 2);
87
88 v[0] = 10; v[1] = 11; v[2] = 12;
89
90 ASSERT_EQUAL(v[0], 10);
91 ASSERT_EQUAL(v[1], 11);
92 ASSERT_EQUAL(v[2], 12);
93
94 Vector w(3);
95 w[0] = v[0];
96 w[1] = v[1];
97 w[2] = v[2];
98
99 ASSERT_EQUAL(v, w);
100 }
101 DECLARE_VECTOR_UNITTEST(TestVectorElementAssignment);
102
103
104 template <class Vector>
TestVectorFromSTLVector(void)105 void TestVectorFromSTLVector(void)
106 {
107 typedef typename Vector::value_type T;
108
109 std::vector<T> stl_vector(3);
110 stl_vector[0] = 0;
111 stl_vector[1] = 1;
112 stl_vector[2] = 2;
113
114 thrust::host_vector<T> v(stl_vector);
115
116 ASSERT_EQUAL(v.size(), 3lu);
117 ASSERT_EQUAL(v[0], 0);
118 ASSERT_EQUAL(v[1], 1);
119 ASSERT_EQUAL(v[2], 2);
120
121 v = stl_vector;
122
123 ASSERT_EQUAL(v.size(), 3lu);
124 ASSERT_EQUAL(v[0], 0);
125 ASSERT_EQUAL(v[1], 1);
126 ASSERT_EQUAL(v[2], 2);
127 }
128 DECLARE_VECTOR_UNITTEST(TestVectorFromSTLVector);
129
130
131 template <class Vector>
TestVectorFillAssign(void)132 void TestVectorFillAssign(void)
133 {
134 typedef typename Vector::value_type T;
135
136 thrust::host_vector<T> v;
137 v.assign(3, 13);
138
139 ASSERT_EQUAL(v.size(), 3lu);
140 ASSERT_EQUAL(v[0], 13);
141 ASSERT_EQUAL(v[1], 13);
142 ASSERT_EQUAL(v[2], 13);
143 }
144 DECLARE_VECTOR_UNITTEST(TestVectorFillAssign);
145
146
147 template <class Vector>
TestVectorAssignFromSTLVector(void)148 void TestVectorAssignFromSTLVector(void)
149 {
150 typedef typename Vector::value_type T;
151
152 std::vector<T> stl_vector(3);
153 stl_vector[0] = 0;
154 stl_vector[1] = 1;
155 stl_vector[2] = 2;
156
157 thrust::host_vector<T> v;
158 v.assign(stl_vector.begin(), stl_vector.end());
159
160 ASSERT_EQUAL(v.size(), 3lu);
161 ASSERT_EQUAL(v[0], 0);
162 ASSERT_EQUAL(v[1], 1);
163 ASSERT_EQUAL(v[2], 2);
164 }
165 DECLARE_VECTOR_UNITTEST(TestVectorAssignFromSTLVector);
166
167
168 template <class Vector>
TestVectorFromBiDirectionalIterator(void)169 void TestVectorFromBiDirectionalIterator(void)
170 {
171 typedef typename Vector::value_type T;
172
173 std::list<T> stl_list;
174 stl_list.push_back(0);
175 stl_list.push_back(1);
176 stl_list.push_back(2);
177
178 Vector v(stl_list.begin(), stl_list.end());
179
180 ASSERT_EQUAL(v.size(), 3lu);
181 ASSERT_EQUAL(v[0], 0);
182 ASSERT_EQUAL(v[1], 1);
183 ASSERT_EQUAL(v[2], 2);
184 }
185 DECLARE_VECTOR_UNITTEST(TestVectorFromBiDirectionalIterator);
186
187
188 template <class Vector>
TestVectorAssignFromBiDirectionalIterator(void)189 void TestVectorAssignFromBiDirectionalIterator(void)
190 {
191 typedef typename Vector::value_type T;
192
193 std::list<T> stl_list;
194 stl_list.push_back(0);
195 stl_list.push_back(1);
196 stl_list.push_back(2);
197
198 Vector v;
199 v.assign(stl_list.begin(), stl_list.end());
200
201 ASSERT_EQUAL(v.size(), 3lu);
202 ASSERT_EQUAL(v[0], 0);
203 ASSERT_EQUAL(v[1], 1);
204 ASSERT_EQUAL(v[2], 2);
205 }
206 DECLARE_VECTOR_UNITTEST(TestVectorAssignFromBiDirectionalIterator);
207
208
209 template <class Vector>
TestVectorAssignFromHostVector(void)210 void TestVectorAssignFromHostVector(void)
211 {
212 typedef typename Vector::value_type T;
213
214 thrust::host_vector<T> h(3);
215 h[0] = 0;
216 h[1] = 1;
217 h[2] = 2;
218
219 Vector v;
220 v.assign(h.begin(), h.end());
221
222 ASSERT_EQUAL(v, h);
223 }
224 DECLARE_VECTOR_UNITTEST(TestVectorAssignFromHostVector);
225
226
227 template <class Vector>
TestVectorToAndFromHostVector(void)228 void TestVectorToAndFromHostVector(void)
229 {
230 typedef typename Vector::value_type T;
231
232 thrust::host_vector<T> h(3);
233 h[0] = 0;
234 h[1] = 1;
235 h[2] = 2;
236
237 Vector v(h);
238
239 ASSERT_EQUAL(v, h);
240
241 THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING(v = v);
242
243 ASSERT_EQUAL(v, h);
244
245 v[0] = 10;
246 v[1] = 11;
247 v[2] = 12;
248
249 ASSERT_EQUAL(h[0], 0); ASSERT_EQUAL(v[0], 10);
250 ASSERT_EQUAL(h[1], 1); ASSERT_EQUAL(v[1], 11);
251 ASSERT_EQUAL(h[2], 2); ASSERT_EQUAL(v[2], 12);
252
253 h = v;
254
255 ASSERT_EQUAL(v, h);
256
257 h[1] = 11;
258
259 v = h;
260
261 ASSERT_EQUAL(v, h);
262 }
263 DECLARE_VECTOR_UNITTEST(TestVectorToAndFromHostVector);
264
265
266 template <class Vector>
TestVectorAssignFromDeviceVector(void)267 void TestVectorAssignFromDeviceVector(void)
268 {
269 typedef typename Vector::value_type T;
270
271 thrust::device_vector<T> d(3);
272 d[0] = 0;
273 d[1] = 1;
274 d[2] = 2;
275
276 Vector v;
277 v.assign(d.begin(), d.end());
278
279 ASSERT_EQUAL(v, d);
280 }
281 DECLARE_VECTOR_UNITTEST(TestVectorAssignFromDeviceVector);
282
283
284 template <class Vector>
TestVectorToAndFromDeviceVector(void)285 void TestVectorToAndFromDeviceVector(void)
286 {
287 typedef typename Vector::value_type T;
288
289 thrust::device_vector<T> h(3);
290 h[0] = 0;
291 h[1] = 1;
292 h[2] = 2;
293
294 Vector v(h);
295
296 ASSERT_EQUAL(v, h);
297
298 THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING(v = v);
299
300 ASSERT_EQUAL(v, h);
301
302 v[0] = 10;
303 v[1] = 11;
304 v[2] = 12;
305
306 ASSERT_EQUAL(h[0], 0); ASSERT_EQUAL(v[0], 10);
307 ASSERT_EQUAL(h[1], 1); ASSERT_EQUAL(v[1], 11);
308 ASSERT_EQUAL(h[2], 2); ASSERT_EQUAL(v[2], 12);
309
310 h = v;
311
312 ASSERT_EQUAL(v, h);
313
314 h[1] = 11;
315
316 v = h;
317
318 ASSERT_EQUAL(v, h);
319 }
320 DECLARE_VECTOR_UNITTEST(TestVectorToAndFromDeviceVector);
321
322
323 template <class Vector>
TestVectorWithInitialValue(void)324 void TestVectorWithInitialValue(void)
325 {
326 typedef typename Vector::value_type T;
327
328 const T init = 17;
329
330 Vector v(3, init);
331
332 ASSERT_EQUAL(v.size(), 3lu);
333 ASSERT_EQUAL(v[0], init);
334 ASSERT_EQUAL(v[1], init);
335 ASSERT_EQUAL(v[2], init);
336 }
337 DECLARE_VECTOR_UNITTEST(TestVectorWithInitialValue);
338
339
340 template <class Vector>
TestVectorSwap(void)341 void TestVectorSwap(void)
342 {
343 Vector v(3);
344 v[0] = 0; v[1] = 1; v[2] = 2;
345
346 Vector u(3);
347 u[0] = 10; u[1] = 11; u[2] = 12;
348
349 v.swap(u);
350
351 ASSERT_EQUAL(v[0], 10); ASSERT_EQUAL(u[0], 0);
352 ASSERT_EQUAL(v[1], 11); ASSERT_EQUAL(u[1], 1);
353 ASSERT_EQUAL(v[2], 12); ASSERT_EQUAL(u[2], 2);
354 }
355 DECLARE_VECTOR_UNITTEST(TestVectorSwap);
356
357
358 template <class Vector>
TestVectorErasePosition(void)359 void TestVectorErasePosition(void)
360 {
361 Vector v(5);
362 v[0] = 0; v[1] = 1; v[2] = 2; v[3] = 3; v[4] = 4;
363
364 v.erase(v.begin() + 2);
365
366 ASSERT_EQUAL(v.size(), 4lu);
367 ASSERT_EQUAL(v[0], 0);
368 ASSERT_EQUAL(v[1], 1);
369 ASSERT_EQUAL(v[2], 3);
370 ASSERT_EQUAL(v[3], 4);
371
372 v.erase(v.begin() + 0);
373
374 ASSERT_EQUAL(v.size(), 3lu);
375 ASSERT_EQUAL(v[0], 1);
376 ASSERT_EQUAL(v[1], 3);
377 ASSERT_EQUAL(v[2], 4);
378
379 v.erase(v.begin() + 2);
380
381 ASSERT_EQUAL(v.size(), 2lu);
382 ASSERT_EQUAL(v[0], 1);
383 ASSERT_EQUAL(v[1], 3);
384
385 v.erase(v.begin() + 1);
386
387 ASSERT_EQUAL(v.size(), 1lu);
388 ASSERT_EQUAL(v[0], 1);
389
390 v.erase(v.begin() + 0);
391
392 ASSERT_EQUAL(v.size(), 0lu);
393 }
394 DECLARE_VECTOR_UNITTEST(TestVectorErasePosition);
395
396
397 template <class Vector>
TestVectorEraseRange(void)398 void TestVectorEraseRange(void)
399 {
400 Vector v(6);
401 v[0] = 0; v[1] = 1; v[2] = 2; v[3] = 3; v[4] = 4; v[5] = 5;
402
403 v.erase(v.begin() + 1, v.begin() + 3);
404
405 ASSERT_EQUAL(v.size(), 4lu);
406 ASSERT_EQUAL(v[0], 0);
407 ASSERT_EQUAL(v[1], 3);
408 ASSERT_EQUAL(v[2], 4);
409 ASSERT_EQUAL(v[3], 5);
410
411 v.erase(v.begin() + 2, v.end());
412
413 ASSERT_EQUAL(v.size(), 2lu);
414 ASSERT_EQUAL(v[0], 0);
415 ASSERT_EQUAL(v[1], 3);
416
417 v.erase(v.begin() + 0, v.begin() + 1);
418
419 ASSERT_EQUAL(v.size(), 1lu);
420 ASSERT_EQUAL(v[0], 3);
421
422 v.erase(v.begin(), v.end());
423
424 ASSERT_EQUAL(v.size(), 0lu);
425 }
426 DECLARE_VECTOR_UNITTEST(TestVectorEraseRange);
427
428
TestVectorEquality(void)429 void TestVectorEquality(void)
430 {
431 thrust::host_vector<int> h_a(3);
432 thrust::host_vector<int> h_b(3);
433 thrust::host_vector<int> h_c(3);
434 h_a[0] = 0; h_a[1] = 1; h_a[2] = 2;
435 h_b[0] = 0; h_b[1] = 1; h_b[2] = 3;
436 h_b[0] = 0; h_b[1] = 1;
437
438 thrust::device_vector<int> d_a(3);
439 thrust::device_vector<int> d_b(3);
440 thrust::device_vector<int> d_c(3);
441 d_a[0] = 0; d_a[1] = 1; d_a[2] = 2;
442 d_b[0] = 0; d_b[1] = 1; d_b[2] = 3;
443 d_b[0] = 0; d_b[1] = 1;
444
445 std::vector<int> s_a(3);
446 std::vector<int> s_b(3);
447 std::vector<int> s_c(3);
448 s_a[0] = 0; s_a[1] = 1; s_a[2] = 2;
449 s_b[0] = 0; s_b[1] = 1; s_b[2] = 3;
450 s_b[0] = 0; s_b[1] = 1;
451
452 ASSERT_EQUAL((h_a == h_a), true); ASSERT_EQUAL((h_a == d_a), true); ASSERT_EQUAL((d_a == h_a), true); ASSERT_EQUAL((d_a == d_a), true);
453 ASSERT_EQUAL((h_b == h_b), true); ASSERT_EQUAL((h_b == d_b), true); ASSERT_EQUAL((d_b == h_b), true); ASSERT_EQUAL((d_b == d_b), true);
454 ASSERT_EQUAL((h_c == h_c), true); ASSERT_EQUAL((h_c == d_c), true); ASSERT_EQUAL((d_c == h_c), true); ASSERT_EQUAL((d_c == d_c), true);
455
456 // test vector vs device_vector
457 ASSERT_EQUAL((s_a == d_a), true); ASSERT_EQUAL((d_a == s_a), true);
458 ASSERT_EQUAL((s_b == d_b), true); ASSERT_EQUAL((d_b == s_b), true);
459 ASSERT_EQUAL((s_c == d_c), true); ASSERT_EQUAL((d_c == s_c), true);
460
461 // test vector vs host_vector
462 ASSERT_EQUAL((s_a == h_a), true); ASSERT_EQUAL((h_a == s_a), true);
463 ASSERT_EQUAL((s_b == h_b), true); ASSERT_EQUAL((h_b == s_b), true);
464 ASSERT_EQUAL((s_c == h_c), true); ASSERT_EQUAL((h_c == s_c), true);
465
466 ASSERT_EQUAL((h_a == h_b), false); ASSERT_EQUAL((h_a == d_b), false); ASSERT_EQUAL((d_a == h_b), false); ASSERT_EQUAL((d_a == d_b), false);
467 ASSERT_EQUAL((h_b == h_a), false); ASSERT_EQUAL((h_b == d_a), false); ASSERT_EQUAL((d_b == h_a), false); ASSERT_EQUAL((d_b == d_a), false);
468 ASSERT_EQUAL((h_a == h_c), false); ASSERT_EQUAL((h_a == d_c), false); ASSERT_EQUAL((d_a == h_c), false); ASSERT_EQUAL((d_a == d_c), false);
469 ASSERT_EQUAL((h_c == h_a), false); ASSERT_EQUAL((h_c == d_a), false); ASSERT_EQUAL((d_c == h_a), false); ASSERT_EQUAL((d_c == d_a), false);
470 ASSERT_EQUAL((h_b == h_c), false); ASSERT_EQUAL((h_b == d_c), false); ASSERT_EQUAL((d_b == h_c), false); ASSERT_EQUAL((d_b == d_c), false);
471 ASSERT_EQUAL((h_c == h_b), false); ASSERT_EQUAL((h_c == d_b), false); ASSERT_EQUAL((d_c == h_b), false); ASSERT_EQUAL((d_c == d_b), false);
472
473 // test vector vs device_vector
474 ASSERT_EQUAL((s_a == d_b), false); ASSERT_EQUAL((d_a == s_b), false);
475 ASSERT_EQUAL((s_b == d_a), false); ASSERT_EQUAL((d_b == s_a), false);
476 ASSERT_EQUAL((s_a == d_c), false); ASSERT_EQUAL((d_a == s_c), false);
477 ASSERT_EQUAL((s_c == d_a), false); ASSERT_EQUAL((d_c == s_a), false);
478 ASSERT_EQUAL((s_b == d_c), false); ASSERT_EQUAL((d_b == s_c), false);
479 ASSERT_EQUAL((s_c == d_b), false); ASSERT_EQUAL((d_c == s_b), false);
480
481 // test vector vs host_vector
482 ASSERT_EQUAL((s_a == h_b), false); ASSERT_EQUAL((h_a == s_b), false);
483 ASSERT_EQUAL((s_b == h_a), false); ASSERT_EQUAL((h_b == s_a), false);
484 ASSERT_EQUAL((s_a == h_c), false); ASSERT_EQUAL((h_a == s_c), false);
485 ASSERT_EQUAL((s_c == h_a), false); ASSERT_EQUAL((h_c == s_a), false);
486 ASSERT_EQUAL((s_b == h_c), false); ASSERT_EQUAL((h_b == s_c), false);
487 ASSERT_EQUAL((s_c == h_b), false); ASSERT_EQUAL((h_c == s_b), false);
488 }
489 DECLARE_UNITTEST(TestVectorEquality);
490
TestVectorInequality(void)491 void TestVectorInequality(void)
492 {
493 thrust::host_vector<int> h_a(3);
494 thrust::host_vector<int> h_b(3);
495 thrust::host_vector<int> h_c(3);
496 h_a[0] = 0; h_a[1] = 1; h_a[2] = 2;
497 h_b[0] = 0; h_b[1] = 1; h_b[2] = 3;
498 h_b[0] = 0; h_b[1] = 1;
499
500 thrust::device_vector<int> d_a(3);
501 thrust::device_vector<int> d_b(3);
502 thrust::device_vector<int> d_c(3);
503 d_a[0] = 0; d_a[1] = 1; d_a[2] = 2;
504 d_b[0] = 0; d_b[1] = 1; d_b[2] = 3;
505 d_b[0] = 0; d_b[1] = 1;
506
507 std::vector<int> s_a(3);
508 std::vector<int> s_b(3);
509 std::vector<int> s_c(3);
510 s_a[0] = 0; s_a[1] = 1; s_a[2] = 2;
511 s_b[0] = 0; s_b[1] = 1; s_b[2] = 3;
512 s_b[0] = 0; s_b[1] = 1;
513
514 ASSERT_EQUAL((h_a != h_a), false); ASSERT_EQUAL((h_a != d_a), false); ASSERT_EQUAL((d_a != h_a), false); ASSERT_EQUAL((d_a != d_a), false);
515 ASSERT_EQUAL((h_b != h_b), false); ASSERT_EQUAL((h_b != d_b), false); ASSERT_EQUAL((d_b != h_b), false); ASSERT_EQUAL((d_b != d_b), false);
516 ASSERT_EQUAL((h_c != h_c), false); ASSERT_EQUAL((h_c != d_c), false); ASSERT_EQUAL((d_c != h_c), false); ASSERT_EQUAL((d_c != d_c), false);
517
518 // test vector vs device_vector
519 ASSERT_EQUAL((s_a != d_a), false); ASSERT_EQUAL((d_a != s_a), false);
520 ASSERT_EQUAL((s_b != d_b), false); ASSERT_EQUAL((d_b != s_b), false);
521 ASSERT_EQUAL((s_c != d_c), false); ASSERT_EQUAL((d_c != s_c), false);
522
523 // test vector vs host_vector
524 ASSERT_EQUAL((s_a != h_a), false); ASSERT_EQUAL((h_a != s_a), false);
525 ASSERT_EQUAL((s_b != h_b), false); ASSERT_EQUAL((h_b != s_b), false);
526 ASSERT_EQUAL((s_c != h_c), false); ASSERT_EQUAL((h_c != s_c), false);
527
528 ASSERT_EQUAL((h_a != h_b), true); ASSERT_EQUAL((h_a != d_b), true); ASSERT_EQUAL((d_a != h_b), true); ASSERT_EQUAL((d_a != d_b), true);
529 ASSERT_EQUAL((h_b != h_a), true); ASSERT_EQUAL((h_b != d_a), true); ASSERT_EQUAL((d_b != h_a), true); ASSERT_EQUAL((d_b != d_a), true);
530 ASSERT_EQUAL((h_a != h_c), true); ASSERT_EQUAL((h_a != d_c), true); ASSERT_EQUAL((d_a != h_c), true); ASSERT_EQUAL((d_a != d_c), true);
531 ASSERT_EQUAL((h_c != h_a), true); ASSERT_EQUAL((h_c != d_a), true); ASSERT_EQUAL((d_c != h_a), true); ASSERT_EQUAL((d_c != d_a), true);
532 ASSERT_EQUAL((h_b != h_c), true); ASSERT_EQUAL((h_b != d_c), true); ASSERT_EQUAL((d_b != h_c), true); ASSERT_EQUAL((d_b != d_c), true);
533 ASSERT_EQUAL((h_c != h_b), true); ASSERT_EQUAL((h_c != d_b), true); ASSERT_EQUAL((d_c != h_b), true); ASSERT_EQUAL((d_c != d_b), true);
534
535 // test vector vs device_vector
536 ASSERT_EQUAL((s_a != d_b), true); ASSERT_EQUAL((d_a != s_b), true);
537 ASSERT_EQUAL((s_b != d_a), true); ASSERT_EQUAL((d_b != s_a), true);
538 ASSERT_EQUAL((s_a != d_c), true); ASSERT_EQUAL((d_a != s_c), true);
539 ASSERT_EQUAL((s_c != d_a), true); ASSERT_EQUAL((d_c != s_a), true);
540 ASSERT_EQUAL((s_b != d_c), true); ASSERT_EQUAL((d_b != s_c), true);
541 ASSERT_EQUAL((s_c != d_b), true); ASSERT_EQUAL((d_c != s_b), true);
542
543 // test vector vs host_vector
544 ASSERT_EQUAL((s_a != h_b), true); ASSERT_EQUAL((h_a != s_b), true);
545 ASSERT_EQUAL((s_b != h_a), true); ASSERT_EQUAL((h_b != s_a), true);
546 ASSERT_EQUAL((s_a != h_c), true); ASSERT_EQUAL((h_a != s_c), true);
547 ASSERT_EQUAL((s_c != h_a), true); ASSERT_EQUAL((h_c != s_a), true);
548 ASSERT_EQUAL((s_b != h_c), true); ASSERT_EQUAL((h_b != s_c), true);
549 ASSERT_EQUAL((s_c != h_b), true); ASSERT_EQUAL((h_c != s_b), true);
550 }
551 DECLARE_UNITTEST(TestVectorInequality);
552
553
554 template <class Vector>
TestVectorResizing(void)555 void TestVectorResizing(void)
556 {
557 Vector v;
558
559 v.resize(3);
560
561 ASSERT_EQUAL(v.size(), 3lu);
562
563 v[0] = 0; v[1] = 1; v[2] = 2;
564
565 v.resize(5);
566
567 ASSERT_EQUAL(v.size(), 5lu);
568
569 ASSERT_EQUAL(v[0], 0);
570 ASSERT_EQUAL(v[1], 1);
571 ASSERT_EQUAL(v[2], 2);
572
573 v[3] = 3; v[4] = 4;
574
575 v.resize(4);
576
577 ASSERT_EQUAL(v.size(), 4lu);
578
579 ASSERT_EQUAL(v[0], 0);
580 ASSERT_EQUAL(v[1], 1);
581 ASSERT_EQUAL(v[2], 2);
582 ASSERT_EQUAL(v[3], 3);
583
584 v.resize(0);
585
586 ASSERT_EQUAL(v.size(), 0lu);
587
588 // TODO remove this WAR
589 #if defined(__CUDACC__) && CUDA_VERSION==3000
590 // depending on sizeof(T), we will receive one
591 // of two possible exceptions
592 try
593 {
594 v.resize(std::numeric_limits<size_t>::max());
595 }
596 catch(std::length_error e) {}
597 catch(std::bad_alloc e)
598 {
599 // reset the CUDA error
600 cudaGetLastError();
601 } // end catch
602 #endif // defined(__CUDACC__) && CUDA_VERSION==3000
603
604 ASSERT_EQUAL(v.size(), 0lu);
605 }
606 DECLARE_VECTOR_UNITTEST(TestVectorResizing);
607
608
609
610 template <class Vector>
TestVectorReserving(void)611 void TestVectorReserving(void)
612 {
613 Vector v;
614
615 v.reserve(3);
616
617 ASSERT_GEQUAL(v.capacity(), 3lu);
618
619 size_t old_capacity = v.capacity();
620
621 v.reserve(0);
622
623 ASSERT_EQUAL(v.capacity(), old_capacity);
624
625 // TODO remove this WAR
626 #if defined(__CUDACC__) && CUDA_VERSION==3000
627 try
628 {
629 v.reserve(std::numeric_limits<size_t>::max());
630 }
631 catch(std::length_error e) {}
632 catch(std::bad_alloc e) {}
633 #endif // defined(__CUDACC__) && CUDA_VERSION==3000
634
635 ASSERT_EQUAL(v.capacity(), old_capacity);
636 }
DECLARE_VECTOR_UNITTEST(TestVectorReserving)637 DECLARE_VECTOR_UNITTEST(TestVectorReserving)
638
639
640
641 template <class Vector>
642 void TestVectorShrinkToFit(void)
643 {
644 typedef typename Vector::value_type T;
645
646 Vector v;
647
648 v.reserve(200);
649
650 ASSERT_GEQUAL(v.capacity(), 200lu);
651
652 v.push_back(1);
653 v.push_back(2);
654 v.push_back(3);
655
656 v.shrink_to_fit();
657
658 ASSERT_EQUAL(T(1), v[0]);
659 ASSERT_EQUAL(T(2), v[1]);
660 ASSERT_EQUAL(T(3), v[2]);
661 ASSERT_EQUAL(3lu, v.size());
662 ASSERT_EQUAL(3lu, v.capacity());
663 }
664 DECLARE_VECTOR_UNITTEST(TestVectorShrinkToFit)
665
666 template <int N>
667 struct LargeStruct
668 {
669 int data[N];
670
671 __host__ __device__
operator ==LargeStruct672 bool operator==(const LargeStruct & ls) const
673 {
674 for (int i = 0; i < N; i++)
675 if (data[i] != ls.data[i])
676 return false;
677 return true;
678 }
679 };
680
TestVectorContainingLargeType(void)681 void TestVectorContainingLargeType(void)
682 {
683 // Thrust issue #5
684 // http://code.google.com/p/thrust/issues/detail?id=5
685 const static int N = 100;
686 typedef LargeStruct<N> T;
687
688 thrust::device_vector<T> dv1;
689 thrust::host_vector<T> hv1;
690
691 ASSERT_EQUAL_QUIET(dv1, hv1);
692
693 thrust::device_vector<T> dv2(20);
694 thrust::host_vector<T> hv2(20);
695
696 ASSERT_EQUAL_QUIET(dv2, hv2);
697
698 // initialize tofirst element to something nonzero
699 T ls;
700
701 for (int i = 0; i < N; i++)
702 ls.data[i] = i;
703
704 thrust::device_vector<T> dv3(20, ls);
705 thrust::host_vector<T> hv3(20, ls);
706
707 ASSERT_EQUAL_QUIET(dv3, hv3);
708
709 // change first element
710 ls.data[0] = -13;
711
712 dv3[2] = ls;
713 hv3[2] = ls;
714
715 ASSERT_EQUAL_QUIET(dv3, hv3);
716 }
717 DECLARE_UNITTEST(TestVectorContainingLargeType);
718
719
720 template <typename Vector>
TestVectorReversed(void)721 void TestVectorReversed(void)
722 {
723 Vector v(3);
724 v[0] = 0; v[1] = 1; v[2] = 2;
725
726 ASSERT_EQUAL(3, v.rend() - v.rbegin());
727 ASSERT_EQUAL(3, static_cast<const Vector&>(v).rend() - static_cast<const Vector&>(v).rbegin());
728 ASSERT_EQUAL(3, v.crend() - v.crbegin());
729
730 ASSERT_EQUAL(2, *v.rbegin());
731 ASSERT_EQUAL(2, *static_cast<const Vector&>(v).rbegin());
732 ASSERT_EQUAL(2, *v.crbegin());
733
734 ASSERT_EQUAL(1, *(v.rbegin() + 1));
735 ASSERT_EQUAL(0, *(v.rbegin() + 2));
736
737 ASSERT_EQUAL(0, *(v.rend() - 1));
738 ASSERT_EQUAL(1, *(v.rend() - 2));
739 }
740 DECLARE_VECTOR_UNITTEST(TestVectorReversed);
741
742 #if __cplusplus >= 201103L
743 template <class Vector>
TestVectorMove(void)744 void TestVectorMove(void)
745 {
746 //test move construction
747 Vector v1(3);
748 v1[0] = 0; v1[1] = 1; v1[2] = 2;
749
750 const auto ptr1 = v1.data();
751 const auto size1 = v1.size();
752
753 Vector v2(std::move(v1));
754 const auto ptr2 = v2.data();
755 const auto size2 = v2.size();
756
757 // ensure v1 was left empty
758 ASSERT_EQUAL(true, v1.empty());
759
760 // ensure v2 received the data from before
761 ASSERT_EQUAL(v2[0], 0);
762 ASSERT_EQUAL(v2[1], 1);
763 ASSERT_EQUAL(v2[2], 2);
764 ASSERT_EQUAL(size1, size2);
765
766 // ensure v2 received the pointer from before
767 ASSERT_EQUAL(ptr1, ptr2);
768
769 //test move assignment
770 Vector v3(3);
771 v3[0] = 3; v3[1] = 4; v3[2] = 5;
772
773 const auto ptr3 = v3.data();
774 const auto size3 = v3.size();
775
776 v2 = std::move(v3);
777 const auto ptr4 = v2.data();
778 const auto size4 = v2.size();
779
780 // ensure v3 was left empty
781 ASSERT_EQUAL(true, v3.empty());
782
783 // ensure v2 received the data from before
784 ASSERT_EQUAL(v2[0], 3);
785 ASSERT_EQUAL(v2[1], 4);
786 ASSERT_EQUAL(v2[2], 5);
787 ASSERT_EQUAL(size3, size4);
788
789 // ensure v2 received the pointer from before
790 ASSERT_EQUAL(ptr3, ptr4);
791 }
792 DECLARE_VECTOR_UNITTEST(TestVectorMove);
793 #endif
794
795