//
|
// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech>
|
// Copyright 2018 Capitar IT Group BV <info@capitar.com>
|
//
|
// This software is supplied under the terms of the MIT License, a
|
// copy of which should be located in the distribution where this
|
// file was obtained (LICENSE.txt). A copy of the license may also be
|
// found online at https://opensource.org/licenses/MIT.
|
//
|
|
#include <nuts.h>
|
|
struct add_arg {
|
int cnt;
|
nng_duration delay;
|
nng_mtx * mx;
|
nng_cv * cv;
|
};
|
|
void
|
add(void *arg)
|
{
|
struct add_arg *aa = arg;
|
|
if (aa->delay > 0) {
|
nng_msleep(aa->delay);
|
}
|
nng_mtx_lock(aa->mx);
|
aa->cnt++;
|
nng_cv_wake(aa->cv);
|
nng_mtx_unlock(aa->mx);
|
}
|
|
#ifdef __has_feature
|
#if __has_feature(thread_sanitizer) || __has_feature(memory_sanitizer)
|
#define RELAXED_CLOCKS
|
#endif
|
#endif
|
|
void
|
test_sleep(void)
|
{
|
uint64_t start;
|
NUTS_CLOCK(start);
|
nng_msleep(100);
|
NUTS_AFTER(start + 100);
|
#ifndef RELAXED_CLOCKS
|
NUTS_BEFORE(start + 500);
|
#endif
|
}
|
|
void
|
test_clock(void)
|
{
|
uint64_t s0, s1;
|
nng_time t0, t1;
|
|
NUTS_CLOCK(s0);
|
t0 = nng_clock();
|
nng_msleep(200);
|
t1 = nng_clock();
|
NUTS_CLOCK(s1);
|
|
NUTS_TRUE(t1 > t0);
|
NUTS_TRUE((t1 - t0) >= 200);
|
NUTS_TRUE((t1 - t0) < 500);
|
|
#ifndef RELAXED_CLOCKS
|
NUTS_TRUE(abs((int) (s1 - s0) - (int) (t1 - t0)) < 50);
|
#endif
|
}
|
|
void
|
test_mutex(void)
|
{
|
nng_mtx *mx, *mx2;
|
|
NUTS_PASS(nng_mtx_alloc(&mx));
|
nng_mtx_lock(mx);
|
nng_mtx_unlock(mx);
|
|
nng_mtx_lock(mx);
|
nng_mtx_unlock(mx);
|
nng_mtx_free(mx);
|
|
// Verify that the mutexes are not always the same!
|
NUTS_PASS(nng_mtx_alloc(&mx));
|
NUTS_PASS(nng_mtx_alloc(&mx2));
|
NUTS_TRUE(mx != mx2);
|
nng_mtx_free(mx);
|
nng_mtx_free(mx2);
|
}
|
|
void
|
test_thread(void)
|
{
|
nng_thread * thr;
|
struct add_arg aa;
|
|
NUTS_PASS(nng_mtx_alloc(&aa.mx));
|
NUTS_PASS(nng_cv_alloc(&aa.cv, aa.mx));
|
aa.cnt = 0;
|
aa.delay = 0;
|
|
NUTS_PASS(nng_thread_create(&thr, add, &aa));
|
nng_thread_destroy(thr);
|
NUTS_TRUE(aa.cnt == 1);
|
|
nng_cv_free(aa.cv);
|
nng_mtx_free(aa.mx);
|
}
|
|
void
|
test_cond_var(void)
|
{
|
nng_thread * thr;
|
struct add_arg aa;
|
|
NUTS_PASS(nng_mtx_alloc(&aa.mx));
|
NUTS_PASS(nng_cv_alloc(&aa.cv, aa.mx));
|
aa.cnt = 0;
|
aa.delay = 0;
|
|
NUTS_PASS(nng_thread_create(&thr, add, &aa));
|
|
nng_mtx_lock(aa.mx);
|
while (aa.cnt == 0) {
|
nng_cv_wait(aa.cv);
|
}
|
nng_mtx_unlock(aa.mx);
|
nng_thread_destroy(thr);
|
NUTS_TRUE(aa.cnt == 1);
|
|
nng_cv_free(aa.cv);
|
nng_mtx_free(aa.mx);
|
}
|
|
void
|
test_cond_wake(void)
|
{
|
nng_thread * thr;
|
struct add_arg aa;
|
nng_time now;
|
|
NUTS_PASS(nng_mtx_alloc(&aa.mx));
|
NUTS_PASS(nng_cv_alloc(&aa.cv, aa.mx));
|
aa.cnt = 0;
|
aa.delay = 200;
|
|
now = nng_clock();
|
|
NUTS_PASS(nng_thread_create(&thr, add, &aa));
|
|
nng_mtx_lock(aa.mx);
|
nng_cv_until(aa.cv, now + 500);
|
nng_mtx_unlock(aa.mx);
|
|
NUTS_TRUE(nng_clock() >= now + 200);
|
NUTS_TRUE(nng_clock() < now + 500);
|
|
nng_thread_destroy(thr);
|
nng_cv_free(aa.cv);
|
nng_mtx_free(aa.mx);
|
}
|
|
void
|
test_cond_until(void)
|
{
|
struct add_arg aa;
|
nng_time now;
|
|
NUTS_PASS(nng_mtx_alloc(&aa.mx));
|
NUTS_PASS(nng_cv_alloc(&aa.cv, aa.mx));
|
aa.cnt = 0;
|
aa.delay = 0;
|
|
now = nng_clock();
|
nng_mtx_lock(aa.mx);
|
nng_cv_until(aa.cv, now + 100);
|
nng_mtx_unlock(aa.mx);
|
|
NUTS_TRUE(nng_clock() >= now);
|
#ifdef NO_SPRIOUS_WAKEUPS
|
// Some systems (e.g. Win32) will occasionally wake a threaed
|
// spuriously. We therefore can't rely on condwait to be
|
// an absolute guarantee of minimum time passage.
|
NUTS_TRUE(nng_clock() >= now + 100);
|
#endif
|
NUTS_TRUE(nng_clock() < now + 1000);
|
|
nng_cv_free(aa.cv);
|
nng_mtx_free(aa.mx);
|
}
|
|
void
|
test_random(void)
|
{
|
int same = 0;
|
uint32_t values[1000];
|
|
for (int i = 0; i < 1000; i++) {
|
values[i] = nng_random();
|
}
|
for (int i = 0; i < 1000; i++) {
|
for (int j = 0; j < i; j++) {
|
if (values[j] == values[i]) {
|
same++;
|
}
|
}
|
}
|
|
// 1% reproduction is *highly* unlikely.
|
// There are 4 billion possible options, we are only looking at
|
// 1000 of them. In general, it would be an extreme outlier
|
// to see more than 2 repeats, unless your RNG is biased.
|
NUTS_TRUE(same < 5);
|
}
|
|
NUTS_TESTS = {
|
{ "sleep", test_sleep },
|
{ "clock", test_clock },
|
{ "mutex", test_mutex },
|
{ "thread", test_thread },
|
{ "cond var", test_cond_var },
|
{ "cond wake", test_cond_wake },
|
{ "cond until", test_cond_until },
|
{ "random", test_random },
|
{ NULL, NULL },
|
};
|
