2023-07-11 09:55:29

by Thomas Weißschuh

Subject: [PATCH 0/4] selftests/nolibc: simplify conditions and testcases

A few cleanups to the existing test logic.

Signed-off-by: Thomas Weißschuh <[email protected]>
---
Thomas Weißschuh (4):
selftests/nolibc: make evaluation of test conditions
selftests/nolibc: simplify status printing
selftests/nolibc: simplify status argument
selftests/nolibc: avoid gaps in test numbers

tools/testing/selftests/nolibc/nolibc-test.c | 201 +++++++++++----------------
1 file changed, 85 insertions(+), 116 deletions(-)
---
base-commit: 078cda365b3f47f61047a08230925a1478e9a1c8
change-id: 20230711-nolibc-sizeof-long-gaps-0f28cba7ee4d

Best regards,
--
Thomas Weißschuh <[email protected]>

2023-07-11 09:59:02

by Thomas Weißschuh

Subject: [PATCH 3/4] selftests/nolibc: simplify status argument

I'm not sure if this is an improvement over the previous patch.
If so it should be squashed into it.

Not-Signed-off-by
---
tools/testing/selftests/nolibc/nolibc-test.c | 115 ++++++++++-----------------
1 file changed, 40 insertions(+), 75 deletions(-)

diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index b7ed10512d67..754815c142f6 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -127,17 +127,13 @@ static void putcharn(char c, size_t n)
fputs(buf, stdout);
}

-enum RESULT {
- OK,
- FAIL,
- SKIPPED,
-};
+#define SKIPPED INT_MIN

-static void result(int llen, enum RESULT r)
+static void result(int llen, int r)
{
const char *msg;

- if (r == OK)
+ if (r == 0)
msg = " [OK]";
else if (r == SKIPPED)
msg = "[SKIPPED]";
@@ -162,7 +158,7 @@ static int expect_zr(int expr, int llen)
int ret = !(expr == 0);

llen += printf(" = %d ", expr);
- result(llen, ret ? FAIL : OK);
+ result(llen, ret);
return ret;
}

@@ -175,7 +171,7 @@ static int expect_nz(int expr, int llen)
int ret = !(expr != 0);

llen += printf(" = %d ", expr);
- result(llen, ret ? FAIL : OK);
+ result(llen, ret);
return ret;
}

@@ -188,7 +184,7 @@ static int expect_eq(uint64_t expr, int llen, uint64_t val)
int ret = !(expr == val);

llen += printf(" = %lld ", (long long)expr);
- result(llen, ret ? FAIL : OK);
+ result(llen, ret);
return ret;
}

@@ -201,7 +197,7 @@ static int expect_ne(int expr, int llen, int val)
int ret = !(expr != val);

llen += printf(" = %d ", expr);
- result(llen, ret ? FAIL : OK);
+ result(llen, ret);
return ret;
}

@@ -214,7 +210,7 @@ static int expect_ge(int expr, int llen, int val)
int ret = !(expr >= val);

llen += printf(" = %d ", expr);
- result(llen, ret ? FAIL : OK);
+ result(llen, ret);
return ret;
}

@@ -227,7 +223,7 @@ static int expect_gt(int expr, int llen, int val)
int ret = !(expr > val);

llen += printf(" = %d ", expr);
- result(llen, ret ? FAIL : OK);
+ result(llen, ret);
return ret;
}

@@ -240,7 +236,7 @@ static int expect_le(int expr, int llen, int val)
int ret = !(expr <= val);

llen += printf(" = %d ", expr);
- result(llen, ret ? FAIL : OK);
+ result(llen, ret);
return ret;
}

@@ -253,7 +249,7 @@ static int expect_lt(int expr, int llen, int val)
int ret = !(expr < val);

llen += printf(" = %d ", expr);
- result(llen, ret ? FAIL : OK);
+ result(llen, ret);
return ret;
}

@@ -268,11 +264,10 @@ static int expect_syszr(int expr, int llen)
if (expr) {
ret = 1;
llen += printf(" = %d %s ", expr, errorname(errno));
- result(llen, FAIL);
} else {
llen += printf(" = %d ", expr);
- result(llen, OK);
}
+ result(llen, ret);
return ret;
}

@@ -287,11 +282,10 @@ static int expect_syseq(int expr, int llen, int val)
if (expr != val) {
ret = 1;
llen += printf(" = %d %s ", expr, errorname(errno));
- result(llen, FAIL);
} else {
llen += printf(" = %d ", expr);
- result(llen, OK);
}
+ result(llen, ret);
return ret;
}

