dylanyunlong/project_6
1
0
Fork 0
Code Issues Pull Requests Actions Projects Releases Wiki Activity
Files
900ae0b1efc19e46cd313eb3ba7eb694fa596f6b
project_6/cccl_upstream/thrust/testing/unittest/assertions.h
EngineX CI 56fd68e7dd [INFRA] Import NVIDIA/CCCL upstream as optimization reference library 
CCCL (CUDA C++ Core Libraries) provides:
- CUB: device/block/warp-level GPU primitives (reduce, scan, sort, topk)
- Thrust: high-level parallel algorithms (transform_reduce, sort, scan)
- libcudacxx: CUDA C++ standard library (atomics, barriers, memory)
- cudax: experimental features (memory resources, allocators)
- Tuning policies: per-SM hardware-specific algorithm parameters

Competition optimization vectors mapped to CCCL:
- Output TPS (83% weight): warp_reduce, block_reduce, device_topk
- Input TPS (14% weight): device_scan, block_load, prefetch
- Cache TPS (3% weight): prefix caching strategy patterns
- Memory (0.9 util): pooled/cached/buddy allocators

Source: https://github.com/NVIDIA/cccl (shallow clone, HEAD only)
License: Apache-2.0
2026-07-30 09:35:51 +00:00

768 lines
28 KiB
C++
Raw Blame History

