From 24b9948e25d1b8c1e782b64d8fa252dad2e07939 Mon Sep 17 00:00:00 2001 From: Christopher Friedt Date: Mon, 3 Jul 2023 07:35:26 -0400 Subject: [PATCH] tests: posix: nanosleep: condense test cases Most Zephyr testsuites do not break tests down to the level of granularity that `nanosleep()` tests, and this change makes reports less verbose. This change makes the `nonosleep()` test cases significantly less verbose. Signed-off-by: Christopher Friedt --- tests/posix/common/src/nanosleep.c | 225 +++++++++-------------------- 1 file changed, 67 insertions(+), 158 deletions(-) diff --git a/tests/posix/common/src/nanosleep.c b/tests/posix/common/src/nanosleep.c index 3039f5c33c9be0..ec565ac85138ae 100644 --- a/tests/posix/common/src/nanosleep.c +++ b/tests/posix/common/src/nanosleep.c @@ -11,157 +11,85 @@ #include #include -/** req and rem are both NULL */ -ZTEST(posix_apis, test_nanosleep_NULL_NULL) -{ - int r = nanosleep(NULL, NULL); - - zassert_equal(r, -1, "actual: %d expected: %d", r, -1); - zassert_equal(errno, EFAULT, "actual: %d expected: %d", errno, EFAULT); -} - -/** - * req is NULL, rem is non-NULL (all-zero) - * - * Expect rem to be the same when function returns - */ -ZTEST(posix_apis, test_nanosleep_NULL_notNULL) +ZTEST(posix_apis, test_nanosleep_errors_errno) { struct timespec rem = {}; - - errno = 0; - int r = nanosleep(NULL, &rem); - - zassert_equal(r, -1, "actual: %d expected: %d", r, -1); - zassert_equal(errno, EFAULT, "actual: %d expected: %d", - errno, EFAULT); - zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", - rem.tv_sec, 0); - zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", - rem.tv_nsec, 0); -} - -/** - * req is non-NULL (all-zero), rem is NULL - * - * Expect req to be the same when function returns - */ -ZTEST(posix_apis, test_nanosleep_notNULL_NULL) -{ struct timespec req = {}; - errno = 0; - int r = nanosleep(&req, NULL); - - zassert_equal(req.tv_sec, 0, "actual: %d expected: %d", - req.tv_sec, 0); - zassert_equal(req.tv_nsec, 0, "actual: %d expected: %d", - req.tv_nsec, 0); - zassert_equal(r, 0, "actual: %d expected: %d", r, -1); - zassert_equal(errno, 0, "actual: %d expected: %d", errno, 0); -} - -/** - * req is non-NULL (all-zero), rem is non-NULL (all-zero) - * - * Expect req & rem to be the same when function returns - */ -ZTEST(posix_apis, test_nanosleep_notNULL_notNULL) -{ - struct timespec req = {}; - struct timespec rem = {}; + /* + * invalid parameters + */ + zassert_equal(nanosleep(NULL, NULL), -1); + zassert_equal(errno, EFAULT); + /* NULL request */ errno = 0; - int r = nanosleep(&req, &rem); - - zassert_equal(r, 0, "actual: %d expected: %d", r, -1); - zassert_equal(errno, 0, "actual: %d expected: %d", errno, 0); - zassert_equal(req.tv_sec, 0, "actual: %d expected: %d", - req.tv_sec, 0); - zassert_equal(req.tv_nsec, 0, "actual: %d expected: %d", - req.tv_nsec, 0); - zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", - rem.tv_sec, 0); - zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", - rem.tv_nsec, 0); -} - -/** - * req and rem point to the same timespec - * - * Normative spec says they may be the same. - * Expect rem to be zero after returning. - */ -ZTEST(posix_apis, test_nanosleep_req_is_rem) -{ - struct timespec ts = {0, 1}; + zassert_equal(nanosleep(NULL, &rem), -1); + zassert_equal(errno, EFAULT); + /* Expect rem to be the same when function returns */ + zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", rem.tv_sec, 0); + zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", rem.tv_nsec, 0); + /* negative times */ errno = 0; - int r = nanosleep(&ts, &ts); - - zassert_equal(r, 0, "actual: %d expected: %d", r, -1); - zassert_equal(errno, 0, "actual: %d expected: %d", errno, 0); - zassert_equal(ts.tv_sec, 0, "actual: %d expected: %d", - ts.tv_sec, 0); - zassert_equal(ts.tv_nsec, 0, "actual: %d expected: %d", - ts.tv_nsec, 0); -} - -/** req tv_sec is -1 */ -ZTEST(posix_apis, test_nanosleep_n1_0) -{ - struct timespec req = {-1, 0}; + req = (struct timespec){.tv_sec = -1, .tv_nsec = 0}; + zassert_equal(nanosleep(&req, NULL), -1); + zassert_equal(errno, EINVAL); errno = 0; - int r = nanosleep(&req, NULL); - - zassert_equal(r, -1, "actual: %d expected: %d", r, -1); - zassert_equal(errno, EINVAL, "actual: %d expected: %d", errno, EFAULT); -} - -/** req tv_nsec is -1 */ -ZTEST(posix_apis, test_nanosleep_0_n1) -{ - struct timespec req = {0, -1}; + req = (struct timespec){.tv_sec = 0, .tv_nsec = -1}; + zassert_equal(nanosleep(&req, NULL), -1); + zassert_equal(errno, EINVAL); errno = 0; - int r = nanosleep(&req, NULL); - - zassert_equal(r, -1, "actual: %d expected: %d", r, -1); - zassert_equal(errno, EINVAL, "actual: %d expected: %d", errno, EFAULT); -} - -/** req tv_sec and tv_nsec are both -1 */ -ZTEST(posix_apis, test_nanosleep_n1_n1) -{ - struct timespec req = {-1, -1}; + req = (struct timespec){.tv_sec = -1, .tv_nsec = -1}; + zassert_equal(nanosleep(&req, NULL), -1); + zassert_equal(errno, EINVAL); + /* nanoseconds too high */ errno = 0; - int r = nanosleep(&req, NULL); - - zassert_equal(r, -1, "actual: %d expected: %d", r, -1); - zassert_equal(errno, EINVAL, "actual: %d expected: %d", errno, EFAULT); -} - -/** req tv_sec is 0 tv_nsec is 10^9 */ -ZTEST(posix_apis, test_nanosleep_0_1000000000) -{ - struct timespec req = {0, 1000000000}; + req = (struct timespec){.tv_sec = 0, .tv_nsec = 1000000000}; + zassert_equal(nanosleep(&req, NULL), -1); + zassert_equal(errno, EINVAL); + /* + * Valid parameters + */ errno = 0; - int r = nanosleep(&req, NULL); - zassert_equal(r, -1, "actual: %d expected: %d", r, -1); - zassert_equal(errno, EINVAL, "actual: %d expected: %d", errno, EFAULT); + /* Happy path, plus make sure the const input is unmodified */ + req = (struct timespec){.tv_sec = 1, .tv_nsec = 1}; + zassert_equal(nanosleep(&req, NULL), 0); + zassert_equal(errno, 0); + zassert_equal(req.tv_sec, 1); + zassert_equal(req.tv_nsec, 1); + + /* Sleep for 0.0 s. Expect req & rem to be the same when function returns */ + zassert_equal(nanosleep(&req, &rem), 0); + zassert_equal(errno, 0); + zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", rem.tv_sec, 0); + zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", rem.tv_nsec, 0); + + /* + * req and rem point to the same timespec + * + * Normative spec says they may be the same. + * Expect rem to be zero after returning. + */ + req = (struct timespec){.tv_sec = 0, .tv_nsec = 1}; + zassert_equal(nanosleep(&req, &req), 0); + zassert_equal(errno, 0); + zassert_equal(req.tv_sec, 0, "actual: %d expected: %d", req.tv_sec, 0); + zassert_equal(req.tv_nsec, 0, "actual: %d expected: %d", req.tv_nsec, 0); } static void common(const uint32_t s, uint32_t ns) { - uint32_t then; - uint32_t now; int r; - struct timespec req = {s, ns}; + uint32_t now; + uint32_t then; struct timespec rem = {0, 0}; + struct timespec req = {s, ns}; errno = 0; then = k_cycle_get_32(); @@ -170,14 +98,10 @@ static void common(const uint32_t s, uint32_t ns) zassert_equal(r, 0, "actual: %d expected: %d", r, -1); zassert_equal(errno, 0, "actual: %d expected: %d", errno, 0); - zassert_equal(req.tv_sec, s, "actual: %d expected: %d", - req.tv_sec, s); - zassert_equal(req.tv_nsec, ns, "actual: %d expected: %d", - req.tv_nsec, ns); - zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", - rem.tv_sec, 0); - zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", - rem.tv_nsec, 0); + zassert_equal(req.tv_sec, s, "actual: %d expected: %d", req.tv_sec, s); + zassert_equal(req.tv_nsec, ns, "actual: %d expected: %d", req.tv_nsec, ns); + zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", rem.tv_sec, 0); + zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", rem.tv_nsec, 0); uint64_t actual_ns = k_cyc_to_ns_ceil64((now - then)); uint64_t exp_ns = (uint64_t)s * NSEC_PER_SEC + ns; @@ -191,38 +115,23 @@ static void common(const uint32_t s, uint32_t ns) /* TODO: Upper bounds check when hr timers are available */ } -/** sleep for 1ns */ -ZTEST(posix_apis, test_nanosleep_0_1) +ZTEST(posix_apis, test_nanosleep_execution) { + /* sleep for 1ns */ common(0, 1); -} -/** sleep for 1us + 1ns */ -ZTEST(posix_apis, test_nanosleep_0_1001) -{ + /* sleep for 1us + 1ns */ common(0, 1001); -} -/** sleep for 500000000ns */ -ZTEST(posix_apis, test_nanosleep_0_500000000) -{ + /* sleep for 500000000ns */ common(0, 500000000); -} -/** sleep for 1s */ -ZTEST(posix_apis, test_nanosleep_1_0) -{ + /* sleep for 1s */ common(1, 0); -} -/** sleep for 1s + 1ns */ -ZTEST(posix_apis, test_nanosleep_1_1) -{ + /* sleep for 1s + 1ns */ common(1, 1); -} -/** sleep for 1s + 1us + 1ns */ -ZTEST(posix_apis, test_nanosleep_1_1001) -{ + /* sleep for 1s + 1us + 1ns */ common(1, 1001); }