root/pbsplash
1
0
Fork 0
mirror of https://git.sr.ht/~calebccff/pbsplash synced 2026-01-12 20:48:40 -09:00
Code Issues Projects Releases Packages Wiki Activity Actions
pbsplash/src/timespec.c
Caleb Connolly 01af13950c
WIP: vendor tfblib + clang-format 
We only need a subset of it, to iterate faster and integrate features
like in-line rotation let's vendor it for now.

Signed-off-by: Caleb Connolly <caleb@connolly.tech>
2023-07-28 20:15:06 +01:00

990 lines
No EOL
39 KiB
C
Raw Blame History

/* Functions for working with timespec structures
* Written by Daniel Collins (2017-2021)
* timespec_mod by Alex Forencich (2019)
* Various contributions by Ingo Albrecht (2021)
*
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* For more information, please refer to <http://unlicense.org/>
*/
/** \file timespec.c
* \brief Functions for working with timespec structures.
*
* This library aims to provide a comprehensive set of functions with
* well-defined behaviour that handle all edge cases (e.g. negative values) in
* a sensible manner.
*
* Negative values are allowed in the tv_sec and/or tv_usec field of timespec
* structures, tv_usec is always relative to tv_sec, so mixing positive and
* negative values will produce consistent results:
*
* <PRE>
* { tv_sec = 1, tv_nsec = 500000000 } == 1.5 seconds
* { tv_sec = 1, tv_nsec = 0 } == 1.0 seconds
* { tv_sec = 1, tv_nsec = -500000000 } == 0.5 seconds
* { tv_sec = 0, tv_nsec = 500000000 } == 0.5 seconds
* { tv_sec = 0, tv_nsec = 0 } == 0.0 seconds
* { tv_sec = 0, tv_nsec = -500000000 } == -0.5 seconds
* { tv_sec = -1, tv_nsec = 500000000 } == -0.5 seconds
* { tv_sec = -1, tv_nsec = 0 } == -1.0 seconds
* { tv_sec = -1, tv_nsec = -500000000 } == -1.5 seconds
* </PRE>
*
* Furthermore, any timespec structure processed or returned by library functions
* is normalised according to the rules in timespec_normalise().
*/
#include <inttypes.h>
#include <limits.h>
#include <stdbool.h>
#include <sys/time.h>
#include <time.h>
#include "timespec.h"
#define NSEC_PER_SEC 1000000000
/** \fn struct timespec timespec_add(struct timespec ts1, struct timespec ts2)
* \brief Returns the result of adding two timespec structures.
*/
struct timespec timespec_add(struct timespec ts1, struct timespec ts2)
{
/* Normalise inputs to prevent tv_nsec rollover if whole-second values
* are packed in it.
*/
ts1 = timespec_normalise(ts1);
ts2 = timespec_normalise(ts2);
ts1.tv_sec += ts2.tv_sec;
ts1.tv_nsec += ts2.tv_nsec;
return timespec_normalise(ts1);
}
/** \fn struct timespec timespec_sub(struct timespec ts1, struct timespec ts2)
* \brief Returns the result of subtracting ts2 from ts1.
*/
struct timespec timespec_sub(struct timespec ts1, struct timespec ts2)
{
/* Normalise inputs to prevent tv_nsec rollover if whole-second values
* are packed in it.
*/
ts1 = timespec_normalise(ts1);
ts2 = timespec_normalise(ts2);
ts1.tv_sec -= ts2.tv_sec;
ts1.tv_nsec -= ts2.tv_nsec;
return timespec_normalise(ts1);
}
/** \fn struct timespec timespec_mod(struct timespec ts1, struct timespec ts2)
* \brief Returns the remainder left over after dividing ts1 by ts2 (ts1%ts2).
*/
struct timespec timespec_mod(struct timespec ts1, struct timespec ts2)
{
int i = 0;
bool neg1 = false;
bool neg2 = false;
/* Normalise inputs to prevent tv_nsec rollover if whole-second values
* are packed in it.
*/
ts1 = timespec_normalise(ts1);
ts2 = timespec_normalise(ts2);
/* If ts2 is zero, just return ts1
*/
if (ts2.tv_sec == 0 && ts2.tv_nsec == 0) {
return ts1;
}
/* If inputs are negative, flip and record sign
*/
if (ts1.tv_sec < 0 || ts1.tv_nsec < 0) {
neg1 = true;
ts1.tv_sec = -ts1.tv_sec;
ts1.tv_nsec = -ts1.tv_nsec;
}
if (ts2.tv_sec < 0 || ts2.tv_nsec < 0) {
neg2 = true;
ts2.tv_sec = -ts2.tv_sec;
ts2.tv_nsec = -ts2.tv_nsec;
}
/* Shift ts2 until it is larger than ts1 or is about to overflow
*/
while ((ts2.tv_sec < (LONG_MAX >> 1)) && timespec_ge(ts1, ts2)) {
i++;
ts2.tv_nsec <<= 1;
ts2.tv_sec <<= 1;
if (ts2.tv_nsec > NSEC_PER_SEC) {
ts2.tv_nsec -= NSEC_PER_SEC;
ts2.tv_sec++;
}
}
/* Division by repeated subtraction
*/
while (i >= 0) {
if (timespec_ge(ts1, ts2)) {
ts1 = timespec_sub(ts1, ts2);
}
if (i == 0) {
break;
}
i--;
if (ts2.tv_sec & 1) {
ts2.tv_nsec += NSEC_PER_SEC;
}
ts2.tv_nsec >>= 1;
ts2.tv_sec >>= 1;
}
/* If signs differ and result is nonzero, subtract once more to cross zero
*/
if (neg1 ^ neg2 && (ts1.tv_sec != 0 || ts1.tv_nsec != 0)) {
ts1 = timespec_sub(ts1, ts2);
}
/* Restore sign
*/
if (neg1) {
ts1.tv_sec = -ts1.tv_sec;
ts1.tv_nsec = -ts1.tv_nsec;
}
return ts1;
}
/** \fn struct timespec timespec_min(struct timespec ts1, struct timespec ts2)
* \brief Return the lesser one of the two given timespec values.
*/
struct timespec timespec_min(struct timespec ts1, struct timespec ts2)
{
if (timespec_le(ts1, ts2)) {
return ts1;
} else {
return ts2;
}
}
/** \fn struct timespec timespec_max(struct timespec ts1, struct timespec ts2)
* \brief Return the greater one of the two given timespec values.
*/
struct timespec timespec_max(struct timespec ts1, struct timespec ts2)
{
if (timespec_ge(ts1, ts2)) {
return ts1;
} else {
return ts2;
}
}
/** \fn struct timespec timespec_clamp(struct timespec ts, struct timespec min, struct timespec max)
* \brief Clamp the value of TS between MIN and MAX.
*/
struct timespec timespec_clamp(struct timespec ts, struct timespec min, struct timespec max)
{
if (timespec_gt(ts, max)) {
return max;
}
if (timespec_lt(ts, min)) {
return min;
}
return ts;
}
/** \fn int timespec_cmp(struct timespec ts1, struct timespec ts2)
* \brief Returns (1, 0, -1) if ts1 is (greater than, equal to, less than) to ts2.
*/
int timespec_cmp(struct timespec ts1, struct timespec ts2)
{
ts1 = timespec_normalise(ts1);
ts2 = timespec_normalise(ts2);
if (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec == ts2.tv_nsec) {
return 0;
} else if ((ts1.tv_sec > ts2.tv_sec) ||
(ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec > ts2.tv_nsec)) {
return 1;
} else {
return -1;
}
}
/** \fn bool timespec_eq(struct timespec ts1, struct timespec ts2)
* \brief Returns true if the two timespec structures are equal.
*/
bool timespec_eq(struct timespec ts1, struct timespec ts2)
{
ts1 = timespec_normalise(ts1);
ts2 = timespec_normalise(ts2);
return (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec == ts2.tv_nsec);
}
/** \fn bool timespec_gt(struct timespec ts1, struct timespec ts2)
* \brief Returns true if ts1 is greater than ts2.
*/
bool timespec_gt(struct timespec ts1, struct timespec ts2)
{
ts1 = timespec_normalise(ts1);
ts2 = timespec_normalise(ts2);
return (ts1.tv_sec > ts2.tv_sec || (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec > ts2.tv_nsec));
}
/** \fn bool timespec_ge(struct timespec ts1, struct timespec ts2)
* \brief Returns true if ts1 is greater than or equal to ts2.
*/
bool timespec_ge(struct timespec ts1, struct timespec ts2)
{
ts1 = timespec_normalise(ts1);
ts2 = timespec_normalise(ts2);
return (ts1.tv_sec > ts2.tv_sec ||
(ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec >= ts2.tv_nsec));
}
/** \fn bool timespec_lt(struct timespec ts1, struct timespec ts2)
* \brief Returns true if ts1 is less than ts2.
*/
bool timespec_lt(struct timespec ts1, struct timespec ts2)
{
ts1 = timespec_normalise(ts1);
ts2 = timespec_normalise(ts2);
return (ts1.tv_sec < ts2.tv_sec || (ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec < ts2.tv_nsec));
}
/** \fn bool timespec_le(struct timespec ts1, struct timespec ts2)
* \brief Returns true if ts1 is less than or equal to ts2.
*/
bool timespec_le(struct timespec ts1, struct timespec ts2)
{
ts1 = timespec_normalise(ts1);
ts2 = timespec_normalise(ts2);
return (ts1.tv_sec < ts2.tv_sec ||
(ts1.tv_sec == ts2.tv_sec && ts1.tv_nsec <= ts2.tv_nsec));
}
/** \fn struct timespec timespec_from_double(double s)
* \brief Converts a fractional number of seconds to a timespec.
*/
struct timespec timespec_from_double(double s)
{
struct timespec ts = {
.tv_sec = s,
.tv_nsec = (s - (long)(s)) * NSEC_PER_SEC,
};
return timespec_normalise(ts);
}
/** \fn double timespec_to_double(struct timespec ts)
* \brief Converts a timespec to a fractional number of seconds.
*/
double timespec_to_double(struct timespec ts)
{
return ((double)(ts.tv_sec) + ((double)(ts.tv_nsec) / NSEC_PER_SEC));
}
/** \fn struct timespec timespec_from_timeval(struct timeval tv)
* \brief Converts a timeval to a timespec.
*/
struct timespec timespec_from_timeval(struct timeval tv)
{
struct timespec ts = { .tv_sec = tv.tv_sec, .tv_nsec = tv.tv_usec * 1000 };
return timespec_normalise(ts);
}
/** \fn struct timeval timespec_to_timeval(struct timespec ts)
* \brief Converts a timespec to a timeval.
*/
struct timeval timespec_to_timeval(struct timespec ts)
{
ts = timespec_normalise(ts);
struct timeval tv = {
.tv_sec = ts.tv_sec,
.tv_usec = ts.tv_nsec / 1000,
};
return tv;
}
/** \fn struct timespec timespec_from_ms(long milliseconds)
* \brief Converts an integer number of milliseconds to a timespec.
*/
struct timespec timespec_from_ms(long milliseconds)
{
struct timespec ts = {
.tv_sec = (milliseconds / 1000),
.tv_nsec = (milliseconds % 1000) * 1000000,
};
return timespec_normalise(ts);
}
/** \fn long timespec_to_ms(struct timespec ts)
* \brief Converts a timespec to an integer number of milliseconds.
*/
long timespec_to_ms(struct timespec ts)
{
return (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
}
/** \fn struct timespec timespec_normalise(struct timespec ts)
* \brief Normalises a timespec structure.
*
* Returns a normalised version of a timespec structure, according to the
* following rules:
*
* 1) If tv_nsec is >=1,000,000,00 or <=-1,000,000,000, flatten the surplus
* nanoseconds into the tv_sec field.
*
* 2) If tv_nsec is negative, decrement tv_sec and roll tv_nsec up to represent
* the same value attainable by ADDING nanoseconds to tv_sec.
*/
struct timespec timespec_normalise(struct timespec ts)
{
while (ts.tv_nsec >= NSEC_PER_SEC) {
++(ts.tv_sec);
ts.tv_nsec -= NSEC_PER_SEC;
}
while (ts.tv_nsec <= -NSEC_PER_SEC) {
--(ts.tv_sec);
ts.tv_nsec += NSEC_PER_SEC;
}
if (ts.tv_nsec < 0) {
/* Negative nanoseconds isn't valid according to POSIX.
* Decrement tv_sec and roll tv_nsec over.
*/
--(ts.tv_sec);
ts.tv_nsec = (NSEC_PER_SEC + ts.tv_nsec);
}
return ts;
}
struct timespec timespec_now()
{
struct timespec t;
clock_gettime(CLOCK_REALTIME, &t);
return t;
}
#ifdef TEST
#include <stdio.h>
#define TEST_NORMALISE(ts_sec, ts_nsec, expect_sec, expect_nsec) \
{ \
struct timespec in = { .tv_sec = ts_sec, .tv_nsec = ts_nsec }; \
struct timespec got = timespec_normalise(in); \
if (got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) { \
printf("%s:%d: timespec_normalise({%ld, %ld}) returned wrong values\n", \
__FILE__, __LINE__, (long)(ts_sec), (long)(ts_nsec)); \
printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), \
(long)(expect_nsec)); \
printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), \
(long)(got.tv_nsec)); \
++result; \
} \
}
#define TEST_BINOP(func, ts1_sec, ts1_nsec, ts2_sec, ts2_nsec, expect_sec, expect_nsec) \
{ \
struct timespec ts1 = { .tv_sec = ts1_sec, .tv_nsec = ts1_nsec }; \
struct timespec ts2 = { .tv_sec = ts2_sec, .tv_nsec = ts2_nsec }; \
struct timespec got = func(ts1, ts2); \
if (got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) { \
printf(#func "({%ld, %ld}, {%ld, %ld}) returned wrong values\n", \
(long)(ts1_sec), (long)(ts1_nsec), (long)(ts2_sec), \
(long)(ts2_nsec)); \
printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), \
(long)(expect_nsec)); \
printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), \
(long)(got.tv_nsec)); \
++result; \
} \
}
#define TEST_TRINOP(func, ts1_sec, ts1_nsec, ts2_sec, ts2_nsec, ts3_sec, ts3_nsec, expect_sec, \
expect_nsec) \
{ \
struct timespec ts1 = { .tv_sec = ts1_sec, .tv_nsec = ts1_nsec }; \
struct timespec ts2 = { .tv_sec = ts2_sec, .tv_nsec = ts2_nsec }; \
struct timespec ts3 = { .tv_sec = ts3_sec, .tv_nsec = ts3_nsec }; \
struct timespec got = func(ts1, ts2, ts3); \
if (got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) { \
printf(#func \
"({%ld, %ld}, {%ld, %ld}, {%ld, %ld}) returned wrong values\n", \
(long)(ts1_sec), (long)(ts1_nsec), (long)(ts2_sec), \
(long)(ts2_nsec), (long)(ts3_sec), (long)(ts3_nsec)); \
printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), \
(long)(expect_nsec)); \
printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), \
(long)(got.tv_nsec)); \
++result; \
} \
}
#define TEST_TEST_FUNC(func, ts1_sec, ts1_nsec, ts2_sec, ts2_nsec, expect) \
{ \
struct timespec ts1 = { .tv_sec = ts1_sec, .tv_nsec = ts1_nsec }; \
struct timespec ts2 = { .tv_sec = ts2_sec, .tv_nsec = ts2_nsec }; \
int got = func(ts1, ts2); \
if (got != expect) { \
printf("%s:%d: " #func \
"({%ld, %ld}, {%ld, %ld}) returned %d, expected %s\n", \
__FILE__, __LINE__, (long)(ts1_sec), (long)(ts1_nsec), \
(long)(ts2_sec), (long)(ts2_nsec), got, #expect); \
++result; \
} \
}
#define TEST_FROM_DOUBLE(d_secs, expect_sec, expect_nsec) \
{ \
struct timespec got = timespec_from_double(d_secs); \
if (got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) { \
printf("%s:%d: timespec_from_double(%f) returned wrong values\n", \
__FILE__, __LINE__, (double)(d_secs)); \
printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), \
(long)(expect_nsec)); \
printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), \
(long)(got.tv_nsec)); \
++result; \
} \
}
#define TEST_TO_DOUBLE(ts_sec, ts_nsec, expect) \
{ \
struct timespec ts = { .tv_sec = ts_sec, .tv_nsec = ts_nsec }; \
double got = timespec_to_double(ts); \
if (got != expect) { \
printf("%s:%d: timespec_to_double({%ld, %ld}) returned wrong value\n", \
__FILE__, __LINE__, (long)(ts_sec), (long)(ts_nsec)); \
printf(" Expected: %f\n", (double)(expect)); \
printf(" Got: %f\n", got); \
++result; \
} \
}
#define TEST_FROM_TIMEVAL(in_sec, in_usec, expect_sec, expect_nsec) \
{ \
struct timeval tv = { .tv_sec = in_sec, .tv_usec = in_usec }; \
struct timespec got = timespec_from_timeval(tv); \
if (got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) { \
printf("%s:%d: timespec_from_timeval({%ld, %ld}) returned wrong values\n", \
__FILE__, __LINE__, (long)(in_sec), (long)(in_usec)); \
printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), \
(long)(expect_nsec)); \
printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), \
(long)(got.tv_nsec)); \
++result; \
} \
}
#define TEST_TO_TIMEVAL(ts_sec, ts_nsec, expect_sec, expect_usec) \
{ \
struct timespec ts = { .tv_sec = ts_sec, .tv_nsec = ts_nsec }; \
struct timeval got = timespec_to_timeval(ts); \
if (got.tv_sec != expect_sec || got.tv_usec != expect_usec) { \
printf("%s:%d: timespec_to_timeval({%ld, %ld}) returned wrong values\n", \
__FILE__, __LINE__, (long)(ts_sec), (long)(ts_nsec)); \
printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), \
(long)(expect_usec)); \
printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), \
(long)(got.tv_usec)); \
++result; \
} \
}
#define TEST_FROM_MS(msecs, expect_sec, expect_nsec) \
{ \
struct timespec got = timespec_from_ms(msecs); \
if (got.tv_sec != expect_sec || got.tv_nsec != expect_nsec) { \
printf("%s:%d: timespec_from_ms(%ld) returned wrong values\n", __FILE__, \
__LINE__, (long)(msecs)); \
printf(" Expected: {%ld, %ld}\n", (long)(expect_sec), \
(long)(expect_nsec)); \
printf(" Got: {%ld, %ld}\n", (long)(got.tv_sec), \
(long)(got.tv_nsec)); \
++result; \
} \
}
#define TEST_TO_MS(ts_sec, ts_nsec, expect) \
{ \
struct timespec ts = { .tv_sec = ts_sec, .tv_nsec = ts_nsec }; \
long got = timespec_to_ms(ts); \
if (got != expect) { \
printf("%s:%d: timespec_to_ms({%ld, %ld}) returned wrong value\n", \
__FILE__, __LINE__, (long)(ts_sec), (long)(ts_nsec)); \
printf(" Expected: %ld\n", (long)(expect)); \
printf(" Got: %ld\n", got); \
++result; \
} \
}
int main()
{
int result = 0;
// timespec_add
TEST_BINOP(timespec_add, 0, 0, 0, 0, 0, 0);
TEST_BINOP(timespec_add, 0, 0, 1, 0, 1, 0);
TEST_BINOP(timespec_add, 1, 0, 0, 0, 1, 0);
TEST_BINOP(timespec_add, 1, 0, 1, 0, 2, 0);
TEST_BINOP(timespec_add, 1, 500000000, 1, 0, 2, 500000000);
TEST_BINOP(timespec_add, 1, 0, 1, 500000000, 2, 500000000);
TEST_BINOP(timespec_add, 1, 500000000, 1, 500000000, 3, 0);
TEST_BINOP(timespec_add, 1, 500000000, 1, 499999999, 2, 999999999);
TEST_BINOP(timespec_add, 1, 500000000, 1, 500000000, 3, 0);
TEST_BINOP(timespec_add, 1, 999999999, 1, 999999999, 3, 999999998);
TEST_BINOP(timespec_add, 0, 500000000, 1, 500000000, 2, 0);
TEST_BINOP(timespec_add, 1, 500000000, 0, 500000000, 2, 0);
// timespec_sub
TEST_BINOP(timespec_sub, 0, 0, 0, 0, 0, 0);
TEST_BINOP(timespec_sub, 1, 0, 0, 0, 1, 0);
TEST_BINOP(timespec_sub, 1, 0, 1, 0, 0, 0);
TEST_BINOP(timespec_sub, 1, 500000000, 0, 500000000, 1, 0);
TEST_BINOP(timespec_sub, 5, 500000000, 2, 999999999, 2, 500000001);
TEST_BINOP(timespec_sub, 0, 0, 1, 0, -1, 0);
TEST_BINOP(timespec_sub, 0, 500000000, 1, 500000000, -1, 0);
TEST_BINOP(timespec_sub, 0, 0, 1, 500000000, -2, 500000000);
TEST_BINOP(timespec_sub, 1, 0, 1, 500000000, -1, 500000000);
TEST_BINOP(timespec_sub, 1, 0, 1, 499999999, -1, 500000001);
// timespec_mod
TEST_BINOP(timespec_mod, 0, 0, 0, 0, 0, 0);
TEST_BINOP(timespec_mod, 0, 0, 1, 0, 0, 0);
TEST_BINOP(timespec_mod, 1, 0, 0, 0, 1, 0);
TEST_BINOP(timespec_mod, 1, 0, 1, 0, 0, 0);
TEST_BINOP(timespec_mod, 10, 0, 1, 0, 0, 0);
TEST_BINOP(timespec_mod, 10, 0, 3, 0, 1, 0);
TEST_BINOP(timespec_mod, 10, 0, -3, 0, -2, 0);
TEST_BINOP(timespec_mod, -10, 0, 3, 0, 2, 0);
TEST_BINOP(timespec_mod, -10, 0, -3, 0, -1, 0);
TEST_BINOP(timespec_mod, 10, 0, 5, 0, 0, 0);
TEST_BINOP(timespec_mod, 10, 0, -5, 0, 0, 0);
TEST_BINOP(timespec_mod, -10, 0, 5, 0, 0, 0);
TEST_BINOP(timespec_mod, -10, 0, -5, 0, 0, 0);
TEST_BINOP(timespec_mod, 1, 500000000, 0, 500000000, 0, 0);
TEST_BINOP(timespec_mod, 5, 500000000, 2, 999999999, 2, 500000001);
TEST_BINOP(timespec_mod, 0, 500000000, 1, 500000000, 0, 500000000);
TEST_BINOP(timespec_mod, 0, 0, 1, 500000000, 0, 0);
TEST_BINOP(timespec_mod, 1, 0, 1, 500000000, 1, 0);
TEST_BINOP(timespec_mod, 1, 0, 0, 1, 0, 0);
TEST_BINOP(timespec_mod, 1, 123456789, 0, 1000, 0, 789);
TEST_BINOP(timespec_mod, 1, 0, 0, 9999999, 0, 100);
TEST_BINOP(timespec_mod, 12345, 54321, 0, 100001, 0, 5555);
TEST_BINOP(timespec_mod, LONG_MAX, 0, 0, 1, 0, 0);
TEST_BINOP(timespec_mod, LONG_MAX, 0, LONG_MAX, 1, LONG_MAX, 0);
// timespec_clamp
TEST_TRINOP(timespec_clamp, 0, 0, 0, 0, 0, 0, 0, 0);
TEST_TRINOP(timespec_clamp, 1000, 0, 2000, 0, 3000, 0, 2000, 0);
TEST_TRINOP(timespec_clamp, 1500, 0, 2000, 0, 3000, 0, 2000, 0);
TEST_TRINOP(timespec_clamp, 1999, 0, 2000, 0, 3000, 0, 2000, 0);
TEST_TRINOP(timespec_clamp, 2000, 0, 2000, 0, 3000, 0, 2000, 0);
TEST_TRINOP(timespec_clamp, 2001, 0, 2000, 0, 3000, 0, 2001, 0);
TEST_TRINOP(timespec_clamp, 2250, 0, 2000, 0, 3000, 0, 2250, 0);
TEST_TRINOP(timespec_clamp, 2500, 0, 2000, 0, 3000, 0, 2500, 0);
TEST_TRINOP(timespec_clamp, 2750, 0, 2000, 0, 3000, 0, 2750, 0);
TEST_TRINOP(timespec_clamp, 2999, 0, 2000, 0, 3000, 0, 2999, 0);
TEST_TRINOP(timespec_clamp, 3000, 0, 2000, 0, 3000, 0, 3000, 0);
TEST_TRINOP(timespec_clamp, 3001, 0, 2000, 0, 3000, 0, 3000, 0);
TEST_TRINOP(timespec_clamp, 3500, 0, 2000, 0, 3000, 0, 3000, 0);
TEST_TRINOP(timespec_clamp, 4000, 0, 2000, 0, 3000, 0, 3000, 0);
TEST_TRINOP(timespec_clamp, 0, 1000, 0, 2000, 0, 3000, 0, 2000);
TEST_TRINOP(timespec_clamp, 0, 1500, 0, 2000, 0, 3000, 0, 2000);
TEST_TRINOP(timespec_clamp, 0, 1999, 0, 2000, 0, 3000, 0, 2000);
TEST_TRINOP(timespec_clamp, 0, 2000, 0, 2000, 0, 3000, 0, 2000);
TEST_TRINOP(timespec_clamp, 0, 2001, 0, 2000, 0, 3000, 0, 2001);
TEST_TRINOP(timespec_clamp, 0, 2250, 0, 2000, 0, 3000, 0, 2250);
TEST_TRINOP(timespec_clamp, 0, 2500, 0, 2000, 0, 3000, 0, 2500);
TEST_TRINOP(timespec_clamp, 0, 2750, 0, 2000, 0, 3000, 0, 2750);
TEST_TRINOP(timespec_clamp, 0, 2999, 0, 2000, 0, 3000, 0, 2999);
TEST_TRINOP(timespec_clamp, 0, 3000, 0, 2000, 0, 3000, 0, 3000);
TEST_TRINOP(timespec_clamp, 0, 3001, 0, 2000, 0, 3000, 0, 3000);
TEST_TRINOP(timespec_clamp, 0, 3500, 0, 2000, 0, 3000, 0, 3000);
TEST_TRINOP(timespec_clamp, 0, 4000, 0, 2000, 0, 3000, 0, 3000);
TEST_TRINOP(timespec_clamp, 0, -1000, 0, -3000, 0, -2000, 0, -2000);
TEST_TRINOP(timespec_clamp, 0, -1500, 0, -3000, 0, -2000, 0, -2000);
TEST_TRINOP(timespec_clamp, 0, -1999, 0, -3000, 0, -2000, 0, -2000);
TEST_TRINOP(timespec_clamp, 0, -3000, 0, -3000, 0, -2000, 0, -3000);
TEST_TRINOP(timespec_clamp, 0, -2001, 0, -3000, 0, -2000, 0, -2001);
TEST_TRINOP(timespec_clamp, 0, -2250, 0, -3000, 0, -2000, 0, -2250);
TEST_TRINOP(timespec_clamp, 0, -2500, 0, -3000, 0, -2000, 0, -2500);
TEST_TRINOP(timespec_clamp, 0, -2750, 0, -3000, 0, -2000, 0, -2750);
TEST_TRINOP(timespec_clamp, 0, -2999, 0, -3000, 0, -2000, 0, -2999);
TEST_TRINOP(timespec_clamp, 0, -2000, 0, -3000, 0, -2000, 0, -2000);
TEST_TRINOP(timespec_clamp, 0, -3001, 0, -3000, 0, -2000, 0, -3000);
TEST_TRINOP(timespec_clamp, 0, -3500, 0, -3000, 0, -2000, 0, -3000);
TEST_TRINOP(timespec_clamp, 0, -2000, 0, -3000, 0, -2000, 0, -2000);
TEST_TRINOP(timespec_clamp, 0, -4000, 0, -3000, 0, 3000, 0, -3000);
TEST_TRINOP(timespec_clamp, 0, -3001, 0, -3000, 0, 3000, 0, -3000);
TEST_TRINOP(timespec_clamp, 0, -3000, 0, -3000, 0, 3000, 0, -3000);
TEST_TRINOP(timespec_clamp, 0, -2999, 0, -3000, 0, 3000, 0, -2999);
TEST_TRINOP(timespec_clamp, 0, -1500, 0, -3000, 0, 3000, 0, -1500);
TEST_TRINOP(timespec_clamp, 0, -1, 0, -3000, 0, 3000, 0, -1);
TEST_TRINOP(timespec_clamp, 0, 0, 0, -3000, 0, 3000, 0, 0);
TEST_TRINOP(timespec_clamp, 0, 1, 0, -3000, 0, 3000, 0, 1);
TEST_TRINOP(timespec_clamp, 0, 1500, 0, -3000, 0, 3000, 0, 1500);
TEST_TRINOP(timespec_clamp, 0, 2999, 0, -3000, 0, 3000, 0, 2999);
TEST_TRINOP(timespec_clamp, 0, 3000, 0, -3000, 0, 3000, 0, 3000);
TEST_TRINOP(timespec_clamp, 0, 3001, 0, -3000, 0, 3000, 0, 3000);
TEST_TRINOP(timespec_clamp, 0, 4000, 0, -3000, 0, 3000, 0, 3000);
// timespec_min
TEST_BINOP(timespec_min, 0, 0, 0, 0, 0, 0);
TEST_BINOP(timespec_min, 0, 0, 1, 0, 0, 0);
TEST_BINOP(timespec_min, 1, 0, 0, 0, 0, 0);
TEST_BINOP(timespec_min, 1, 0, 1, 0, 1, 0);
TEST_BINOP(timespec_min, 10, 0, 1, 0, 1, 0);
TEST_BINOP(timespec_min, 10, 0, 3, 0, 3, 0);
TEST_BINOP(timespec_min, 10, 0, -3, 0, -3, 0);
TEST_BINOP(timespec_min, -10, 0, 3, 0, -10, 0);
TEST_BINOP(timespec_min, -10, 0, -3, 0, -10, 0);
TEST_BINOP(timespec_min, 10, 0, 5, 0, 5, 0);
TEST_BINOP(timespec_min, 10, 0, -5, 0, -5, 0);
TEST_BINOP(timespec_min, -10, 0, 5, 0, -10, 0);
TEST_BINOP(timespec_min, -10, 0, -5, 0, -10, 0);
TEST_BINOP(timespec_min, 1, 500000000, 0, 500000000, 0, 500000000);
TEST_BINOP(timespec_min, 5, 500000000, 2, 999999999, 2, 999999999);
TEST_BINOP(timespec_min, 0, 500000000, 1, 500000000, 0, 500000000);
TEST_BINOP(timespec_min, 0, 0, 1, 500000000, 0, 0);
TEST_BINOP(timespec_min, 1, 0, 1, 500000000, 1, 0);
TEST_BINOP(timespec_min, 1, 0, 0, 1, 0, 1);
TEST_BINOP(timespec_min, 1, 123456789, 0, 1000, 0, 1000);
TEST_BINOP(timespec_min, 1, 0, 0, 9999999, 0, 9999999);
TEST_BINOP(timespec_min, 12345, 54321, 0, 100001, 0, 100001);
TEST_BINOP(timespec_min, LONG_MIN, 0, 0, 1, LONG_MIN, 0);
TEST_BINOP(timespec_min, LONG_MIN, 0, 0, -1, LONG_MIN, 0);
TEST_BINOP(timespec_min, LONG_MIN, 0, LONG_MAX, 0, LONG_MIN, 0);
TEST_BINOP(timespec_min, LONG_MIN, 0, LONG_MIN, 0, LONG_MIN, 0);
TEST_BINOP(timespec_min, LONG_MAX, 0, 0, 1, 0, 1);
TEST_BINOP(timespec_min, LONG_MAX, 0, 0, -1, 0, -1);
TEST_BINOP(timespec_min, LONG_MAX, 0, LONG_MAX, 0, LONG_MAX, 0);
TEST_BINOP(timespec_min, LONG_MAX, 0, LONG_MIN, 0, LONG_MIN, 0);
// timespec_max
TEST_BINOP(timespec_max, 0, 0, 0, 0, 0, 0);
TEST_BINOP(timespec_max, 0, 0, 1, 0, 1, 0);
TEST_BINOP(timespec_max, 1, 0, 0, 0, 1, 0);
TEST_BINOP(timespec_max, 1, 0, 1, 0, 1, 0);
TEST_BINOP(timespec_max, 10, 0, 1, 0, 10, 0);
TEST_BINOP(timespec_max, 10, 0, 3, 0, 10, 0);
TEST_BINOP(timespec_max, 10, 0, -3, 0, 10, 0);
TEST_BINOP(timespec_max, -10, 0, 3, 0, 3, 0);
TEST_BINOP(timespec_max, -10, 0, -3, 0, -3, 0);
TEST_BINOP(timespec_max, 10, 0, 5, 0, 10, 0);
TEST_BINOP(timespec_max, 10, 0, -5, 0, 10, 0);
TEST_BINOP(timespec_max, -10, 0, 5, 0, 5, 0);
TEST_BINOP(timespec_max, -10, 0, -5, 0, -5, 0);
TEST_BINOP(timespec_max, 1, 500000000, 0, 500000000, 1, 500000000);
TEST_BINOP(timespec_max, 5, 500000000, 2, 999999999, 5, 500000000);
TEST_BINOP(timespec_max, 0, 500000000, 1, 500000000, 1, 500000000);
TEST_BINOP(timespec_max, 0, 0, 1, 500000000, 1, 500000000);
TEST_BINOP(timespec_max, 1, 0, 1, 500000000, 1, 500000000);
TEST_BINOP(timespec_max, 1, 0, 0, 1, 1, 0);
TEST_BINOP(timespec_max, 1, 123456789, 0, 1000, 1, 123456789);
TEST_BINOP(timespec_max, 1, 0, 0, 9999999, 1, 0);
TEST_BINOP(timespec_max, 12345, 54321, 0, 100001, 12345, 54321);
TEST_BINOP(timespec_max, LONG_MIN, 0, 0, 1, 0, 1);
TEST_BINOP(timespec_max, LONG_MIN, 0, 0, -1, 0, -1);
TEST_BINOP(timespec_max, LONG_MIN, 0, LONG_MAX, 0, LONG_MAX, 0);
TEST_BINOP(timespec_max, LONG_MIN, 0, LONG_MIN, 0, LONG_MIN, 0);
TEST_BINOP(timespec_max, LONG_MAX, 0, 0, 1, LONG_MAX, 0);
TEST_BINOP(timespec_max, LONG_MAX, 0, 0, -1, LONG_MAX, 0);
TEST_BINOP(timespec_max, LONG_MAX, 0, LONG_MAX, 0, LONG_MAX, 0);
TEST_BINOP(timespec_max, LONG_MAX, 0, LONG_MIN, 0, LONG_MAX, 0);
// timespec_cmp
TEST_TEST_FUNC(timespec_cmp, 0, 0, 0, 0, 0);
TEST_TEST_FUNC(timespec_cmp, 100, 0, 100, 0, 0);
TEST_TEST_FUNC(timespec_cmp, -100, 0, -100, 0, 0);
TEST_TEST_FUNC(timespec_cmp, 1, 0, 0, 0, 1);
TEST_TEST_FUNC(timespec_cmp, 0, 0, 1, 0, -1);
TEST_TEST_FUNC(timespec_cmp, 0, 1, 0, 0, 1);
TEST_TEST_FUNC(timespec_cmp, 0, 0, 0, 1, -1);
TEST_TEST_FUNC(timespec_cmp, 1, 0, 0, 100, 1);
TEST_TEST_FUNC(timespec_cmp, 0, 100, 1, 0, -1);
TEST_TEST_FUNC(timespec_cmp, -0, -0, 0, 0, 0);
TEST_TEST_FUNC(timespec_cmp, -10, -500000000, -11, 500000000, 0);
TEST_TEST_FUNC(timespec_cmp, -10, -500000001, -11, 499999999, 0);
TEST_TEST_FUNC(timespec_cmp, -10, -500000001, -11, 500000001, -1);
TEST_TEST_FUNC(timespec_cmp, -11, 500000001, -10, -500000001, 1);
// timespec_eq
TEST_TEST_FUNC(timespec_eq, 0, 0, 0, 0, true);
TEST_TEST_FUNC(timespec_eq, 100, 0, 100, 0, true);
TEST_TEST_FUNC(timespec_eq, -200, 0, -200, 0, true);
TEST_TEST_FUNC(timespec_eq, 0, 300, 0, 300, true);
TEST_TEST_FUNC(timespec_eq, 0, -400, 0, -400, true);
TEST_TEST_FUNC(timespec_eq, 100, 1, 100, 0, false);
TEST_TEST_FUNC(timespec_eq, 101, 0, 100, 0, false);
TEST_TEST_FUNC(timespec_eq, -100, 0, 100, 0, false);
TEST_TEST_FUNC(timespec_eq, 0, 10, 0, -10, false);
TEST_TEST_FUNC(timespec_eq, -0, -0, 0, 0, true);
TEST_TEST_FUNC(timespec_eq, -10, -500000000, -11, 500000000, true);
TEST_TEST_FUNC(timespec_eq, -10, -500000001, -11, 499999999, true);
TEST_TEST_FUNC(timespec_eq, -10, -500000001, -11, 500000001, false);
// timespec_gt
TEST_TEST_FUNC(timespec_gt, 1, 0, 0, 0, true);
TEST_TEST_FUNC(timespec_gt, 0, 0, -1, 0, true);
TEST_TEST_FUNC(timespec_gt, 0, 1, 0, 0, true);
TEST_TEST_FUNC(timespec_gt, 0, 0, 0, -1, true);
TEST_TEST_FUNC(timespec_gt, 1, 0, 1, 0, false);
TEST_TEST_FUNC(timespec_gt, 1, 1, 1, 1, false);
TEST_TEST_FUNC(timespec_gt, -1, 0, 0, 0, false);
TEST_TEST_FUNC(timespec_gt, 0, -1, 0, 0, false);
TEST_TEST_FUNC(timespec_gt, 0, 0, -0, -0, false);
TEST_TEST_FUNC(timespec_gt, -10, -500000000, -11, 500000000, false);
TEST_TEST_FUNC(timespec_gt, -11, 500000000, -10, -500000000, false);
TEST_TEST_FUNC(timespec_gt, -10, -500000001, -11, 499999999, false);
TEST_TEST_FUNC(timespec_gt, -11, 499999999, -11, 499999999, false);
TEST_TEST_FUNC(timespec_gt, -10, -500000001, -11, 500000001, false);
TEST_TEST_FUNC(timespec_gt, -11, 500000001, -10, -500000001, true);
// timespec_ge
TEST_TEST_FUNC(timespec_ge, 1, 0, 0, 0, true);
TEST_TEST_FUNC(timespec_ge, 0, 0, -1, 0, true);
TEST_TEST_FUNC(timespec_ge, 0, 1, 0, 0, true);
TEST_TEST_FUNC(timespec_ge, 0, 0, 0, -1, true);
TEST_TEST_FUNC(timespec_ge, 1, 0, 1, 0, true);
TEST_TEST_FUNC(timespec_ge, 1, 1, 1, 1, true);
TEST_TEST_FUNC(timespec_ge, -1, 0, 0, 0, false);
TEST_TEST_FUNC(timespec_ge, 0, -1, 0, 0, false);
TEST_TEST_FUNC(timespec_ge, 0, 0, -0, -0, true);
TEST_TEST_FUNC(timespec_ge, -10, -500000000, -11, 500000000, true);
TEST_TEST_FUNC(timespec_ge, -11, 500000000, -10, -500000000, true);
TEST_TEST_FUNC(timespec_ge, -10, -500000001, -11, 499999999, true);
TEST_TEST_FUNC(timespec_ge, -11, 499999999, -11, 499999999, true);
TEST_TEST_FUNC(timespec_ge, -10, -500000001, -11, 500000001, false);
TEST_TEST_FUNC(timespec_ge, -11, 500000001, -10, -500000001, true);
// timespec_lt
TEST_TEST_FUNC(timespec_lt, 0, 0, 1, 0, true);
TEST_TEST_FUNC(timespec_lt, -1, 0, 0, 0, true);
TEST_TEST_FUNC(timespec_lt, 0, 0, 0, 1, true);
TEST_TEST_FUNC(timespec_lt, 0, -1, 0, 0, true);
TEST_TEST_FUNC(timespec_lt, 1, 0, 1, 0, false);
TEST_TEST_FUNC(timespec_lt, 1, 1, 1, 1, false);
TEST_TEST_FUNC(timespec_lt, 0, 0, -1, 0, false);
TEST_TEST_FUNC(timespec_lt, 0, 0, 0, -1, false);
TEST_TEST_FUNC(timespec_lt, 0, 0, -0, -0, false);
TEST_TEST_FUNC(timespec_lt, -10, -500000000, -11, 500000000, false);
TEST_TEST_FUNC(timespec_lt, -11, 500000000, -10, -500000000, false);
TEST_TEST_FUNC(timespec_lt, -10, -500000001, -11, 499999999, false);
TEST_TEST_FUNC(timespec_lt, -11, 499999999, -11, 499999999, false);
TEST_TEST_FUNC(timespec_lt, -10, -500000001, -11, 500000001, true);
TEST_TEST_FUNC(timespec_lt, -11, 500000001, -10, -500000001, false);
// timespec_le
TEST_TEST_FUNC(timespec_le, 0, 0, 1, 0, true);
TEST_TEST_FUNC(timespec_le, -1, 0, 0, 0, true);
TEST_TEST_FUNC(timespec_le, 0, 0, 0, 1, true);
TEST_TEST_FUNC(timespec_le, 0, -1, 0, 0, true);
TEST_TEST_FUNC(timespec_le, 1, 0, 1, 0, true);
TEST_TEST_FUNC(timespec_le, 1, 1, 1, 1, true);
TEST_TEST_FUNC(timespec_le, 0, 0, -1, 0, false);
TEST_TEST_FUNC(timespec_le, 0, 0, 0, -1, false);
TEST_TEST_FUNC(timespec_le, 0, 0, -0, -0, true);
TEST_TEST_FUNC(timespec_le, -10, -500000000, -11, 500000000, true);
TEST_TEST_FUNC(timespec_le, -11, 500000000, -10, -500000000, true);
TEST_TEST_FUNC(timespec_le, -10, -500000001, -11, 499999999, true);
TEST_TEST_FUNC(timespec_le, -11, 499999999, -11, 499999999, true);
TEST_TEST_FUNC(timespec_le, -10, -500000001, -11, 500000001, true);
TEST_TEST_FUNC(timespec_le, -11, 500000001, -10, -500000001, false);
// timespec_from_double
TEST_FROM_DOUBLE(0.0, 0, 0);
TEST_FROM_DOUBLE(10.0, 10, 0);
TEST_FROM_DOUBLE(-10.0, -10, 0);
TEST_FROM_DOUBLE(0.5, 0, 500000000);
TEST_FROM_DOUBLE(-0.5, -1, 500000000);
TEST_FROM_DOUBLE(10.5, 10, 500000000);
TEST_FROM_DOUBLE(-10.5, -11, 500000000);
// timespec_to_double
TEST_TO_DOUBLE(0, 0, 0.0);
TEST_TO_DOUBLE(10, 0, 10.0);
TEST_TO_DOUBLE(-10, 0, -10.0);
TEST_TO_DOUBLE(0, 500000000, 0.5);
TEST_TO_DOUBLE(0, -500000000, -0.5);
TEST_TO_DOUBLE(10, 500000000, 10.5);
TEST_TO_DOUBLE(10, -500000000, 9.5);
TEST_TO_DOUBLE(-10, 500000000, -9.5);
TEST_TO_DOUBLE(-10, -500000000, -10.5);
// timespec_from_timeval
TEST_FROM_TIMEVAL(0, 0, 0, 0);
TEST_FROM_TIMEVAL(1, 0, 1, 0);
TEST_FROM_TIMEVAL(1000, 0, 1000, 0);
TEST_FROM_TIMEVAL(0, 0, 0, 0);
TEST_FROM_TIMEVAL(-1, 0, -1, 0);
TEST_FROM_TIMEVAL(-1000, 0, -1000, 0);
TEST_FROM_TIMEVAL(1, 1, 1, 1000);
TEST_FROM_TIMEVAL(1, 1000, 1, 1000000);
TEST_FROM_TIMEVAL(1, -1, 0, 999999000);
TEST_FROM_TIMEVAL(1, -1000, 0, 999000000);
TEST_FROM_TIMEVAL(-1, -1, -2, 999999000);
TEST_FROM_TIMEVAL(-1, -1000, -2, 999000000);
// timespec_to_timeval
TEST_TO_TIMEVAL(0, 0, 0, 0);
TEST_TO_TIMEVAL(1, 0, 1, 0);
TEST_TO_TIMEVAL(10, 0, 10, 0);
TEST_TO_TIMEVAL(-1, 0, -1, 0);
TEST_TO_TIMEVAL(-10, 0, -10, 0);
TEST_TO_TIMEVAL(1, 1, 1, 0);
TEST_TO_TIMEVAL(1, 999, 1, 0);
TEST_TO_TIMEVAL(1, 1000, 1, 1);
TEST_TO_TIMEVAL(1, 1001, 1, 1);
TEST_TO_TIMEVAL(1, 2000, 1, 2);
TEST_TO_TIMEVAL(1, 2000000, 1, 2000);
TEST_TO_TIMEVAL(1, -1, 0, 999999);
TEST_TO_TIMEVAL(1, -999, 0, 999999);
TEST_TO_TIMEVAL(1, -1000, 0, 999999);
TEST_TO_TIMEVAL(1, -1001, 0, 999998);
TEST_TO_TIMEVAL(1, -2000, 0, 999998);
TEST_TO_TIMEVAL(1, -2000000, 0, 998000);
TEST_TO_TIMEVAL(-1, -1, -2, 999999);
TEST_TO_TIMEVAL(-1, -999, -2, 999999);
TEST_TO_TIMEVAL(-1, -1000, -2, 999999);
TEST_TO_TIMEVAL(-1, -1001, -2, 999998);
TEST_TO_TIMEVAL(-1, -2000, -2, 999998);
TEST_TO_TIMEVAL(-1, -2000000, -2, 998000);
TEST_TO_TIMEVAL(1, 1500000000, 2, 500000);
TEST_TO_TIMEVAL(1, -1500000000, -1, 500000);
TEST_TO_TIMEVAL(-1, -1500000000, -3, 500000);
// timespec_from_ms
TEST_FROM_MS(0, 0, 0);
TEST_FROM_MS(1, 0, 1000000);
TEST_FROM_MS(-1, -1, 999000000);
TEST_FROM_MS(1500, 1, 500000000);
TEST_FROM_MS(-1000, -1, 0);
TEST_FROM_MS(-1500, -2, 500000000);
// timespec_to_ms
TEST_TO_MS(0, 0, 0);
TEST_TO_MS(10, 0, 10000);
TEST_TO_MS(-10, 0, -10000);
TEST_TO_MS(0, 500000000, 500);
TEST_TO_MS(0, -500000000, -500);
TEST_TO_MS(10, 500000000, 10500);
TEST_TO_MS(10, -500000000, 9500);
TEST_TO_MS(-10, 500000000, -9500);
TEST_TO_MS(-10, -500000000, -10500);
// timespec_normalise
TEST_NORMALISE(0, 0, 0, 0);
TEST_NORMALISE(0, 1000000000, 1, 0);
TEST_NORMALISE(0, 1500000000, 1, 500000000);
TEST_NORMALISE(0, -1000000000, -1, 0);
TEST_NORMALISE(0, -1500000000, -2, 500000000);
TEST_NORMALISE(5, 1000000000, 6, 0);
TEST_NORMALISE(5, 1500000000, 6, 500000000);
TEST_NORMALISE(-5, -1000000000, -6, 0);
TEST_NORMALISE(-5, -1500000000, -7, 500000000);
TEST_NORMALISE(0, 2000000000, 2, 0);
TEST_NORMALISE(0, 2100000000, 2, 100000000);
TEST_NORMALISE(0, -2000000000, -2, 0);
TEST_NORMALISE(0, -2100000000, -3, 900000000);
TEST_NORMALISE(1, -500000001, 0, 499999999);
TEST_NORMALISE(1, -500000000, 0, 500000000);
TEST_NORMALISE(1, -499999999, 0, 500000001);
TEST_NORMALISE(0, -499999999, -1, 500000001);
TEST_NORMALISE(-1, 500000000, -1, 500000000);
TEST_NORMALISE(-1, 499999999, -1, 499999999);
if (result > 0) {
printf("%d tests failed\n", result);
} else {
printf("All tests passed\n");
}
return !!result; /* Don't overflow the exit status */
}
#endif
Reference in a new issue View git blame Copy permalink