#pragma once
#include <thrust/complex.h>
#include <thrust/detail/type_traits.h>
#include <thrust/device_vector.h>
#include <thrust/host_vector.h>
#include <thrust/iterator/iterator_traits.h>
#include <thrust/universal_vector.h>
#include <cuda/std/utility>
#include <unittest/exceptions.h>
#include <unittest/util.h>
#define ASSERT_EQUAL_WITH_FILE_AND_LINE(X, Y, FILE_, LINE_) unittest::assert_equal((X), (Y), FILE_, LINE_)
#define ASSERT_EQUAL_QUIET_WITH_FILE_AND_LINE(X, Y, FILE_, LINE_) unittest::assert_equal_quiet((X), (Y), FILE_, LINE_)
#define ASSERT_NOT_EQUAL_WITH_FILE_AND_LINE(X, Y, FILE_, LINE_) unittest::assert_not_equal((X), (Y), FILE_, LINE_)
#define ASSERT_NOT_EQUAL_QUIET_WITH_FILE_AND_LINE(X, Y, FILE_, LINE_) \
unittest::assert_not_equal_quiet((X), (Y), FILE_, LINE_)
#define ASSERT_LEQUAL_WITH_FILE_AND_LINE(X, Y, FILE_, LINE_) unittest::assert_lequal((X), (Y), FILE_, LINE_)
#define ASSERT_GEQUAL_WITH_FILE_AND_LINE(X, Y, FILE_, LINE_) unittest::assert_gequal((X), (Y), FILE_, LINE_)
#define ASSERT_LESS_WITH_FILE_AND_LINE(X, Y, FILE_, LINE_) unittest::assert_less((X), (Y), FILE_, LINE_)
#define ASSERT_GREATER_WITH_FILE_AND_LINE(X, Y, FILE_, LINE_) unittest::assert_greater((X), (Y), FILE_, LINE_)
#define ASSERT_ALMOST_EQUAL_WITH_FILE_AND_LINE(X, Y, FILE_, LINE_) unittest::assert_almost_equal((X), (Y), FILE_, LINE_)
#define ASSERT_EQUAL_RANGES_WITH_FILE_AND_LINE(X, Y, Z, FILE_, LINE_) \
unittest::assert_equal((X), (Y), (Z), FILE_, LINE_)
#define ASSERT_THROWS_WITH_FILE_AND_LINE(EXPR, EXCEPTION_TYPE, FILE_, LINE_) \
{ \
unittest::threw_status THRUST_PP_CAT2(__s, LINE_) = unittest::did_not_throw; \
try \
{ \
EXPR; \
} \
catch (EXCEPTION_TYPE const&) \
{ \
THRUST_PP_CAT2(__s, LINE_) = unittest::threw_right_type; \
} \
catch (...) \
{ \
THRUST_PP_CAT2(__s, LINE_) = unittest::threw_wrong_type; \
} \
unittest::check_assert_throws(THRUST_PP_CAT2(__s, LINE_), THRUST_PP_STRINGIZE(EXCEPTION_TYPE), FILE_, LINE_); \
} \
/**/
#define ASSERT_THROWS_EQUAL_WITH_FILE_AND_LINE(EXPR, EXCEPTION_TYPE, VALUE, FILE_, LINE_) \
{ \
unittest::threw_status THRUST_PP_CAT2(__s, LINE_) = unittest::did_not_throw; \
try \
{ \
EXPR; \
} \
catch (EXCEPTION_TYPE const& THRUST_PP_CAT2(__e, LINE_)) \
{ \
if (VALUE == THRUST_PP_CAT2(__e, LINE_)) \
THRUST_PP_CAT2(__s, LINE_) = unittest::threw_right_type; \
else \
THRUST_PP_CAT2(__s, LINE_) = unittest::threw_right_type_but_wrong_value; \
} \
catch (...) \
{ \
THRUST_PP_CAT2(__s, LINE_) = unittest::threw_wrong_type; \
} \
unittest::check_assert_throws(THRUST_PP_CAT2(__s, LINE_), THRUST_PP_STRINGIZE(EXCEPTION_TYPE), FILE_, LINE_); \
} \
/**/
#define KNOWN_FAILURE_WITH_FILE_AND_LINE(FILE_, LINE_) \
{ \
unittest::UnitTestKnownFailure f; \
f << "[" << FILE_ ":" << LINE_ << "]"; \
throw f; \
} \
/**/
#define ASSERT_EQUAL(X, Y) ASSERT_EQUAL_WITH_FILE_AND_LINE((X), (Y), __FILE__, __LINE__)
#define ASSERT_EQUAL_QUIET(X, Y) ASSERT_EQUAL_QUIET_WITH_FILE_AND_LINE((X), (Y), __FILE__, __LINE__)
#define ASSERT_NOT_EQUAL(X, Y) ASSERT_NOT_EQUAL_WITH_FILE_AND_LINE((X), (Y), __FILE__, __LINE__)
#define ASSERT_NOT_EQUAL_QUIET(X, Y) ASSERT_NOT_EQUAL_QUIET_WITH_FILE_AND_LINE((X), (Y), __FILE__, __LINE__)
#define ASSERT_LEQUAL(X, Y) ASSERT_LEQUAL_WITH_FILE_AND_LINE((X), (Y), __FILE__, __LINE__)
#define ASSERT_GEQUAL(X, Y) ASSERT_GEQUAL_WITH_FILE_AND_LINE((X), (Y), __FILE__, __LINE__)
#define ASSERT_LESS(X, Y) ASSERT_LESS_WITH_FILE_AND_LINE((X), (Y), __FILE__, __LINE__)
#define ASSERT_GREATER(X, Y) ASSERT_GREATER_WITH_FILE_AND_LINE((X), (Y), __FILE__, __LINE__)
#define ASSERT_ALMOST_EQUAL(X, Y) ASSERT_ALMOST_EQUAL_WITH_FILE_AND_LINE((X), (Y), __FILE__, __LINE__)
#define ASSERT_EQUAL_RANGES(X, Y, Z) ASSERT_EQUAL_WITH_FILE_AND_LINE((X), (Y), (Z), __FILE__, __LINE__)
#define ASSERT_THROWS(EXPR, EXCEPTION_TYPE) \
ASSERT_THROWS_WITH_FILE_AND_LINE(EXPR, EXCEPTION_TYPE, __FILE__, __LINE__) \
/**/
#define ASSERT_THROWS_EQUAL(EXPR, EXCEPTION_TYPE, VALUE) \
ASSERT_THROWS_EQUAL_WITH_FILE_AND_LINE(EXPR, EXCEPTION_TYPE, VALUE, __FILE__, __LINE__) \
/**/
#define KNOWN_FAILURE KNOWN_FAILURE_WITH_FILE_AND_LINE(__FILE__, __LINE__)
namespace unittest
{
size_t const MAX_OUTPUT_LINES = 10;
double const DEFAULT_RELATIVE_TOL = 1e-4;
double const DEFAULT_ABSOLUTE_TOL = 1e-4;
template <typename T>
struct value_type
{
using type = ::cuda::std::remove_const_t<::cuda::std::remove_reference_t<T>>;
};
template <typename T>
struct value_type<THRUST_NS_QUALIFIER::device_reference<T>>
{
using type = typename value_type<T>::type;
};
////
// check scalar values
template <typename T1, typename T2>
void assert_equal(T1 a, T2 b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a == b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << "values are not equal: " << a << " " << b;
f << " [type='" << type_name<T1>() << "']";
throw f;
}
}
void assert_equal(char a, char b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a == b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << "values are not equal: " << int(a) << " " << int(b);
f << " [type='" << type_name<char>() << "']";
throw f;
}
}
// sometimes its not possible to << a type
template <typename T1, typename T2>
void assert_equal_quiet(const T1& a, const T2& b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a == b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << "values are not equal";
f << " [type='" << type_name<T1>() << "']";
throw f;
}
}
////
// check scalar values
template <typename T1, typename T2>
void assert_not_equal(T1 a, T2 b, const std::string& filename = "unknown", int lineno = -1)
{
if (a == b)
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << "values are equal: " << a << " " << b;
f << " [type='" << type_name<T1>() << "']";
throw f;
}
}
void assert_not_equal(char a, char b, const std::string& filename = "unknown", int lineno = -1)
{
if (a == b)
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << "values are equal: " << int(a) << " " << int(b);
f << " [type='" << type_name<char>() << "']";
throw f;
}
}
// sometimes its not possible to << a type
template <typename T1, typename T2>
void assert_not_equal_quiet(const T1& a, const T2& b, const std::string& filename = "unknown", int lineno = -1)
{
if (a == b)
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << "values are equal";
f << " [type='" << type_name<T1>() << "']";
throw f;
}
}
template <typename T1, typename T2>
void assert_less(T1 a, T2 b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a < b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << a << " is greater or equal to " << b;
f << " [type='" << type_name<T1>() << "']";
throw f;
}
}
void assert_less(char a, char b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a < b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << int(a) << " is greater than or equal to " << int(b);
f << " [type='" << type_name<char>() << "']";
throw f;
}
}
template <typename T1, typename T2>
void assert_greater(T1 a, T2 b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a > b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << a << " is less than or equal to " << b;
f << " [type='" << type_name<T1>() << "']";
throw f;
}
}
void assert_greater(char a, char b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a > b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << int(a) << " is less than or equal to " << int(b);
f << " [type='" << type_name<char>() << "']";
throw f;
}
}
template <typename T1, typename T2>
void assert_lequal(T1 a, T2 b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a <= b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << a << " is greater than " << b;
f << " [type='" << type_name<T1>() << "']";
throw f;
}
}
void assert_lequal(char a, char b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a <= b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << int(a) << " is greater than " << int(b);
f << " [type='" << type_name<char>() << "']";
throw f;
}
}
template <typename T1, typename T2>
void assert_gequal(T1 a, T2 b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a >= b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << a << " is less than " << b;
f << " [type='" << type_name<T1>() << "']";
throw f;
}
}
void assert_gequal(char a, char b, const std::string& filename = "unknown", int lineno = -1)
{
if (!(a >= b))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << int(a) << " is less than " << int(b);
f << " [type='" << type_name<char>() << "']";
throw f;
}
}
// will catch everything implicitly convertible to a double
bool almost_equal(double a, double b, double a_tol, double r_tol)
{
if (std::abs(a - b) > r_tol * (std::abs(a) + std::abs(b)) + a_tol)
{
return false;
}
else
{
return true;
}
}
namespace
{ // anonymous namespace
template <typename>
struct is_complex : public THRUST_NS_QUALIFIER::false_type
{};
template <typename T>
struct is_complex<THRUST_NS_QUALIFIER::complex<T>> : public THRUST_NS_QUALIFIER::true_type
{};
template <typename T>
struct is_complex<std::complex<T>> : public THRUST_NS_QUALIFIER::true_type
{};
} // namespace
template <typename T1, typename T2>
inline ::cuda::std::enable_if_t<is_complex<T1>::value && is_complex<T2>::value, bool>
almost_equal(const T1& a, const T2& b, double a_tol, double r_tol)
{
return almost_equal(a.real(), b.real(), a_tol, r_tol) && almost_equal(a.imag(), b.imag(), a_tol, r_tol);
}
template <typename T1, typename T2>
void assert_almost_equal(
T1 a,
T2 b,
const std::string& filename = "unknown",
int lineno = -1,
double a_tol = DEFAULT_ABSOLUTE_TOL,
double r_tol = DEFAULT_RELATIVE_TOL)
{
if (!almost_equal(a, b, a_tol, r_tol))
{
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
f << "values are not approximately equal: " << a << " " << b;
f << " [type='" << type_name<T1>() << "']";
throw f;
}
}
template <typename T>
class almost_equal_to
{
public:
double a_tol, r_tol;
almost_equal_to(double _a_tol = DEFAULT_ABSOLUTE_TOL, double _r_tol = DEFAULT_RELATIVE_TOL)
: a_tol(_a_tol)
, r_tol(_r_tol)
{}
bool operator()(const T& a, const T& b) const
{
return almost_equal((double) a, (double) b, a_tol, r_tol);
}
};
template <typename T>
class almost_equal_to<THRUST_NS_QUALIFIER::complex<T>>
{
public:
double a_tol, r_tol;
almost_equal_to(double _a_tol = DEFAULT_ABSOLUTE_TOL, double _r_tol = DEFAULT_RELATIVE_TOL)
: a_tol(_a_tol)
, r_tol(_r_tol)
{}
bool operator()(const THRUST_NS_QUALIFIER::complex<T>& a, const THRUST_NS_QUALIFIER::complex<T>& b) const
{
return almost_equal((double) a.real(), (double) b.real(), a_tol, r_tol)
&& almost_equal((double) a.imag(), (double) b.imag(), a_tol, r_tol);
}
};
////
// check sequences
inline int promote_char(char c)
{
return c;
}
template <typename T>
T&& promote_char(T&& t)
{
return ::cuda::std::forward<T>(t);
}
template <typename ForwardIterator1, typename ForwardIterator2, typename BinaryPredicate>
void assert_equal(
ForwardIterator1 first1,
ForwardIterator1 last1,
ForwardIterator2 first2,
ForwardIterator2 last2,
BinaryPredicate op,
const std::string& filename = "unknown",
int lineno = -1)
{
using difference_type = THRUST_NS_QUALIFIER::detail::it_difference_t<ForwardIterator1>;
using InputType = THRUST_NS_QUALIFIER::detail::it_value_t<ForwardIterator1>;
bool failure = false;
difference_type length1 = ::cuda::std::distance(first1, last1);
difference_type length2 = ::cuda::std::distance(first2, last2);
difference_type min_length = ::cuda::std::min(length1, length2);
unittest::UnitTestFailure f;
f << "[" << filename << ":" << lineno << "] ";
// check lengths
if (length1 != length2)
{
failure = true;
f << "Sequences have different sizes (" << length1 << " != " << length2 << ")\n";
}
// check values
size_t mismatches = 0;
for (difference_type i = 0; i < min_length; i++)
{
if (!op(*first1, *first2))
{
if (mismatches == 0)
{
failure = true;
f << "Sequences are not equal [type='" << type_name<InputType>() << "']\n";
f << "--------------------------------\n";
}
mismatches++;
if (mismatches <= MAX_OUTPUT_LINES)
{
f << " [" << i << "] " << promote_char(*first1) << " " << promote_char(*first2) << "\n";
}
}
first1++;
first2++;
}
if (mismatches > 0)
{
if (mismatches > MAX_OUTPUT_LINES)
{
f << " (output limit reached)\n";
}
f << "--------------------------------\n";
f << "Sequences differ at " << mismatches << " of " << min_length << " positions"
<< "\n";
}
else if (length1 != length2)
{
f << "Sequences agree through " << min_length << " positions [type='" << type_name<InputType>() << "']\n";
}
if (failure)
{
throw f;
}
}
template <typename ForwardIterator1, typename ForwardIterator2>
void assert_equal(
ForwardIterator1 first1,
ForwardIterator1 last1,
ForwardIterator2 first2,
ForwardIterator2 last2,
const std::string& filename = "unknown",
int lineno = -1)
{
using InputType = typename ::cuda::std::iterator_traits<ForwardIterator1>::value_type;
assert_equal(first1, last1, first2, last2, cuda::std::equal_to<InputType>(), filename, lineno);
}
template <typename ForwardIterator1, typename ForwardIterator2>
void assert_almost_equal(
ForwardIterator1 first1,
ForwardIterator1 last1,
ForwardIterator2 first2,
ForwardIterator2 last2,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
using InputType = typename ::cuda::std::iterator_traits<ForwardIterator1>::value_type;
assert_equal(first1, last1, first2, last2, almost_equal_to<InputType>(a_tol, r_tol), filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const THRUST_NS_QUALIFIER::host_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::host_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
assert_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const THRUST_NS_QUALIFIER::host_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::device_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
THRUST_NS_QUALIFIER::host_vector<T, Alloc1> B_host = B;
assert_equal(A, B_host, filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const THRUST_NS_QUALIFIER::device_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::host_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
THRUST_NS_QUALIFIER::host_vector<T, Alloc2> A_host = A;
assert_equal(A_host, B, filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const THRUST_NS_QUALIFIER::device_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::device_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
THRUST_NS_QUALIFIER::host_vector<T> A_host = A;
THRUST_NS_QUALIFIER::host_vector<T> B_host = B;
assert_equal(A_host, B_host, filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const THRUST_NS_QUALIFIER::universal_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::universal_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
assert_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const THRUST_NS_QUALIFIER::host_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::universal_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
assert_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const THRUST_NS_QUALIFIER::universal_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::host_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
assert_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const THRUST_NS_QUALIFIER::device_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::universal_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
THRUST_NS_QUALIFIER::host_vector<T, Alloc1> A_host = A;
assert_equal(A_host, B, filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const THRUST_NS_QUALIFIER::universal_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::device_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
THRUST_NS_QUALIFIER::host_vector<T, Alloc1> B_host = B;
assert_equal(A, B_host, filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_equal(const std::vector<T, Alloc1>& A,
const std::vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1)
{
assert_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const THRUST_NS_QUALIFIER::host_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::host_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
assert_almost_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno, a_tol, r_tol);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const THRUST_NS_QUALIFIER::host_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::device_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
THRUST_NS_QUALIFIER::host_vector<T, Alloc1> B_host = B;
assert_almost_equal(A, B_host, filename, lineno, a_tol, r_tol);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const THRUST_NS_QUALIFIER::device_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::host_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
THRUST_NS_QUALIFIER::host_vector<T, Alloc2> A_host = A;
assert_almost_equal(A_host, B, filename, lineno, a_tol, r_tol);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const THRUST_NS_QUALIFIER::device_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::device_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
THRUST_NS_QUALIFIER::host_vector<T> A_host = A;
THRUST_NS_QUALIFIER::host_vector<T> B_host = B;
assert_almost_equal(A_host, B_host, filename, lineno, a_tol, r_tol);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const THRUST_NS_QUALIFIER::universal_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::universal_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
assert_almost_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno, a_tol, r_tol);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const THRUST_NS_QUALIFIER::host_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::universal_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
assert_almost_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno, a_tol, r_tol);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const THRUST_NS_QUALIFIER::universal_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::host_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
assert_almost_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno, a_tol, r_tol);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const THRUST_NS_QUALIFIER::device_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::universal_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
THRUST_NS_QUALIFIER::host_vector<T, Alloc1> A_host = A;
assert_almost_equal(A_host, B, filename, lineno, a_tol, r_tol);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const THRUST_NS_QUALIFIER::universal_vector<T, Alloc1>& A,
const THRUST_NS_QUALIFIER::device_vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
THRUST_NS_QUALIFIER::host_vector<T, Alloc1> B_host = B;
assert_almost_equal(A, B_host, filename, lineno, a_tol, r_tol);
}
template <typename T, typename Alloc1, typename Alloc2>
void assert_almost_equal(
const std::vector<T, Alloc1>& A,
const std::vector<T, Alloc2>& B,
const std::string& filename = "unknown",
int lineno = -1,
const double a_tol = DEFAULT_ABSOLUTE_TOL,
const double r_tol = DEFAULT_RELATIVE_TOL)
{
assert_almost_equal(A.begin(), A.end(), B.begin(), B.end(), filename, lineno, a_tol, r_tol);
}
enum threw_status
{
did_not_throw,
threw_wrong_type,
threw_right_type_but_wrong_value,
threw_right_type
};
void check_assert_throws(
threw_status s, std::string const& exception_name, std::string const& file_name = "unknown", int line_number = -1)
{
switch (s)
{
case did_not_throw: {
unittest::UnitTestFailure f;
f << "[" << file_name << ":" << line_number << "] did not throw anything";
throw f;
}
case threw_wrong_type: {
unittest::UnitTestFailure f;
f << "[" << file_name << ":" << line_number << "] did not throw an "
<< "object of type " << exception_name;
throw f;
}
case threw_right_type_but_wrong_value: {
unittest::UnitTestFailure f;
f << "[" << file_name << ":" << line_number << "] threw an object of the "
<< "correct type (" << exception_name << ") but wrong value";
throw f;
}
case threw_right_type:
break;
default: {
unittest::UnitTestFailure f;
f << "[" << file_name << ":" << line_number << "] encountered an "
<< "unknown error";
throw f;
}
}
}
}; // end namespace unittest
Reference in New Issue View Git Blame Copy Permalink