nerdcruft/libcruft-util
1
0
Fork 0
Code Issues Releases Activity

Make all check macros uppercase

Browse Source
This commit is contained in:
Danny Robson 2012-05-11 12:34:21 +10:00
parent c1ba948b20
commit 4f5d75a1df
34 changed files with 242 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
backtrace_execinfo.cpp
View File

@ -17,7 +17,7 @@ debug::backtrace::backtrace (void):
while ((final = ::backtrace (&m_frames[0], m_frames.size ())) == m_frames.size ())
m_frames.resize (m_frames.size () * 2);
check_hard (final > 0);
CHECK_HARD (final > 0);
m_frames.resize ((unsigned)final);
}

32
debug.hpp
View File

@ -37,38 +37,38 @@ do { \
#define DEBUG_ONLY(X)
#endif
#define trace { \
#define TRACE { \
std::cerr << __FILE__ << ":" << __func__ << ":" << __LINE__ << std::endl; \
}
#define warn(MSG) do { \
#define WARN(MSG) do { \
std::cerr << __FILE__ << ":" << __func__ << ":" __LINE__ << ", " << (MSG) << std::endl; \
} while (0)
#define warn_if(C, MSG) do { \
#define WARN_IF(C, MSG) do { \
if (C) { \
std::cerr << __FILE__ << ":" << __func__ << ":" __LINE__ << ", " << (MSG) << std::endl; \
} \
} while (0)
#define verify_soft(C, COND) ({ \
#define VERIFY_SOFT(C, COND) ({ \
const auto __DEBUG_value = (C); \
check_soft(__DEBUG_value COND); \
CHECK_SOFT(__DEBUG_value COND); \
__DEBUG_value; \
})
#define verify_hard(C, COND) ({ \
#define VERIFY_HARD(C, COND) ({ \
const auto __DEBUG_value = (C); \
check_hard(__DEBUG_value COND); \
CHECK_HARD(__DEBUG_value COND); \
__DEBUG_value; \
})
#define _check_meta(C, SUCCESS, FAILURE) do { \
#define _CHECK_META(C, SUCCESS, FAILURE) do { \
const auto __DEBUG_value = (C); \
if (unlikely (!__DEBUG_value)) { \
std::cerr << PACKAGE << ": " \
@ -85,14 +85,14 @@ do { \
} while (0)
#define check_hard(C) _check_meta((C), { ; }, { panic (); })
#define check_soft(C) _check_meta((C), { ; }, { breakpoint (); })
#define CHECK_HARD(C) _CHECK_META((C), { ; }, { panic (); })
#define CHECK_SOFT(C) _CHECK_META((C), { ; }, { breakpoint (); })
#define check_eq(A,B) do { \
#define CHECK_EQ(A,B) do { \
const auto __a = (A); \
const auto __b = (B); \
_check_meta (almost_equal (__a, __b), \
_CHECK_META (almost_equal (__a, __b), \
{ ; }, \
{ \
std::ostringstream os; \
@ -105,10 +105,10 @@ do { \
} while (0)
#define check_neq(A,B) do { \
#define CHECK_NEQ(A,B) do { \
const auto __a = (A); \
const auto __b = (B); \
_check_meta (!almost_equal (__a, __b), \
_CHECK_META (!almost_equal (__a, __b), \
{ ; }, \
{ \
std::ostringstream os; \
@ -121,7 +121,7 @@ do { \
} while (0)
#define check_throws(E,C) do { \
#define CHECK_THROWS(E,C) do { \
bool caught = false; \
\
try \
@ -133,7 +133,7 @@ do { \
panic ("expected exception: " #E); \
} while (0)
#define check(C) check_hard(C)
#define CHECK(C) CHECK_HARD(C)
class panic_error {

12
except.cpp
View File

@ -33,7 +33,7 @@ errno_error::errno_error (int _errno):
runtime_error (strerror (_errno)),
id (_errno)
{
check_hard (_errno != 0);
CHECK_HARD (_errno != 0);
}
@ -43,7 +43,7 @@ errno_error::errno_error ():
runtime_error (strerror (errno)),
id (errno)
{
check_hard (errno != 0);
CHECK_HARD (errno != 0);
}
@ -68,7 +68,7 @@ errno_error::throw_code (void)
void
errno_error::throw_code (int code) {
check_hard (code != 0);
CHECK_HARD (code != 0);
throw errno_error (code);
}
@ -78,7 +78,7 @@ win32_error::win32_error (DWORD _id):
runtime_error ("Win32 error"),
id (_id)
{
check_soft (id != ERROR_SUCCESS);
CHECK_SOFT (id != ERROR_SUCCESS);
}
@ -86,7 +86,7 @@ win32_error::win32_error (void):
runtime_error ("Win32 error"),
id (GetLastError ())
{
check_soft (id != ERROR_SUCCESS);
CHECK_SOFT (id != ERROR_SUCCESS);
}
@ -103,7 +103,7 @@ win32_error::try_code (void) {
void
win32_error::throw_code (void) {
const auto id = GetLastError ();
check (id != ERROR_SUCCESS);
CHECK (id != ERROR_SUCCESS);
throw win32_error (id);
}

2
extent.cpp
View File

@ -64,7 +64,7 @@ extent<T>::operator ==(const extent& rhs) const {
template <typename T>
void
extent<T>::sanity (void) const
{ check (width >= 0 && height >= 0); }
{ CHECK (width >= 0 && height >= 0); }
namespace util {

2
float.cpp
View File

@ -60,7 +60,7 @@ ieee_float<E, S>::operator==(floating_t _floating) const {
// TODO: This method really shouldn't be generated if there's no
// representative native floating point type. But I'm sick of
// C++'s template bullshit for tonight.
check_hard (bits_type<TOTAL_BITS>::has_floating);
CHECK_HARD (bits_type<TOTAL_BITS>::has_floating);
union {
floating_t _floating;

20
io.cpp
View File

@ -52,7 +52,7 @@ util::slurp (const boost::filesystem::path& path) {
unique_ptr <char []> buffer (new char[size + 1]);
buffer.get()[size] = '\0';
check_hard (size >= 0);
CHECK_HARD (size >= 0);
size_t remaining = (size_t)size;
char *cursor = buffer.get();
@ -60,8 +60,8 @@ util::slurp (const boost::filesystem::path& path) {
ssize_t consumed = read (fd, cursor, remaining);
if (consumed == -1)
throw errno_error();
check_hard ( consumed > 0);
check_hard ((size_t)consumed <= remaining);
CHECK_HARD ( consumed > 0);
CHECK_HARD ((size_t)consumed <= remaining);
remaining -= (size_t)consumed;
cursor += consumed;
@ -92,7 +92,7 @@ fd_ref::fd_ref (const boost::filesystem::path &path):
fd_ref::~fd_ref () {
check (fd >= 0);
CHECK (fd >= 0);
close (fd);
}
@ -150,7 +150,7 @@ scoped_cwd::~scoped_cwd () {
void
util::set_cwd (const boost::filesystem::path &path) {
check (path.string ().size () > 0);
CHECK (path.string ().size () > 0);
if (chdir (path.string ().c_str ()) != 0)
throw errno_error ();
@ -177,7 +177,7 @@ mapped_file::mapped_file (const boost::filesystem::path &_path):
mapped_file::~mapped_file () {
check (m_data != NULL);
CHECK (m_data != NULL);
munmap (m_data, m_size);
}
@ -197,8 +197,8 @@ mapped_file::load_fd (void) {
size_t
mapped_file::size (void) const {
check (m_size > 0);
check (m_data != NULL);
CHECK (m_size > 0);
CHECK (m_data != NULL);
return m_size;
}
@ -206,8 +206,8 @@ mapped_file::size (void) const {
const uint8_t*
mapped_file::data (void) const {
check (m_size > 0);
check (m_data != NULL);
CHECK (m_size > 0);
CHECK (m_data != NULL);
return m_data;
}

42
json.cpp.rl
View File

@ -80,9 +80,9 @@ struct parse_context {
action new_array { nodestack.push_back (parse_context(new json::array)); }
action new_object_value {
check_hard (nodestack.back ().root->is_object ());
check (nodestack.back ().key);
check (nodestack.back ().value);
CHECK_HARD (nodestack.back ().root->is_object ());
CHECK (nodestack.back ().key);
CHECK (nodestack.back ().value);
if (!nodestack.back ().key->is_string ())
throw parse_error ("object keys must be strings");
@ -95,8 +95,8 @@ struct parse_context {
}
action new_array_value {
check_hard (nodestack.back ().root->is_array ());
check (nodestack.back ().value);
CHECK_HARD (nodestack.back ().root->is_array ());
CHECK (nodestack.back ().value);
json::array *array = (json::array *)nodestack.back ().root;
array->insert (unique_ptr<json::node> (nodestack.back ().value));
@ -104,8 +104,8 @@ struct parse_context {
}
action new_string {
check_hard (!nodestack.empty ());
check (!nodestack.back ().value);
CHECK_HARD (!nodestack.empty ());
CHECK (!nodestack.back ().value);
std::string value (std::string (nodestack.back ().start,
nodestack.back ().stop));
@ -113,20 +113,20 @@ struct parse_context {
}
action new_boolean {
check_hard (!nodestack.empty ());
check (!nodestack.back ().value);
CHECK_HARD (!nodestack.empty ());
CHECK (!nodestack.back ().value);
throw parse_error ("unable to parse boolean");
}
action new_number {
check_hard (!nodestack.empty ());
CHECK_HARD (!nodestack.empty ());
parse_context &back = nodestack.back ();
check (!back.value);
check_hard (back.start);
check_hard (back.stop);
check_hard (back.start <= back.stop);
CHECK (!back.value);
CHECK_HARD (back.start);
CHECK_HARD (back.stop);
CHECK_HARD (back.start <= back.stop);
errno = 0;
char *end;
@ -137,17 +137,17 @@ struct parse_context {
}
action new_null {
check_hard (!nodestack.empty ());
check (!nodestack.back ().value);
CHECK_HARD (!nodestack.empty ());
CHECK (!nodestack.back ().value);
nodestack.back().value = new json::null ();
}
action new_object_key {
check_hard (!nodestack.empty ());
check_hard (nodestack.back ().root->is_object ());
check (nodestack.back ().value);
check (!nodestack.back ().key);
CHECK_HARD (!nodestack.empty ());
CHECK_HARD (nodestack.back ().root->is_object ());
CHECK (nodestack.back ().value);
CHECK (!nodestack.back ().key);
nodestack.back ().key = nodestack.back ().value;
nodestack.back ().value = NULL;
@ -292,7 +292,7 @@ json::parse (const char *start,
throw parse_error ("unable to parse json");
//__root->print (cout) << endl;
check (*__root == *__root);
CHECK (*__root == *__root);
return std::unique_ptr<json::node> (__root);
}

4
json/schema.cpp
View File

@ -381,7 +381,7 @@ is_additional_items_valid (const json::array &,
bool
is_array_valid (const json::array &node,
const json::object &schema) {
check_hard (node.is_array ());
CHECK_HARD (node.is_array ());
typedef bool (*array_validator_t)(const json::array&, const json::node&);
static const map<string, array_validator_t> VALIDATORS ({
@ -441,7 +441,7 @@ is_properties_valid (const json::object &node,
bool
is_properties_valid (const json::object &node,
const json::node &constraint) {
check (node.is_object ());
CHECK (node.is_object ());
if (!constraint.is_object ())
throw json::schema_error ("properties needs an object");

4
lerp.cpp
View File

@ -33,14 +33,14 @@ lerp::sigmoid (double val) {
double
lerp::linear (double a, double b, double weight) {
check (weight >= 0 && weight <= 1.0);
CHECK (weight >= 0 && weight <= 1.0);
return (1.0 - weight) * a + weight * b;
}
double
lerp::cosine (double a, double b, double weight) {
check (weight >= 0 && weight <= 1.0);
CHECK (weight >= 0 && weight <= 1.0);
double ft = weight * PI;
double f = (1.0 - cos (ft)) * 0.5;

2
log.cpp
View File

@ -37,7 +37,7 @@ using std::map;
void
check_level (level_t l)
{ check (l >= 0 && l < NUM_LEVELS); }
{ CHECK (l >= 0 && l < NUM_LEVELS); }
const string&

2
maths.cpp
View File

@ -84,7 +84,7 @@ almost_equal (const double &a, const double &b)
template <typename T>
typename enable_if<std::is_integral<T>::value, T>::type
round_up (T value, T align) {
check_hard (align > 1);
CHECK_HARD (align > 1);
return (value + align - 1) / align;
}

40
maths/matrix.cpp
View File

@ -50,7 +50,7 @@ matrix::matrix (size_t _rows,
throw std::runtime_error ("rows and columns must be positive");
if (size () != _data.size ())
throw std::runtime_error ("element and initializer size differs");
check_hard (m_rows * m_columns == _data.size());
CHECK_HARD (m_rows * m_columns == _data.size());
m_data = new double[size ()];
std::copy (_data.begin (), _data.end (), m_data);
@ -65,7 +65,7 @@ matrix::matrix (const std::initializer_list <vector> &rhs):
double *row_cursor = m_data;
for (auto i = rhs.begin (); i != rhs.end (); ++i) {
check (i->size () == m_columns);
CHECK (i->size () == m_columns);
std::copy (i->data (), i->data () + i->size (), row_cursor);
row_cursor += m_columns;
@ -95,22 +95,22 @@ matrix::~matrix()
void
matrix::sanity (void) const {
check (m_rows > 0);
check (m_columns > 0);
check (m_data != NULL);
CHECK (m_rows > 0);
CHECK (m_columns > 0);
CHECK (m_data != NULL);
}
const double *
matrix::operator [] (unsigned int row) const {
check_hard (row < m_rows);
CHECK_HARD (row < m_rows);
return m_data + row * m_columns;
}
double *
matrix::operator [] (unsigned int row) {
check_hard (row < m_rows);
CHECK_HARD (row < m_rows);
return m_data + row * m_columns;
}
@ -303,8 +303,8 @@ matrix::determinant (void) const {
double
matrix::determinant2x2 (void) const {
check_eq (m_rows, 2);
check_eq (m_columns, 2);
CHECK_EQ (m_rows, 2);
CHECK_EQ (m_columns, 2);
return (*this)[0][0] * (*this)[1][1] -
(*this)[0][1] * (*this)[1][0];
@ -320,8 +320,8 @@ matrix::determinant2x2 (void) const {
// det (A) = a(ei - fg) + b(fg - di) + c(dh - eg)
double
matrix::determinant3x3 (void) const {
check_eq (m_rows, 3);
check_eq (m_columns, 3);
CHECK_EQ (m_rows, 3);
CHECK_EQ (m_columns, 3);
return (*this)[0][0] * (*this)[1][1] * (*this)[2][2] + // aei
(*this)[0][1] * (*this)[1][2] * (*this)[2][0] + // bfg
@ -335,8 +335,8 @@ matrix::determinant3x3 (void) const {
// From libMathematics, http://www.geometrictools.com/
double
matrix::determinant4x4 (void) const {
check_eq (m_rows, 4);
check_eq (m_columns, 4);
CHECK_EQ (m_rows, 4);
CHECK_EQ (m_columns, 4);
double a0 = m_data[ 0] * m_data[ 5] - m_data[ 1] * m_data[ 4],
a1 = m_data[ 0] * m_data[ 6] - m_data[ 2] * m_data[ 4],
@ -372,8 +372,8 @@ matrix::inverse (void) const {
matrix
matrix::inverse2x2 (void) const {
check (m_rows == 2);
check (m_columns == 2);
CHECK (m_rows == 2);
CHECK (m_columns == 2);
double det = determinant2x2 ();
if (almost_equal (det, 0.))
@ -389,8 +389,8 @@ matrix::inverse2x2 (void) const {
//
matrix
matrix::inverse3x3 (void) const {
check (m_rows == 3);
check (m_columns == 3);
CHECK (m_rows == 3);
CHECK (m_columns == 3);
double det = determinant3x3();
if (almost_equal (det, 0.))
@ -482,7 +482,7 @@ matrix::identity (size_t diag) {
matrix
matrix::magic (size_t n) {
check_hard (n > 2);
CHECK_HARD (n > 2);
if (n % 2 == 1)
return magic_odd (n);
@ -498,8 +498,8 @@ matrix::magic (size_t n) {
// If filled then drop down one row instead. Wrap around indexing.
matrix
matrix::magic_odd (size_t n) {
check_hard (n > 2);
check_hard (n % 2 == 1);
CHECK_HARD (n > 2);
CHECK_HARD (n % 2 == 1);
matrix val (zeroes (n));
for (unsigned int i = 1, x = n / 2, y = 0; i <= n * n; ++i) {

2
maths/vector.cpp
View File

@ -73,7 +73,7 @@ double vector::dot (const double *restrict A,
vector vector::cross (const double *restrict A,
const double *restrict B,
unsigned int size) {
check_hard (size == 3);
CHECK_HARD (size == 3);
return vector ({ A[1] * B[2] - A[2] * B[1],
A[2] * B[0] - A[0] * B[2],
A[0] * B[1] - A[1] * B[0] });

10
matrix.cpp
View File

@ -21,7 +21,7 @@ using namespace util;
void
matrix::scale (double x, double y, double z) {
check_hard (is_affine ());
CHECK_HARD (is_affine ());
values[0][0] *= x;
values[1][1] *= y;
values[2][2] *= z;
@ -30,7 +30,7 @@ matrix::scale (double x, double y, double z) {
void
matrix::translate (double x, double y, double z) {
check_hard (is_affine ());
CHECK_HARD (is_affine ());
values[0][3] += x;
values[1][3] += y;
values[2][3] += z;
@ -45,7 +45,7 @@ matrix::inverse (void) const {
matrix&
matrix::invert (void) {
check_hard (is_affine ());
CHECK_HARD (is_affine ());
// inv ([ M b ] == [ inv(M) -inv(M).b ]
// [ 0 1 ]) [ 0 1
@ -64,7 +64,7 @@ matrix::invert (void) {
double K = (values[0][0] * values[1][1] - values[0][1] * values[1][0]);
double det = values[0][0] * A + values[0][1] * B + values[0][2] * C;
check_neq (det, 0.0);
CHECK_NEQ (det, 0.0);
values[0][0] = A / det;
values[0][1] = D / det;
@ -105,7 +105,7 @@ matrix::operator* (const matrix &rhs) const {
util::point
matrix::to_local (const util::point &p) const {
check_soft (is_affine ());
CHECK_SOFT (is_affine ());
return { p.x * values[0][0] + p.y * values[0][1] + p.z * values[0][2] + values[0][3],
p.x * values[1][0] + p.y * values[1][1] + p.z * values[1][2] + values[1][3],

6
point.cpp
View File

@ -89,9 +89,9 @@ point::operator- (const point &rhs) const {
void
point::sanity (void) const {
check_soft (!std::isnan (x));
check_soft (!std::isnan (y));
check_soft (!std::isnan (z));
CHECK_SOFT (!std::isnan (x));
CHECK_SOFT (!std::isnan (y));
CHECK_SOFT (!std::isnan (z));
}

4
pool.hpp
View File

@ -52,13 +52,13 @@ template <typename T>
~pool () {
check (m_next != NULL);
CHECK (m_next != NULL);
unsigned int doomed_count = 0;
for (node *cursor = m_next; cursor != NULL; cursor = cursor->_chain)
++doomed_count;
check_eq (doomed_count, m_capacity);
CHECK_EQ (doomed_count, m_capacity);
operator delete (m_head);
}

4
range.cpp
View File

@ -57,7 +57,7 @@ range<T>::contains (const range <T> &r) const
template <typename T>
void
range<T>::sanity (void) const
{ check (min <= max); }
{ CHECK (min <= max); }
namespace util {
@ -66,7 +66,7 @@ namespace util {
range<double>::sanity (void) const {
if (std::isnan (min) || std::isnan (max))
return;
check (min <= max);
CHECK (min <= max);
}
}

2
region.cpp
View File

@ -141,7 +141,7 @@ region<T>::operator ==(const region& rhs) const
template <typename T>
void region<T>::sanity (void) const
{ check (w >= 0 && h >= 0); }
{ CHECK (w >= 0 && h >= 0); }
namespace util {

4
test/checksum.cpp
View File

@ -24,8 +24,8 @@ static const struct {
int
main (int, char**) {
for (unsigned i = 0; i < elems (TESTS); ++i) {
check_eq (TESTS[i].adler, adler32 (TESTS[i].data, TESTS[i].size));
check_eq (TESTS[i].bsd, bsdsum (TESTS[i].data, TESTS[i].size));
CHECK_EQ (TESTS[i].adler, adler32 (TESTS[i].data, TESTS[i].size));
CHECK_EQ (TESTS[i].bsd, bsdsum (TESTS[i].data, TESTS[i].size));
}
return EXIT_SUCCESS;

4
test/float.cpp
View File

@ -34,7 +34,7 @@ test_double (void) {
for (unsigned int i = 0; i < elems (tests); ++i) {
ieee_double val;
val.set_bits (tests[i].bits);
check_hard (val == tests[i].floating);
CHECK_HARD (val == tests[i].floating);
}
}
@ -63,7 +63,7 @@ test_single (void) {
for (unsigned int i = 0; i < elems (tests); ++i) {
ieee_single val;
val.set_bits (tests[i].bits);
check_hard (val == tests[i].floating);
CHECK_HARD (val == tests[i].floating);
}
}

8
test/hton.cpp
View File

@ -16,11 +16,11 @@ main (int, char **) {
uint16_t u16 = 0x1358;
uint32_t u32 = 0x12345678;
check_eq (htons (u16), hton (u16));
check_eq (htonl (u32), hton (u32));
CHECK_EQ (htons (u16), hton (u16));
CHECK_EQ (htonl (u32), hton (u32));
check_eq (ntohs (u16), hton (u16));
check_eq (ntohl (u32), hton (u32));
CHECK_EQ (ntohs (u16), hton (u16));
CHECK_EQ (ntohl (u32), hton (u32));
return EXIT_SUCCESS;
}

6
test/ip.cpp
View File

@ -24,12 +24,12 @@ main (int, char **) {
for (unsigned int i = 0; i < elems (data); ++i) {
ipv4::ip parsed (ipv4::ip::parse (data[i].str));
check_hard (parsed == data[i].ip);
CHECK_HARD (parsed == data[i].ip);
uint32_t mine = *(uint32_t*)(parsed.m_octets),
theirs;
check_hard (inet_pton (AF_INET, data[i].str, &theirs) == 1);
check_hard (theirs == mine);
CHECK_HARD (inet_pton (AF_INET, data[i].str, &theirs) == 1);
CHECK_HARD (theirs == mine);
}
return EXIT_SUCCESS;

98
test/json.cpp
View File

@ -24,70 +24,70 @@ main (int, char**) {
"}";
std::unique_ptr<json::node> ptr = json::parse (TEST_STRING);
check_hard (ptr->is_object ());
CHECK_HARD (ptr->is_object ());
const json::node &ref = *ptr;
check_hard ( ref["string"].is_string ());
check_hard (!ref["string"].is_array ());
check_hard (!ref["string"].is_boolean ());
check_hard (!ref["string"].is_null ());
check_hard (!ref["string"].is_number ());
check_hard (!ref["string"].is_object ());
CHECK_HARD ( ref["string"].is_string ());
CHECK_HARD (!ref["string"].is_array ());
CHECK_HARD (!ref["string"].is_boolean ());
CHECK_HARD (!ref["string"].is_null ());
CHECK_HARD (!ref["string"].is_number ());
CHECK_HARD (!ref["string"].is_object ());
check_eq ( ref["string"].as_string (), "brad");
check_hard ( ref["integer"].is_number ());
check_hard (!ref["integer"].is_array ());
check_hard (!ref["integer"].is_boolean ());
check_hard (!ref["integer"].is_null ());
check_hard (!ref["integer"].is_object ());
check_hard (!ref["integer"].is_string ());
CHECK_HARD ( ref["integer"].is_number ());
CHECK_HARD (!ref["integer"].is_array ());
CHECK_HARD (!ref["integer"].is_boolean ());
CHECK_HARD (!ref["integer"].is_null ());
CHECK_HARD (!ref["integer"].is_object ());
CHECK_HARD (!ref["integer"].is_string ());
check_eq ( ref["integer"].as_number (), 1u);
check_hard ( ref["null"].is_null ());
check_hard (!ref["null"].is_array ());
check_hard (!ref["null"].is_boolean ());
check_hard (!ref["null"].is_number ());
check_hard (!ref["null"].is_object ());
check_hard (!ref["null"].is_string ());
CHECK_HARD ( ref["null"].is_null ());
CHECK_HARD (!ref["null"].is_array ());
CHECK_HARD (!ref["null"].is_boolean ());
CHECK_HARD (!ref["null"].is_number ());
CHECK_HARD (!ref["null"].is_object ());
CHECK_HARD (!ref["null"].is_string ());
check_hard ( ref["false"].is_boolean ());
check_hard (!ref["false"].is_array ());
check_hard (!ref["false"].is_null ());
check_hard (!ref["false"].is_number ());
check_hard (!ref["false"].is_object ());
check_hard (!ref["false"].is_string ());
CHECK_HARD ( ref["false"].is_boolean ());
CHECK_HARD (!ref["false"].is_array ());
CHECK_HARD (!ref["false"].is_null ());
CHECK_HARD (!ref["false"].is_number ());
CHECK_HARD (!ref["false"].is_object ());
CHECK_HARD (!ref["false"].is_string ());
check_eq ( ref["false"].as_boolean (), false);
check_hard ( ref["true"].is_boolean ());
check_hard (!ref["true"].is_array ());
check_hard (!ref["true"].is_null ());
check_hard (!ref["true"].is_number ());
check_hard (!ref["true"].is_object ());
check_hard (!ref["true"].is_string ());
CHECK_HARD ( ref["true"].is_boolean ());
CHECK_HARD (!ref["true"].is_array ());
CHECK_HARD (!ref["true"].is_null ());
CHECK_HARD (!ref["true"].is_number ());
CHECK_HARD (!ref["true"].is_object ());
CHECK_HARD (!ref["true"].is_string ());
check_eq ( ref["true"].as_boolean (), true);
check_hard ( ref["double"].is_number ());
check_hard (!ref["double"].is_array ());
check_hard (!ref["double"].is_boolean ());
check_hard (!ref["double"].is_null ());
check_hard (!ref["double"].is_object ());
check_hard (!ref["double"].is_string ());
CHECK_HARD ( ref["double"].is_number ());
CHECK_HARD (!ref["double"].is_array ());
CHECK_HARD (!ref["double"].is_boolean ());
CHECK_HARD (!ref["double"].is_null ());
CHECK_HARD (!ref["double"].is_object ());
CHECK_HARD (!ref["double"].is_string ());
check_eq ( ref["double"].as_number (), 3.14);
check_hard ( ref["object"].is_object ());
check_hard (!ref["object"].is_array ());
check_hard (!ref["object"].is_boolean ());
check_hard (!ref["object"].is_null ());
check_hard (!ref["object"].is_number ());
check_hard (!ref["object"].is_string ());
CHECK_HARD ( ref["object"].is_object ());
CHECK_HARD (!ref["object"].is_array ());
CHECK_HARD (!ref["object"].is_boolean ());
CHECK_HARD (!ref["object"].is_null ());
CHECK_HARD (!ref["object"].is_number ());
CHECK_HARD (!ref["object"].is_string ());
check_hard ( ref["array"].is_array ());
check_hard (!ref["array"].is_boolean ());
check_hard (!ref["array"].is_null ());
check_hard (!ref["array"].is_number ());
check_hard (!ref["array"].is_object ());
check_hard (!ref["array"].is_string ());
CHECK_HARD ( ref["array"].is_array ());
CHECK_HARD (!ref["array"].is_boolean ());
CHECK_HARD (!ref["array"].is_null ());
CHECK_HARD (!ref["array"].is_number ());
CHECK_HARD (!ref["array"].is_object ());
CHECK_HARD (!ref["array"].is_string ());
return EXIT_SUCCESS;
}

40
test/maths.cpp
View File

@ -10,37 +10,37 @@ using std::numeric_limits;
int
main (int, char **) {
check_hard (!almost_equal (-2.0, 0.0));
check_hard (!almost_equal (-2.f, 0.f));
check_hard ( almost_equal ( 0.0, 0.0));
//check_hard ( almost_equal ( 0.0, numeric_limits<double>::min ()));
check_hard ( almost_equal (numeric_limits<double>::infinity (),
CHECK_HARD (!almost_equal (-2.0, 0.0));
CHECK_HARD (!almost_equal (-2.f, 0.f));
CHECK_HARD ( almost_equal ( 0.0, 0.0));
//CHECK_HARD ( almost_equal ( 0.0, numeric_limits<double>::min ()));
CHECK_HARD ( almost_equal (numeric_limits<double>::infinity (),
numeric_limits<double>::infinity ()));
check_hard (!almost_equal (numeric_limits<double>::infinity (), 0.0));
check_hard (!almost_equal (numeric_limits<double>::quiet_NaN (),
CHECK_HARD (!almost_equal (numeric_limits<double>::infinity (), 0.0));
CHECK_HARD (!almost_equal (numeric_limits<double>::quiet_NaN (),
numeric_limits<double>::quiet_NaN ()));
check_eq (min (-2, 0, 2), -2);
check_eq (max (-2, 0, 2), 2);
CHECK_EQ (min (-2, 0, 2), -2);
CHECK_EQ (max (-2, 0, 2), 2);
check_eq (pow2 (2), 4);
check_eq (pow2 (4), 16);
CHECK_EQ (pow2 (2), 4);
CHECK_EQ (pow2 (4), 16);
check_eq (rootsquare (2, 2), sqrt (8));
CHECK_EQ (rootsquare (2, 2), sqrt (8));
double pos_zero = 1.0 / numeric_limits<double>::infinity ();
double neg_zero = -1.0 / numeric_limits<double>::infinity ();
check_eq (sign (-1), -1);
check_eq (sign ( 1), 1);
check_eq (sign (pos_zero), 1);
check_eq (sign (neg_zero), -1);
check_eq (sign ( numeric_limits<double>::infinity ()), 1);
check_eq (sign (-numeric_limits<double>::infinity ()), -1);
CHECK_EQ (sign (-1), -1);
CHECK_EQ (sign ( 1), 1);
CHECK_EQ (sign (pos_zero), 1);
CHECK_EQ (sign (neg_zero), -1);
CHECK_EQ (sign ( numeric_limits<double>::infinity ()), 1);
CHECK_EQ (sign (-numeric_limits<double>::infinity ()), -1);
check_eq (to_degrees (PI), 180);
check_eq (to_radians (180), PI);
CHECK_EQ (to_degrees (PI), 180);
CHECK_EQ (to_radians (180), PI);
return EXIT_SUCCESS;
}

56
test/matrix.cpp
View File

@ -33,7 +33,7 @@ test_zeroes (const matrix &m) {
for (unsigned int i = 0; i < m.rows (); ++i)
for (unsigned int j = 0; j < m.columns (); ++j)
check_hard (almost_equal (m[i][j], 0.0));
CHECK_HARD (almost_equal (m[i][j], 0.0));
}
@ -44,9 +44,9 @@ test_identity (const matrix &m) {
for (unsigned int i = 0; i < m.rows (); ++i)
for (unsigned int j = 0; j < m.columns (); ++j)
if (i == j)
check_hard (almost_equal (m[i][j], 1.0));
CHECK_HARD (almost_equal (m[i][j], 1.0));
else
check_hard (almost_equal (m[i][j], 0.0));
CHECK_HARD (almost_equal (m[i][j], 0.0));
}
@ -58,7 +58,7 @@ main (int, char **) {
}
for (unsigned int i = 3; i < 10; i += 2)
check (matrix::magic (i).is_magic ());
CHECK (matrix::magic (i).is_magic ());
// Create a small matrix with unique element values for comparison tests.
// This should be non-square so that row- vs. column-major problems can
@ -67,15 +67,15 @@ main (int, char **) {
2, 3,
4, 5,
6, 7 });
check_eq (a4x2, a4x2);
CHECK_EQ (a4x2, a4x2);
// Test that copy constructors work correctly. Keep this value around so
// that we can check the following operators don't modify the original
// value.
check_eq (a4x2, matrix(a4x2));
CHECK_EQ (a4x2, matrix(a4x2));
// Check multiplication by identity results in the original value.
check_eq (a4x2, a4x2 * matrix::identity (a4x2.columns ()));
CHECK_EQ (a4x2, a4x2 * matrix::identity (a4x2.columns ()));
matrix seq2x2(2, 2, { 1, 2, 3, 4 });
matrix magic3(3, 3, { 2, 7, 6,
@ -88,26 +88,26 @@ main (int, char **) {
4, 14, 15, 1 });
check_eq (magic3[0][0], 2.0);
check_eq (magic3[0][1], 7.0);
check_eq (magic3[0][2], 6.0);
check_eq (magic3[1][0], 9.0);
check_eq (magic3[1][1], 5.0);
check_eq (magic3[1][2], 1.0);
check_eq (magic3[2][0], 4.0);
check_eq (magic3[2][1], 3.0);
check_eq (magic3[2][2], 8.0);
CHECK_EQ (magic3[0][0], 2.0);
CHECK_EQ (magic3[0][1], 7.0);
CHECK_EQ (magic3[0][2], 6.0);
CHECK_EQ (magic3[1][0], 9.0);
CHECK_EQ (magic3[1][1], 5.0);
CHECK_EQ (magic3[1][2], 1.0);
CHECK_EQ (magic3[2][0], 4.0);
CHECK_EQ (magic3[2][1], 3.0);
CHECK_EQ (magic3[2][2], 8.0);
check_eq (seq2x2.determinant (), -2.0);
check_eq (magic3.determinant (), -360.0);
CHECK_EQ (seq2x2.determinant (), -2.0);
CHECK_EQ (magic3.determinant (), -360.0);
check_hard ( seq2x2.is_square ());
check_hard ( magic3.is_square ());
check_hard (! a4x2.is_square ());
CHECK_HARD ( seq2x2.is_square ());
CHECK_HARD ( magic3.is_square ());
CHECK_HARD (! a4x2.is_square ());
check_eq (seq2x2.inverse (), matrix (2, 2, { -2.0, 1.0,
CHECK_EQ (seq2x2.inverse (), matrix (2, 2, { -2.0, 1.0,
1.5, -0.5 }));
check_eq (magic3.inverse (), matrix (3, 3, { -37.0, 38.0, 23.0,
CHECK_EQ (magic3.inverse (), matrix (3, 3, { -37.0, 38.0, 23.0,
68.0, 8.0, -52.0,
- 7.0, -22.0, 53.0 }) /= 360.0);
@ -115,7 +115,7 @@ main (int, char **) {
9, 7, 6, 12,
5, 11, 10, 8,
0, 0, 0, 1 });
check_eq (invertible4.inverse (), matrix (4, 4, { 4, 25, -21, -136,
CHECK_EQ (invertible4.inverse (), matrix (4, 4, { 4, 25, -21, -136,
-60, -35, 111, -408,
64, 26, -98, 408,
0, 0, 0, 136 }) /= 136);
@ -123,10 +123,10 @@ main (int, char **) {
const matrix homo3x3 (3, 3, { 1, 2, 0,
3, 4, 0,
0, 0, 1 });
check_hard (homo3x3.is_homogeneous ());
check_hard (!matrix::zeroes (3).is_homogeneous ());
check_hard ( matrix::identity (3).is_homogeneous ());
check_hard (invertible4.is_homogeneous ());
CHECK_HARD (homo3x3.is_homogeneous ());
CHECK_HARD (!matrix::zeroes (3).is_homogeneous ());
CHECK_HARD ( matrix::identity (3).is_homogeneous ());
CHECK_HARD (invertible4.is_homogeneous ());
return EXIT_SUCCESS;
}

12
test/pool.cpp
View File

@ -25,7 +25,7 @@ check_unique_ptr (void) {
// Take all pointers out, checking they are unique, then replace for destruction.
for (unsigned int i = 0; i < uintpool.capacity (); ++i) {
bool success = uintset.insert (uintpool.acquire ()).second;
check_hard (success);
CHECK_HARD (success);
}
for (auto i = uintset.begin (); i != uintset.end (); ++i)
@ -35,7 +35,7 @@ check_unique_ptr (void) {
// Do the above one more time to ensure that releasing works right
for (unsigned int i = 0; i < uintpool.capacity (); ++i) {
bool success = uintset.insert (uintpool.acquire ()).second;
check_hard (success);
CHECK_HARD (success);
}
for (auto i = uintset.begin (); i != uintset.end (); ++i)
@ -57,19 +57,19 @@ check_keep_value (void) {
uintvector.push_back(item);
}
check (uintvector.size () == uintpool.capacity ());
CHECK (uintvector.size () == uintpool.capacity ());
// Ensure they're all still present
vector<bool> present(uintpool.capacity (), false);
for (auto i = uintvector.begin (); i != uintvector.end (); ++i) {
check_hard (**i < uintpool.capacity ());
check_hard (present[**i] != true);
CHECK_HARD (**i < uintpool.capacity ());
CHECK_HARD (present[**i] != true);
present[**i] = true;
}
// All must have been marked as present...
check_hard (find (present.begin (), present.end (), false) == present.end ());
CHECK_HARD (find (present.begin (), present.end (), false) == present.end ());
// Release all back into the pool for destruction
for (auto i = uintvector.begin (); i != uintvector.end (); ++i)

30
test/range.cpp
View File

@ -9,24 +9,24 @@ using namespace util;
int
main (int, char **) {
check_hard ( range<double>::UNIT.contains ( 0.0));
check_hard ( range<double>::UNIT.contains ( 0.5));
check_hard ( range<double>::UNIT.contains ( 1.0));
check_hard (!range<double>::UNIT.contains (-0.00001));
check_hard (!range<double>::UNIT.contains ( 1.00001));
CHECK_HARD ( range<double>::UNIT.contains ( 0.0));
CHECK_HARD ( range<double>::UNIT.contains ( 0.5));
CHECK_HARD ( range<double>::UNIT.contains ( 1.0));
CHECK_HARD (!range<double>::UNIT.contains (-0.00001));
CHECK_HARD (!range<double>::UNIT.contains ( 1.00001));
check_hard ( range<uint16_t>::UNIT.contains (0));
check_hard ( range<uint16_t>::UNIT.contains (1));
check_hard (!range<uint16_t>::UNIT.contains (2));
check_hard (!range<uint16_t>::UNIT.contains (numeric_limits <uint16_t>::max ()));
CHECK_HARD ( range<uint16_t>::UNIT.contains (0));
CHECK_HARD ( range<uint16_t>::UNIT.contains (1));
CHECK_HARD (!range<uint16_t>::UNIT.contains (2));
CHECK_HARD (!range<uint16_t>::UNIT.contains (numeric_limits <uint16_t>::max ()));
check_hard ( range<double>::UNLIMITED.contains (0.0));
check_hard ( range<double>::UNLIMITED.contains (+numeric_limits<double>::infinity ()));
check_hard ( range<double>::UNLIMITED.contains (-numeric_limits<double>::infinity ()));
check_hard (!range<double>::UNLIMITED.contains ( numeric_limits<double>::quiet_NaN ()));
CHECK_HARD ( range<double>::UNLIMITED.contains (0.0));
CHECK_HARD ( range<double>::UNLIMITED.contains (+numeric_limits<double>::infinity ()));
CHECK_HARD ( range<double>::UNLIMITED.contains (-numeric_limits<double>::infinity ()));
CHECK_HARD (!range<double>::UNLIMITED.contains ( numeric_limits<double>::quiet_NaN ()));
check_hard ( range<uint16_t>::UNLIMITED.contains (numeric_limits<uint16_t>::min()));
check_hard ( range<uint16_t>::UNLIMITED.contains (numeric_limits<uint16_t>::max()));
CHECK_HARD ( range<uint16_t>::UNLIMITED.contains (numeric_limits<uint16_t>::min()));
CHECK_HARD ( range<uint16_t>::UNLIMITED.contains (numeric_limits<uint16_t>::max()));
return EXIT_SUCCESS;
}

2
test/region.cpp
View File

@ -8,7 +8,7 @@ main (int, char **) {
region<double> a (32.7, -6.09703, 0.8, 2);
region<double> b (33.5, -4.5, 0.5, 0.5);
check_hard (!a.overlaps (b));
CHECK_HARD (!a.overlaps (b));
}
return 0;

4
test/signal.cpp
View File

@ -23,7 +23,7 @@ test_single (void) {
void_signal.connect (increment_uint);
void_signal (val);
check_eq (val, 1);
CHECK_EQ (val, 1);
}
@ -36,7 +36,7 @@ test_double (void) {
void_signal.connect (increment_uint);
void_signal (val);
check_eq (val, 2);
CHECK_EQ (val, 2);
}

10
test/version.cpp
View File

@ -38,12 +38,12 @@ main (int, char **) {
for (auto i = tests.begin (); i != tests.end (); ++i) {
version v (i->str);
if (i->parts.size () > 0) check (v.major () == i->parts[0]);
if (i->parts.size () > 1) check (v.minor () == i->parts[1]);
if (i->parts.size () > 2) check (v.point () == i->parts[2]);
if (i->parts.size () > 3) check (v.build () == i->parts[3]);
if (i->parts.size () > 0) CHECK (v.major () == i->parts[0]);
if (i->parts.size () > 1) CHECK (v.minor () == i->parts[1]);
if (i->parts.size () > 2) CHECK (v.point () == i->parts[2]);
if (i->parts.size () > 3) CHECK (v.build () == i->parts[3]);
check_hard (i->parts.size () <= 4);
CHECK_HARD (i->parts.size () <= 4);
}
return EXIT_SUCCESS;

4
time.cpp
View File

@ -55,8 +55,8 @@ util::nanoseconds (void) {
struct timespec t;
clock_gettime (CLOCK_REALTIME, &t);
check_soft (t.tv_sec > 0);
check_soft (t.tv_nsec > 0);
CHECK_SOFT (t.tv_sec > 0);
CHECK_SOFT (t.tv_nsec > 0);
return static_cast<uint64_t> (t.tv_sec) * 1000000000ULL + static_cast<uint64_t> (t.tv_nsec);
}

6
types.hpp
View File

@ -86,7 +86,7 @@ namespace detail {
std::is_unsigned<T>::value &&
std::is_signed<V>::value, V>::type v)
{
check_hard (v >= 0);
CHECK_HARD (v >= 0);
return static_cast<T> (v);
}
@ -97,7 +97,7 @@ namespace detail {
std::is_signed<T>::value &&
std::is_unsigned<V>::value, V>::type v)
{
check_hard (v < std::numeric_limits<V>::max () / 2);
CHECK_HARD (v < std::numeric_limits<V>::max () / 2);
return static_cast<T> (v);
}
}
@ -124,7 +124,7 @@ namespace detail {
T
_trunc_cast (const typename enable_if<sizeof (T) < sizeof (V) &&
std::is_signed<T>::value == std::is_signed<V>::value, V>::type v) {
check_hard (v <= std::numeric_limits<T>::max ());
CHECK_HARD (v <= std::numeric_limits<T>::max ());
checK_hard (v >= std::numeric_limits<T>::min ());
return static_cast<T> (v);

6
vector.cpp
View File

@ -194,9 +194,9 @@ vector::is_zero (void) const {
void
vector::sanity (void) const {
check_soft (!std::isnan (x));
check_soft (!std::isnan (y));
check_soft (!std::isnan (z));
CHECK_SOFT (!std::isnan (x));
CHECK_SOFT (!std::isnan (y));
CHECK_SOFT (!std::isnan (z));
}

2
version.cpp.rl
View File

@ -72,7 +72,7 @@ check_release (version::release_t r) {
void
version::sanity (void) const {
check_release (m_release);
check (!m_values.empty ());
CHECK (!m_values.empty ());
}