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

debug: drop support for CHECK_HARD

Browse Source 
HARD vs SOFT assertions were never very well defined or supported.
Currently they just imply a level of functionality that isn't present;
it's better to remove them instead of expending the effort at this
point.
This commit is contained in:
Danny Robson 2015-01-28 14:49:34 +11:00
parent c185ea7226
commit 52f53caee5
30 changed files with 189 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
backtrace_execinfo.cpp
View File

@ -42,7 +42,7 @@ debug::backtrace::backtrace (void):
while ((last = ::backtrace (&m_frames[0], m_frames.size ())) == size) while ((last = ::backtrace (&m_frames[0], m_frames.size ())) == size)
m_frames.resize (size = m_frames.size () * 2); m_frames.resize (size = m_frames.size () * 2);
CHECK_HARD (last > 0); CHECK_GT (last, 0);
m_frames.resize (last); m_frames.resize (last);
} }

27
debug.hpp
View File

@ -54,21 +54,6 @@
} while (0) } while (0)
///////////////////////////////////////////////////////////////////////////////
#define VERIFY_SOFT(C, COND) ({ \
const auto __DEBUG_value = (C); \
CHECK_SOFT(__DEBUG_value COND); \
__DEBUG_value; \
})
#define VERIFY_HARD(C, COND) ({ \
const auto __DEBUG_value = (C); \
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); \ const auto __DEBUG_value = (C); \
@ -87,16 +72,8 @@
} while (0) } while (0)
#if defined(ENABLE_DEBUGGING) ///////////////////////////////////////////////////////////////////////////////
#define CHECK_HARD(C) _CHECK_META((C), { ; }, { panic (); }) #define CHECK(C) do { DEBUG_ONLY(_CHECK_META((C), { ; }, { panic (); });); } while (0)
#define CHECK_SOFT(C) _CHECK_META((C), { ; }, { breakpoint (); })
#define CHECK(C) CHECK_HARD(C)
#else
#define CHECK_HARD(C) { };
#define CHECK_SOFT(C) { };
#define CHECK(C) CHECK_SOFT(C)
#endif
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#define CHECK_EQ(A,B) do { \ #define CHECK_EQ(A,B) do { \

6
except.cpp
View File

