Skip to content

Commit

Permalink
tests: posix: nanosleep: condense test cases
Browse files Browse the repository at this point in the history 
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>
  • Loading branch information
@cfriedt
cfriedt committed Jul 6, 2023
1 parent 3a30706 commit 24b9948
Showing 1 changed file with 67 additions and 158 deletions.
225 changes: 67 additions & 158 deletions tests/posix/common/src/nanosleep.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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 = {};

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();
Expand All @@ -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;
Expand All @@ -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);
}

0 comments on commit 24b9948

Please sign in to comment.