From b826bfc171d90f8bde7bd672c0ac14201b8b2742 Mon Sep 17 00:00:00 2001 From: Garrett D'Amore Date: Mon, 16 Nov 2020 20:44:29 -0800 Subject: Work for test refactoring. There are a few major areas in this change. * CMake options are now located in a common cmake/NNGOptions.cmake file. This should make it easier for folks to figure out what the options are, and how they are used. * Tests are now scoped with their directory name, which should avoid possible name collisions with test names. * A number of tests have been either moved or incorporated into the newer testutil/acutest framework. We are moving away from my old c-convey framework to something easier to debug. * We use CMake directories a bit more extensively leading to a much cleaner CMake structure. It's not complete, but a big step in the right direction, and a preview of future work. * Tests are now run with verbose flags, so we get more test results in the CI/CD logs. --- src/platform/platform_test.c | 181 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 src/platform/platform_test.c (limited to 'src/platform/platform_test.c') diff --git a/src/platform/platform_test.c b/src/platform/platform_test.c new file mode 100644 index 00000000..e7dcabaa --- /dev/null +++ b/src/platform/platform_test.c @@ -0,0 +1,181 @@ +// +// Copyright 2020 Staysail Systems, Inc. +// Copyright 2018 Capitar IT Group BV +// +// 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 "testutil.h" + +#include +#include + +#include "acutest.h" + +struct add_arg { + int cnt; + nng_mtx *mx; + nng_cv * cv; +}; + +void +add(void *arg) +{ + struct add_arg *aa = arg; + + nng_mtx_lock(aa->mx); + aa->cnt++; + nng_cv_wake(aa->cv); + nng_mtx_unlock(aa->mx); +} + +void +test_sleep(void) +{ + uint64_t start, end; + start = testutil_clock(); + nng_msleep(100); + end = testutil_clock(); + TEST_CHECK((end - start) >= 100); +#ifdef __has_feature +#if !__has_feature(thread_sanitizer) && !__has_feature(memory_sanitizer) + TEST_CHECK((end - start) <= 500); +#endif +#endif +} + +void +test_clock(void) +{ + uint64_t mstart; + uint64_t msend; + nng_time usend; + nng_time usnow; + + mstart = testutil_clock(); + usnow = nng_clock(); + nng_msleep(200); + usend = nng_clock(); + msend = testutil_clock(); + + TEST_CHECK(usend > usnow); + TEST_CHECK(msend > mstart); + +#ifdef __has_feature +#if !__has_feature(thread_sanitizer) && !__has_feature(memory_sanitizer) + uint64_t usdelta; + uint64_t msdelta; + usdelta = usend - usnow; + msdelta = msend - mstart; + TEST_CHECK(usdelta >= 200); + TEST_CHECK(usdelta < 500); // increased tolerance for CIs + if (msdelta > usdelta) { + TEST_CHECK((msdelta - usdelta) < 50); + } else { + TEST_CHECK((usdelta - msdelta) < 50); + } +#endif +#endif +} + +void +test_mutex(void) +{ + nng_mtx *mx, *mx2; + + TEST_CHECK(nng_mtx_alloc(&mx) == 0); + 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! + TEST_CHECK(nng_mtx_alloc(&mx) == 0); + TEST_CHECK(nng_mtx_alloc(&mx2) == 0); + TEST_CHECK(mx != mx2); + nng_mtx_free(mx); + nng_mtx_free(mx2); +} + +void +test_thread(void) +{ + nng_thread * thr; + int rv; + struct add_arg aa; + + TEST_CHECK(nng_mtx_alloc(&aa.mx) == 0); + TEST_CHECK(nng_cv_alloc(&aa.cv, aa.mx) == 0); + aa.cnt = 0; + + TEST_CHECK((rv = nng_thread_create(&thr, add, &aa)) == 0); + nng_thread_destroy(thr); + TEST_CHECK(aa.cnt == 1); + + nng_cv_free(aa.cv); + nng_mtx_free(aa.mx); +} + +void +test_cond_var(void) +{ + nng_thread * thr; + int rv; + struct add_arg aa; + + TEST_CHECK(nng_mtx_alloc(&aa.mx) == 0); + TEST_CHECK(nng_cv_alloc(&aa.cv, aa.mx) == 0); + aa.cnt = 0; + + TEST_CHECK((rv = nng_thread_create(&thr, add, &aa)) == 0); + + nng_mtx_lock(aa.mx); + while (aa.cnt == 0) { + nng_cv_wait(aa.cv); + } + nng_mtx_unlock(aa.mx); + nng_thread_destroy(thr); + TEST_CHECK(aa.cnt == 1); + + 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 you RNG is biased. + TEST_CHECK_(same < 5, "fewer than 5 in 1000 repeats: %d", same); +} + +TEST_LIST = { + { "sleep", test_sleep }, + { "clock", test_clock }, + { "mutex", test_mutex }, + { "thread", test_thread }, + { "cond var", test_cond_var }, + { "random", test_random }, + { NULL, NULL }, +}; -- cgit v1.2.3-70-g09d2