@@ -306,11 +300,10 @@ static int expect_sysne(int expr, int llen, int val)
if (expr == val) {
ret = 1;
llen += printf(" = %d %s ", expr, errorname(errno));
- result(llen, FAIL);
} else {
llen += printf(" = %d ", expr);
- result(llen, OK);
}
+ result(llen, ret);
return ret;
}

@@ -333,10 +326,8 @@ static int expect_syserr2(int expr, int expret, int experr1, int experr2, int ll
llen += printf(" != (%d %s) ", expret, errorname(experr1));
else
llen += printf(" != (%d %s %s) ", expret, errorname(experr1), errorname(experr2));
- result(llen, FAIL);
- } else {
- result(llen, OK);
}
+ result(llen, ret);
return ret;
}

@@ -349,12 +340,9 @@ static int expect_ptrzr(const void *expr, int llen)
int ret = 0;

llen += printf(" = <%p> ", expr);
- if (expr) {
+ if (expr)
ret = 1;
- result(llen, FAIL);
- } else {
- result(llen, OK);
- }
+ result(llen, ret);
return ret;
}

@@ -367,12 +355,9 @@ static int expect_ptrnz(const void *expr, int llen)
int ret = 0;

llen += printf(" = <%p> ", expr);
- if (!expr) {
+ if (!expr)
ret = 1;
- result(llen, FAIL);
- } else {
- result(llen, OK);
- }
+ result(llen, ret);
return ret;
}

@@ -384,12 +369,9 @@ static int expect_ptreq(const void *expr, int llen, const void *cmp)
int ret = 0;

llen += printf(" = <%p> ", expr);
- if (expr != cmp) {
+ if (expr != cmp)
ret = 1;
- result(llen, FAIL);
- } else {
- result(llen, OK);
- }
+ result(llen, ret);
return ret;
}

@@ -401,12 +383,9 @@ static int expect_ptrne(const void *expr, int llen, const void *cmp)
int ret = 0;

llen += printf(" = <%p> ", expr);
- if (expr == cmp) {
+ if (expr == cmp)
ret = 1;
- result(llen, FAIL);
- } else {
- result(llen, OK);
- }
+ result(llen, ret);
return ret;
}

@@ -428,10 +407,8 @@ static int expect_ptrerr2(const void *expr, const void *expret, int experr1, int
llen += printf(" != (<%p> %s) ", expret, errorname(experr1));
else
llen += printf(" != (<%p> %s %s) ", expret, errorname(experr1), errorname(experr2));
- result(llen, FAIL);
- } else {
- result(llen, OK);
}
+ result(llen, ret);
return ret;
}

@@ -443,12 +420,9 @@ static int expect_strzr(const char *expr, int llen)
int ret = 0;

llen += printf(" = <%s> ", expr);
- if (expr) {
+ if (expr)
ret = 1;
- result(llen, FAIL);
- } else {
- result(llen, OK);
- }
+ result(llen, ret);
return ret;
}

@@ -461,12 +435,9 @@ static int expect_strnz(const char *expr, int llen)
int ret = 0;

llen += printf(" = <%s> ", expr);
- if (!expr) {
+ if (!expr)
ret = 1;
- result(llen, FAIL);
- } else {
- result(llen, OK);
- }
+ result(llen, ret);
return ret;
}

@@ -479,12 +450,9 @@ static int expect_streq(const char *expr, int llen, const char *cmp)
int ret = 0;

llen += printf(" = <%s> ", expr);
- if (strcmp(expr, cmp) != 0) {
+ if (strcmp(expr, cmp) != 0)
ret = 1;
- result(llen, FAIL);
- } else {
- result(llen, OK);
- }
+ result(llen, ret);
return ret;
}

@@ -497,12 +465,9 @@ static int expect_strne(const char *expr, int llen, const char *cmp)
int ret = 0;

llen += printf(" = <%s> ", expr);
- if (strcmp(expr, cmp) == 0) {
+ if (strcmp(expr, cmp) == 0)
ret = 1;
- result(llen, FAIL);
- } else {
- result(llen, OK);
- }
+ result(llen, ret);
return ret;
}

@@ -893,7 +858,7 @@ static int expect_vfprintf(int llen, size_t c, const char *expected, const char

memfile = fdopen(fd, "w+");
if (!memfile) {
- result(llen, FAIL);
+ result(llen, 1);
return 1;
}

@@ -903,7 +868,7 @@ static int expect_vfprintf(int llen, size_t c, const char *expected, const char

if (w != c) {
llen += printf(" written(%d) != %d", w, (int) c);
- result(llen, FAIL);
+ result(llen, 1);
return 1;
}

@@ -917,14 +882,14 @@ static int expect_vfprintf(int llen, size_t c, const char *expected, const char

if (r != w) {
llen += printf(" written(%d) != read(%d)", w, r);
- result(llen, FAIL);
+ result(llen, 1);
return 1;
}

llen += printf(" \"%s\" = \"%s\"", expected, buf);
ret = strncmp(expected, buf, c);

- result(llen, ret ? FAIL : OK);
+ result(llen, ret);
return ret;
}

@@ -987,7 +952,7 @@ static int run_protection(int min, int max)
#if defined(_NOLIBC_STACKPROTECTOR)
if (!__stack_chk_guard) {
llen += printf("__stack_chk_guard not initialized");
- result(llen, FAIL);
+ result(llen, 1);
return 1;
}
#endif
@@ -998,7 +963,7 @@ static int run_protection(int min, int max)
switch (pid) {
case -1:
llen += printf("fork()");
- result(llen, FAIL);
+ result(llen, 1);
return 1;

case 0:
@@ -1014,10 +979,10 @@ static int run_protection(int min, int max)

if (pid == -1 || !WIFSIGNALED(status) || WTERMSIG(status) != SIGABRT) {
llen += printf("waitpid()");
- result(llen, FAIL);
+ result(llen, 1);
return 1;
}
- result(llen, OK);
+ result(llen, 0);
return 0;
}
}

--
2.41.0

2023-07-11 09:59:40

by Thomas Weißschuh

Subject: [PATCH 4/4] selftests/nolibc: avoid gaps in test numbers

As the test numbers are based on line numbers gaps without testcases are
to be avoided.
Instead use the already existing test condition logic to implement
conditional execution.

Signed-off-by: Thomas Weißschuh <[email protected]>
---
tools/testing/selftests/nolibc/nolibc-test.c | 30 ++++++++++++----------------
1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index 754815c142f6..09660b362645 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -815,23 +815,19 @@ int run_stdlib(int min, int max)
CASE_TEST(limit_int_fast64_min); EXPECT_EQ(1, INT_FAST64_MIN, (int_fast64_t) INT64_MIN); break;
CASE_TEST(limit_int_fast64_max); EXPECT_EQ(1, INT_FAST64_MAX, (int_fast64_t) INT64_MAX); break;
CASE_TEST(limit_uint_fast64_max); EXPECT_EQ(1, UINT_FAST64_MAX, (uint_fast64_t) UINT64_MAX); break;
-#if __SIZEOF_LONG__ == 8
- CASE_TEST(limit_intptr_min); EXPECT_EQ(1, INTPTR_MIN, (intptr_t) 0x8000000000000000LL); break;
- CASE_TEST(limit_intptr_max); EXPECT_EQ(1, INTPTR_MAX, (intptr_t) 0x7fffffffffffffffLL); break;
- CASE_TEST(limit_uintptr_max); EXPECT_EQ(1, UINTPTR_MAX, (uintptr_t) 0xffffffffffffffffULL); break;
- CASE_TEST(limit_ptrdiff_min); EXPECT_EQ(1, PTRDIFF_MIN, (ptrdiff_t) 0x8000000000000000LL); break;
- CASE_TEST(limit_ptrdiff_max); EXPECT_EQ(1, PTRDIFF_MAX, (ptrdiff_t) 0x7fffffffffffffffLL); break;
- CASE_TEST(limit_size_max); EXPECT_EQ(1, SIZE_MAX, (size_t) 0xffffffffffffffffULL); break;
-#elif __SIZEOF_LONG__ == 4
- CASE_TEST(limit_intptr_min); EXPECT_EQ(1, INTPTR_MIN, (intptr_t) 0x80000000); break;
- CASE_TEST(limit_intptr_max); EXPECT_EQ(1, INTPTR_MAX, (intptr_t) 0x7fffffff); break;
- CASE_TEST(limit_uintptr_max); EXPECT_EQ(1, UINTPTR_MAX, (uintptr_t) 0xffffffffU); break;
- CASE_TEST(limit_ptrdiff_min); EXPECT_EQ(1, PTRDIFF_MIN, (ptrdiff_t) 0x80000000); break;
- CASE_TEST(limit_ptrdiff_max); EXPECT_EQ(1, PTRDIFF_MAX, (ptrdiff_t) 0x7fffffff); break;
- CASE_TEST(limit_size_max); EXPECT_EQ(1, SIZE_MAX, (size_t) 0xffffffffU); break;
-#else
-# warning "__SIZEOF_LONG__ is undefined"
-#endif /* __SIZEOF_LONG__ */
+ CASE_TEST(sizeof_long_sane); EXPECT_EQ(1, sizeof(long) == 8 || sizeof(long) == 4, 1); break;
+ CASE_TEST(limit_intptr_min_64); EXPECT_EQ(sizeof(long) == 8, INTPTR_MIN, (intptr_t) 0x8000000000000000LL); break;
+ CASE_TEST(limit_intptr_max_64); EXPECT_EQ(sizeof(long) == 8, INTPTR_MAX, (intptr_t) 0x7fffffffffffffffLL); break;
+ CASE_TEST(limit_uintptr_max_64); EXPECT_EQ(sizeof(long) == 8, UINTPTR_MAX, (uintptr_t) 0xffffffffffffffffULL); break;
+ CASE_TEST(limit_ptrdiff_min_64); EXPECT_EQ(sizeof(long) == 8, PTRDIFF_MIN, (ptrdiff_t) 0x8000000000000000LL); break;
+ CASE_TEST(limit_ptrdiff_max_64); EXPECT_EQ(sizeof(long) == 8, PTRDIFF_MAX, (ptrdiff_t) 0x7fffffffffffffffLL); break;
+ CASE_TEST(limit_size_max_64); EXPECT_EQ(sizeof(long) == 8, SIZE_MAX, (size_t) 0xffffffffffffffffULL); break;
+ CASE_TEST(limit_intptr_min_32); EXPECT_EQ(sizeof(long) == 4, INTPTR_MIN, (intptr_t) 0x80000000); break;
+ CASE_TEST(limit_intptr_max_32); EXPECT_EQ(sizeof(long) == 4, INTPTR_MAX, (intptr_t) 0x7fffffff); break;
+ CASE_TEST(limit_uintptr_max_32); EXPECT_EQ(sizeof(long) == 4, UINTPTR_MAX, (uintptr_t) 0xffffffffU); break;
+ CASE_TEST(limit_ptrdiff_min_32); EXPECT_EQ(sizeof(long) == 4, PTRDIFF_MIN, (ptrdiff_t) 0x80000000); break;
+ CASE_TEST(limit_ptrdiff_max_32); EXPECT_EQ(sizeof(long) == 4, PTRDIFF_MAX, (ptrdiff_t) 0x7fffffff); break;
+ CASE_TEST(limit_size_max_32); EXPECT_EQ(sizeof(long) == 4, SIZE_MAX, (size_t) 0xffffffffU); break;
case __LINE__:
return ret; /* must be last */
/* note: do not set any defaults so as to permit holes above */

--
2.41.0

2023-07-11 10:03:04

by Thomas Weißschuh

Subject: [PATCH 2/4] selftests/nolibc: simplify status printing

pad_spc() is only ever used to print the status message of testcases.
The line size is always constant, the return value is never used and the
format string is never used as such.

Remove all the unneeded logic and simplify the API and its users.

Signed-off-by: Thomas Weißschuh <[email protected]>
---
tools/testing/selftests/nolibc/nolibc-test.c | 154 ++++++++++++++-------------
1 file changed, 81 insertions(+), 73 deletions(-)

diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index c252ea0c2f01..b7ed10512d67 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -127,17 +127,25 @@ static void putcharn(char c, size_t n)
fputs(buf, stdout);
}

-static int pad_spc(int llen, int cnt, const char *fmt, ...)
+enum RESULT {
+ OK,
+ FAIL,
+ SKIPPED,
+};
+
+static void result(int llen, enum RESULT r)
{
- va_list args;
- int ret;
+ const char *msg;

- putcharn(' ', cnt - llen);
+ if (r == OK)
+ msg = " [OK]";
+ else if (r == SKIPPED)
+ msg = "[SKIPPED]";
+ else
+ msg = "[FAIL]";

- va_start(args, fmt);
- ret = vfprintf(stdout, fmt, args);
- va_end(args);
- return ret < 0 ? ret : ret + cnt - llen;
+ putcharn(' ', 64 - llen);
+ puts(msg);
}

/* The tests below are intended to be used by the macroes, which evaluate
@@ -147,111 +155,111 @@ static int pad_spc(int llen, int cnt, const char *fmt, ...)
*/

#define EXPECT_ZR(cond, expr) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_zr(expr, llen); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_zr(expr, llen); } while (0)

static int expect_zr(int expr, int llen)
{
int ret = !(expr == 0);

llen += printf(" = %d ", expr);
- pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n");
+ result(llen, ret ? FAIL : OK);
return ret;
}


#define EXPECT_NZ(cond, expr, val) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_nz(expr, llen; } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_nz(expr, llen; } while (0)