@ -34,7 +34,7 @@ errno_error::errno_error (int _errno):
runtime_error (strerror (_errno)), runtime_error (strerror (_errno)),
id (_errno) id (_errno)
{ {
CHECK_HARD (_errno != 0); CHECK_NEQ (_errno, 0);
} }
@ -44,7 +44,7 @@ errno_error::errno_error ():
runtime_error (strerror (errno)), runtime_error (strerror (errno)),
id (errno) id (errno)
{ {
CHECK_HARD (errno != 0); CHECK_NEQ (errno, 0);
} }
@ -69,7 +69,7 @@ errno_error::throw_code (void)
void void
errno_error::throw_code (int code) { errno_error::throw_code (int code) {
CHECK_HARD (code != 0); CHECK_NEQ (code, 0);
throw errno_error (code); throw errno_error (code);
} }

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 // TODO: This method really shouldn't be generated if there's no
// representative native floating point type. But I'm sick of // representative native floating point type. But I'm sick of
// C++'s template bullshit for tonight. // C++'s template bullshit for tonight.
CHECK_HARD (bits_type<TOTAL_BITS>::has_floating); CHECK (bits_type<TOTAL_BITS>::has_floating);
union { union {
floating_t _floating; floating_t _floating;

2
hash/ripemd.cpp
View File

@ -43,7 +43,7 @@ RIPEMD::reset (void) {
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
void void
RIPEMD::update (const uint8_t *data, size_t len) { RIPEMD::update (const uint8_t *data, size_t len) {
CHECK_HARD (data); CHECK (data);
size_t cursor = 0; size_t cursor = 0;

8
image.cpp
View File

@ -34,10 +34,10 @@ write_netpbm (const uint8_t *restrict pixels,
size_t stride, size_t stride,
const boost::filesystem::path &path, const boost::filesystem::path &path,
const char* MAGIC) { const char* MAGIC) {
CHECK_HARD (pixels); CHECK (pixels);
CHECK_HARD (width > 0); CHECK_GT (width, 0);
CHECK_HARD (stride >= width); CHECK_GE (stride, width);
CHECK_HARD (height > 0); CHECK_GT (height, 0);
// Establish an output stream // Establish an output stream
std::ofstream output (path.string ()); std::ofstream output (path.string ());

10
io.cpp
View File

@ -73,7 +73,7 @@ util::slurp (const boost::filesystem::path& path) {
unique_ptr <char []> buffer (new char[size + 1]); unique_ptr <char []> buffer (new char[size + 1]);
buffer.get()[size] = '\0'; buffer.get()[size] = '\0';
CHECK_HARD (size >= 0); CHECK_GE (size, 0);
size_t remaining = (size_t)size; size_t remaining = (size_t)size;
char *cursor = buffer.get(); char *cursor = buffer.get();
@ -81,8 +81,8 @@ util::slurp (const boost::filesystem::path& path) {
ssize_t consumed = ::read (fd, cursor, remaining); ssize_t consumed = ::read (fd, cursor, remaining);
if (consumed == -1) if (consumed == -1)
throw errno_error(); throw errno_error();
CHECK_HARD ( consumed > 0); CHECK_GT ( consumed, 0);
CHECK_HARD ((size_t)consumed <= remaining); CHECK_LE ((size_t)consumed, remaining);
remaining -= (size_t)consumed; remaining -= (size_t)consumed;
cursor += consumed; cursor += consumed;
@ -95,8 +95,8 @@ util::slurp (const boost::filesystem::path& path) {
template <typename T> template <typename T>
void void
util::write (const boost::filesystem::path &path, const T *data, size_t len) { util::write (const boost::filesystem::path &path, const T *data, size_t len) {
CHECK_SOFT (len > 0); CHECK_GT (len, 0);
CHECK_HARD (data); CHECK (data);
fd_ref fd (path, ACCESS_WRITE); fd_ref fd (path, ACCESS_WRITE);
const char *cursor = reinterpret_cast<const char*> (data); const char *cursor = reinterpret_cast<const char*> (data);

38
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_array { nodestack.push_back (parse_context(new json::array)); }
action new_object_value { action new_object_value {
CHECK_HARD (nodestack.back ().root->is_object ()); CHECK (nodestack.back ().root->is_object ());
CHECK (nodestack.back ().key); CHECK (nodestack.back ().key);
CHECK (nodestack.back ().value); CHECK (nodestack.back ().value);
if (!nodestack.back ().key->is_string ()) if (!nodestack.back ().key->is_string ())
throw parse_error ("object keys must be strings"); throw parse_error ("object keys must be strings");
@ -95,8 +95,8 @@ struct parse_context {
} }
action new_array_value { action new_array_value {
CHECK_HARD (nodestack.back ().root->is_array ()); CHECK (nodestack.back ().root->is_array ());
CHECK (nodestack.back ().value); CHECK (nodestack.back ().value);
json::array *array = (json::array *)nodestack.back ().root; json::array *array = (json::array *)nodestack.back ().root;
array->insert (unique_ptr<json::node> (nodestack.back ().value)); array->insert (unique_ptr<json::node> (nodestack.back ().value));
@ -104,8 +104,8 @@ struct parse_context {
} }
action new_string { action new_string {
CHECK_HARD (!nodestack.empty ()); CHECK (!nodestack.empty ());
CHECK (!nodestack.back ().value); CHECK (!nodestack.back ().value);
std::string value (std::string (nodestack.back ().start, std::string value (std::string (nodestack.back ().start,
nodestack.back ().stop)); nodestack.back ().stop));
@ -113,20 +113,20 @@ struct parse_context {
} }
action new_boolean { action new_boolean {
CHECK_HARD (!nodestack.empty ()); CHECK (!nodestack.empty ());
CHECK (!nodestack.back ().value); CHECK (!nodestack.back ().value);
throw parse_error ("unable to parse boolean"); throw parse_error ("unable to parse boolean");
} }
action new_number { action new_number {
CHECK_HARD (!nodestack.empty ()); CHECK (!nodestack.empty ());
parse_context &back = nodestack.back (); parse_context &back = nodestack.back ();
CHECK (!back.value); CHECK (!back.value);
CHECK_HARD (back.start); CHECK (back.start);
CHECK_HARD (back.stop); CHECK (back.stop);
CHECK_HARD (back.start <= back.stop); CHECK_LE (back.start, back.stop);
errno = 0; errno = 0;
char *end; char *end;
@ -137,17 +137,17 @@ struct parse_context {
} }
action new_null { action new_null {
CHECK_HARD (!nodestack.empty ()); CHECK (!nodestack.empty ());
CHECK (!nodestack.back ().value); CHECK (!nodestack.back ().value);
nodestack.back().value = new json::null (); nodestack.back().value = new json::null ();
} }
action new_object_key { action new_object_key {
CHECK_HARD (!nodestack.empty ()); CHECK (!nodestack.empty ());
CHECK_HARD (nodestack.back ().root->is_object ()); CHECK (nodestack.back ().root->is_object ());
CHECK (nodestack.back ().value); CHECK (nodestack.back ().value);
CHECK (!nodestack.back ().key); CHECK (!nodestack.back ().key);
nodestack.back ().key = nodestack.back ().value; nodestack.back ().key = nodestack.back ().value;
nodestack.back ().value = NULL; nodestack.back ().value = NULL;

12
maths/matrix.cpp
View File

@ -44,7 +44,7 @@ matrix::matrix (size_t _rows,
{ {
if (size () != _data.size ()) if (size () != _data.size ())
throw std::runtime_error ("element and initializer size differs"); throw std::runtime_error ("element and initializer size differs");
CHECK_HARD (m_rows * m_columns == _data.size()); CHECK_EQ (m_rows * m_columns, _data.size());
m_data.reset (new double[size ()]); m_data.reset (new double[size ()]);
std::copy (_data.begin (), _data.end (), m_data.get ()); std::copy (_data.begin (), _data.end (), m_data.get ());
@ -98,14 +98,14 @@ matrix::sanity (void) const {
const double * const double *
matrix::operator [] (unsigned int row) const { matrix::operator [] (unsigned int row) const {
CHECK_HARD (row < m_rows); CHECK_LT (row, m_rows);
return m_data.get () + row * m_columns; return m_data.get () + row * m_columns;
} }
double * double *
matrix::operator [] (unsigned int row) { matrix::operator [] (unsigned int row) {
CHECK_HARD (row < m_rows); CHECK_LT (row, m_rows);
return m_data.get () + row * m_columns; return m_data.get () + row * m_columns;
} }
@ -483,7 +483,7 @@ matrix::identity (size_t diag) {
matrix matrix
matrix::magic (size_t n) { matrix::magic (size_t n) {
CHECK_HARD (n > 2); CHECK_GT (n, 2);
if (n % 2 == 1) if (n % 2 == 1)
return magic_odd (n); return magic_odd (n);
@ -499,8 +499,8 @@ matrix::magic (size_t n) {
// If filled then drop down one row instead. Wrap around indexing. // If filled then drop down one row instead. Wrap around indexing.
matrix matrix
matrix::magic_odd (size_t n) { matrix::magic_odd (size_t n) {
CHECK_HARD (n > 2); CHECK_GT (n, 2);
CHECK_HARD (n % 2 == 1); CHECK_EQ (n % 2, 1);
matrix val (zeroes (n)); matrix val (zeroes (n));
for (unsigned int i = 1, x = n / 2, y = 0; i <= n * n; ++i) { 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, vector vector::cross (const double *restrict A,
const double *restrict B, const double *restrict B,
unsigned int size) { unsigned int size) {
CHECK_HARD (size == 3); CHECK_EQ (size, 3);
(void)size; (void)size;
return vector ({ A[1] * B[2] - A[2] * B[1], return vector ({ A[1] * B[2] - A[2] * B[1],
A[2] * B[0] - A[0] * B[2], A[2] * B[0] - A[0] * B[2],

2
matrix.cpp
View File

@ -206,7 +206,7 @@ matrix<T>::inverse_affine (void) const {
template <typename T> template <typename T>
matrix<T>& matrix<T>&
matrix<T>::invert_affine (void) { matrix<T>::invert_affine (void) {
CHECK_HARD (is_affine ()); CHECK (is_affine ());
// inv ([ M b ] == [ inv(M) -inv(M).b ] // inv ([ M b ] == [ inv(M) -inv(M).b ]
// [ 0 1 ]) [ 0 1 ] // [ 0 1 ]) [ 0 1 ]

22
net/socket.cpp
View File

@ -43,7 +43,7 @@ socket_domain<D>::socket_domain (socket_t _fd):
{ {
#ifdef __WIN32 #ifdef __WIN32
#else #else
CHECK_HARD (m_fd >= 0); CHECK_GE (m_fd, 0);
#endif #endif
} }
@ -166,8 +166,8 @@ net::socket<D, type::STREAM>::socket (const socket_type &rhs):
template <domain D> template <domain D>
void void
net::socket<D, type::STREAM>::send (const uint8_t *restrict data, size_t len) { net::socket<D, type::STREAM>::send (const uint8_t *restrict data, size_t len) {
CHECK_HARD (data != NULL); CHECK (data != NULL);
CHECK (len > 0); CHECK_GT (len, 0);
for (size_t sent = 0; sent < len; ) { for (size_t sent = 0; sent < len; ) {
ssize_t result = ::send (this->m_fd, static_cast<const void *>(data + sent), len - sent, 0); ssize_t result = ::send (this->m_fd, static_cast<const void *>(data + sent), len - sent, 0);
@ -183,8 +183,8 @@ net::socket<D, type::STREAM>::send (const uint8_t *restrict data, size_t len) {
template <domain D> template <domain D>
size_t size_t
net::socket<D, type::STREAM>::recv (uint8_t *restrict data, size_t len) { net::socket<D, type::STREAM>::recv (uint8_t *restrict data, size_t len) {
CHECK_HARD (data != NULL); CHECK (data != NULL);
CHECK (len > 0); CHECK_GT (len, 0);
ssize_t received = ::recv (this->m_fd, data, len, 0); ssize_t received = ::recv (this->m_fd, data, len, 0);
if (received < 0) if (received < 0)
@ -263,8 +263,8 @@ void
net::socket<D, type::DGRAM>::send_addr (const address_type &addr, net::socket<D, type::DGRAM>::send_addr (const address_type &addr,
const uint8_t *restrict data, const uint8_t *restrict data,
size_t len) { size_t len) {
CHECK_HARD (data != NULL); CHECK (data != NULL);
CHECK (len > 0); CHECK_GT (len, 0);
typename address_type::sockaddr_type addr_in = addr.to_sockaddr (); typename address_type::sockaddr_type addr_in = addr.to_sockaddr ();
@ -272,7 +272,7 @@ net::socket<D, type::DGRAM>::send_addr (const address_type &addr,
if (sent < 0) if (sent < 0)
net::error::throw_code (); net::error::throw_code ();
CHECK_HARD (sign_cast<size_t>(sent) == len); CHECK_EQ (sign_cast<size_t>(sent), len);
} }
@ -280,14 +280,14 @@ template <domain D>
typename net::socket<D, type::DGRAM>::address_type typename net::socket<D, type::DGRAM>::address_type
net::socket<D, type::DGRAM>::recv_addr (uint8_t *restrict data, net::socket<D, type::DGRAM>::recv_addr (uint8_t *restrict data,
size_t len) { size_t len) {
CHECK_HARD (data != NULL); CHECK (data != NULL);
CHECK (len > 0); CHECK_GT (len, 0);
typename address_type::sockaddr_type addr_in; typename address_type::sockaddr_type addr_in;
socklen_t addr_len = sizeof (addr_in); socklen_t addr_len = sizeof (addr_in);
ssize_t recvd = recvfrom (this->m_fd, data, len, 0, (sockaddr *)&addr_in, &addr_len); ssize_t recvd = recvfrom (this->m_fd, data, len, 0, (sockaddr *)&addr_in, &addr_len);
CHECK_HARD (sizeof (addr_in) == addr_len); CHECK_EQ (sizeof (addr_in), addr_len);
if (recvd < 0) if (recvd < 0)
net::error::throw_code (); net::error::throw_code ();

4
net/types.cpp
View File

@ -39,7 +39,7 @@ protocol
net::string_to_protocol (const char *_name) { net::string_to_protocol (const char *_name) {
struct protoent *entry = getprotobyname (_name); struct protoent *entry = getprotobyname (_name);
// TODO: Throw an exception... // TODO: Throw an exception...
CHECK_HARD (entry); CHECK (entry);
return (protocol)entry->p_proto; return (protocol)entry->p_proto;
} }
@ -47,7 +47,7 @@ net::string_to_protocol (const char *_name) {
std::string std::string
net::protocol_to_string (protocol _protocol) { net::protocol_to_string (protocol _protocol) {
struct protoent *entry = getprotobynumber ((int)_protocol); struct protoent *entry = getprotobynumber ((int)_protocol);
CHECK_HARD (entry); CHECK (entry);
return entry->p_name; return entry->p_name;
} }

4
noise/basis.cpp
View File

@ -247,7 +247,7 @@ cellular::eval (double x, double y) const {
} }
std::sort (std::begin (distances), std::end (distances)); std::sort (std::begin (distances), std::end (distances));
CHECK_SOFT (distances[0] >= 0); CHECK_GE (distances[0], 0);
CHECK_SOFT (bounds ().contains (distances[0])); CHECK (bounds ().contains (distances[0]));
return distances[0]; return distances[0];
} }

6
point.cpp
View File

@ -148,9 +148,9 @@ util::point<S,T>::operator== (const util::point<S,T> &rhs) const
template <size_t S, typename T> template <size_t S, typename T>
void void
util::point<S,T>::sanity (void) const { util::point<S,T>::sanity (void) const {
CHECK_SOFT (std::all_of (begin (this->data), CHECK (std::all_of (begin (this->data),
end (this->data), end (this->data),
[] (double i) { return !std::isnan (i); })); [] (double i) { return !std::isnan (i); }));
} }

4
test/float.cpp
View File

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

2
test/ip.cpp
View File

@ -23,7 +23,7 @@ main (int, char **) {
for (unsigned int i = 0; i < elems (data); ++i) { for (unsigned int i = 0; i < elems (data); ++i) {
ipv4::ip parsed (ipv4::ip::parse (data[i].str)); ipv4::ip parsed (ipv4::ip::parse (data[i].str));
CHECK_HARD (parsed == data[i].ip); CHECK (parsed == data[i].ip);
} }
return EXIT_SUCCESS; return EXIT_SUCCESS;

98
test/json/types.cpp
View File

@ -25,24 +25,24 @@ main (int, char**) {
"}"; "}";
std::unique_ptr<json::node> ptr = json::parse (TEST_STRING); std::unique_ptr<json::node> ptr = json::parse (TEST_STRING);
CHECK_HARD (ptr->is_object ()); CHECK (ptr->is_object ());
const json::node &ref = *ptr; const json::node &ref = *ptr;
CHECK_HARD ( ref["string"].is_string ()); CHECK ( ref["string"].is_string ());
CHECK_HARD (!ref["string"].is_array ()); CHECK (!ref["string"].is_array ());
CHECK_HARD (!ref["string"].is_boolean ()); CHECK (!ref["string"].is_boolean ());
CHECK_HARD (!ref["string"].is_null ()); CHECK (!ref["string"].is_null ());
CHECK_HARD (!ref["string"].is_number ()); CHECK (!ref["string"].is_number ());
CHECK_HARD (!ref["string"].is_object ()); CHECK (!ref["string"].is_object ());
CHECK_EQ ( ref["string"].as_string (), "brad"); CHECK_EQ ( ref["string"].as_string (), "brad");
CHECK_HARD ( ref["integer"].is_number ()); CHECK ( ref["integer"].is_number ());
CHECK_HARD (!ref["integer"].is_array ()); CHECK (!ref["integer"].is_array ());
CHECK_HARD (!ref["integer"].is_boolean ()); CHECK (!ref["integer"].is_boolean ());
CHECK_HARD (!ref["integer"].is_null ()); CHECK (!ref["integer"].is_null ());
CHECK_HARD (!ref["integer"].is_object ()); CHECK (!ref["integer"].is_object ());
CHECK_HARD (!ref["integer"].is_string ()); CHECK (!ref["integer"].is_string ());
CHECK ( CHECK (
exactly_equal ( exactly_equal (
(unsigned)ref["integer"].as_number ().native (), (unsigned)ref["integer"].as_number ().native (),
@ -50,35 +50,35 @@ main (int, char**) {
) )
); );
CHECK_HARD ( ref["null"].is_null ()); CHECK ( ref["null"].is_null ());
CHECK_HARD (!ref["null"].is_array ()); CHECK (!ref["null"].is_array ());
CHECK_HARD (!ref["null"].is_boolean ()); CHECK (!ref["null"].is_boolean ());
CHECK_HARD (!ref["null"].is_number ()); CHECK (!ref["null"].is_number ());
CHECK_HARD (!ref["null"].is_object ()); CHECK (!ref["null"].is_object ());
CHECK_HARD (!ref["null"].is_string ()); CHECK (!ref["null"].is_string ());
CHECK_HARD ( ref["false"].is_boolean ()); CHECK ( ref["false"].is_boolean ());
CHECK_HARD (!ref["false"].is_array ()); CHECK (!ref["false"].is_array ());
CHECK_HARD (!ref["false"].is_null ()); CHECK (!ref["false"].is_null ());
CHECK_HARD (!ref["false"].is_number ()); CHECK (!ref["false"].is_number ());
CHECK_HARD (!ref["false"].is_object ()); CHECK (!ref["false"].is_object ());
CHECK_HARD (!ref["false"].is_string ()); CHECK (!ref["false"].is_string ());
CHECK_EQ ( ref["false"].as_boolean (), false); CHECK_EQ ( ref["false"].as_boolean (), false);
CHECK_HARD ( ref["true"].is_boolean ()); CHECK ( ref["true"].is_boolean ());
CHECK_HARD (!ref["true"].is_array ()); CHECK (!ref["true"].is_array ());
CHECK_HARD (!ref["true"].is_null ()); CHECK (!ref["true"].is_null ());
CHECK_HARD (!ref["true"].is_number ()); CHECK (!ref["true"].is_number ());
CHECK_HARD (!ref["true"].is_object ()); CHECK (!ref["true"].is_object ());
CHECK_HARD (!ref["true"].is_string ()); CHECK (!ref["true"].is_string ());
CHECK_EQ ( ref["true"].as_boolean (), true); CHECK_EQ ( ref["true"].as_boolean (), true);
CHECK_HARD ( ref["double"].is_number ()); CHECK ( ref["double"].is_number ());
CHECK_HARD (!ref["double"].is_array ()); CHECK (!ref["double"].is_array ());
CHECK_HARD (!ref["double"].is_boolean ()); CHECK (!ref["double"].is_boolean ());
CHECK_HARD (!ref["double"].is_null ()); CHECK (!ref["double"].is_null ());
CHECK_HARD (!ref["double"].is_object ()); CHECK (!ref["double"].is_object ());
CHECK_HARD (!ref["double"].is_string ()); CHECK (!ref["double"].is_string ());
CHECK ( CHECK (
exactly_equal ( exactly_equal (
ref["double"].as_number ().native (), ref["double"].as_number ().native (),
@ -86,19 +86,19 @@ main (int, char**) {
) )
); );
CHECK_HARD ( ref["object"].is_object ()); CHECK ( ref["object"].is_object ());
CHECK_HARD (!ref["object"].is_array ()); CHECK (!ref["object"].is_array ());
CHECK_HARD (!ref["object"].is_boolean ()); CHECK (!ref["object"].is_boolean ());
CHECK_HARD (!ref["object"].is_null ()); CHECK (!ref["object"].is_null ());
CHECK_HARD (!ref["object"].is_number ()); CHECK (!ref["object"].is_number ());
CHECK_HARD (!ref["object"].is_string ()); CHECK (!ref["object"].is_string ());
CHECK_HARD ( ref["array"].is_array ()); CHECK ( ref["array"].is_array ());
CHECK_HARD (!ref["array"].is_boolean ()); CHECK (!ref["array"].is_boolean ());
CHECK_HARD (!ref["array"].is_null ()); CHECK (!ref["array"].is_null ());
CHECK_HARD (!ref["array"].is_number ()); CHECK (!ref["array"].is_number ());
CHECK_HARD (!ref["array"].is_object ()); CHECK (!ref["array"].is_object ());
CHECK_HARD (!ref["array"].is_string ()); CHECK (!ref["array"].is_string ());
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

16
test/maths/maths.cpp
View File

@ -13,15 +13,15 @@ main (int, char **) {
std::cerr.precision (15); std::cerr.precision (15);
std::cout.precision (15); std::cout.precision (15);
CHECK_HARD (!almost_equal (-2.0, 0.0)); CHECK (!almost_equal (-2.0, 0.0));
CHECK_HARD (!almost_equal (-2.f, 0.f)); CHECK (!almost_equal (-2.f, 0.f));
CHECK_HARD ( almost_equal ( 0.0, 0.0)); CHECK ( almost_equal ( 0.0, 0.0));
//CHECK_HARD ( almost_equal ( 0.0, numeric_limits<double>::min ())); //CHECK_HARD ( almost_equal ( 0.0, numeric_limits<double>::min ()));
CHECK_HARD ( almost_equal (numeric_limits<double>::infinity (), CHECK ( almost_equal (numeric_limits<double>::infinity (),
numeric_limits<double>::infinity ())); numeric_limits<double>::infinity ()));
CHECK_HARD (!almost_equal (numeric_limits<double>::infinity (), 0.0)); CHECK (!almost_equal (numeric_limits<double>::infinity (), 0.0));
CHECK_HARD (!almost_equal (numeric_limits<double>::quiet_NaN (), CHECK (!almost_equal (numeric_limits<double>::quiet_NaN (),
numeric_limits<double>::quiet_NaN ())); numeric_limits<double>::quiet_NaN ()));
CHECK_EQ (min (-2, 0, 2), -2); CHECK_EQ (min (-2, 0, 2), -2);

20
test/maths/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 i = 0; i < m.rows (); ++i)
for (unsigned int j = 0; j < m.columns (); ++j) for (unsigned int j = 0; j < m.columns (); ++j)
CHECK_HARD (almost_equal (m[i][j], 0.0)); CHECK (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 i = 0; i < m.rows (); ++i)
for (unsigned int j = 0; j < m.columns (); ++j) for (unsigned int j = 0; j < m.columns (); ++j)
if (i == j) { if (i == j) {
CHECK_HARD (almost_equal (m[i][j], 1.0)); CHECK (almost_equal (m[i][j], 1.0));
} else { } else {
CHECK_HARD (almost_equal (m[i][j], 0.0)); CHECK (almost_equal (m[i][j], 0.0));
} }
} }
@ -102,9 +102,9 @@ main (int, char **) {
CHECK_EQ (seq2x2.determinant (), -2.0); CHECK_EQ (seq2x2.determinant (), -2.0);
CHECK_EQ (magic3.determinant (), -360.0); CHECK_EQ (magic3.determinant (), -360.0);
CHECK_HARD ( seq2x2.is_square ()); CHECK ( seq2x2.is_square ());
CHECK_HARD ( magic3.is_square ()); CHECK ( magic3.is_square ());
CHECK_HARD (! a4x2.is_square ()); CHECK (! 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 })); 1.5, -0.5 }));
@ -124,10 +124,10 @@ main (int, char **) {
const matrix homo3x3 (3, 3, { 1, 2, 0, const matrix homo3x3 (3, 3, { 1, 2, 0,
3, 4, 0, 3, 4, 0,
0, 0, 1 }); 0, 0, 1 });
CHECK_HARD (homo3x3.is_homogeneous ()); CHECK (homo3x3.is_homogeneous ());
CHECK_HARD (!matrix::zeroes (3).is_homogeneous ()); CHECK (!matrix::zeroes (3).is_homogeneous ());
CHECK_HARD ( matrix::identity (3).is_homogeneous ()); CHECK ( matrix::identity (3).is_homogeneous ());
CHECK_HARD (invertible4.is_homogeneous ()); CHECK (invertible4.is_homogeneous ());
return EXIT_SUCCESS; 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. // Take all pointers out, checking they are unique, then replace for destruction.
for (unsigned int i = 0; i < uintpool.capacity (); ++i) { for (unsigned int i = 0; i < uintpool.capacity (); ++i) {
bool success = uintset.insert (uintpool.acquire ()).second; bool success = uintset.insert (uintpool.acquire ()).second;
CHECK_HARD (success); CHECK (success);
} }
for (auto i = uintset.begin (); i != uintset.end (); ++i) 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 // Do the above one more time to ensure that releasing works right
for (unsigned int i = 0; i < uintpool.capacity (); ++i) { for (unsigned int i = 0; i < uintpool.capacity (); ++i) {
bool success = uintset.insert (uintpool.acquire ()).second; bool success = uintset.insert (uintpool.acquire ()).second;
CHECK_HARD (success); CHECK (success);
} }
for (auto i = uintset.begin (); i != uintset.end (); ++i) for (auto i = uintset.begin (); i != uintset.end (); ++i)
@ -57,19 +57,19 @@ check_keep_value (void) {
uintvector.push_back(item); uintvector.push_back(item);
} }
CHECK (uintvector.size () == uintpool.capacity ()); CHECK_EQ (uintvector.size (), uintpool.capacity ());
// Ensure they're all still present // Ensure they're all still present
vector<bool> present(uintpool.capacity (), false); vector<bool> present(uintpool.capacity (), false);
for (auto i = uintvector.begin (); i != uintvector.end (); ++i) { for (auto i = uintvector.begin (); i != uintvector.end (); ++i) {
CHECK_HARD (**i < uintpool.capacity ()); CHECK (**i < uintpool.capacity ());
CHECK_HARD (present[**i] != true); CHECK (present[**i] != true);
present[**i] = true; present[**i] = true;
} }
// All must have been marked as present... // All must have been marked as present...
CHECK_HARD (find (present.begin (), present.end (), false) == present.end ()); CHECK (find (present.begin (), present.end (), false) == present.end ());
// Release all back into the pool for destruction // Release all back into the pool for destruction
for (auto i = uintvector.begin (); i != uintvector.end (); ++i) for (auto i = uintvector.begin (); i != uintvector.end (); ++i)

40
test/range.cpp
View File

@ -10,35 +10,35 @@ using namespace util;
int int
main (int, char **) { main (int, char **) {
// Check some simple cases close to the edges of a unit range. Tests float rounding. // Check some simple cases close to the edges of a unit range. Tests float rounding.
CHECK_HARD ( range<double>::UNIT.contains ( 0.0)); CHECK ( range<double>::UNIT.contains ( 0.0));
CHECK_HARD ( range<double>::UNIT.contains ( 0.5)); CHECK ( range<double>::UNIT.contains ( 0.5));
CHECK_HARD ( range<double>::UNIT.contains ( 1.0)); CHECK ( range<double>::UNIT.contains ( 1.0));
CHECK_HARD ( range<double>::UNIT.contains (std::numeric_limits<double>::min ())); CHECK ( range<double>::UNIT.contains (std::numeric_limits<double>::min ()));
CHECK_HARD (!range<double>::UNIT.contains (-0.00001)); CHECK (!range<double>::UNIT.contains (-0.00001));
CHECK_HARD (!range<double>::UNIT.contains ( 1.00001)); CHECK (!range<double>::UNIT.contains ( 1.00001));
// Check edge cases of unit with integer values // Check edge cases of unit with integer values
CHECK_HARD ( range<uint16_t>::UNIT.contains (0)); CHECK ( range<uint16_t>::UNIT.contains (0));
CHECK_HARD ( range<uint16_t>::UNIT.contains (1)); CHECK ( range<uint16_t>::UNIT.contains (1));
CHECK_HARD (!range<uint16_t>::UNIT.contains (2)); CHECK (!range<uint16_t>::UNIT.contains (2));
CHECK_HARD (!range<uint16_t>::UNIT.contains (numeric_limits <uint16_t>::max ())); CHECK (!range<uint16_t>::UNIT.contains (numeric_limits <uint16_t>::max ()));
// Check the inclusivity of UNLIMITED with special floating values // Check the inclusivity of UNLIMITED with special floating values
CHECK_HARD ( range<double>::UNLIMITED.contains (0.0)); CHECK ( range<double>::UNLIMITED.contains (0.0));
CHECK_HARD ( range<double>::UNLIMITED.contains (+numeric_limits<double>::infinity ())); CHECK ( range<double>::UNLIMITED.contains (+numeric_limits<double>::infinity ()));
CHECK_HARD ( range<double>::UNLIMITED.contains (-numeric_limits<double>::infinity ())); CHECK ( range<double>::UNLIMITED.contains (-numeric_limits<double>::infinity ()));
CHECK_HARD (!range<double>::UNLIMITED.contains ( numeric_limits<double>::quiet_NaN ())); CHECK (!range<double>::UNLIMITED.contains ( numeric_limits<double>::quiet_NaN ()));
// Check the inclusivity of UNLIMITED with some large numbers // Check the inclusivity of UNLIMITED with some large numbers
CHECK_HARD ( range<uint16_t>::UNLIMITED.contains (numeric_limits<uint16_t>::min())); CHECK ( range<uint16_t>::UNLIMITED.contains (numeric_limits<uint16_t>::min()));
CHECK_HARD ( range<uint16_t>::UNLIMITED.contains (numeric_limits<uint16_t>::max())); CHECK ( range<uint16_t>::UNLIMITED.contains (numeric_limits<uint16_t>::max()));
// Check inclusivity of MAX // Check inclusivity of MAX
CHECK_HARD (!range<double>::MAX.contains ( numeric_limits<double>::infinity ())); CHECK (!range<double>::MAX.contains ( numeric_limits<double>::infinity ()));
CHECK_HARD (!range<double>::MAX.contains (-numeric_limits<double>::infinity ())); CHECK (!range<double>::MAX.contains (-numeric_limits<double>::infinity ()));
CHECK_HARD ( range<uint16_t>::MAX.contains (numeric_limits<uint16_t>::min())); CHECK ( range<uint16_t>::MAX.contains (numeric_limits<uint16_t>::min()));
CHECK_HARD ( range<uint16_t>::MAX.contains (numeric_limits<uint16_t>::max())); CHECK ( range<uint16_t>::MAX.contains (numeric_limits<uint16_t>::max()));
// Check that expansion via NaN is a noop // Check that expansion via NaN is a noop
{ {

22
test/region.cpp
View File

@ -12,25 +12,25 @@ main (int, char **) {
region<double> a (32.7, -6.09703, 0.8, 2); region<double> a (32.7, -6.09703, 0.8, 2);
region<double> b (33.5, -4.5, 0.5, 0.5); region<double> b (33.5, -4.5, 0.5, 0.5);
CHECK_HARD (!a.intersects (b)); CHECK (!a.intersects (b));
} }
CHECK_HARD (region<double>::MAX.intersects (region<double>::UNIT)); CHECK (region<double>::MAX.intersects (region<double>::UNIT));
CHECK_HARD (region< float>::MAX.intersects (region< float>::UNIT)); CHECK (region< float>::MAX.intersects (region< float>::UNIT));
CHECK_EQ (region<double>::UNIT.area (), 1.0); CHECK_EQ (region<double>::UNIT.area (), 1.0);
CHECK_EQ (region< float>::UNIT.area (), 1.0f); CHECK_EQ (region< float>::UNIT.area (), 1.0f);
CHECK_HARD (region<int> (0, 0, 2, 2).includes (point<2,int>(1, 1))); CHECK (region<int> (0, 0, 2, 2).includes (point<2,int>(1, 1)));
CHECK_HARD (region<int> (0, 0, 2, 2).includes (point<2,int>(0, 0))); CHECK (region<int> (0, 0, 2, 2).includes (point<2,int>(0, 0)));
CHECK_HARD (region<int> (0, 0, 2, 2).includes (point<2,int>(2, 2))); CHECK (region<int> (0, 0, 2, 2).includes (point<2,int>(2, 2)));
CHECK_HARD ( region<int> (0, 0, 2, 2).contains (point<2,int>(1, 1))); CHECK ( region<int> (0, 0, 2, 2).contains (point<2,int>(1, 1)));
CHECK_HARD (!region<int> (0, 0, 2, 2).contains (point<2,int>(0, 0))); CHECK (!region<int> (0, 0, 2, 2).contains (point<2,int>(0, 0)));
CHECK_HARD (!region<int> (0, 0, 2, 2).contains (point<2,int>(2, 2))); CHECK (!region<int> (0, 0, 2, 2).contains (point<2,int>(2, 2)));
//CHECK_HARD (region<intmax_t> (0, 0, 10, 10).includes (point2d (0.4, 0.01))); //CHECK (region<intmax_t> (0, 0, 10, 10).includes (point2d (0.4, 0.01)));
//CHECK_HARD (region<intmax_t> (0, 0, 10, 10).contains (point2d (0.4, 0.01))); //CHECK (region<intmax_t> (0, 0, 10, 10).contains (point2d (0.4, 0.01)));
return 0; return 0;
} }

4
test/ripemd.cpp
View File

@ -111,7 +111,7 @@ main(int, char**) {
strlen (TESTS[i].input)); strlen (TESTS[i].input));
obj.finish (); obj.finish ();
CHECK_HARD (obj.digest () == TESTS[i].output); CHECK (obj.digest () == TESTS[i].output);
} }
// Perform 'million-a' check // Perform 'million-a' check
@ -130,7 +130,7 @@ main(int, char**) {
0x52, 0x78, 0x32, 0x43, 0xc1, 0x69, 0x7b, 0xdb, 0xe1, 0x6d, 0x52, 0x78, 0x32, 0x43, 0xc1, 0x69, 0x7b, 0xdb, 0xe1, 0x6d,
0x37, 0xf9, 0x7f, 0x68, 0xf0, 0x83, 0x25, 0xdc, 0x15, 0x28 0x37, 0xf9, 0x7f, 0x68, 0xf0, 0x83, 0x25, 0xdc, 0x15, 0x28
}; };
CHECK_HARD (obj.digest () == MILLION); CHECK (obj.digest () == MILLION);
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

2
test/version.cpp
View File

@ -44,7 +44,7 @@ main (int, char **) {
if (i->parts.size () > 2) CHECK (v.point () == i->parts[2]); 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 () > 3) CHECK (v.build () == i->parts[3]);
CHECK_HARD (i->parts.size () <= 4); CHECK_LE (i->parts.size (), 4);
} }
return EXIT_SUCCESS; return EXIT_SUCCESS;

4
time.cpp
View File

@ -58,8 +58,8 @@ util::nanoseconds (void) {
struct timespec t; struct timespec t;
clock_gettime (CLOCK_MONOTONIC, &t); clock_gettime (CLOCK_MONOTONIC, &t);
CHECK_SOFT (t.tv_sec > 0); CHECK_GT (t.tv_sec, 0);
CHECK_SOFT (t.tv_nsec > 0); CHECK_GT (t.tv_nsec, 0);
return static_cast<uint64_t> (t.tv_sec) * SECOND + static_cast<uint64_t> (t.tv_nsec); return static_cast<uint64_t> (t.tv_sec) * SECOND + static_cast<uint64_t> (t.tv_nsec);
} }

2
tools/json-schema.cpp
View File

@ -382,7 +382,7 @@ is_additional_items_valid (const json::array &,
bool bool
is_array_valid (const json::array &node, is_array_valid (const json::array &node,
const json::object &schema) { const json::object &schema) {
CHECK_HARD (node.is_array ()); CHECK (node.is_array ());
typedef bool (*array_validator_t)(const json::array&, const json::node&); typedef bool (*array_validator_t)(const json::array&, const json::node&);
static const map<string, array_validator_t> VALIDATORS ({ static const map<string, array_validator_t> VALIDATORS ({

20
types/casts.hpp
View File

@ -34,7 +34,7 @@ namespace detail {
std::is_unsigned<T>::value && std::is_unsigned<T>::value &&
std::is_signed<V>::value, V>::type v) std::is_signed<V>::value, V>::type v)
{ {
CHECK_HARD (v >= 0); CHECK_GE (v, 0);
return static_cast<T> (v); return static_cast<T> (v);
} }
@ -45,7 +45,7 @@ namespace detail {
std::is_signed<T>::value && std::is_signed<T>::value &&
std::is_unsigned<V>::value, V>::type v) std::is_unsigned<V>::value, V>::type v)
{ {
CHECK_HARD (v < std::numeric_limits<V>::max () / 2); CHECK_LT (v, std::numeric_limits<V>::max () / 2);
return static_cast<T> (v); return static_cast<T> (v);
} }
@ -80,8 +80,8 @@ namespace detail {
_trunc_cast (const typename std::enable_if<sizeof (T) < sizeof (V) && _trunc_cast (const typename std::enable_if<sizeof (T) < sizeof (V) &&
std::is_signed<T>::value == std::is_signed<V>::value && std::is_signed<T>::value == std::is_signed<V>::value &&
std::is_integral<T>::value, V>::type v) { std::is_integral<T>::value, V>::type v) {
CHECK_HARD (v <= std::numeric_limits<T>::max ()); CHECK_LE (v, std::numeric_limits<T>::max ());
CHECK_HARD (v >= std::numeric_limits<T>::lowest ()); CHECK_GE (v, std::numeric_limits<T>::lowest ());
return static_cast<T> (v); return static_cast<T> (v);
} }
@ -92,9 +92,9 @@ namespace detail {
_trunc_cast (const typename std::enable_if<sizeof (T) < sizeof (V) && _trunc_cast (const typename std::enable_if<sizeof (T) < sizeof (V) &&
std::is_signed<T>::value == std::is_signed<V>::value && std::is_signed<T>::value == std::is_signed<V>::value &&
std::is_floating_point<T>::value, V>::type v) { std::is_floating_point<T>::value, V>::type v) {
CHECK_HARD (v <= std::numeric_limits<T>::max ()); CHECK_LE (v, std::numeric_limits<T>::max ());
CHECK_HARD (v >= std::numeric_limits<T>::lowest ()); CHECK_GE (v, std::numeric_limits<T>::lowest ());
CHECK_HARD (exactly_equal (remainder (v, 1), 0.0)); CHECK_EQ (remainder (v, 1), 0.0);
return static_cast<T> (v); return static_cast<T> (v);
} }
@ -111,8 +111,8 @@ trunc_cast (V v)
template <typename T, typename V> template <typename T, typename V>
T T
size_cast (const V v) { size_cast (const V v) {
CHECK_HARD (std::numeric_limits<T>::lowest () <= v); CHECK_LE (std::numeric_limits<T>::lowest (), v);
CHECK_HARD (std::numeric_limits<T>::max () >= v); CHECK_GE (std::numeric_limits<T>::max (), v);
return static_cast<T> (v); return static_cast<T> (v);
} }
@ -122,7 +122,7 @@ size_cast (const V v) {
template <typename T, typename V> template <typename T, typename V>
T* T*
known_cast (V *v) { known_cast (V *v) {
CHECK_HARD (nullptr != dynamic_cast<T*> (v)); CHECK (dynamic_cast<T*> (v));
return static_cast<T*> (v); return static_cast<T*> (v);
} }

6
vector.cpp
View File

@ -346,9 +346,9 @@ util::vector<S,T>::ZERO (T{0});
template <size_t S, typename T> template <size_t S, typename T>
void void
util::vector<S,T>::sanity (void) const { util::vector<S,T>::sanity (void) const {
CHECK_SOFT (std::all_of (begin (this->data), CHECK (std::all_of (begin (this->data),
end (this->data), end (this->data),
[] (T i) { return !std::isnan (i); })); [] (T i) { return !std::isnan (i); }));
} }

2
version.cpp.rl
View File

@ -180,7 +180,7 @@ version::operator== (const version &rhs) const {
std::ostream& std::ostream&
operator <<(std::ostream& os, const util::version& rhs) { operator <<(std::ostream& os, const util::version& rhs) {
size_t elements = rhs.size; size_t elements = rhs.size;
CHECK_HARD (elements > 0); CHECK_GT (elements, 0);
os << rhs.major (); os << rhs.major ();
if (!--elements) if (!--elements)