Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

757 lines (554 sloc) 19.766 kB
#include <unittest/unittest.h>
#include <thrust/sequence.h>
#include <thrust/device_malloc_allocator.h>
#include <vector>
#include <list>
#include <limits>
template <class Vector>
void TestVectorZeroSize(void)
{
Vector v;
ASSERT_EQUAL(v.size(), 0);
ASSERT_EQUAL((v.begin() == v.end()), true);
}
DECLARE_VECTOR_UNITTEST(TestVectorZeroSize);
void TestVectorBool(void)
{
thrust::host_vector<bool> h(3);
thrust::device_vector<bool> d(3);
h[0] = true; h[1] = false; h[2] = true;
d[0] = true; d[1] = false; d[2] = true;
ASSERT_EQUAL(h[0], true);
ASSERT_EQUAL(h[1], false);
ASSERT_EQUAL(h[2], true);
ASSERT_EQUAL(d[0], true);
ASSERT_EQUAL(d[1], false);
ASSERT_EQUAL(d[2], true);
}
DECLARE_UNITTEST(TestVectorBool);
template <class Vector>
void TestVectorFrontBack(void)
{
typedef typename Vector::value_type T;
Vector v(3);
v[0] = 0; v[1] = 1; v[2] = 2;
ASSERT_EQUAL(v.front(), 0);
ASSERT_EQUAL(v.back(), 2);
}
DECLARE_VECTOR_UNITTEST(TestVectorFrontBack);
template <class Vector>
void TestVectorData(void)
{
typedef typename Vector::value_type T;
Vector v(3);
v[0] = 0; v[1] = 1; v[2] = 2;
ASSERT_EQUAL(0, *v.data());
ASSERT_EQUAL(1, *(v.data() + 1));
ASSERT_EQUAL(2, *(v.data() + 2));
ASSERT_EQUAL(&v.front(), v.data());
ASSERT_EQUAL(&*v.begin(), v.data());
ASSERT_EQUAL(&v[0], v.data());
const Vector &c_v = v;
ASSERT_EQUAL(0, *c_v.data());
ASSERT_EQUAL(1, *(c_v.data() + 1));
ASSERT_EQUAL(2, *(c_v.data() + 2));
ASSERT_EQUAL(&c_v.front(), c_v.data());
ASSERT_EQUAL(&*c_v.begin(), c_v.data());
ASSERT_EQUAL(&c_v[0], c_v.data());
}
DECLARE_VECTOR_UNITTEST(TestVectorData);
template <class Vector>
void TestVectorElementAssignment(void)
{
typedef typename Vector::value_type T;
Vector v(3);
v[0] = 0; v[1] = 1; v[2] = 2;
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 1);
ASSERT_EQUAL(v[2], 2);
v[0] = 10; v[1] = 11; v[2] = 12;
ASSERT_EQUAL(v[0], 10);
ASSERT_EQUAL(v[1], 11);
ASSERT_EQUAL(v[2], 12);
Vector w(3);
w[0] = v[0];
w[1] = v[1];
w[2] = v[2];
ASSERT_EQUAL(v, w);
}
DECLARE_VECTOR_UNITTEST(TestVectorElementAssignment);
template <class Vector>
void TestVectorFromSTLVector(void)
{
typedef typename Vector::value_type T;
std::vector<T> stl_vector(3);
stl_vector[0] = 0;
stl_vector[1] = 1;
stl_vector[2] = 2;
thrust::host_vector<T> v(stl_vector);
ASSERT_EQUAL(v.size(), 3);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 1);
ASSERT_EQUAL(v[2], 2);
v = stl_vector;
ASSERT_EQUAL(v.size(), 3);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 1);
ASSERT_EQUAL(v[2], 2);
}
DECLARE_VECTOR_UNITTEST(TestVectorFromSTLVector);
template <class Vector>
void TestVectorFillAssign(void)
{
typedef typename Vector::value_type T;
thrust::host_vector<T> v;
v.assign(3, 13);
ASSERT_EQUAL(v.size(), 3);
ASSERT_EQUAL(v[0], 13);
ASSERT_EQUAL(v[1], 13);
ASSERT_EQUAL(v[2], 13);
}
DECLARE_VECTOR_UNITTEST(TestVectorFillAssign);
template <class Vector>
void TestVectorAssignFromSTLVector(void)
{
typedef typename Vector::value_type T;
std::vector<T> stl_vector(3);
stl_vector[0] = 0;
stl_vector[1] = 1;
stl_vector[2] = 2;
thrust::host_vector<T> v;
v.assign(stl_vector.begin(), stl_vector.end());
ASSERT_EQUAL(v.size(), 3);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 1);
ASSERT_EQUAL(v[2], 2);
}
DECLARE_VECTOR_UNITTEST(TestVectorAssignFromSTLVector);
template <class Vector>
void TestVectorFromBiDirectionalIterator(void)
{
typedef typename Vector::value_type T;
std::list<T> stl_list;
stl_list.push_back(0);
stl_list.push_back(1);
stl_list.push_back(2);
thrust::host_vector<int> v(stl_list.begin(), stl_list.end());
ASSERT_EQUAL(v.size(), 3);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 1);
ASSERT_EQUAL(v[2], 2);
}
DECLARE_VECTOR_UNITTEST(TestVectorFromBiDirectionalIterator);
template <class Vector>
void TestVectorAssignFromBiDirectionalIterator(void)
{
typedef typename Vector::value_type T;
std::list<T> stl_list;
stl_list.push_back(0);
stl_list.push_back(1);
stl_list.push_back(2);
Vector v;
v.assign(stl_list.begin(), stl_list.end());
ASSERT_EQUAL(v.size(), 3);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 1);
ASSERT_EQUAL(v[2], 2);
}
DECLARE_VECTOR_UNITTEST(TestVectorAssignFromBiDirectionalIterator);
template <class Vector>
void TestVectorAssignFromHostVector(void)
{
typedef typename Vector::value_type T;
thrust::host_vector<T> h(3);
h[0] = 0;
h[1] = 1;
h[2] = 2;
Vector v;
v.assign(h.begin(), h.end());
ASSERT_EQUAL(v, h);
}
DECLARE_VECTOR_UNITTEST(TestVectorAssignFromHostVector);
template <class Vector>
void TestVectorToAndFromHostVector(void)
{
typedef typename Vector::value_type T;
thrust::host_vector<T> h(3);
h[0] = 0;
h[1] = 1;
h[2] = 2;
Vector v(h);
ASSERT_EQUAL(v, h);
v = v;
ASSERT_EQUAL(v, h);
v[0] = 10;
v[1] = 11;
v[2] = 12;
ASSERT_EQUAL(h[0], 0); ASSERT_EQUAL(v[0], 10);
ASSERT_EQUAL(h[1], 1); ASSERT_EQUAL(v[1], 11);
ASSERT_EQUAL(h[2], 2); ASSERT_EQUAL(v[2], 12);
h = v;
ASSERT_EQUAL(v, h);
h[1] = 11;
v = h;
ASSERT_EQUAL(v, h);
}
DECLARE_VECTOR_UNITTEST(TestVectorToAndFromHostVector);
template <class Vector>
void TestVectorAssignFromDeviceVector(void)
{
typedef typename Vector::value_type T;
thrust::device_vector<T> d(3);
d[0] = 0;
d[1] = 1;
d[2] = 2;
Vector v;
v.assign(d.begin(), d.end());
ASSERT_EQUAL(v, d);
}
DECLARE_VECTOR_UNITTEST(TestVectorAssignFromDeviceVector);
template <class Vector>
void TestVectorToAndFromDeviceVector(void)
{
typedef typename Vector::value_type T;
thrust::device_vector<T> h(3);
h[0] = 0;
h[1] = 1;
h[2] = 2;
Vector v(h);
ASSERT_EQUAL(v, h);
v = v;
ASSERT_EQUAL(v, h);
v[0] = 10;
v[1] = 11;
v[2] = 12;
ASSERT_EQUAL(h[0], 0); ASSERT_EQUAL(v[0], 10);
ASSERT_EQUAL(h[1], 1); ASSERT_EQUAL(v[1], 11);
ASSERT_EQUAL(h[2], 2); ASSERT_EQUAL(v[2], 12);
h = v;
ASSERT_EQUAL(v, h);
h[1] = 11;
v = h;
ASSERT_EQUAL(v, h);
}
DECLARE_VECTOR_UNITTEST(TestVectorToAndFromDeviceVector);
template <class Vector>
void TestVectorWithInitialValue(void)
{
typedef typename Vector::value_type T;
const T init = 17;
Vector v(3, init);
ASSERT_EQUAL(v.size(), 3);
ASSERT_EQUAL(v[0], init);
ASSERT_EQUAL(v[1], init);
ASSERT_EQUAL(v[2], init);
}
DECLARE_VECTOR_UNITTEST(TestVectorWithInitialValue);
template <class Vector>
void TestVectorSwap(void)
{
typedef typename Vector::value_type T;
Vector v(3);
v[0] = 0; v[1] = 1; v[2] = 2;
Vector u(3);
u[0] = 10; u[1] = 11; u[2] = 12;
v.swap(u);
ASSERT_EQUAL(v[0], 10); ASSERT_EQUAL(u[0], 0);
ASSERT_EQUAL(v[1], 11); ASSERT_EQUAL(u[1], 1);
ASSERT_EQUAL(v[2], 12); ASSERT_EQUAL(u[2], 2);
}
DECLARE_VECTOR_UNITTEST(TestVectorSwap);
template <class Vector>
void TestVectorErasePosition(void)
{
typedef typename Vector::value_type T;
Vector v(5);
v[0] = 0; v[1] = 1; v[2] = 2; v[3] = 3; v[4] = 4;
v.erase(v.begin() + 2);
ASSERT_EQUAL(v.size(), 4);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 1);
ASSERT_EQUAL(v[2], 3);
ASSERT_EQUAL(v[3], 4);
v.erase(v.begin() + 0);
ASSERT_EQUAL(v.size(), 3);
ASSERT_EQUAL(v[0], 1);
ASSERT_EQUAL(v[1], 3);
ASSERT_EQUAL(v[2], 4);
v.erase(v.begin() + 2);
ASSERT_EQUAL(v.size(), 2);
ASSERT_EQUAL(v[0], 1);
ASSERT_EQUAL(v[1], 3);
v.erase(v.begin() + 1);
ASSERT_EQUAL(v.size(), 1);
ASSERT_EQUAL(v[0], 1);
v.erase(v.begin() + 0);
ASSERT_EQUAL(v.size(), 0);
}
DECLARE_VECTOR_UNITTEST(TestVectorErasePosition);
template <class Vector>
void TestVectorEraseRange(void)
{
typedef typename Vector::value_type T;
Vector v(6);
v[0] = 0; v[1] = 1; v[2] = 2; v[3] = 3; v[4] = 4; v[5] = 5;
v.erase(v.begin() + 1, v.begin() + 3);
ASSERT_EQUAL(v.size(), 4);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 3);
ASSERT_EQUAL(v[2], 4);
ASSERT_EQUAL(v[3], 5);
v.erase(v.begin() + 2, v.end());
ASSERT_EQUAL(v.size(), 2);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 3);
v.erase(v.begin() + 0, v.begin() + 1);
ASSERT_EQUAL(v.size(), 1);
ASSERT_EQUAL(v[0], 3);
v.erase(v.begin(), v.end());
ASSERT_EQUAL(v.size(), 0);
}
DECLARE_VECTOR_UNITTEST(TestVectorEraseRange);
void TestVectorEquality(void)
{
thrust::host_vector<int> h_a(3);
thrust::host_vector<int> h_b(3);
thrust::host_vector<int> h_c(3);
h_a[0] = 0; h_a[1] = 1; h_a[2] = 2;
h_b[0] = 0; h_b[1] = 1; h_b[2] = 3;
h_b[0] = 0; h_b[1] = 1;
thrust::device_vector<int> d_a(3);
thrust::device_vector<int> d_b(3);
thrust::device_vector<int> d_c(3);
d_a[0] = 0; d_a[1] = 1; d_a[2] = 2;
d_b[0] = 0; d_b[1] = 1; d_b[2] = 3;
d_b[0] = 0; d_b[1] = 1;
std::vector<int> s_a(3);
std::vector<int> s_b(3);
std::vector<int> s_c(3);
s_a[0] = 0; s_a[1] = 1; s_a[2] = 2;
s_b[0] = 0; s_b[1] = 1; s_b[2] = 3;
s_b[0] = 0; s_b[1] = 1;
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);
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);
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);
// test vector vs device_vector
ASSERT_EQUAL((s_a == d_a), true); ASSERT_EQUAL((d_a == s_a), true);
ASSERT_EQUAL((s_b == d_b), true); ASSERT_EQUAL((d_b == s_b), true);
ASSERT_EQUAL((s_c == d_c), true); ASSERT_EQUAL((d_c == s_c), true);
// test vector vs host_vector
ASSERT_EQUAL((s_a == h_a), true); ASSERT_EQUAL((h_a == s_a), true);
ASSERT_EQUAL((s_b == h_b), true); ASSERT_EQUAL((h_b == s_b), true);
ASSERT_EQUAL((s_c == h_c), true); ASSERT_EQUAL((h_c == s_c), true);
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);
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);
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);
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);
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);
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);
// test vector vs device_vector
ASSERT_EQUAL((s_a == d_b), false); ASSERT_EQUAL((d_a == s_b), false);
ASSERT_EQUAL((s_b == d_a), false); ASSERT_EQUAL((d_b == s_a), false);
ASSERT_EQUAL((s_a == d_c), false); ASSERT_EQUAL((d_a == s_c), false);
ASSERT_EQUAL((s_c == d_a), false); ASSERT_EQUAL((d_c == s_a), false);
ASSERT_EQUAL((s_b == d_c), false); ASSERT_EQUAL((d_b == s_c), false);
ASSERT_EQUAL((s_c == d_b), false); ASSERT_EQUAL((d_c == s_b), false);
// test vector vs host_vector
ASSERT_EQUAL((s_a == h_b), false); ASSERT_EQUAL((h_a == s_b), false);
ASSERT_EQUAL((s_b == h_a), false); ASSERT_EQUAL((h_b == s_a), false);
ASSERT_EQUAL((s_a == h_c), false); ASSERT_EQUAL((h_a == s_c), false);
ASSERT_EQUAL((s_c == h_a), false); ASSERT_EQUAL((h_c == s_a), false);
ASSERT_EQUAL((s_b == h_c), false); ASSERT_EQUAL((h_b == s_c), false);
ASSERT_EQUAL((s_c == h_b), false); ASSERT_EQUAL((h_c == s_b), false);
}
DECLARE_UNITTEST(TestVectorEquality);
void TestVectorInequality(void)
{
thrust::host_vector<int> h_a(3);
thrust::host_vector<int> h_b(3);
thrust::host_vector<int> h_c(3);
h_a[0] = 0; h_a[1] = 1; h_a[2] = 2;
h_b[0] = 0; h_b[1] = 1; h_b[2] = 3;
h_b[0] = 0; h_b[1] = 1;
thrust::device_vector<int> d_a(3);
thrust::device_vector<int> d_b(3);
thrust::device_vector<int> d_c(3);
d_a[0] = 0; d_a[1] = 1; d_a[2] = 2;
d_b[0] = 0; d_b[1] = 1; d_b[2] = 3;
d_b[0] = 0; d_b[1] = 1;
std::vector<int> s_a(3);
std::vector<int> s_b(3);
std::vector<int> s_c(3);
s_a[0] = 0; s_a[1] = 1; s_a[2] = 2;
s_b[0] = 0; s_b[1] = 1; s_b[2] = 3;
s_b[0] = 0; s_b[1] = 1;
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);
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);
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);
// test vector vs device_vector
ASSERT_EQUAL((s_a != d_a), false); ASSERT_EQUAL((d_a != s_a), false);
ASSERT_EQUAL((s_b != d_b), false); ASSERT_EQUAL((d_b != s_b), false);
ASSERT_EQUAL((s_c != d_c), false); ASSERT_EQUAL((d_c != s_c), false);
// test vector vs host_vector
ASSERT_EQUAL((s_a != h_a), false); ASSERT_EQUAL((h_a != s_a), false);
ASSERT_EQUAL((s_b != h_b), false); ASSERT_EQUAL((h_b != s_b), false);
ASSERT_EQUAL((s_c != h_c), false); ASSERT_EQUAL((h_c != s_c), false);
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);
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);
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);
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);
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);
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);
// test vector vs device_vector
ASSERT_EQUAL((s_a != d_b), true); ASSERT_EQUAL((d_a != s_b), true);
ASSERT_EQUAL((s_b != d_a), true); ASSERT_EQUAL((d_b != s_a), true);
ASSERT_EQUAL((s_a != d_c), true); ASSERT_EQUAL((d_a != s_c), true);
ASSERT_EQUAL((s_c != d_a), true); ASSERT_EQUAL((d_c != s_a), true);
ASSERT_EQUAL((s_b != d_c), true); ASSERT_EQUAL((d_b != s_c), true);
ASSERT_EQUAL((s_c != d_b), true); ASSERT_EQUAL((d_c != s_b), true);
// test vector vs host_vector
ASSERT_EQUAL((s_a != h_b), true); ASSERT_EQUAL((h_a != s_b), true);
ASSERT_EQUAL((s_b != h_a), true); ASSERT_EQUAL((h_b != s_a), true);
ASSERT_EQUAL((s_a != h_c), true); ASSERT_EQUAL((h_a != s_c), true);
ASSERT_EQUAL((s_c != h_a), true); ASSERT_EQUAL((h_c != s_a), true);
ASSERT_EQUAL((s_b != h_c), true); ASSERT_EQUAL((h_b != s_c), true);
ASSERT_EQUAL((s_c != h_b), true); ASSERT_EQUAL((h_c != s_b), true);
}
DECLARE_UNITTEST(TestVectorInequality);
template <class Vector>
void TestVectorResizing(void)
{
typedef typename Vector::value_type T;
Vector v;
v.resize(3);
ASSERT_EQUAL(v.size(), 3);
v[0] = 0; v[1] = 1; v[2] = 2;
v.resize(5);
ASSERT_EQUAL(v.size(), 5);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 1);
ASSERT_EQUAL(v[2], 2);
v[3] = 3; v[4] = 4;
v.resize(4);
ASSERT_EQUAL(v.size(), 4);
ASSERT_EQUAL(v[0], 0);
ASSERT_EQUAL(v[1], 1);
ASSERT_EQUAL(v[2], 2);
ASSERT_EQUAL(v[3], 3);
v.resize(0);
ASSERT_EQUAL(v.size(), 0);
// TODO remove this WAR
#if defined(__CUDACC__) && CUDA_VERSION==3000
// depending on sizeof(T), we will receive one
// of two possible exceptions
try
{
v.resize(std::numeric_limits<size_t>::max());
}
catch(std::length_error e) {}
catch(std::bad_alloc e)
{
// reset the CUDA error
cudaGetLastError();
} // end catch
#endif // defined(__CUDACC__) && CUDA_VERSION==3000
ASSERT_EQUAL(v.size(), 0);
}
DECLARE_VECTOR_UNITTEST(TestVectorResizing);
template <class Vector>
void TestVectorReserving(void)
{
typedef typename Vector::value_type T;
Vector v;
v.reserve(3);
ASSERT_GEQUAL(v.capacity(), 3);
size_t old_capacity = v.capacity();
v.reserve(0);
ASSERT_EQUAL(v.capacity(), old_capacity);
// TODO remove this WAR
#if defined(__CUDACC__) && CUDA_VERSION==3000
try
{
v.reserve(std::numeric_limits<size_t>::max());
}
catch(std::length_error e) {}
catch(std::bad_alloc e) {}
#endif // defined(__CUDACC__) && CUDA_VERSION==3000
ASSERT_EQUAL(v.capacity(), old_capacity);
}
DECLARE_VECTOR_UNITTEST(TestVectorReserving)
template <class Vector>
void TestVectorShrinkToFit(void)
{
typedef typename Vector::value_type T;
Vector v;
v.reserve(200);
ASSERT_GEQUAL(v.capacity(), 200);
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.shrink_to_fit();
ASSERT_EQUAL(1, v[0]);
ASSERT_EQUAL(2, v[1]);
ASSERT_EQUAL(3, v[2]);
ASSERT_EQUAL(3, v.size());
ASSERT_EQUAL(3, v.capacity());
}
DECLARE_VECTOR_UNITTEST(TestVectorShrinkToFit)
template <int N>
struct LargeStruct
{
int data[N];
__host__ __device__
bool operator==(const LargeStruct & ls) const
{
for (int i = 0; i < N; i++)
if (data[i] != ls.data[i])
return false;
return true;
}
};
void TestVectorContainingLargeType(void)
{
// Thrust issue #5
// http://code.google.com/p/thrust/issues/detail?id=5
const static int N = 100;
typedef LargeStruct<N> T;
thrust::device_vector<T> dv1;
thrust::host_vector<T> hv1;
ASSERT_EQUAL_QUIET(dv1, hv1);
thrust::device_vector<T> dv2(20);
thrust::host_vector<T> hv2(20);
ASSERT_EQUAL_QUIET(dv2, hv2);
// initialize tofirst element to something nonzero
T ls;
for (int i = 0; i < N; i++)
ls.data[i] = i;
thrust::device_vector<T> dv3(20, ls);
thrust::host_vector<T> hv3(20, ls);
ASSERT_EQUAL_QUIET(dv3, hv3);
// change first element
ls.data[0] = -13;
dv3[2] = ls;
hv3[2] = ls;
ASSERT_EQUAL_QUIET(dv3, hv3);
}
DECLARE_UNITTEST(TestVectorContainingLargeType);
template <typename Vector>
void TestVectorReversed(void)
{
Vector v(3);
typedef typename Vector::value_type T;
v[0] = 0; v[1] = 1; v[2] = 2;
ASSERT_EQUAL(3, v.rend() - v.rbegin());
ASSERT_EQUAL(3, static_cast<const Vector&>(v).rend() - static_cast<const Vector&>(v).rbegin());
ASSERT_EQUAL(3, v.crend() - v.crbegin());
ASSERT_EQUAL(2, *v.rbegin());
ASSERT_EQUAL(2, *static_cast<const Vector&>(v).rbegin());
ASSERT_EQUAL(2, *v.crbegin());
ASSERT_EQUAL(1, *(v.rbegin() + 1));
ASSERT_EQUAL(0, *(v.rbegin() + 2));
ASSERT_EQUAL(0, *(v.rend() - 1));
ASSERT_EQUAL(1, *(v.rend() - 2));
}
DECLARE_VECTOR_UNITTEST(TestVectorReversed);
Jump to Line
Something went wrong with that request. Please try again.