static int expect_nz(int expr, int llen)
{
int ret = !(expr != 0);

llen += printf(" = %d ", expr);
- pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n");
+ result(llen, ret ? FAIL : OK);
return ret;
}


#define EXPECT_EQ(cond, expr, val) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_eq(expr, llen, val); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_eq(expr, llen, val); } while (0)

static int expect_eq(uint64_t expr, int llen, uint64_t val)
{
int ret = !(expr == val);

llen += printf(" = %lld ", (long long)expr);
- pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n");
+ result(llen, ret ? FAIL : OK);
return ret;
}


#define EXPECT_NE(cond, expr, val) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ne(expr, llen, val); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ne(expr, llen, val); } while (0)

static int expect_ne(int expr, int llen, int val)
{
int ret = !(expr != val);

llen += printf(" = %d ", expr);
- pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n");
+ result(llen, ret ? FAIL : OK);
return ret;
}


#define EXPECT_GE(cond, expr, val) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ge(expr, llen, val); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ge(expr, llen, val); } while (0)

static int expect_ge(int expr, int llen, int val)
{
int ret = !(expr >= val);

llen += printf(" = %d ", expr);
- pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n");
+ result(llen, ret ? FAIL : OK);
return ret;
}


#define EXPECT_GT(cond, expr, val) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_gt(expr, llen, val); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_gt(expr, llen, val); } while (0)

static int expect_gt(int expr, int llen, int val)
{
int ret = !(expr > val);

llen += printf(" = %d ", expr);
- pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n");
+ result(llen, ret ? FAIL : OK);
return ret;
}


#define EXPECT_LE(cond, expr, val) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_le(expr, llen, val); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_le(expr, llen, val); } while (0)

static int expect_le(int expr, int llen, int val)
{
int ret = !(expr <= val);

llen += printf(" = %d ", expr);
- pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n");
+ result(llen, ret ? FAIL : OK);
return ret;
}


#define EXPECT_LT(cond, expr, val) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_lt(expr, llen, val); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_lt(expr, llen, val); } while (0)

static int expect_lt(int expr, int llen, int val)
{
int ret = !(expr < val);

llen += printf(" = %d ", expr);
- pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n");
+ result(llen, ret ? FAIL : OK);
return ret;
}


#define EXPECT_SYSZR(cond, expr) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syszr(expr, llen); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_syszr(expr, llen); } while (0)

static int expect_syszr(int expr, int llen)
{
@@ -260,17 +268,17 @@ static int expect_syszr(int expr, int llen)
if (expr) {
ret = 1;
llen += printf(" = %d %s ", expr, errorname(errno));
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
llen += printf(" = %d ", expr);
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}


#define EXPECT_SYSEQ(cond, expr, val) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syseq(expr, llen, val); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_syseq(expr, llen, val); } while (0)

static int expect_syseq(int expr, int llen, int val)
{
@@ -279,17 +287,17 @@ static int expect_syseq(int expr, int llen, int val)
if (expr != val) {
ret = 1;
llen += printf(" = %d %s ", expr, errorname(errno));
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
llen += printf(" = %d ", expr);
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}


#define EXPECT_SYSNE(cond, expr, val) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_sysne(expr, llen, val); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_sysne(expr, llen, val); } while (0)

static int expect_sysne(int expr, int llen, int val)
{
@@ -298,17 +306,17 @@ static int expect_sysne(int expr, int llen, int val)
if (expr == val) {
ret = 1;
llen += printf(" = %d %s ", expr, errorname(errno));
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
llen += printf(" = %d ", expr);
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}


#define EXPECT_SYSER2(cond, expr, expret, experr1, experr2) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syserr2(expr, expret, experr1, experr2, llen); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_syserr2(expr, expret, experr1, experr2, llen); } while (0)

#define EXPECT_SYSER(cond, expr, expret, experr) \
EXPECT_SYSER2(cond, expr, expret, experr, 0)
@@ -325,16 +333,16 @@ static int expect_syserr2(int expr, int expret, int experr1, int experr2, int ll
llen += printf(" != (%d %s) ", expret, errorname(experr1));
else
llen += printf(" != (%d %s %s) ", expret, errorname(experr1), errorname(experr2));
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}


#define EXPECT_PTRZR(cond, expr) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrzr(expr, llen); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrzr(expr, llen); } while (0)

static int expect_ptrzr(const void *expr, int llen)
{
@@ -343,16 +351,16 @@ static int expect_ptrzr(const void *expr, int llen)
llen += printf(" = <%p> ", expr);
if (expr) {
ret = 1;
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}


#define EXPECT_PTRNZ(cond, expr) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrnz(expr, llen); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrnz(expr, llen); } while (0)

static int expect_ptrnz(const void *expr, int llen)
{
@@ -361,15 +369,15 @@ static int expect_ptrnz(const void *expr, int llen)
llen += printf(" = <%p> ", expr);
if (!expr) {
ret = 1;
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}

#define EXPECT_PTREQ(cond, expr, cmp) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptreq(expr, llen, cmp); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptreq(expr, llen, cmp); } while (0)

static int expect_ptreq(const void *expr, int llen, const void *cmp)
{
@@ -378,15 +386,15 @@ static int expect_ptreq(const void *expr, int llen, const void *cmp)
llen += printf(" = <%p> ", expr);
if (expr != cmp) {
ret = 1;
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}

#define EXPECT_PTRNE(cond, expr, cmp) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrne(expr, llen, cmp); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrne(expr, llen, cmp); } while (0)

static int expect_ptrne(const void *expr, int llen, const void *cmp)
{
@@ -395,15 +403,15 @@ static int expect_ptrne(const void *expr, int llen, const void *cmp)
llen += printf(" = <%p> ", expr);
if (expr == cmp) {
ret = 1;
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}

#define EXPECT_PTRER2(cond, expr, expret, experr1, experr2) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrerr2(expr, expret, experr1, experr2, llen); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrerr2(expr, expret, experr1, experr2, llen); } while (0)

#define EXPECT_PTRER(cond, expr, expret, experr) \
EXPECT_PTRER2(cond, expr, expret, experr, 0)
@@ -420,15 +428,15 @@ static int expect_ptrerr2(const void *expr, const void *expret, int experr1, int
llen += printf(" != (<%p> %s) ", expret, errorname(experr1));
else
llen += printf(" != (<%p> %s %s) ", expret, errorname(experr1), errorname(experr2));
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}

#define EXPECT_STRZR(cond, expr) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strzr(expr, llen); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strzr(expr, llen); } while (0)

static int expect_strzr(const char *expr, int llen)
{
@@ -437,16 +445,16 @@ static int expect_strzr(const char *expr, int llen)
llen += printf(" = <%s> ", expr);
if (expr) {
ret = 1;
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}


#define EXPECT_STRNZ(cond, expr) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strnz(expr, llen); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strnz(expr, llen); } while (0)

static int expect_strnz(const char *expr, int llen)
{
@@ -455,16 +463,16 @@ static int expect_strnz(const char *expr, int llen)
llen += printf(" = <%s> ", expr);
if (!expr) {
ret = 1;
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}


#define EXPECT_STREQ(cond, expr, cmp) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_streq(expr, llen, cmp); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_streq(expr, llen, cmp); } while (0)

static int expect_streq(const char *expr, int llen, const char *cmp)
{
@@ -473,16 +481,16 @@ static int expect_streq(const char *expr, int llen, const char *cmp)
llen += printf(" = <%s> ", expr);
if (strcmp(expr, cmp) != 0) {
ret = 1;
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}


#define EXPECT_STRNE(cond, expr, cmp) \
- do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strne(expr, llen, cmp); } while (0)
+ do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strne(expr, llen, cmp); } while (0)

static int expect_strne(const char *expr, int llen, const char *cmp)
{
@@ -491,9 +499,9 @@ static int expect_strne(const char *expr, int llen, const char *cmp)
llen += printf(" = <%s> ", expr);
if (strcmp(expr, cmp) == 0) {
ret = 1;
- llen += pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
} else {
- llen += pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
}
return ret;
}
@@ -879,13 +887,13 @@ static int expect_vfprintf(int llen, size_t c, const char *expected, const char

fd = open("/tmp", O_TMPFILE | O_EXCL | O_RDWR, 0600);
if (fd == -1) {
- pad_spc(llen, 64, "[SKIPPED]\n");
+ result(llen, SKIPPED);
return 0;
}

memfile = fdopen(fd, "w+");
if (!memfile) {
- pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
return 1;
}

@@ -895,7 +903,7 @@ static int expect_vfprintf(int llen, size_t c, const char *expected, const char

if (w != c) {
llen += printf(" written(%d) != %d", w, (int) c);
- pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
return 1;
}

@@ -909,14 +917,14 @@ static int expect_vfprintf(int llen, size_t c, const char *expected, const char

if (r != w) {
llen += printf(" written(%d) != read(%d)", w, r);
- pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
return 1;
}

llen += printf(" \"%s\" = \"%s\"", expected, buf);
ret = strncmp(expected, buf, c);

- pad_spc(llen, 64, ret ? "[FAIL]\n" : " [OK]\n");
+ result(llen, ret ? FAIL : OK);
return ret;
}

@@ -972,14 +980,14 @@ static int run_protection(int min, int max)

#if !defined(_NOLIBC_STACKPROTECTOR)
llen += printf("not supported");
- pad_spc(llen, 64, "[SKIPPED]\n");
+ result(llen, SKIPPED);
return 0;
#endif

#if defined(_NOLIBC_STACKPROTECTOR)
if (!__stack_chk_guard) {
llen += printf("__stack_chk_guard not initialized");
- pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
return 1;
}
#endif
@@ -990,7 +998,7 @@ static int run_protection(int min, int max)
switch (pid) {
case -1:
llen += printf("fork()");
- pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
return 1;

case 0:
@@ -1006,10 +1014,10 @@ static int run_protection(int min, int max)

if (pid == -1 || !WIFSIGNALED(status) || WTERMSIG(status) != SIGABRT) {
llen += printf("waitpid()");
- pad_spc(llen, 64, "[FAIL]\n");
+ result(llen, FAIL);
return 1;
}
- pad_spc(llen, 64, " [OK]\n");
+ result(llen, OK);
return 0;
}
}

--
2.41.0

2023-07-11 10:03:43

by Thomas Weißschuh

Subject: [PATCH 1/4] selftests/nolibc: make evaluation of test conditions

If "cond" is a multi-token statement the behavior of the preprocessor
will lead to the negation "!" to be only applied to the first token.
Although currently no test uses such multi-token conditions but it can
happen at any time.

Put braces around "cond" to ensure the negation works as expected.

Signed-off-by: Thomas Weißschuh <[email protected]>
---
tools/testing/selftests/nolibc/nolibc-test.c | 42 ++++++++++++++--------------
1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index f357bd815abc..c252ea0c2f01 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -147,7 +147,7 @@ static int pad_spc(int llen, int cnt, const char *fmt, ...)
*/

#define EXPECT_ZR(cond, expr) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_zr(expr, llen); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_zr(expr, llen); } while (0)

static int expect_zr(int expr, int llen)
{
@@ -160,7 +160,7 @@ static int expect_zr(int expr, int llen)


#define EXPECT_NZ(cond, expr, val) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_nz(expr, llen; } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_nz(expr, llen; } while (0)

static int expect_nz(int expr, int llen)
{
@@ -173,7 +173,7 @@ static int expect_nz(int expr, int llen)


#define EXPECT_EQ(cond, expr, val) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_eq(expr, llen, val); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_eq(expr, llen, val); } while (0)

static int expect_eq(uint64_t expr, int llen, uint64_t val)
{
@@ -186,7 +186,7 @@ static int expect_eq(uint64_t expr, int llen, uint64_t val)


#define EXPECT_NE(cond, expr, val) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ne(expr, llen, val); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ne(expr, llen, val); } while (0)

static int expect_ne(int expr, int llen, int val)
{
@@ -199,7 +199,7 @@ static int expect_ne(int expr, int llen, int val)


#define EXPECT_GE(cond, expr, val) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ge(expr, llen, val); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ge(expr, llen, val); } while (0)

static int expect_ge(int expr, int llen, int val)
{
@@ -212,7 +212,7 @@ static int expect_ge(int expr, int llen, int val)


#define EXPECT_GT(cond, expr, val) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_gt(expr, llen, val); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_gt(expr, llen, val); } while (0)

static int expect_gt(int expr, int llen, int val)
{
@@ -225,7 +225,7 @@ static int expect_gt(int expr, int llen, int val)


#define EXPECT_LE(cond, expr, val) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_le(expr, llen, val); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_le(expr, llen, val); } while (0)

static int expect_le(int expr, int llen, int val)
{
@@ -238,7 +238,7 @@ static int expect_le(int expr, int llen, int val)


#define EXPECT_LT(cond, expr, val) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_lt(expr, llen, val); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_lt(expr, llen, val); } while (0)

static int expect_lt(int expr, int llen, int val)
{
@@ -251,7 +251,7 @@ static int expect_lt(int expr, int llen, int val)


#define EXPECT_SYSZR(cond, expr) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syszr(expr, llen); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syszr(expr, llen); } while (0)

static int expect_syszr(int expr, int llen)
{
@@ -270,7 +270,7 @@ static int expect_syszr(int expr, int llen)


#define EXPECT_SYSEQ(cond, expr, val) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syseq(expr, llen, val); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syseq(expr, llen, val); } while (0)

static int expect_syseq(int expr, int llen, int val)
{
@@ -289,7 +289,7 @@ static int expect_syseq(int expr, int llen, int val)


#define EXPECT_SYSNE(cond, expr, val) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_sysne(expr, llen, val); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_sysne(expr, llen, val); } while (0)

static int expect_sysne(int expr, int llen, int val)
{
@@ -308,7 +308,7 @@ static int expect_sysne(int expr, int llen, int val)


#define EXPECT_SYSER2(cond, expr, expret, experr1, experr2) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syserr2(expr, expret, experr1, experr2, llen); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_syserr2(expr, expret, experr1, experr2, llen); } while (0)

#define EXPECT_SYSER(cond, expr, expret, experr) \
EXPECT_SYSER2(cond, expr, expret, experr, 0)
@@ -334,7 +334,7 @@ static int expect_syserr2(int expr, int expret, int experr1, int experr2, int ll


#define EXPECT_PTRZR(cond, expr) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrzr(expr, llen); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrzr(expr, llen); } while (0)

static int expect_ptrzr(const void *expr, int llen)
{
@@ -352,7 +352,7 @@ static int expect_ptrzr(const void *expr, int llen)


#define EXPECT_PTRNZ(cond, expr) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrnz(expr, llen); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrnz(expr, llen); } while (0)

static int expect_ptrnz(const void *expr, int llen)
{
@@ -369,7 +369,7 @@ static int expect_ptrnz(const void *expr, int llen)
}

#define EXPECT_PTREQ(cond, expr, cmp) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptreq(expr, llen, cmp); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptreq(expr, llen, cmp); } while (0)

static int expect_ptreq(const void *expr, int llen, const void *cmp)
{
@@ -386,7 +386,7 @@ static int expect_ptreq(const void *expr, int llen, const void *cmp)
}

#define EXPECT_PTRNE(cond, expr, cmp) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrne(expr, llen, cmp); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrne(expr, llen, cmp); } while (0)

static int expect_ptrne(const void *expr, int llen, const void *cmp)
{
@@ -403,7 +403,7 @@ static int expect_ptrne(const void *expr, int llen, const void *cmp)
}

#define EXPECT_PTRER2(cond, expr, expret, experr1, experr2) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrerr2(expr, expret, experr1, experr2, llen); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_ptrerr2(expr, expret, experr1, experr2, llen); } while (0)

#define EXPECT_PTRER(cond, expr, expret, experr) \
EXPECT_PTRER2(cond, expr, expret, experr, 0)
@@ -428,7 +428,7 @@ static int expect_ptrerr2(const void *expr, const void *expret, int experr1, int
}

#define EXPECT_STRZR(cond, expr) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strzr(expr, llen); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strzr(expr, llen); } while (0)

static int expect_strzr(const char *expr, int llen)
{
@@ -446,7 +446,7 @@ static int expect_strzr(const char *expr, int llen)


#define EXPECT_STRNZ(cond, expr) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strnz(expr, llen); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strnz(expr, llen); } while (0)

static int expect_strnz(const char *expr, int llen)
{
@@ -464,7 +464,7 @@ static int expect_strnz(const char *expr, int llen)


#define EXPECT_STREQ(cond, expr, cmp) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_streq(expr, llen, cmp); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_streq(expr, llen, cmp); } while (0)

static int expect_streq(const char *expr, int llen, const char *cmp)
{
@@ -482,7 +482,7 @@ static int expect_streq(const char *expr, int llen, const char *cmp)


#define EXPECT_STRNE(cond, expr, cmp) \
- do { if (!cond) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strne(expr, llen, cmp); } while (0)
+ do { if (!(cond)) pad_spc(llen, 64, "[SKIPPED]\n"); else ret += expect_strne(expr, llen, cmp); } while (0)

static int expect_strne(const char *expr, int llen, const char *cmp)
{

--
2.41.0

2023-07-11 19:47:13

by Willy Tarreau

Subject: Re: [PATCH 3/4] selftests/nolibc: simplify status argument

Hi Thomas,

On Tue, Jul 11, 2023 at 11:48:41AM +0200, Thomas Wei?schuh wrote:
> I'm not sure if this is an improvement over the previous patch.
> If so it should be squashed into it.

Indeed, I find it less readable, because when you read:

result(llen, ret ? FAIL : OK);

it makes it explicit what values of ret are expected with what meaning,
but this one:

result(llen, ret);

makes it quite opaque. I'd rather keep the ternary operator and the 3
values that are likely more accessible to newcomers who will more quickly
figure how to do what they need.

Thus I dropped this one and applied the 3 other ones which are indeed
a nice cleanup.

Thanks,
Willy