And removed zNEW_test now that everything's integrated back in.
This commit is contained in:
Pietro Gagliardi
parent
1cf87d5c5e
commit
de35499976
|
|
@ -1,35 +0,0 @@
|
|||
# 23 march 2019
|
||||
|
||||
libui_test_sources += [
|
||||
'lib/testing.c',
|
||||
'lib/testingpriv.c',
|
||||
'lib/timer.c',
|
||||
]
|
||||
|
||||
if libui_OS == 'windows'
|
||||
libui_test_sources += [
|
||||
'lib/thread_windows.c',
|
||||
'lib/timer_windows.c',
|
||||
]
|
||||
else # including Haiku, since it's POSIX-compliant
|
||||
libui_test_sources += [
|
||||
'lib/thread_darwinunix.c',
|
||||
'lib/timer_darwinunix.c'
|
||||
]
|
||||
endif
|
||||
|
||||
libui_test_deps += [
|
||||
dependency('threads',
|
||||
required: true),
|
||||
]
|
||||
if libui_OS == 'windows'
|
||||
# static mode already gives us these dependencies
|
||||
if libui_mode != 'static'
|
||||
libui_test_deps += [
|
||||
meson.get_compiler('c').find_library('kernel32',
|
||||
required: true),
|
||||
meson.get_compiler('c').find_library('user32',
|
||||
required: true),
|
||||
]
|
||||
endif
|
||||
endif
|
||||
|
|
@ -1,326 +0,0 @@
|
|||
// 27 february 2018
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <setjmp.h>
|
||||
#include <string.h>
|
||||
#include "timer.h"
|
||||
#include "testing.h"
|
||||
#include "testingpriv.h"
|
||||
|
||||
struct defer {
|
||||
void (*f)(testingT *, void *);
|
||||
void *data;
|
||||
struct defer *next;
|
||||
};
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// Microsoft defines jmp_buf with a __declspec(align()), and for whatever reason, they have a warning that triggers when you use that for any reason, and that warning is enabled with /W4
|
||||
// Silence the warning; it's harmless.
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable: 4324)
|
||||
#endif
|
||||
|
||||
struct testingT {
|
||||
// set at test creation time
|
||||
const char *name;
|
||||
void (*f)(testingT *, void *);
|
||||
void *data;
|
||||
|
||||
// for sorting tests in a set; not used by subtests
|
||||
const char *file;
|
||||
long line;
|
||||
|
||||
// test status
|
||||
bool failed;
|
||||
bool skipped;
|
||||
bool returned;
|
||||
jmp_buf returnNowBuf;
|
||||
|
||||
// deferred functions
|
||||
struct defer *defers;
|
||||
bool defersRun;
|
||||
|
||||
// execution options
|
||||
testingOptions opts;
|
||||
|
||||
// output
|
||||
testingprivOutbuf *outbuf;
|
||||
};
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
static void initTest(testingT *t, const char *name, void (*f)(testingT *, void *), void *data, const char *file, long line)
|
||||
{
|
||||
memset(t, 0, sizeof (testingT));
|
||||
t->name = name;
|
||||
t->f = f;
|
||||
t->data = data;
|
||||
t->file = file;
|
||||
t->line = line;
|
||||
}
|
||||
|
||||
struct testingSet {
|
||||
testingprivArray tests;
|
||||
};
|
||||
|
||||
static testingSet mainTests = { testingprivArrayStaticInit(testingT, 32, "testingT[]") };
|
||||
|
||||
void testingprivSetRegisterTest(testingSet **pset, const char *name, void (*f)(testingT *, void *), void *data, const char *file, long line)
|
||||
{
|
||||
testingSet *set;
|
||||
testingT *t;
|
||||
|
||||
set = &mainTests;
|
||||
if (pset != NULL) {
|
||||
set = *pset;
|
||||
if (set == NULL) {
|
||||
set = testingprivNew(testingSet);
|
||||
testingprivArrayInit(set->tests, testingT, 32, "testingT[]");
|
||||
*pset = set;
|
||||
}
|
||||
}
|
||||
t = (testingT *) testingprivArrayAppend(&(set->tests), 1);
|
||||
initTest(t, name, f, data, file, line);
|
||||
}
|
||||
|
||||
static int testcmp(const void *a, const void *b)
|
||||
{
|
||||
const testingT *ta = (const testingT *) a;
|
||||
const testingT *tb = (const testingT *) b;
|
||||
int ret;
|
||||
|
||||
ret = strcmp(ta->file, tb->file);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
if (ta->line < tb->line)
|
||||
return -1;
|
||||
if (ta->line > tb->line)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void runDefers(testingT *t)
|
||||
{
|
||||
struct defer *d;
|
||||
|
||||
if (t->defersRun)
|
||||
return;
|
||||
t->defersRun = true;
|
||||
for (d = t->defers; d != NULL; d = d->next)
|
||||
(*(d->f))(t, d->data);
|
||||
// and now free the defers
|
||||
// we could use t->defers == NULL instead of t->defersRun but then recursive calls to runDefers() (for instance, if a deferred function calls testingTFatalf()) would explode
|
||||
while (t->defers != NULL) {
|
||||
d = t->defers;
|
||||
t->defers = t->defers->next;
|
||||
testingprivFree(d);
|
||||
}
|
||||
}
|
||||
|
||||
static const testingOptions defaultOptions = {
|
||||
.Verbose = 0,
|
||||
};
|
||||
|
||||
static bool testingprivTRun(testingT *t, testingprivOutbuf *parentbuf)
|
||||
{
|
||||
const char *status;
|
||||
timerTime start, end;
|
||||
char timerstr[timerDurationStringLen];
|
||||
bool printStatus;
|
||||
|
||||
if (t->opts.Verbose)
|
||||
testingprivOutbufPrintf(parentbuf, "=== RUN %s\n", t->name);
|
||||
t->outbuf = testingprivNewOutbuf();
|
||||
|
||||
start = timerMonotonicNow();
|
||||
if (setjmp(t->returnNowBuf) == 0)
|
||||
(*(t->f))(t, t->data);
|
||||
end = timerMonotonicNow();
|
||||
t->returned = true;
|
||||
runDefers(t);
|
||||
|
||||
printStatus = t->opts.Verbose;
|
||||
status = "PASS";
|
||||
if (t->failed) {
|
||||
status = "FAIL";
|
||||
printStatus = true; // always print status on failure
|
||||
} else if (t->skipped)
|
||||
// note that failed overrides skipped
|
||||
status = "SKIP";
|
||||
timerDurationString(timerTimeSub(end, start), timerstr);
|
||||
if (printStatus) {
|
||||
testingprivOutbufPrintf(parentbuf, "--- %s: %s (%s)\n", status, t->name, timerstr);
|
||||
testingprivOutbufAppendOutbuf(parentbuf, t->outbuf);
|
||||
}
|
||||
|
||||
testingprivOutbufFree(t->outbuf);
|
||||
t->outbuf = NULL;
|
||||
return !t->failed;
|
||||
}
|
||||
|
||||
// TODO make options and opts consistent throughout? what about format vs fmt in public-facing functions?
|
||||
static void testingprivSetRun(testingSet *set, const testingOptions *opts, testingprivOutbuf *outbuf, bool *anyFailed)
|
||||
{
|
||||
size_t i;
|
||||
testingT *t;
|
||||
|
||||
testingprivArrayQsort(&(set->tests), testcmp);
|
||||
t = (testingT *) (set->tests.buf);
|
||||
for (i = 0; i < set->tests.len; i++) {
|
||||
t->opts = *opts;
|
||||
if (!testingprivTRun(t, outbuf))
|
||||
*anyFailed = true;
|
||||
t++;
|
||||
}
|
||||
}
|
||||
|
||||
void testingSetRun(testingSet *set, const struct testingOptions *options, bool *anyRun, bool *anyFailed)
|
||||
{
|
||||
*anyRun = false;
|
||||
*anyFailed = false;
|
||||
if (set == NULL)
|
||||
set = &mainTests;
|
||||
if (options == NULL)
|
||||
options = &defaultOptions;
|
||||
if (set->tests.len == 0)
|
||||
return;
|
||||
testingprivSetRun(set, options, NULL, anyFailed);
|
||||
*anyRun = true;
|
||||
}
|
||||
|
||||
void testingprivTLogfFullThen(testingT *t, void (*then)(testingT *t), const char *file, long line, const char *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, format);
|
||||
// run va_end() *before* then, just to be safe
|
||||
testingprivTLogvfFullThen(t, NULL, file, line, format, ap);
|
||||
va_end(ap);
|
||||
if (then != NULL)
|
||||
(*then)(t);
|
||||
}
|
||||
|
||||
static const char *basename(const char *file)
|
||||
{
|
||||
const char *p;
|
||||
|
||||
for (;;) {
|
||||
p = strpbrk(file, "/\\");
|
||||
if (p == NULL)
|
||||
break;
|
||||
file = p + 1;
|
||||
}
|
||||
return file;
|
||||
}
|
||||
|
||||
void testingprivTLogvfFullThen(testingT *t, void (*then)(testingT *t), const char *file, long line, const char *format, va_list ap)
|
||||
{
|
||||
testingprivOutbufPrintf(t->outbuf, "%s:%ld: ", basename(file), line);
|
||||
testingprivOutbufVprintfIndented(t->outbuf, format, ap);
|
||||
testingprivOutbufPrintf(t->outbuf, "\n");
|
||||
if (then != NULL)
|
||||
(*then)(t);
|
||||
}
|
||||
|
||||
void testingTFail(testingT *t)
|
||||
{
|
||||
t->failed = true;
|
||||
}
|
||||
|
||||
static void returnNow(testingT *t)
|
||||
{
|
||||
if (!t->returned) {
|
||||
// set this now so a FailNow inside a Defer doesn't longjmp twice
|
||||
t->returned = true;
|
||||
// run defers before calling longjmp() just to be safe
|
||||
runDefers(t);
|
||||
longjmp(t->returnNowBuf, 1);
|
||||
}
|
||||
}
|
||||
|
||||
void testingTFailNow(testingT *t)
|
||||
{
|
||||
testingTFail(t);
|
||||
returnNow(t);
|
||||
}
|
||||
|
||||
void testingTSkipNow(testingT *t)
|
||||
{
|
||||
t->skipped = true;
|
||||
returnNow(t);
|
||||
}
|
||||
|
||||
void testingTDefer(testingT *t, void (*f)(testingT *t, void *data), void *data)
|
||||
{
|
||||
struct defer *d;
|
||||
|
||||
d = testingprivNew(struct defer);
|
||||
d->f = f;
|
||||
d->data = data;
|
||||
// add to the head of the list so defers are run in reverse order of how they were added
|
||||
d->next = t->defers;
|
||||
t->defers = d;
|
||||
}
|
||||
|
||||
void testingTRun(testingT *t, const char *subname, void (*subfunc)(testingT *t, void *data), void *data)
|
||||
{
|
||||
testingT *subt;
|
||||
testingprivOutbuf *rewrittenName;
|
||||
char *fullName;
|
||||
|
||||
rewrittenName = testingprivNewOutbuf();
|
||||
while (*subname != '\0') {
|
||||
const char *replaced;
|
||||
|
||||
replaced = NULL;
|
||||
switch (*subname) {
|
||||
case ' ':
|
||||
case '\f':
|
||||
case '\n':
|
||||
case '\r':
|
||||
case '\t':
|
||||
case '\v':
|
||||
replaced = "_";
|
||||
break;
|
||||
case '\a':
|
||||
replaced = "\\a";
|
||||
break;
|
||||
case '\b':
|
||||
replaced = "\\b";
|
||||
break;
|
||||
}
|
||||
if (replaced != NULL)
|
||||
testingprivOutbufPrintf(rewrittenName, "%s", replaced);
|
||||
else if (isprint(*subname))
|
||||
testingprivOutbufPrintf(rewrittenName, "%c", *subname);
|
||||
else
|
||||
testingprivOutbufPrintf(rewrittenName, "\\x%x", (unsigned int) (*subname));
|
||||
subname++;
|
||||
}
|
||||
fullName = testingprivSmprintf("%s/%s", t->name, testingprivOutbufString(rewrittenName));
|
||||
testingprivOutbufFree(rewrittenName);
|
||||
|
||||
subt = testingprivNew(testingT);
|
||||
initTest(subt, fullName, subfunc, data, NULL, 0);
|
||||
subt->opts = t->opts;
|
||||
if (!testingprivTRun(subt, t->outbuf))
|
||||
t->failed = true;
|
||||
testingprivFree(subt);
|
||||
|
||||
testingprivFree(fullName);
|
||||
}
|
||||
|
||||
// Utility functions, provided here to avoid mucking up the sharedbits functions.
|
||||
|
||||
char *testingUtilStrdup(const char *s)
|
||||
{
|
||||
return testingprivStrdup(s);
|
||||
}
|
||||
|
||||
void testingUtilFreeStrdup(char *s)
|
||||
{
|
||||
testingprivFree(s);
|
||||
}
|
||||
|
|
@ -1,114 +0,0 @@
|
|||
// 27 february 2018
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define testingprivImplName(basename) testingprivImpl ## basename
|
||||
|
||||
#define testingprivScaffoldName(basename) testingprivScaffold ## basename
|
||||
#define testingprivMkScaffold(basename, argtype, argname) \
|
||||
static void testingprivScaffoldName(basename)(argtype *argname, void *data) { testingprivImplName(basename)(argname); }
|
||||
|
||||
// references:
|
||||
// - https://gitlab.gnome.org/GNOME/glib/blob/master/glib/gconstructor.h
|
||||
// - https://gitlab.gnome.org/GNOME/glib/blob/master/gio/glib-compile-resources.c
|
||||
// - https://msdn.microsoft.com/en-us/library/bb918180.aspx
|
||||
#define testingprivCtorName(basename) testingprivCtor ## basename
|
||||
#define testingprivCtorPtrName(basename) testingprivCtorPtr ## basename
|
||||
#if defined(__GNUC__)
|
||||
#define testingprivMkCtor(basename, pset) \
|
||||
__attribute__((constructor)) static void testingprivCtorName(basename)(void) { testingprivSetRegisterTest(pset, #basename, testingprivScaffoldName(basename), NULL, __FILE__, __LINE__); }
|
||||
#elif defined(_MSC_VER)
|
||||
#define testingprivMkCtor(basename, pset) \
|
||||
static int testingprivCtorName(basename)(void) { testingprivSetRegisterTest(pset, #basename, testingprivScaffoldName(basename), NULL, __FILE__, __LINE__); return 0; } \
|
||||
__pragma(section(".CRT$XCU",read)) \
|
||||
__declspec(allocate(".CRT$XCU")) static int (*testingprivCtorPtrName(basename))(void) = testingprivCtorName(basename);
|
||||
#else
|
||||
#error unknown compiler for making constructors in C; cannot continue
|
||||
#endif
|
||||
|
||||
#define testingprivMk(basename, argtype, argname, pset) \
|
||||
void testingprivImplName(basename)(argtype *argname); \
|
||||
testingprivMkScaffold(basename, argtype, argname) \
|
||||
testingprivMkCtor(basename, pset) \
|
||||
void testingprivImplName(basename)(argtype *argname)
|
||||
|
||||
#define testingTest(Name) \
|
||||
testingprivMk(Test ## Name, testingT, t, NULL)
|
||||
#define testingTestInSet(Set, Name) \
|
||||
testingprivMk(Test ## Name, testingT, t, &Set)
|
||||
|
||||
typedef struct testingSet testingSet;
|
||||
typedef struct testingOptions testingOptions;
|
||||
|
||||
struct testingOptions {
|
||||
bool Verbose;
|
||||
};
|
||||
|
||||
extern void testingSetRun(testingSet *set, const struct testingOptions *options, bool *anyRun, bool *anyFailed);
|
||||
|
||||
typedef struct testingT testingT;
|
||||
|
||||
#define testingTLogf(t, ...) \
|
||||
testingprivTLogfFullThen(t, NULL, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#define testingTLogvf(t, format, ap) \
|
||||
testingprivTLogvfFullThen(t, NULL, __FILE__, __LINE__, format, ap)
|
||||
#define testingTLogfFull(t, file, line, ...) \
|
||||
testingprivTLogfFullThen(t, NULL, file, line, __VA_ARGS__)
|
||||
#define testingTLogvfFull(t, file, line, format, ap) \
|
||||
testingprivTLogvfFullThen(t, NULL, file, line, format, ap)
|
||||
|
||||
#define testingTErrorf(t, ...) \
|
||||
testingprivTLogfFullThen(t, testingTFail, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#define testingTErrorvf(t, format, ap) \
|
||||
testingprivTLogvfFullThen(t, testingTFail, __FILE__, __LINE__, format, ap)
|
||||
#define testingTErrorfFull(t, file, line, ...) \
|
||||
testingprivTLogfFullThen(t, testingTFail, file, line, __VA_ARGS__)
|
||||
#define testingTErrorvfFull(t, file, line, format, ap) \
|
||||
testingprivTLogvfFullThen(t, testingTFail, file, line, format, ap)
|
||||
|
||||
#define testingTFatalf(t, ...) \
|
||||
testingprivTLogfFullThen(t, testingTFailNow, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#define testingTFatalvf(t, format, ap) \
|
||||
testingprivTLogvfFullThen(t, testingTFailNow, __FILE__, __LINE__, format, ap)
|
||||
#define testingTFatalfFull(t, file, line, ...) \
|
||||
testingprivTLogfFullThen(t, testingTFailNow, file, line, __VA_ARGS__)
|
||||
#define testingTFatalvfFull(t, file, line, format, ap) \
|
||||
testingprivTLogvfFullThen(t, testingTFailNow, file, line, format, ap)
|
||||
|
||||
#define testingTSkipf(t, ...) \
|
||||
testingprivTLogfFullThen(t, testingTSkipNow, __FILE__, __LINE__, __VA_ARGS__)
|
||||
#define testingTSkipvf(t, format, ap) \
|
||||
testingprivTLogvfFullThen(t, testingTSkipNow, __FILE__, __LINE__, format, ap)
|
||||
#define testingTSkipfFull(t, file, line, ...) \
|
||||
testingprivTLogfFullThen(t, testingTSkipNow, file, line, __VA_ARGS__)
|
||||
#define testingTSkipvfFull(t, file, line, format, ap) \
|
||||
testingprivTLogvfFullThen(t, testingTSkipNow, file, line, format, ap)
|
||||
|
||||
extern void testingTFail(testingT *t);
|
||||
extern void testingTFailNow(testingT *t);
|
||||
extern void testingTSkipNow(testingT *t);
|
||||
|
||||
extern void testingTDefer(testingT *t, void (*f)(testingT *t, void *data), void *data);
|
||||
extern void testingTRun(testingT *t, const char *subname, void (*subfunc)(testingT *t, void *data), void *data);
|
||||
|
||||
extern void testingprivSetRegisterTest(testingSet **pset, const char *, void (*)(testingT *, void *), void *, const char *, long);
|
||||
#include "../../sharedbits/printfwarn_header.h"
|
||||
sharedbitsPrintfFunc(
|
||||
extern void testingprivTLogfFullThen(testingT *, void (*)(testingT *), const char *, long, const char *, ...),
|
||||
5, 6);
|
||||
#undef sharedbitsPrintfFunc
|
||||
extern void testingprivTLogvfFullThen(testingT *, void (*)(testingT *), const char *, long, const char *, va_list);
|
||||
|
||||
// Utility functions, provided here to avoid mucking up the sharedbits functions.
|
||||
extern char *testingUtilStrdup(const char *s);
|
||||
extern void testingUtilFreeStrdup(char *s);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,218 +0,0 @@
|
|||
// 19 may 2019
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "testing.h"
|
||||
#include "testingpriv.h"
|
||||
|
||||
void testingprivInternalError(const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
fprintf(stderr, "** testing internal error: ");
|
||||
vfprintf(stderr, fmt, ap);
|
||||
fprintf(stderr, "; aborting\n");
|
||||
va_end(ap);
|
||||
abort();
|
||||
}
|
||||
|
||||
#define sharedbitsPrefix testingpriv
|
||||
#include "../../sharedbits/alloc_impl.h"
|
||||
#include "../../sharedbits/array_impl.h"
|
||||
#undef sharedbitsPrefix
|
||||
|
||||
#define sharedbitsPrefix testingprivImpl
|
||||
#define sharedbitsStatic static
|
||||
#define sharedbitsInternalError testingprivInternalError
|
||||
#include "../../sharedbits/strsafe_impl.h"
|
||||
#undef sharedbitsInternalError
|
||||
#undef sharedbitsStatic
|
||||
#undef sharedbitsPrefix
|
||||
|
||||
#define sharedbitsPrefix testingpriv
|
||||
#define testingprivStrncpy testingprivImplStrncpy
|
||||
#include "../../sharedbits/strdup_impl.h"
|
||||
#undef testingprivStrncpy
|
||||
#undef sharedbitsPrefix
|
||||
|
||||
int testingprivVsnprintf(char *s, size_t n, const char *fmt, va_list ap)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = testingprivImplVsnprintf(s, n, fmt, ap);
|
||||
if (ret < 0)
|
||||
testingprivInternalError("encoding error in vsnprintf(); this likely means your call to testingTLogf() and the like is invalid");
|
||||
return ret;
|
||||
}
|
||||
|
||||
int testingprivSnprintf(char *s, size_t n, const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
int ret;
|
||||
|
||||
va_start(ap, fmt);
|
||||
ret = testingprivVsnprintf(s, n, fmt, ap);
|
||||
va_end(ap);
|
||||
return ret;
|
||||
}
|
||||
|
||||
char *testingprivVsmprintf(const char *fmt, va_list ap)
|
||||
{
|
||||
char *s;
|
||||
va_list ap2;
|
||||
int n;
|
||||
|
||||
va_copy(ap2, ap);
|
||||
n = testingprivVsnprintf(NULL, 0, fmt, ap2);
|
||||
va_end(ap2);
|
||||
s = (char *) testingprivAlloc((n + 1) * sizeof (char), "char[]");
|
||||
testingprivVsnprintf(s, n + 1, fmt, ap);
|
||||
return s;
|
||||
}
|
||||
|
||||
char *testingprivSmprintf(const char *fmt, ...)
|
||||
{
|
||||
char *s;
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
s = testingprivVsmprintf(fmt, ap);
|
||||
va_end(ap);
|
||||
return s;
|
||||
}
|
||||
|
||||
struct testingprivOutbuf {
|
||||
testingprivArray buf;
|
||||
};
|
||||
|
||||
testingprivOutbuf *testingprivNewOutbuf(void)
|
||||
{
|
||||
testingprivOutbuf *o;
|
||||
|
||||
o = testingprivNew(testingprivOutbuf);
|
||||
testingprivArrayInit(o->buf, char, 32, "testing output buffer");
|
||||
return o;
|
||||
}
|
||||
|
||||
void testingprivOutbufFree(testingprivOutbuf *o)
|
||||
{
|
||||
testingprivArrayFree(o->buf);
|
||||
testingprivFree(o);
|
||||
}
|
||||
|
||||
void testingprivOutbufVprintf(testingprivOutbuf *o, const char *fmt, va_list ap)
|
||||
{
|
||||
char *dest;
|
||||
va_list ap2;
|
||||
int n;
|
||||
|
||||
if (o == NULL) {
|
||||
vprintf(fmt, ap);
|
||||
return;
|
||||
}
|
||||
va_copy(ap2, ap);
|
||||
n = testingprivVsnprintf(NULL, 0, fmt, ap2);
|
||||
va_end(ap2);
|
||||
// To conserve memory, we only allocate the terminating NUL once.
|
||||
if (o->buf.len == 0)
|
||||
dest = (char *) testingprivArrayAppend(&(o->buf), n + 1);
|
||||
else {
|
||||
dest = (char *) testingprivArrayAppend(&(o->buf), n);
|
||||
dest--;
|
||||
}
|
||||
testingprivVsnprintf(dest, n + 1, fmt, ap);
|
||||
}
|
||||
|
||||
void testingprivOutbufVprintfIndented(testingprivOutbuf *o, const char *fmt, va_list ap)
|
||||
{
|
||||
char *buf;
|
||||
char *lineStart, *lineEnd;
|
||||
const char *indent;
|
||||
|
||||
buf = testingprivVsmprintf(fmt, ap);
|
||||
|
||||
lineStart = buf;
|
||||
indent = "";
|
||||
for (;;) {
|
||||
lineEnd = strchr(lineStart, '\n');
|
||||
if (lineEnd == NULL)
|
||||
break;
|
||||
*lineEnd = '\0';
|
||||
testingprivOutbufPrintf(o, "%s%s\n", indent, lineStart);
|
||||
lineStart = lineEnd + 1;
|
||||
indent = " ";
|
||||
}
|
||||
// and print the last line fragment, if any
|
||||
if (*lineStart != '\0')
|
||||
testingprivOutbufPrintf(o, "%s%s", indent, lineStart);
|
||||
testingprivFree(buf);
|
||||
}
|
||||
|
||||
void testingprivOutbufPrintf(testingprivOutbuf *o, const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
testingprivOutbufVprintf(o, fmt, ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
// TODO right now this assumes the last character in o before calling this is a newline
|
||||
void testingprivOutbufAppendOutbuf(testingprivOutbuf *o, testingprivOutbuf *src)
|
||||
{
|
||||
char *buf;
|
||||
size_t n;
|
||||
bool hasTrailingBlankLine;
|
||||
size_t trailingBlankLinePos = 0; // silence incorrect MSVC warning
|
||||
char *lineStart, *lineEnd;
|
||||
|
||||
buf = src->buf.buf;
|
||||
n = src->buf.len;
|
||||
if (n == 0)
|
||||
// nothing to write
|
||||
return;
|
||||
|
||||
// strip trailing blank lines, if any
|
||||
hasTrailingBlankLine = false;
|
||||
if (buf[n - 1] == '\n') {
|
||||
hasTrailingBlankLine = true;
|
||||
while (n > 0 && buf[n - 1] == '\n')
|
||||
n--;
|
||||
if (n == 0) {
|
||||
// the buffer only has blank lines, so just add a single newline and be done with it
|
||||
// TODO verify that this is the correct behavior
|
||||
testingprivOutbufPrintf(o, "\n");
|
||||
return;
|
||||
}
|
||||
trailingBlankLinePos = n;
|
||||
buf[trailingBlankLinePos] = '\0';
|
||||
}
|
||||
|
||||
lineStart = buf;
|
||||
for (;;) {
|
||||
lineEnd = strchr(lineStart, '\n');
|
||||
if (lineEnd == NULL) // last line
|
||||
break;
|
||||
*lineEnd = '\0';
|
||||
testingprivOutbufPrintf(o, " %s\n", lineStart);
|
||||
// be sure to restore src to its original state
|
||||
*lineEnd = '\n';
|
||||
lineStart = lineEnd + 1;
|
||||
}
|
||||
// print the last line, if any
|
||||
if (*lineStart != '\0')
|
||||
testingprivOutbufPrintf(o, " %s\n", lineStart);
|
||||
|
||||
// restore src to its original state
|
||||
if (hasTrailingBlankLine)
|
||||
buf[trailingBlankLinePos] = '\n';
|
||||
}
|
||||
|
||||
const char *testingprivOutbufString(testingprivOutbuf *o)
|
||||
{
|
||||
if (o->buf.buf == NULL)
|
||||
return "";
|
||||
return o->buf.buf;
|
||||
}
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
// 19 may 2019
|
||||
|
||||
#include "../../sharedbits/printfwarn_header.h"
|
||||
|
||||
sharedbitsPrintfFunc(
|
||||
extern void testingprivInternalError(const char *fmt, ...),
|
||||
1, 2);
|
||||
|
||||
#define sharedbitsPrefix testingpriv
|
||||
|
||||
#include "../../sharedbits/alloc_header.h"
|
||||
#define testingprivNew(T) ((T *) testingprivAlloc(sizeof (T), #T))
|
||||
#define testingprivNewArray(T, n) ((T *) testingprivAlloc(n * sizeof (T), #T "[]"))
|
||||
#define testingprivResizeArray(x, T, old, new) ((T *) testingprivRealloc(x, old * sizeof (T), new * sizeof (T), #T "[]"))
|
||||
|
||||
#include "../../sharedbits/array_header.h"
|
||||
#define testingprivArrayStaticInit(T, nGrow, what) { NULL, 0, 0, sizeof (T), nGrow, what }
|
||||
#define testingprivArrayInit(arr, T, nGrow, what) testingprivArrayInitFull(&(arr), sizeof (T), nGrow, what)
|
||||
#define testingprivArrayFree(arr) testingprivArrayFreeFull(&(arr))
|
||||
#define testingprivArrayAt(arr, T, n) (((T *) (arr.buf)) + (n))
|
||||
|
||||
#include "../../sharedbits/strdup_header.h"
|
||||
|
||||
#undef sharedbitsPrefix
|
||||
|
||||
extern int testingprivVsnprintf(char *s, size_t n, const char *fmt, va_list ap);
|
||||
sharedbitsPrintfFunc(
|
||||
extern int testingprivSnprintf(char *s, size_t n, const char *fmt, ...),
|
||||
3, 4);
|
||||
extern char *testingprivVsmprintf(const char *fmt, va_list ap);
|
||||
sharedbitsPrintfFunc(
|
||||
extern char *testingprivSmprintf(const char *fmt, ...),
|
||||
1, 2);
|
||||
|
||||
// a testingprivOutbuf of NULL writes directly to stdout
|
||||
typedef struct testingprivOutbuf testingprivOutbuf;
|
||||
extern testingprivOutbuf *testingprivNewOutbuf(void);
|
||||
extern void testingprivOutbufFree(testingprivOutbuf *o);
|
||||
extern void testingprivOutbufVprintf(testingprivOutbuf *o, const char *fmt, va_list ap);
|
||||
extern void testingprivOutbufVprintfIndented(testingprivOutbuf *o, const char *fmt, va_list ap);
|
||||
sharedbitsPrintfFunc(
|
||||
extern void testingprivOutbufPrintf(testingprivOutbuf *o, const char *fmt, ...),
|
||||
2, 3);
|
||||
extern void testingprivOutbufAppendOutbuf(testingprivOutbuf *o, testingprivOutbuf *src);
|
||||
extern const char *testingprivOutbufString(testingprivOutbuf *o);
|
||||
|
||||
#undef sharedbitsPrintfFunc
|
||||
|
|
@ -1,352 +0,0 @@
|
|||
// 2 may 2019
|
||||
#include <string.h>
|
||||
#include "timer.h"
|
||||
#include "timerpriv.h"
|
||||
|
||||
// This is based on the algorithm that Go uses for time.Duration.
|
||||
// Of course, we're not expressing it the same way...
|
||||
struct timerStringPart {
|
||||
char suffix;
|
||||
char suffix2;
|
||||
int mode;
|
||||
uint32_t maxOrMod;
|
||||
int precision;
|
||||
};
|
||||
|
||||
enum {
|
||||
modeMaxAndStop,
|
||||
modeFracModContinue,
|
||||
};
|
||||
|
||||
static const struct timerStringPart parts[] = {
|
||||
{ 'n', 's', modeMaxAndStop, 1000, 0 },
|
||||
{ 'u', 's', modeMaxAndStop, 1000000, 3 },
|
||||
{ 'm', 's', modeMaxAndStop, 1000000000, 6 },
|
||||
{ 's', 0, modeFracModContinue, 60, 9 },
|
||||
{ 'm', 0, modeFracModContinue, 60, 0 },
|
||||
{ 'h', 0, modeFracModContinue, 60, 0 },
|
||||
{ 0, 0, 0, 0, 0 },
|
||||
};
|
||||
|
||||
static int fillFracPart(char *buf, int precision, int start, uint64_t *unsec)
|
||||
{
|
||||
int i;
|
||||
bool print;
|
||||
uint64_t digit;
|
||||
|
||||
print = false;
|
||||
for (i = 0; i < precision; i++) {
|
||||
digit = *unsec % 10;
|
||||
print = print || (digit != 0);
|
||||
if (print) {
|
||||
buf[start - 1] = "0123456789"[digit];
|
||||
start--;
|
||||
}
|
||||
*unsec /= 10;
|
||||
}
|
||||
if (print) {
|
||||
buf[start - 1] = '.';
|
||||
start--;
|
||||
}
|
||||
return start;
|
||||
}
|
||||
|
||||
static int fillIntPart(char *buf, int start, uint64_t unsec)
|
||||
{
|
||||
if (unsec == 0) {
|
||||
buf[start - 1] = '0';
|
||||
start--;
|
||||
return start;
|
||||
}
|
||||
while (unsec != 0) {
|
||||
buf[start - 1] = "0123456789"[unsec % 10];
|
||||
start--;
|
||||
unsec /= 10;
|
||||
}
|
||||
return start;
|
||||
}
|
||||
|
||||
void timerDurationString(timerDuration d, char buf[timerDurationStringLen])
|
||||
{
|
||||
uint64_t unsec;
|
||||
bool neg;
|
||||
int start;
|
||||
const struct timerStringPart *p;
|
||||
|
||||
memset(buf, 0, timerDurationStringLen * sizeof (char));
|
||||
start = 32;
|
||||
|
||||
if (d == 0) {
|
||||
buf[0] = '0';
|
||||
buf[1] = 's';
|
||||
return;
|
||||
}
|
||||
neg = d < 0;
|
||||
if (neg) {
|
||||
// C99 §6.2.6.2 resticts the possible signed integer representations in C to either sign-magnitude, 1's complement, or 2's complement.
|
||||
// Therefore, INT64_MIN will always be either -INT64_MAX or -INT64_MAX - 1, so we can safely do this to see if we need to special-case INT64_MIN as -INT64_MIN cannot be safely represented, or if we can just say -d as that can be safely represented.
|
||||
// See also https://stackoverflow.com/questions/29808397/how-to-portably-find-out-minint-max-absint-min
|
||||
if (d < -INT64_MAX) {
|
||||
// INT64_MIN is -INT64_MAX - 1.
|
||||
// This value comes directly from forcing such a value into Go's code; let's just use it.
|
||||
memmove(buf, "-2562047h47m16.854775808s", (25 + 1) * sizeof (char));
|
||||
return;
|
||||
}
|
||||
unsec = (uint64_t) (-d);
|
||||
} else
|
||||
unsec = (uint64_t) d;
|
||||
|
||||
for (p = parts; p->suffix != 0; p++) {
|
||||
if (p->mode == modeMaxAndStop && unsec < p->maxOrMod) {
|
||||
if (p->suffix2 != 0) {
|
||||
buf[start - 1] = p->suffix2;
|
||||
start--;
|
||||
}
|
||||
buf[start - 1] = p->suffix;
|
||||
start--;
|
||||
start = fillFracPart(buf, p->precision, start, &unsec);
|
||||
start = fillIntPart(buf, start, unsec);
|
||||
break;
|
||||
}
|
||||
if (p->mode == modeFracModContinue && unsec != 0) {
|
||||
if (p->suffix2 != 0) {
|
||||
buf[start - 1] = p->suffix2;
|
||||
start--;
|
||||
}
|
||||
buf[start - 1] = p->suffix;
|
||||
start--;
|
||||
start = fillFracPart(buf, p->precision, start, &unsec);
|
||||
start = fillIntPart(buf, start, unsec % p->maxOrMod);
|
||||
unsec /= p->maxOrMod;
|
||||
// and move on to the next one
|
||||
}
|
||||
}
|
||||
|
||||
if (neg) {
|
||||
buf[start - 1] = '-';
|
||||
start--;
|
||||
}
|
||||
memmove(buf, buf + start, 33 - start);
|
||||
}
|
||||
|
||||
// portable implementations of 64x64-bit MulDiv(), because:
|
||||
// - a division intrinsic was not added to Visual Studio until VS2015
|
||||
// - there does not seem to be a division intrinsic in GCC or clang as far as I can tell
|
||||
// - there are no 128-bit facilities in macOS as far as I can tell
|
||||
|
||||
static void int128FromUint64(uint64_t n, timerprivInt128 *out)
|
||||
{
|
||||
out->neg = false;
|
||||
out->high = 0;
|
||||
out->low = n;
|
||||
}
|
||||
|
||||
static void int128FromInt64(int64_t n, timerprivInt128 *out)
|
||||
{
|
||||
if (n >= 0) {
|
||||
int128FromUint64((uint64_t) n, out);
|
||||
return;
|
||||
}
|
||||
out->neg = true;
|
||||
out->high = 0;
|
||||
// And now we do the same INT64_MIN/INT64_MAX juggling as above.
|
||||
if (n < -INT64_MAX) {
|
||||
out->low = ((uint64_t) INT64_MAX) + 1;
|
||||
return;
|
||||
}
|
||||
out->low = (uint64_t) (-n);
|
||||
}
|
||||
|
||||
// references for this part:
|
||||
// - https://opensource.apple.com/source/Libc/Libc-1272.200.26/gen/nanosleep.c.auto.html
|
||||
// - https://en.wikipedia.org/wiki/Division_algorithm#Integer_division_(unsigned)_with_remainder
|
||||
|
||||
static void int128UAdd(timerprivInt128 *x, const timerprivInt128 *y)
|
||||
{
|
||||
x->high += y->high;
|
||||
x->low += y->low;
|
||||
if (x->low < y->low)
|
||||
x->high++;
|
||||
}
|
||||
|
||||
static void int128USub(timerprivInt128 *x, const timerprivInt128 *y)
|
||||
{
|
||||
x->high -= y->high;
|
||||
if (x->low < y->low)
|
||||
x->high--;
|
||||
x->low -= y->low;
|
||||
}
|
||||
|
||||
static void int128Lsh1(timerprivInt128 *x)
|
||||
{
|
||||
x->high <<= 1;
|
||||
if ((x->low & 0x8000000000000000) != 0)
|
||||
x->high |= 1;
|
||||
x->low <<= 1;
|
||||
}
|
||||
|
||||
static uint64_t int128Bit(const timerprivInt128 *x, int i)
|
||||
{
|
||||
uint64_t which;
|
||||
|
||||
which = x->low;
|
||||
if (i >= 64) {
|
||||
i -= 64;
|
||||
which = x->high;
|
||||
}
|
||||
return (which >> i) & 1;
|
||||
}
|
||||
|
||||
static int int128UCmp(const timerprivInt128 *x, const timerprivInt128 *y)
|
||||
{
|
||||
if (x->high < y->high)
|
||||
return -1;
|
||||
if (x->high > y->high)
|
||||
return 1;
|
||||
if (x->low < y->low)
|
||||
return -1;
|
||||
if (x->low > y->low)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void int128BitSet(timerprivInt128 *x, int i)
|
||||
{
|
||||
uint64_t bit;
|
||||
|
||||
bit = 1;
|
||||
if (i >= 64) {
|
||||
i -= 64;
|
||||
bit <<= i;
|
||||
x->high |= bit;
|
||||
return;
|
||||
}
|
||||
bit <<= i;
|
||||
x->low |= bit;
|
||||
}
|
||||
|
||||
static void int128MulDiv64(timerprivInt128 *x, timerprivInt128 *y, timerprivInt128 *z, timerprivInt128 *quot)
|
||||
{
|
||||
bool finalNeg;
|
||||
uint64_t x64high, x64low;
|
||||
uint64_t y64high, y64low;
|
||||
timerprivInt128 add, numer, rem;
|
||||
int i;
|
||||
|
||||
finalNeg = false;
|
||||
if (x->neg)
|
||||
finalNeg = !finalNeg;
|
||||
if (y->neg)
|
||||
finalNeg = !finalNeg;
|
||||
if (z->neg)
|
||||
finalNeg = !finalNeg;
|
||||
quot->neg = finalNeg;
|
||||
// we now treat x, y, and z as unsigned
|
||||
|
||||
// first, multiply x and y into numer
|
||||
// this assumes x->high == y->high == 0
|
||||
numer.neg = false;
|
||||
// the idea is if x = (a * 2^32) + b and y = (c * 2^32) + d, we can express x * y as ((a * 2^32) + b) * ((c * 2^32) + d)...
|
||||
x64high = (x->low >> 32) & 0xFFFFFFFF;
|
||||
x64low = x->low & 0xFFFFFFFF;
|
||||
y64high = (y->low >> 32) & 0xFFFFFFFF;
|
||||
y64low = y->low & 0xFFFFFFFF;
|
||||
// and we can expand that out to get...
|
||||
numer.high = x64high * y64high; // a * c * 2^64 +
|
||||
numer.low = x64low * y64low; // b * d +
|
||||
add.neg = false;
|
||||
add.high = x64high * y64low; // a * d * 2^32 +
|
||||
add.low = (add.high & 0xFFFFFFFF) << 32;
|
||||
add.high >>= 32;
|
||||
int128UAdd(&numer, &add);
|
||||
add.high = x64low * y64high; // b * c * 2^32
|
||||
add.low = (add.high & 0xFFFFFFFF) << 32;
|
||||
add.high >>= 32;
|
||||
int128UAdd(&numer, &add);
|
||||
// I did type this all by hand, btw; the idea does come from Apple's implementation, though they explain it a bit more obtusely, and the odd behavior with anding high into low is to avoid looking like I directly copied their code which does the opposite
|
||||
|
||||
// and now long-divide
|
||||
// Apple's implementation uses Newton–Raphson division using doubles to store 1/z but I'd rather go with "slow but guaranteed to be accurate"
|
||||
// (Apple also rejects quotients > UINT64_MAX; we won't)
|
||||
quot->high = 0;
|
||||
quot->low = 0;
|
||||
rem.neg = false;
|
||||
rem.high = 0;
|
||||
rem.low = 0;
|
||||
for (i = 127; i >= 0; i--) {
|
||||
int128Lsh1(&rem);
|
||||
rem.low |= int128Bit(&numer, i);
|
||||
if (int128UCmp(&rem, z) >= 0) {
|
||||
int128USub(&rem, z);
|
||||
int128BitSet(quot, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void timerprivMulDivInt64(int64_t x, int64_t y, int64_t z, timerprivInt128 *quot)
|
||||
{
|
||||
timerprivInt128 a, b, c;
|
||||
|
||||
int128FromInt64(x, &a);
|
||||
int128FromInt64(y, &b);
|
||||
int128FromInt64(z, &c);
|
||||
int128MulDiv64(&a, &b, &c, quot);
|
||||
}
|
||||
|
||||
void timerprivMulDivUint64(uint64_t x, uint64_t y, uint64_t z, timerprivInt128 *quot)
|
||||
{
|
||||
timerprivInt128 a, b, c;
|
||||
|
||||
int128FromUint64(x, &a);
|
||||
int128FromUint64(y, &b);
|
||||
int128FromUint64(z, &c);
|
||||
int128MulDiv64(&a, &b, &c, quot);
|
||||
}
|
||||
|
||||
int64_t timerprivInt128ToInt64(const timerprivInt128 *n, int64_t min, int64_t minCap, int64_t max, int64_t maxCap)
|
||||
{
|
||||
if (n->neg) {
|
||||
int64_t ret;
|
||||
|
||||
if (n->high > 0)
|
||||
return minCap;
|
||||
if (n->low > (uint64_t) INT64_MAX) {
|
||||
// we can't safely convert n->low to int64_t
|
||||
#if INT64_MIN == -INT64_MAX
|
||||
// in this case, we can't store -n->low in an int64_t at all!
|
||||
// therefore, it must be out of range
|
||||
return minCap;
|
||||
#else
|
||||
// in this case, INT64_MIN == -INT64_MAX - 1
|
||||
if (n->low > ((uint64_t) INT64_MAX) + 1)
|
||||
// we still can't store -n->low in an int64_t
|
||||
return minCap;
|
||||
// only one option left
|
||||
ret = INT64_MIN;
|
||||
#endif
|
||||
} else {
|
||||
// -n->low can safely be stored in an int64_t, so do so
|
||||
ret = (int64_t) (n->low);
|
||||
ret = -ret;
|
||||
}
|
||||
if (ret < min)
|
||||
return minCap;
|
||||
return ret;
|
||||
}
|
||||
if (n->high > 0)
|
||||
return maxCap;
|
||||
if (n->low > (uint64_t) max)
|
||||
return maxCap;
|
||||
return (int64_t) (n->low);
|
||||
}
|
||||
|
||||
uint64_t timerprivInt128ToUint64(const timerprivInt128 *n, uint64_t max, uint64_t maxCap)
|
||||
{
|
||||
if (n->neg)
|
||||
return 0;
|
||||
if (n->high != 0)
|
||||
return maxCap;
|
||||
if (n->low > maxCap)
|
||||
return maxCap;
|
||||
return n->low;
|
||||
}
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
// 2 may 2019
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef int64_t timerDuration;
|
||||
typedef int64_t timerTime;
|
||||
|
||||
#define timerTimeMax ((timerTime) INT64_MAX)
|
||||
#define timerDurationMin ((timerDuration) INT64_MIN)
|
||||
#define timerDurationMax ((timerDuration) INT64_MAX)
|
||||
|
||||
#define timerNanosecond ((timerDuration) 1)
|
||||
#define timerMicrosecond ((timerDuration) 1000)
|
||||
#define timerMillisecond ((timerDuration) 1000000)
|
||||
#define timerSecond ((timerDuration) 1000000000)
|
||||
|
||||
extern timerTime timerMonotonicNow(void);
|
||||
extern timerDuration timerTimeSub(timerTime end, timerTime start);
|
||||
|
||||
// The Go algorithm says 32 should be enough.
|
||||
// We use 33 to count the terminating NUL.
|
||||
#define timerDurationStringLen 33
|
||||
extern void timerDurationString(timerDuration d, char buf[timerDurationStringLen]);
|
||||
|
||||
typedef uint64_t timerSysError;
|
||||
#ifdef _WIN32
|
||||
#define timerSysErrorFmt "0x%08I32X"
|
||||
#define timerSysErrorFmtArg(x) ((uint32_t) x)
|
||||
#else
|
||||
#include <string.h>
|
||||
#define timerSysErrorFmt "%s (%d)"
|
||||
#define timerSysErrorFmtArg(x) strerror((int) x), ((int) x)
|
||||
#endif
|
||||
|
||||
extern timerSysError timerRunWithTimeout(timerDuration d, void (*f)(void *data), void *data, bool *timedOut);
|
||||
|
||||
extern timerSysError timerSleep(timerDuration d);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,268 +0,0 @@
|
|||
// 3 may 2019
|
||||
// TODO pin down minimum POSIX versions (depends on what macOS 10.8 conforms to and what GLib/GTK+ require)
|
||||
// TODO also pin down which of these I should be defining, because apparently FreeBSD only checks for _XOPEN_SOURCE (and 2004 POSIX says that defining this as 600 *implies* _POSIX_C_SOURCE being 200112L so only _XOPEN_SOURCE is needed...)
|
||||
#define _POSIX_C_SOURCE 200112L
|
||||
#define _XOPEN_SOURCE 600
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <setjmp.h>
|
||||
#include <signal.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/time.h>
|
||||
#include <time.h>
|
||||
#ifdef __APPLE__
|
||||
#include <mach/mach.h>
|
||||
#include <mach/mach_time.h>
|
||||
#endif
|
||||
#include "timer.h"
|
||||
#include "timerpriv.h"
|
||||
|
||||
static void mustpthread_once(pthread_once_t *once, void (*init)(void))
|
||||
{
|
||||
int err;
|
||||
|
||||
err = pthread_once(once, init);
|
||||
if (err != 0) {
|
||||
fprintf(stderr, "*** internal error in timerMonotonicNow(): pthread_once() failed: %s (%d)\n", strerror(err), err);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __APPLE__
|
||||
|
||||
static uint64_t base;
|
||||
static mach_timebase_info_data_t mt;
|
||||
static pthread_once_t baseOnce = PTHREAD_ONCE_INIT;
|
||||
|
||||
static void baseInit(void)
|
||||
{
|
||||
kern_return_t err;
|
||||
|
||||
base = mach_absolute_time();
|
||||
err = mach_timebase_info(&mt);
|
||||
if (err != KERN_SUCCESS) {
|
||||
fprintf(stderr, "*** internal error in timerMonotonicNow(): mach_timebase_info() failed: kern_return_t %d\n", err);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
timerTime timerMonotonicNow(void)
|
||||
{
|
||||
uint64_t t;
|
||||
timerprivInt128 quot;
|
||||
|
||||
mustpthread_once(&baseOnce, baseInit);
|
||||
t = mach_absolute_time() - base;
|
||||
timerprivMulDivUint64(t, mt.numer, mt.denom, ");
|
||||
// on overflow, return the maximum possible timerTime; this is inspired by what Go does
|
||||
// the limit check will ensure we can safely cast the return value to a timerTime
|
||||
return (timerTime) timerprivInt128ToUint64(",
|
||||
(uint64_t) timerTimeMax, (uint64_t) timerTimeMax);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static void mustclock_gettime(clockid_t id, struct timespec *ts)
|
||||
{
|
||||
int err;
|
||||
|
||||
errno = 0;
|
||||
if (clock_gettime(id, ts) != 0) {
|
||||
err = errno;
|
||||
fprintf(stderr, "*** internal error in timerMonotonicNow(): clock_gettime() failed: %s (%d)\n", strerror(err), err);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
static struct timespec base;
|
||||
static pthread_once_t baseOnce = PTHREAD_ONCE_INIT;
|
||||
|
||||
static void baseInit(void)
|
||||
{
|
||||
mustclock_gettime(CLOCK_MONOTONIC, &base);
|
||||
}
|
||||
|
||||
timerTime timerMonotonicNow(void)
|
||||
{
|
||||
struct timespec ts;
|
||||
timerTime ret;
|
||||
|
||||
mustpthread_once(&baseOnce, baseInit);
|
||||
mustclock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
ts.tv_sec -= base.tv_sec;
|
||||
ts.tv_nsec -= base.tv_nsec;
|
||||
if (ts.tv_nsec < 0) { // this is safe because POSIX requires this to be of type long
|
||||
ts.tv_sec--;
|
||||
ts.tv_nsec += timerSecond;
|
||||
}
|
||||
ret = ((timerTime) (ts.tv_sec)) * timerSecond;
|
||||
ret += (timerTime) (ts.tv_nsec);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
timerDuration timerTimeSub(timerTime end, timerTime start)
|
||||
{
|
||||
return end - start;
|
||||
}
|
||||
|
||||
struct timeoutParams {
|
||||
jmp_buf retpos;
|
||||
struct itimerval prevDuration;
|
||||
struct sigaction prevSig;
|
||||
};
|
||||
|
||||
static struct timeoutParams p;
|
||||
|
||||
static void onTimeout(int sig, siginfo_t *info, void *ctx)
|
||||
{
|
||||
longjmp(p.retpos, 1);
|
||||
}
|
||||
|
||||
// POSIX doesn't have atomic operations :|
|
||||
// We could have special OS X-specific code that uses OSAtomic.h, but they have signedness type mismatches :| :|
|
||||
// There's also the GCC intrinsic atomic operations, but I cannot find a way to portably detect their presence :| :| :|
|
||||
// And pthread_mutex_lock() and pthread_mutex_unlock() CAN fail :| :| :| :|
|
||||
|
||||
static pthread_mutex_t nonReentranceMutex = PTHREAD_MUTEX_INITIALIZER;
|
||||
static volatile uint32_t nonReentranceInCall = 0;
|
||||
|
||||
static void mustpthread_mutex_lock(pthread_mutex_t *mu)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = pthread_mutex_lock(mu);
|
||||
if (err != 0) {
|
||||
fprintf(stderr, "*** internal error in timerRunWithTimeout(): pthread_mutex_lock() failed: %s (%d)\n", strerror(err), err);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
static void mustpthread_mutex_unlock(pthread_mutex_t *mu)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = pthread_mutex_unlock(mu);
|
||||
if (err != 0) {
|
||||
fprintf(stderr, "*** internal error in timerRunWithTimeout(): pthread_mutex_unlock() failed: %s (%d)\n", strerror(err), err);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
static int setupNonReentrance(void)
|
||||
{
|
||||
int err;
|
||||
|
||||
mustpthread_mutex_lock(&nonReentranceMutex);
|
||||
err = 0;
|
||||
if (nonReentranceInCall)
|
||||
err = EALREADY;
|
||||
else
|
||||
nonReentranceInCall = 1;
|
||||
mustpthread_mutex_unlock(&nonReentranceMutex);
|
||||
return err;
|
||||
}
|
||||
|
||||
static void teardownNonReentrance(void)
|
||||
{
|
||||
mustpthread_mutex_lock(&nonReentranceMutex);
|
||||
nonReentranceInCall = 0;
|
||||
mustpthread_mutex_unlock(&nonReentranceMutex);
|
||||
}
|
||||
|
||||
timerSysError timerRunWithTimeout(timerDuration d, void (*f)(void *data), void *data, bool *timedOut)
|
||||
{
|
||||
sigset_t sigalrm, allsigs;
|
||||
sigset_t prevMask;
|
||||
volatile bool restorePrevMask = false;
|
||||
struct sigaction sig;
|
||||
volatile bool restoreSignal = false;
|
||||
struct itimerval duration;
|
||||
volatile bool destroyTimer = false;
|
||||
int err = 0;
|
||||
|
||||
*timedOut = false;
|
||||
err = setupNonReentrance();
|
||||
if (err != 0)
|
||||
return (timerSysError) err;
|
||||
|
||||
memset(&p, 0, sizeof (struct timeoutParams));
|
||||
|
||||
errno = 0;
|
||||
if (sigemptyset(&sigalrm) != 0)
|
||||
return (timerSysError) errno;
|
||||
errno = 0;
|
||||
if (sigaddset(&sigalrm, SIGALRM) != 0)
|
||||
return (timerSysError) errno;
|
||||
errno = 0;
|
||||
if (sigfillset(&allsigs) != 0)
|
||||
return (timerSysError) errno;
|
||||
|
||||
err = pthread_sigmask(SIG_BLOCK, &sigalrm, &prevMask);
|
||||
if (err != 0)
|
||||
return (timerSysError) err;
|
||||
restorePrevMask = true;
|
||||
|
||||
if (setjmp(p.retpos) == 0) {
|
||||
sig.sa_mask = allsigs;
|
||||
sig.sa_flags = SA_SIGINFO;
|
||||
sig.sa_sigaction = onTimeout;
|
||||
errno = 0;
|
||||
if (sigaction(SIGALRM, &sig, &(p.prevSig)) != 0) {
|
||||
err = errno;
|
||||
goto out;
|
||||
}
|
||||
restoreSignal = true;
|
||||
|
||||
duration.it_interval.tv_sec = 0;
|
||||
duration.it_interval.tv_usec = 0;
|
||||
duration.it_value.tv_sec = d / timerSecond;
|
||||
duration.it_value.tv_usec = (d % timerSecond) / timerMicrosecond;
|
||||
errno = 0;
|
||||
if (setitimer(ITIMER_REAL, &duration, &(p.prevDuration)) != 0) {
|
||||
err = errno;
|
||||
goto out;
|
||||
}
|
||||
destroyTimer = true;
|
||||
|
||||
// and fire away
|
||||
err = pthread_sigmask(SIG_UNBLOCK, &sigalrm, NULL);
|
||||
if (err != 0)
|
||||
goto out;
|
||||
|
||||
(*f)(data);
|
||||
} else
|
||||
*timedOut = true;
|
||||
err = 0;
|
||||
|
||||
out:
|
||||
if (destroyTimer)
|
||||
setitimer(ITIMER_REAL, &(p.prevDuration), NULL);
|
||||
if (restoreSignal)
|
||||
sigaction(SIGALRM, &(p.prevSig), NULL);
|
||||
if (restorePrevMask)
|
||||
pthread_sigmask(SIG_SETMASK, &prevMask, NULL);
|
||||
teardownNonReentrance();
|
||||
return (timerSysError) err;
|
||||
}
|
||||
|
||||
timerSysError timerSleep(timerDuration d)
|
||||
{
|
||||
struct timespec duration, remaining;
|
||||
int err;
|
||||
|
||||
duration.tv_sec = d / timerSecond;
|
||||
duration.tv_nsec = d % timerSecond;
|
||||
for (;;) {
|
||||
errno = 0;
|
||||
if (nanosleep(&duration, &remaining) == 0)
|
||||
return 0;
|
||||
err = errno;
|
||||
if (err != EINTR)
|
||||
return (timerSysError) err;
|
||||
duration = remaining;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,432 +0,0 @@
|
|||
// 23 april 2019
|
||||
#define UNICODE
|
||||
#define _UNICODE
|
||||
#define STRICT
|
||||
#define STRICT_TYPED_ITEMIDS
|
||||
#define WINVER 0x0600
|
||||
#define _WIN32_WINNT 0x0600
|
||||
#define _WIN32_WINDOWS 0x0600
|
||||
#define _WIN32_IE 0x0700
|
||||
#define NTDDI_VERSION 0x06000000
|
||||
#include <windows.h>
|
||||
#include <errno.h>
|
||||
#include <process.h>
|
||||
#include <setjmp.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "timer.h"
|
||||
#include "timerpriv.h"
|
||||
|
||||
// blah MinGW-w64
|
||||
#ifndef UI_E_ILLEGAL_REENTRANCY
|
||||
#define UI_E_ILLEGAL_REENTRANCY 0x802A0003
|
||||
#endif
|
||||
|
||||
static HRESULT lastErrorCodeToHRESULT(DWORD lastError)
|
||||
{
|
||||
if (lastError == 0)
|
||||
return E_FAIL;
|
||||
return HRESULT_FROM_WIN32(lastError);
|
||||
}
|
||||
|
||||
static HRESULT lastErrorToHRESULT(void)
|
||||
{
|
||||
return lastErrorCodeToHRESULT(GetLastError());
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrWaitForMultipleObjectsEx(DWORD n, const HANDLE *objects, BOOL waitAll, DWORD timeout, BOOL alertable, DWORD *result)
|
||||
{
|
||||
SetLastError(0);
|
||||
*result = WaitForMultipleObjectsEx(n, objects, waitAll, timeout, alertable);
|
||||
if (*result == WAIT_FAILED)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrSuspendThread(HANDLE thread)
|
||||
{
|
||||
DWORD ret;
|
||||
|
||||
SetLastError(0);
|
||||
ret = SuspendThread(thread);
|
||||
if (ret == (DWORD) (-1))
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrGetThreadContext(HANDLE thread, LPCONTEXT ctx)
|
||||
{
|
||||
BOOL ret;
|
||||
|
||||
SetLastError(0);
|
||||
ret = GetThreadContext(thread, ctx);
|
||||
if (ret == 0)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrSetThreadContext(HANDLE thread, CONST CONTEXT *ctx)
|
||||
{
|
||||
BOOL ret;
|
||||
|
||||
SetLastError(0);
|
||||
ret = SetThreadContext(thread, ctx);
|
||||
if (ret == 0)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrPostThreadMessageW(DWORD threadID, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||||
{
|
||||
BOOL ret;
|
||||
|
||||
SetLastError(0);
|
||||
ret = PostThreadMessageW(threadID, uMsg, wParam, lParam);
|
||||
if (ret == 0)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrResumeThread(HANDLE thread)
|
||||
{
|
||||
DWORD ret;
|
||||
|
||||
SetLastError(0);
|
||||
ret = ResumeThread(thread);
|
||||
if (ret == (DWORD) (-1))
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrDuplicateHandle(HANDLE sourceProcess, HANDLE sourceHandle, HANDLE targetProcess, LPHANDLE targetHandle, DWORD access, BOOL inherit, DWORD options)
|
||||
{
|
||||
BOOL ret;
|
||||
|
||||
SetLastError(0);
|
||||
ret = DuplicateHandle(sourceProcess, sourceHandle,
|
||||
targetProcess, targetHandle,
|
||||
access, inherit, options);
|
||||
if (ret == 0)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrCreateWaitableTimerW(LPSECURITY_ATTRIBUTES attributes, BOOL manualReset, LPCWSTR name, HANDLE *handle)
|
||||
{
|
||||
SetLastError(0);
|
||||
*handle = CreateWaitableTimerW(attributes, manualReset, name);
|
||||
if (*handle == NULL)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrCreateEventW(LPSECURITY_ATTRIBUTES attributes, BOOL manualReset, BOOL initialState, LPCWSTR name, HANDLE *handle)
|
||||
{
|
||||
SetLastError(0);
|
||||
*handle = CreateEventW(attributes, manualReset, initialState, name);
|
||||
if (*handle == NULL)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrSetWaitableTimer(HANDLE timer, const LARGE_INTEGER *duration, LONG period, PTIMERAPCROUTINE completionRoutine, LPVOID completionData, BOOL resume)
|
||||
{
|
||||
BOOL ret;
|
||||
|
||||
SetLastError(0);
|
||||
ret = SetWaitableTimer(timer, duration, period, completionRoutine, completionData, resume);
|
||||
if (ret == 0)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT __cdecl hr_beginthreadex(void *security, unsigned stackSize, unsigned (__stdcall *threadProc)(void *arg), void *threadProcArg, unsigned flags, unsigned *thirdArg, uintptr_t *handle)
|
||||
{
|
||||
DWORD lastError;
|
||||
|
||||
// _doserrno is the equivalent of GetLastError(), or at least that's how _beginthreadex() uses it.
|
||||
_doserrno = 0;
|
||||
*handle = _beginthreadex(security, stackSize, threadProc, threadProcArg, flags, thirdArg);
|
||||
if (*handle == 0) {
|
||||
lastError = (DWORD) _doserrno;
|
||||
return lastErrorCodeToHRESULT(lastError);
|
||||
}
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrSetEvent(HANDLE event)
|
||||
{
|
||||
BOOL ret;
|
||||
|
||||
SetLastError(0);
|
||||
ret = SetEvent(event);
|
||||
if (ret == 0)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT WINAPI hrWaitForSingleObject(HANDLE handle, DWORD timeout)
|
||||
{
|
||||
DWORD ret;
|
||||
|
||||
SetLastError(0);
|
||||
ret = WaitForSingleObject(handle, timeout);
|
||||
if (ret == WAIT_FAILED)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
timerTime timerMonotonicNow(void)
|
||||
{
|
||||
LARGE_INTEGER qpc;
|
||||
|
||||
QueryPerformanceCounter(&qpc);
|
||||
return qpc.QuadPart;
|
||||
}
|
||||
|
||||
timerDuration timerTimeSub(timerTime end, timerTime start)
|
||||
{
|
||||
LARGE_INTEGER qpf;
|
||||
timerprivInt128 quot;
|
||||
|
||||
QueryPerformanceFrequency(&qpf);
|
||||
timerprivMulDivInt64(end - start, timerSecond, qpf.QuadPart, ");
|
||||
// on underflow/overflow, return the minimum/maximum possible timerDuration (respectively); this is based on what Go does
|
||||
return timerprivInt128ToInt64(",
|
||||
INT64_MIN, timerDurationMin,
|
||||
INT64_MAX, timerDurationMax);
|
||||
}
|
||||
|
||||
// note: the idea for the SetThreadContext() nuttery is from https://www.codeproject.com/Articles/71529/Exception-Injection-Throwing-an-Exception-in-Other
|
||||
|
||||
struct timeoutParams {
|
||||
jmp_buf retpos;
|
||||
HANDLE timer;
|
||||
HANDLE finished;
|
||||
HANDLE targetThread;
|
||||
DWORD targetThreadID;
|
||||
HRESULT hr;
|
||||
};
|
||||
|
||||
static DWORD timeoutParamsSlot;
|
||||
static HRESULT timeoutParamsHRESULT = S_OK;
|
||||
static INIT_ONCE timeoutParamsOnce = INIT_ONCE_STATIC_INIT;
|
||||
|
||||
static void onTimeout(void)
|
||||
{
|
||||
struct timeoutParams *p;
|
||||
|
||||
p = (struct timeoutParams *) TlsGetValue(timeoutParamsSlot);
|
||||
longjmp(p->retpos, 1);
|
||||
}
|
||||
|
||||
static BOOL CALLBACK timeoutParamsSlotInit(PINIT_ONCE once, PVOID param, PVOID *ctx)
|
||||
{
|
||||
SetLastError(0);
|
||||
timeoutParamsSlot = TlsAlloc();
|
||||
if (timeoutParamsSlot == TLS_OUT_OF_INDEXES)
|
||||
timeoutParamsHRESULT = lastErrorToHRESULT();
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static HRESULT setupNonReentrance(struct timeoutParams *p)
|
||||
{
|
||||
SetLastError(0);
|
||||
if (InitOnceExecuteOnce(&timeoutParamsOnce, timeoutParamsSlotInit, NULL, NULL) == 0)
|
||||
return lastErrorToHRESULT();
|
||||
if (timeoutParamsHRESULT != S_OK)
|
||||
return timeoutParamsHRESULT;
|
||||
if (TlsGetValue(timeoutParamsSlot) != NULL)
|
||||
return UI_E_ILLEGAL_REENTRANCY;
|
||||
SetLastError(0);
|
||||
if (TlsSetValue(timeoutParamsSlot, p) == 0)
|
||||
return lastErrorToHRESULT();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static void teardownNonReentrance(void)
|
||||
{
|
||||
TlsSetValue(timeoutParamsSlot, NULL);
|
||||
}
|
||||
|
||||
static void redirectToOnTimeout(CONTEXT *ctx, struct timeoutParams *p)
|
||||
{
|
||||
#if defined(_AMD64_)
|
||||
ctx->Rip = (DWORD64) onTimeout;
|
||||
#elif defined(_ARM_)
|
||||
ctx->Pc = (DWORD) onTimeout;
|
||||
#elif defined(_ARM64_)
|
||||
ctx->Pc = (DWORD64) onTimeout;
|
||||
#elif defined(_X86_)
|
||||
ctx->Eip = (DWORD) onTimeout;
|
||||
#elif defined(_IA64_)
|
||||
// TODO verify that this is correct
|
||||
ctx->StIIP = (ULONGLONG) onTimeout;
|
||||
#else
|
||||
#error unknown CPU architecture; cannot create CONTEXT objects for CPU-specific Windows test code
|
||||
#endif
|
||||
}
|
||||
|
||||
static void criticalCallFailed(const char *func, HRESULT hr)
|
||||
{
|
||||
fprintf(stderr, "*** internal error in timerRunWithTimeout(): %s failed: 0x%08I32X\n", func, hr);
|
||||
abort();
|
||||
}
|
||||
|
||||
static unsigned __stdcall timerThreadProc(void *data)
|
||||
{
|
||||
struct timeoutParams *p = (struct timeoutParams *) data;
|
||||
HANDLE objects[2];
|
||||
CONTEXT ctx;
|
||||
DWORD which;
|
||||
HRESULT hr;
|
||||
|
||||
objects[0] = p->timer;
|
||||
objects[1] = p->finished;
|
||||
p->hr = hrWaitForMultipleObjectsEx(2, objects,
|
||||
FALSE, INFINITE, FALSE, &which);
|
||||
if (p->hr != S_OK)
|
||||
// act as if we timed out; the other thread will see the error
|
||||
which = WAIT_OBJECT_0;
|
||||
if (which == WAIT_OBJECT_0 + 1)
|
||||
// we succeeded; do nothing
|
||||
return 0;
|
||||
|
||||
// we timed out (or there was an error); signal it
|
||||
hr = hrSuspendThread(p->targetThread);
|
||||
if (hr != S_OK)
|
||||
criticalCallFailed("SuspendThread()", hr);
|
||||
ZeroMemory(&ctx, sizeof (CONTEXT));
|
||||
ctx.ContextFlags = CONTEXT_CONTROL;
|
||||
hr = hrGetThreadContext(p->targetThread, &ctx);
|
||||
if (hr != S_OK)
|
||||
criticalCallFailed("GetThreadContext()", hr);
|
||||
redirectToOnTimeout(&ctx, p);
|
||||
hr = hrSetThreadContext(p->targetThread, &ctx);
|
||||
if (hr != S_OK)
|
||||
criticalCallFailed("SetThreadContext()", hr);
|
||||
// and force the thread to return from GetMessage(), if we are indeed in that
|
||||
// and yes, this is the way to do it (https://devblogs.microsoft.com/oldnewthing/?p=16553, https://devblogs.microsoft.com/oldnewthing/20050405-46/?p=35973, https://devblogs.microsoft.com/oldnewthing/20080528-00/?p=22163)
|
||||
hr = hrPostThreadMessageW(p->targetThreadID, WM_NULL, 0, 0);
|
||||
if (hr != S_OK)
|
||||
criticalCallFailed("PostThreadMessageW()", hr);
|
||||
hr = hrResumeThread(p->targetThread);
|
||||
if (hr != S_OK)
|
||||
criticalCallFailed("ResumeThread()", hr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
timerSysError timerRunWithTimeout(timerDuration d, void (*f)(void *data), void *data, bool *timedOut)
|
||||
{
|
||||
struct timeoutParams *p;
|
||||
bool doTeardownNonReentrance = false;
|
||||
MSG msg;
|
||||
volatile HANDLE timerThread = NULL;
|
||||
LARGE_INTEGER duration;
|
||||
HRESULT hr;
|
||||
|
||||
*timedOut = false;
|
||||
// we use a pointer to heap memory here to avoid volatile kludges
|
||||
p = (struct timeoutParams *) malloc(sizeof (struct timeoutParams));
|
||||
if (p == NULL)
|
||||
return (timerSysError) E_OUTOFMEMORY;
|
||||
ZeroMemory(p, sizeof (struct timeoutParams));
|
||||
|
||||
hr = setupNonReentrance(p);
|
||||
if (hr != S_OK)
|
||||
goto out;
|
||||
doTeardownNonReentrance = true;
|
||||
|
||||
// to ensure that the PostThreadMessage() above will not fail because the thread doesn't have a message queue
|
||||
PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
|
||||
|
||||
hr = hrDuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
|
||||
GetCurrentProcess(), &(p->targetThread),
|
||||
0, FALSE, DUPLICATE_SAME_ACCESS);
|
||||
if (hr != S_OK) {
|
||||
p->targetThread = NULL;
|
||||
goto out;
|
||||
}
|
||||
p->targetThreadID = GetCurrentThreadId();
|
||||
|
||||
hr = hrCreateWaitableTimerW(NULL, TRUE, NULL, &(p->timer));
|
||||
if (hr != S_OK) {
|
||||
p->timer = NULL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
hr = hrCreateEventW(NULL, TRUE, FALSE, NULL, &(p->finished));
|
||||
if (hr != S_OK) {
|
||||
p->finished = NULL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (setjmp(p->retpos) == 0) {
|
||||
uintptr_t timerThreadValue = 0;
|
||||
|
||||
hr = hr_beginthreadex(NULL, 0, timerThreadProc, p, 0, NULL, &timerThreadValue);
|
||||
if (hr != S_OK) {
|
||||
timerThread = NULL;
|
||||
goto out;
|
||||
}
|
||||
timerThread = (HANDLE) timerThreadValue;
|
||||
|
||||
duration.QuadPart = d / 100;
|
||||
duration.QuadPart = -duration.QuadPart;
|
||||
hr = hrSetWaitableTimer(p->timer, &duration, 0, NULL, NULL, FALSE);
|
||||
if (hr != S_OK)
|
||||
goto out;
|
||||
|
||||
(*f)(data);
|
||||
} else if (p->hr != S_OK) {
|
||||
hr = p->hr;
|
||||
goto out;
|
||||
} else
|
||||
*timedOut = true;
|
||||
hr = S_OK;
|
||||
|
||||
out:
|
||||
if (timerThread != NULL) {
|
||||
HRESULT xhr; // don't overwrite hr below
|
||||
|
||||
// if either of these two fail, we cannot continue because the timer thread might interrupt us later, screwing everything up
|
||||
xhr = hrSetEvent(p->finished);
|
||||
if (xhr != S_OK)
|
||||
criticalCallFailed("SetEvent()", xhr);
|
||||
xhr = hrWaitForSingleObject(timerThread, INFINITE);
|
||||
if (xhr != S_OK)
|
||||
criticalCallFailed("WaitForSingleObject()", xhr);
|
||||
CloseHandle(timerThread);
|
||||
}
|
||||
if (p->finished != NULL)
|
||||
CloseHandle(p->finished);
|
||||
if (p->timer != NULL)
|
||||
CloseHandle(p->timer);
|
||||
if (p->targetThread != NULL)
|
||||
CloseHandle(p->targetThread);
|
||||
if (doTeardownNonReentrance)
|
||||
teardownNonReentrance();
|
||||
free(p);
|
||||
return (timerSysError) hr;
|
||||
}
|
||||
|
||||
timerSysError timerSleep(timerDuration d)
|
||||
{
|
||||
HANDLE timer;
|
||||
LARGE_INTEGER duration;
|
||||
HRESULT hr;
|
||||
|
||||
duration.QuadPart = d / 100;
|
||||
duration.QuadPart = -duration.QuadPart;
|
||||
hr = hrCreateWaitableTimerW(NULL, TRUE, NULL, &timer);
|
||||
if (hr != S_OK)
|
||||
return (timerSysError) hr;
|
||||
hr = hrSetWaitableTimer(timer, &duration, 0, NULL, NULL, FALSE);
|
||||
if (hr != S_OK) {
|
||||
CloseHandle(timer);
|
||||
return (timerSysError) hr;
|
||||
}
|
||||
hr = hrWaitForSingleObject(timer, INFINITE);
|
||||
CloseHandle(timer);
|
||||
return (timerSysError) hr;
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
// 5 may 2019
|
||||
|
||||
typedef struct timerprivInt128 timerprivInt128;
|
||||
|
||||
struct timerprivInt128 {
|
||||
bool neg;
|
||||
uint64_t high;
|
||||
uint64_t low;
|
||||
};
|
||||
|
||||
extern void timerprivMulDivInt64(int64_t x, int64_t y, int64_t z, timerprivInt128 *quot);
|
||||
extern void timerprivMulDivUint64(uint64_t x, uint64_t y, uint64_t z, timerprivInt128 *quot);
|
||||
extern int64_t timerprivInt128ToInt64(const timerprivInt128 *n, int64_t min, int64_t minCap, int64_t max, int64_t maxCap);
|
||||
extern uint64_t timerprivInt128ToUint64(const timerprivInt128 *n, uint64_t max, uint64_t maxCap);
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
// 10 april 2019
|
||||
#include "test.h"
|
||||
|
||||
void timeoutMain(void *data)
|
||||
{
|
||||
uiMain();
|
||||
}
|
||||
|
||||
void deferFree(testingT *t, void *data)
|
||||
{
|
||||
free(data);
|
||||
}
|
||||
|
||||
void deferEventFree(testingT *t, void *data)
|
||||
{
|
||||
uiEventFree((uiEvent *) data);
|
||||
}
|
||||
|
||||
static void runSetORingResults(testingSet *set, const struct testingOptions *options, bool *anyRun, bool *anyFailed)
|
||||
{
|
||||
bool ar, af;
|
||||
|
||||
testingSetRun(set, options, &ar, &af);
|
||||
if (ar)
|
||||
*anyRun = true;
|
||||
if (af)
|
||||
*anyFailed = true;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
testingOptions opts;
|
||||
bool anyRun = false, anyFailed = false;
|
||||
uiInitError err;
|
||||
|
||||
memset(&opts, 0, sizeof (testingOptions));
|
||||
if (argc == 2 && strcmp(argv[1], "-v") == 0)
|
||||
opts.Verbose = true;
|
||||
else if (argc != 1) {
|
||||
fprintf(stderr, "usage: %s [-v]\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
runSetORingResults(beforeTests, &opts, &anyRun, &anyFailed);
|
||||
memset(&err, 0, sizeof (uiInitError));
|
||||
err.Size = sizeof (uiInitError);
|
||||
if (!uiInit(NULL, &err)) {
|
||||
fprintf(stderr, "uiInit() failed: %s; can't continue\n", err.Message);
|
||||
printf("FAIL\n");
|
||||
return 1;
|
||||
}
|
||||
testControlType = uiRegisterControlType("TestControl", testVtable(), testOSVtable(), testImplDataSize());
|
||||
testControlType2 = uiRegisterControlType("TestControl2", testVtable(), testOSVtable(), testImplDataSize());
|
||||
|
||||
runSetORingResults(NULL, &opts, &anyRun, &anyFailed);
|
||||
|
||||
if (!anyRun)
|
||||
fprintf(stderr, "warning: no tests to run\n");
|
||||
if (anyFailed) {
|
||||
printf("FAIL\n");
|
||||
return 1;
|
||||
}
|
||||
printf("PASS\n");
|
||||
fflush(stdout); // AddressSanitizer can chop the tail end of the output for whatever reason
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
# 23 march 2019
|
||||
|
||||
libui_test_sources = [
|
||||
'controls.c',
|
||||
'controls_errors.cpp',
|
||||
'errors.c',
|
||||
'events.c',
|
||||
'events_errors.cpp',
|
||||
'initmain.c',
|
||||
'main.c',
|
||||
'noinitwrongthread.cpp',
|
||||
]
|
||||
|
||||
if libui_OS == 'windows'
|
||||
libui_test_sources += [
|
||||
'controls_windows.c',
|
||||
'controls_windows_errors.cpp',
|
||||
]
|
||||
elif libui_OS == 'darwin'
|
||||
libui_test_sources += [
|
||||
'controls_darwin.m',
|
||||
'controls_darwin_errors.m',
|
||||
]
|
||||
elif libui_OS == 'haiku'
|
||||
libui_test_sources += [
|
||||
'controls_haiku.c',
|
||||
'controls_haiku_errors.cpp',
|
||||
]
|
||||
else
|
||||
libui_test_sources += [
|
||||
'controls_unix.c',
|
||||
'controls_unix_errors.cpp',
|
||||
]
|
||||
endif
|
||||
|
||||
libui_test_cpp_extra_args = []
|
||||
if libui_OS == 'windows'
|
||||
libui_test_sources += [
|
||||
windows.compile_resources('resources_' + libui_mode + '.rc',
|
||||
args: libui_manifest_args,
|
||||
depend_files: ['test_' + libui_mode + '.manifest']),
|
||||
]
|
||||
elif libui_OS == 'darwin'
|
||||
# since we use a deployment target of 10.8, the non-C++11-compliant libstdc++ is chosen by default; we need C++11
|
||||
# see issue #302 for more details
|
||||
libui_test_cpp_extra_args += ['--stdlib=libc++']
|
||||
endif
|
||||
|
||||
libui_test_deps = []
|
||||
|
||||
subdir('lib')
|
||||
|
||||
# TODO once we upgrade to 0.49.0, add pie: true
|
||||
# TODO once we upgrade to 0.50.0, add protocol: 'exitcode'
|
||||
libui_tester = executable('tester', libui_test_sources,
|
||||
dependencies: libui_binary_deps + libui_test_deps,
|
||||
link_with: libui_libui,
|
||||
cpp_args: libui_test_cpp_extra_args,
|
||||
link_args: libui_test_cpp_extra_args,
|
||||
gui_app: false,
|
||||
install: false)
|
||||
test('test', libui_tester,
|
||||
is_parallel: false,
|
||||
should_fail: false)
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
// 28 april 2019
|
||||
#include <errno.h>
|
||||
#include <inttypes.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "../ui.h"
|
||||
#ifdef libuiOSHeader
|
||||
#include libuiOSHeader
|
||||
#endif
|
||||
#include "../common/testhooks.h"
|
||||
#include "lib/testing.h"
|
||||
#include "lib/thread.h"
|
||||
#include "lib/timer.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define diff(fmt) "\ngot " fmt "\nwant " fmt
|
||||
|
||||
// main.c
|
||||
extern void timeoutMain(void *data);
|
||||
#define timeout_uiMain(t, d) { \
|
||||
timerSysError err; \
|
||||
bool timedOut; \
|
||||
err = timerRunWithTimeout(d, timeoutMain, NULL, &timedOut); \
|
||||
if (err != 0) \
|
||||
testingTErrorf(t, "error running uiMain() in timeout: " timerSysErrorFmt, timerSysErrorFmtArg(err)); \
|
||||
if (timedOut) { \
|
||||
char timeoutstr[timerDurationStringLen]; \
|
||||
timerDurationString(d, timeoutstr); \
|
||||
testingTErrorf(t, "uiMain() timed out (%s)", timeoutstr); \
|
||||
} \
|
||||
}
|
||||
extern void deferFree(testingT *t, void *data);
|
||||
extern void deferEventFree(testingT *t, void *data);
|
||||
|
||||
// init.c
|
||||
extern testingSet *beforeTests;
|
||||
|
||||
// errors.c
|
||||
struct checkErrorCase {
|
||||
const char *name;
|
||||
void (*f)(void);
|
||||
const char *msgWant;
|
||||
};
|
||||
extern void checkProgrammerErrorsFull(testingT *t, const char *file, long line, const struct checkErrorCase *cases, bool inThread);
|
||||
#define checkProgrammerErrors(t, cases) checkProgrammerErrorsFull(t, __FILE__, __LINE__, cases, false)
|
||||
#define checkProgrammerErrorsInThread(t, cases) checkProgrammerErrorsFull(t, __FILE__, __LINE__, cases, true)
|
||||
|
||||
// controls.c
|
||||
extern void *testControlFailInit;
|
||||
extern const uiControlVtable *testVtable(void);
|
||||
extern const uiControlOSVtable *testOSVtable(void);
|
||||
extern size_t testImplDataSize(void);
|
||||
extern uint32_t testControlType;
|
||||
extern uint32_t testControlType2;
|
||||
|
||||
// controls_errors.cpp
|
||||
extern const struct checkErrorCase controlOSVtableCases[];
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
Loading…
Reference in New Issue