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 <cfriedt@meta.com>
This commit is contained in:
Christopher Friedt
Chris Friedt
parent
85110ad917
commit
807d923955
|
|
@ -11,157 +11,85 @@
|
|||
#include <zephyr/sys_clock.h>
|
||||
#include <zephyr/ztest.h>
|
||||
|
||||
/** 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 = {};
|
||||
|
||||
/*
|
||||
* invalid parameters
|
||||
*/
|
||||
zassert_equal(nanosleep(NULL, NULL), -1);
|
||||
zassert_equal(errno, EFAULT);
|
||||
|
||||
/* NULL request */
|
||||
errno = 0;
|
||||
int r = nanosleep(&req, NULL);
|
||||
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);
|
||||
|
||||
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 = {};
|
||||
/* negative times */
|
||||
errno = 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, &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};
|
||||
req = (struct timespec){.tv_sec = 0, .tv_nsec = -1};
|
||||
zassert_equal(nanosleep(&req, NULL), -1);
|
||||
zassert_equal(errno, EINVAL);
|
||||
|
||||
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 = -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_nsec is -1 */
|
||||
ZTEST(posix_apis, test_nanosleep_0_n1)
|
||||
{
|
||||
struct timespec req = {0, -1};
|
||||
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);
|
||||
|
||||
/** req tv_sec and tv_nsec are both -1 */
|
||||
ZTEST(posix_apis, test_nanosleep_n1_n1)
|
||||
{
|
||||
struct timespec req = {-1, -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);
|
||||
|
||||
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};
|
||||
|
||||
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 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);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue