Skip to content

Commit f97b956

Browse files
torvaldstorvalds
committed
Merge tag 'nolibc.2024.07.15a' of git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu
Pull nolibc updates from Paul McKenney: - Fix selftest printf format mismatch in expect_str_buf_eq() - Stop using brk() and sbrk() when testing against musl, which implements these two functions with ENOMEM - Make tests use -Werror to force failure on compiler warnings - Add limits for the {u,}intmax_t, ulong and {u,}llong types - Implement strtol() and friends - Add facility to skip nolibc-specific tests when running against non-nolibc libraries - Implement strerror() - Also use strerror() on nolibc when running kselftests * tag 'nolibc.2024.07.15a' of git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu: selftests: kselftest: also use strerror() on nolibc tools/nolibc: implement strerror() selftests/nolibc: introduce condition to run tests only on nolibc tools/nolibc: implement strtol() and friends tools/nolibc: add limits for {u,}intmax_t, ulong and {u,}llong selftests/nolibc: run-tests.sh: use -Werror by default selftests/nolibc: disable brk()/sbrk() tests on musl selftests/nolibc: fix printf format mismatch in expect_str_buf_eq()
2 parents e4b2b0b + 6ca8f2e commit f97b956

File tree

7 files changed

+238
-28
lines changed

7 files changed

+238
-28
lines changed

‎tools/include/nolibc/stdint.h

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -96,6 +96,10 @@ typedef uint64_t uintmax_t;
9696
#define UINT_FAST32_MAX SIZE_MAX
9797
#define UINT_FAST64_MAX UINT64_MAX
9898

99+
#define INTMAX_MIN INT64_MIN
100+
#define INTMAX_MAX INT64_MAX
101+
#define UINTMAX_MAX UINT64_MAX
102+
99103
#ifndef INT_MIN
100104
#define INT_MIN (-__INT_MAX__ - 1)
101105
#endif
@@ -110,4 +114,19 @@ typedef uint64_t uintmax_t;
110114
#define LONG_MAX __LONG_MAX__
111115
#endif
112116

117+
#ifndef ULONG_MAX
118+
#define ULONG_MAX ((unsigned long)(__LONG_MAX__) * 2 + 1)
119+
#endif
120+
121+
#ifndef LLONG_MIN
122+
#define LLONG_MIN (-__LONG_LONG_MAX__ - 1)
123+
#endif
124+
#ifndef LLONG_MAX
125+
#define LLONG_MAX __LONG_LONG_MAX__
126+
#endif
127+
128+
#ifndef ULLONG_MAX
129+
#define ULLONG_MAX ((unsigned long long)(__LONG_LONG_MAX__) * 2 + 1)
130+
#endif
131+
113132
#endif /* _NOLIBC_STDINT_H */

‎tools/include/nolibc/stdio.h

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -376,6 +376,16 @@ int setvbuf(FILE *stream __attribute__((unused)),
376376
return 0;
377377
}
378378

379+
static __attribute__((unused))
380+
const char *strerror(int errno)
381+
{
382+
static char buf[18] = "errno=";
383+
384+
i64toa_r(errno, &buf[6]);
385+
386+
return buf;
387+
}
388+
379389
/* make sure to include all global symbols */
380390
#include "nolibc.h"
381391

‎tools/include/nolibc/stdlib.h

Lines changed: 109 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -438,6 +438,115 @@ char *u64toa(uint64_t in)
438438
return itoa_buffer;
439439
}
440440

441+
static __attribute__((unused))
442+
uintmax_t __strtox(const char *nptr, char **endptr, int base, intmax_t lower_limit, uintmax_t upper_limit)
443+
{
444+
const char signed_ = lower_limit != 0;
445+
unsigned char neg = 0, overflow = 0;
446+
uintmax_t val = 0, limit, old_val;
447+
char c;
448+
449+
if (base < 0 || base > 36) {
450+
SET_ERRNO(EINVAL);
451+
goto out;
452+
}
453+
454+
while (isspace(*nptr))
455+
nptr++;
456+
457+
if (*nptr == '+') {
458+
nptr++;
459+
} else if (*nptr == '-') {
460+
neg = 1;
461+
nptr++;
462+
}
463+
464+
if (signed_ && neg)
465+
limit = -(uintmax_t)lower_limit;
466+
else
467+
limit = upper_limit;
468+
469+
if ((base == 0 || base == 16) &&
470+
(strncmp(nptr, "0x", 2) == 0 || strncmp(nptr, "0X", 2) == 0)) {
471+
base = 16;
472+
nptr += 2;
473+
} else if (base == 0 && strncmp(nptr, "0", 1) == 0) {
474+
base = 8;
475+
nptr += 1;
476+
} else if (base == 0) {
477+
base = 10;
478+
}
479+
480+
while (*nptr) {
481+
c = *nptr;
482+
483+
if (c >= '0' && c <= '9')
484+
c -= '0';
485+
else if (c >= 'a' && c <= 'z')
486+
c = c - 'a' + 10;
487+
else if (c >= 'A' && c <= 'Z')
488+
c = c - 'A' + 10;
489+
else
490+
goto out;
491+
492+
if (c >= base)
493+
goto out;
494+
495+
nptr++;
496+
old_val = val;
497+
val *= base;
498+
val += c;
499+
500+
if (val > limit || val < old_val)
501+
overflow = 1;
502+
}
503+
504+
out:
505+
if (overflow) {
506+
SET_ERRNO(ERANGE);
507+
val = limit;
508+
}
509+
if (endptr)
510+
*endptr = (char *)nptr;
511+
return neg ? -val : val;
512+
}
513+
514+
static __attribute__((unused))
515+
long strtol(const char *nptr, char **endptr, int base)
516+
{
517+
return __strtox(nptr, endptr, base, LONG_MIN, LONG_MAX);
518+
}
519+
520+
static __attribute__((unused))
521+
unsigned long strtoul(const char *nptr, char **endptr, int base)
522+
{
523+
return __strtox(nptr, endptr, base, 0, ULONG_MAX);
524+
}
525+
526+
static __attribute__((unused))
527+
long long strtoll(const char *nptr, char **endptr, int base)
528+
{
529+
return __strtox(nptr, endptr, base, LLONG_MIN, LLONG_MAX);
530+
}
531+
532+
static __attribute__((unused))
533+
unsigned long long strtoull(const char *nptr, char **endptr, int base)
534+
{
535+
return __strtox(nptr, endptr, base, 0, ULLONG_MAX);
536+
}
537+
538+
static __attribute__((unused))
539+
intmax_t strtoimax(const char *nptr, char **endptr, int base)
540+
{
541+
return __strtox(nptr, endptr, base, INTMAX_MIN, INTMAX_MAX);
542+
}
543+
544+
static __attribute__((unused))
545+
uintmax_t strtoumax(const char *nptr, char **endptr, int base)
546+
{
547+
return __strtox(nptr, endptr, base, 0, UINTMAX_MAX);
548+
}
549+
441550
/* make sure to include all global symbols */
442551
#include "nolibc.h"
443552

‎tools/testing/selftests/kselftest.h

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -168,15 +168,7 @@ static inline __printf(1, 2) void ksft_print_msg(const char *msg, ...)
168168

169169
static inline void ksft_perror(const char *msg)
170170
{
171-
#ifndef NOLIBC
172171
ksft_print_msg("%s: %s (%d)\n", msg, strerror(errno), errno);
173-
#else
174-
/*
175-
* nolibc doesn't provide strerror() and it seems
176-
* inappropriate to add one, just print the errno.
177-
*/
178-
ksft_print_msg("%s: %d)\n", msg, errno);
179-
#endif
180172
}
181173

182174
static inline __printf(1, 2) void ksft_test_result_pass(const char *msg, ...)

‎tools/testing/selftests/nolibc/Makefile

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -152,7 +152,7 @@ CFLAGS_mips32be = -EB -mabi=32
152152
CFLAGS_STACKPROTECTOR ?= $(call cc-option,-mstack-protector-guard=global $(call cc-option,-fstack-protector-all))
153153
CFLAGS ?= -Os -fno-ident -fno-asynchronous-unwind-tables -std=c89 -W -Wall -Wextra \
154154
$(call cc-option,-fno-stack-protector) \
155-
$(CFLAGS_$(XARCH)) $(CFLAGS_STACKPROTECTOR)
155+
$(CFLAGS_$(XARCH)) $(CFLAGS_STACKPROTECTOR) $(CFLAGS_EXTRA)
156156
LDFLAGS :=
157157

158158
REPORT ?= awk '/\[OK\][\r]*$$/{p++} /\[FAIL\][\r]*$$/{if (!f) printf("\n"); f++; print;} /\[SKIPPED\][\r]*$$/{s++} \

‎tools/testing/selftests/nolibc/nolibc-test.c

Lines changed: 92 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,14 @@ static const char *argv0;
6464
/* will be used by constructor tests */
6565
static int constructor_test_value;
6666

67+
static const int is_nolibc =
68+
#ifdef NOLIBC
69+
1
70+
#else
71+
0
72+
#endif
73+
;
74+
6775
/* definition of a series of tests */
6876
struct test {
6977
const char *name; /* test name */
@@ -607,7 +615,7 @@ int expect_strne(const char *expr, int llen, const char *cmp)
607615
static __attribute__((unused))
608616
int expect_str_buf_eq(size_t expr, const char *buf, size_t val, int llen, const char *cmp)
609617
{
610-
llen += printf(" = %lu <%s> ", expr, buf);
618+
llen += printf(" = %lu <%s> ", (unsigned long)expr, buf);
611619
if (strcmp(buf, cmp) != 0) {
612620
result(llen, FAIL);
613621
return 1;
@@ -621,6 +629,51 @@ int expect_str_buf_eq(size_t expr, const char *buf, size_t val, int llen, const
621629
return 0;
622630
}
623631

632+
#define EXPECT_STRTOX(cond, func, input, base, expected, chars, expected_errno) \
633+
do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strtox(llen, func, input, base, expected, chars, expected_errno); } while (0)
634+
635+
static __attribute__((unused))
636+
int expect_strtox(int llen, void *func, const char *input, int base, intmax_t expected, int expected_chars, int expected_errno)
637+
{
638+
char *endptr;
639+
int actual_errno, actual_chars;
640+
intmax_t r;
641+
642+
errno = 0;
643+
if (func == strtol) {
644+
r = strtol(input, &endptr, base);
645+
} else if (func == strtoul) {
646+
r = strtoul(input, &endptr, base);
647+
} else {
648+
result(llen, FAIL);
649+
return 1;
650+
}
651+
actual_errno = errno;
652+
actual_chars = endptr - input;
653+
654+
llen += printf(" %lld = %lld", (long long)expected, (long long)r);
655+
if (r != expected) {
656+
result(llen, FAIL);
657+
return 1;
658+
}
659+
if (expected_chars == -1) {
660+
if (*endptr != '\0') {
661+
result(llen, FAIL);
662+
return 1;
663+
}
664+
} else if (expected_chars != actual_chars) {
665+
result(llen, FAIL);
666+
return 1;
667+
}
668+
if (actual_errno != expected_errno) {
669+
result(llen, FAIL);
670+
return 1;
671+
}
672+
673+
result(llen, OK);
674+
return 0;
675+
}
676+
624677
/* declare tests based on line numbers. There must be exactly one test per line. */
625678
#define CASE_TEST(name) \
626679
case __LINE__: llen += printf("%d %s", test, #name);
@@ -942,6 +995,7 @@ int run_syscall(int min, int max)
942995
int ret = 0;
943996
void *p1, *p2;
944997
int has_gettid = 1;
998+
int has_brk;
945999

9461000
/* <proc> indicates whether or not /proc is mounted */
9471001
proc = stat("/proc", &stat_buf) == 0;
@@ -954,6 +1008,9 @@ int run_syscall(int min, int max)
9541008
has_gettid = __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 30);
9551009
#endif
9561010

1011+
/* on musl setting brk()/sbrk() always fails */
1012+
has_brk = brk(0) == 0;
1013+
9571014
for (test = min; test >= 0 && test <= max; test++) {
9581015
int llen = 0; /* line length */
9591016

@@ -969,9 +1026,9 @@ int run_syscall(int min, int max)
9691026
CASE_TEST(kill_0); EXPECT_SYSZR(1, kill(getpid(), 0)); break;
9701027
CASE_TEST(kill_CONT); EXPECT_SYSZR(1, kill(getpid(), 0)); break;
9711028
CASE_TEST(kill_BADPID); EXPECT_SYSER(1, kill(INT_MAX, 0), -1, ESRCH); break;
972-
CASE_TEST(sbrk_0); EXPECT_PTRNE(1, sbrk(0), (void *)-1); break;
973-
CASE_TEST(sbrk); if ((p1 = p2 = sbrk(4096)) != (void *)-1) p2 = sbrk(-4096); EXPECT_SYSZR(1, (p2 == (void *)-1) || p2 == p1); break;
974-
CASE_TEST(brk); EXPECT_SYSZR(1, brk(sbrk(0))); break;
1029+
CASE_TEST(sbrk_0); EXPECT_PTRNE(has_brk, sbrk(0), (void *)-1); break;
1030+
CASE_TEST(sbrk); if ((p1 = p2 = sbrk(4096)) != (void *)-1) p2 = sbrk(-4096); EXPECT_SYSZR(has_brk, (p2 == (void *)-1) || p2 == p1); break;
1031+
CASE_TEST(brk); EXPECT_SYSZR(has_brk, brk(sbrk(0))); break;
9751032
CASE_TEST(chdir_root); EXPECT_SYSZR(1, chdir("/")); chdir(getenv("PWD")); break;
9761033
CASE_TEST(chdir_dot); EXPECT_SYSZR(1, chdir(".")); break;
9771034
CASE_TEST(chdir_blah); EXPECT_SYSER(1, chdir("/blah"), -1, ENOENT); break;
@@ -1076,19 +1133,17 @@ int run_stdlib(int min, int max)
10761133
CASE_TEST(strchr_foobar_z); EXPECT_STRZR(1, strchr("foobar", 'z')); break;
10771134
CASE_TEST(strrchr_foobar_o); EXPECT_STREQ(1, strrchr("foobar", 'o'), "obar"); break;
10781135
CASE_TEST(strrchr_foobar_z); EXPECT_STRZR(1, strrchr("foobar", 'z')); break;
1079-
#ifdef NOLIBC
1080-
CASE_TEST(strlcat_0); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 0), buf, 3, "test"); break;
1081-
CASE_TEST(strlcat_1); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 1), buf, 4, "test"); break;
1082-
CASE_TEST(strlcat_5); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 5), buf, 7, "test"); break;
1083-
CASE_TEST(strlcat_6); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 6), buf, 7, "testb"); break;
1084-
CASE_TEST(strlcat_7); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 7), buf, 7, "testba"); break;
1085-
CASE_TEST(strlcat_8); EXPECT_STRBUFEQ(1, strlcat(buf, "bar", 8), buf, 7, "testbar"); break;
1086-
CASE_TEST(strlcpy_0); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 0), buf, 3, "test"); break;
1087-
CASE_TEST(strlcpy_1); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 1), buf, 3, ""); break;
1088-
CASE_TEST(strlcpy_2); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 2), buf, 3, "b"); break;
1089-
CASE_TEST(strlcpy_3); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 3), buf, 3, "ba"); break;
1090-
CASE_TEST(strlcpy_4); EXPECT_STRBUFEQ(1, strlcpy(buf, "bar", 4), buf, 3, "bar"); break;
1091-
#endif
1136+
CASE_TEST(strlcat_0); EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 0), buf, 3, "test"); break;
1137+
CASE_TEST(strlcat_1); EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 1), buf, 4, "test"); break;
1138+
CASE_TEST(strlcat_5); EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 5), buf, 7, "test"); break;
1139+
CASE_TEST(strlcat_6); EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 6), buf, 7, "testb"); break;
1140+
CASE_TEST(strlcat_7); EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 7), buf, 7, "testba"); break;
1141+
CASE_TEST(strlcat_8); EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 8), buf, 7, "testbar"); break;
1142+
CASE_TEST(strlcpy_0); EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 0), buf, 3, "test"); break;
1143+
CASE_TEST(strlcpy_1); EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 1), buf, 3, ""); break;
1144+
CASE_TEST(strlcpy_2); EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 2), buf, 3, "b"); break;
1145+
CASE_TEST(strlcpy_3); EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 3), buf, 3, "ba"); break;
1146+
CASE_TEST(strlcpy_4); EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 4), buf, 3, "bar"); break;
10921147
CASE_TEST(memcmp_20_20); EXPECT_EQ(1, memcmp("aaa\x20", "aaa\x20", 4), 0); break;
10931148
CASE_TEST(memcmp_20_60); EXPECT_LT(1, memcmp("aaa\x20", "aaa\x60", 4), 0); break;
10941149
CASE_TEST(memcmp_60_20); EXPECT_GT(1, memcmp("aaa\x60", "aaa\x20", 4), 0); break;
@@ -1139,6 +1194,26 @@ int run_stdlib(int min, int max)
11391194
CASE_TEST(limit_ptrdiff_min); EXPECT_EQ(1, PTRDIFF_MIN, sizeof(long) == 8 ? (ptrdiff_t) 0x8000000000000000LL : (ptrdiff_t) 0x80000000); break;
11401195
CASE_TEST(limit_ptrdiff_max); EXPECT_EQ(1, PTRDIFF_MAX, sizeof(long) == 8 ? (ptrdiff_t) 0x7fffffffffffffffLL : (ptrdiff_t) 0x7fffffff); break;
11411196
CASE_TEST(limit_size_max); EXPECT_EQ(1, SIZE_MAX, sizeof(long) == 8 ? (size_t) 0xffffffffffffffffULL : (size_t) 0xffffffffU); break;
1197+
CASE_TEST(strtol_simple); EXPECT_STRTOX(1, strtol, "35", 10, 35, -1, 0); break;
1198+
CASE_TEST(strtol_positive); EXPECT_STRTOX(1, strtol, "+35", 10, 35, -1, 0); break;
1199+
CASE_TEST(strtol_negative); EXPECT_STRTOX(1, strtol, "-35", 10, -35, -1, 0); break;
1200+
CASE_TEST(strtol_hex_auto); EXPECT_STRTOX(1, strtol, "0xFF", 0, 255, -1, 0); break;
1201+
CASE_TEST(strtol_base36); EXPECT_STRTOX(1, strtol, "12yZ", 36, 50507, -1, 0); break;
1202+
CASE_TEST(strtol_cutoff); EXPECT_STRTOX(1, strtol, "1234567890", 8, 342391, 7, 0); break;
1203+
CASE_TEST(strtol_octal_auto); EXPECT_STRTOX(1, strtol, "011", 0, 9, -1, 0); break;
1204+
CASE_TEST(strtol_hex_00); EXPECT_STRTOX(1, strtol, "0x00", 16, 0, -1, 0); break;
1205+
CASE_TEST(strtol_hex_FF); EXPECT_STRTOX(1, strtol, "FF", 16, 255, -1, 0); break;
1206+
CASE_TEST(strtol_hex_ff); EXPECT_STRTOX(1, strtol, "ff", 16, 255, -1, 0); break;
1207+
CASE_TEST(strtol_hex_prefix); EXPECT_STRTOX(1, strtol, "0xFF", 16, 255, -1, 0); break;
1208+
CASE_TEST(strtol_trailer); EXPECT_STRTOX(1, strtol, "35foo", 10, 35, 2, 0); break;
1209+
CASE_TEST(strtol_overflow); EXPECT_STRTOX(1, strtol, "0x8000000000000000", 16, LONG_MAX, -1, ERANGE); break;
1210+
CASE_TEST(strtol_underflow); EXPECT_STRTOX(1, strtol, "-0x8000000000000001", 16, LONG_MIN, -1, ERANGE); break;
1211+
CASE_TEST(strtoul_negative); EXPECT_STRTOX(1, strtoul, "-0x1", 16, ULONG_MAX, 4, 0); break;
1212+
CASE_TEST(strtoul_overflow); EXPECT_STRTOX(1, strtoul, "0x10000000000000000", 16, ULONG_MAX, -1, ERANGE); break;
1213+
CASE_TEST(strerror_success); EXPECT_STREQ(is_nolibc, strerror(0), "errno=0"); break;
1214+
CASE_TEST(strerror_EINVAL); EXPECT_STREQ(is_nolibc, strerror(EINVAL), "errno=22"); break;
1215+
CASE_TEST(strerror_int_max); EXPECT_STREQ(is_nolibc, strerror(INT_MAX), "errno=2147483647"); break;
1216+
CASE_TEST(strerror_int_min); EXPECT_STREQ(is_nolibc, strerror(INT_MIN), "errno=-2147483648"); break;
11421217

11431218
case __LINE__:
11441219
return ret; /* must be last */

‎tools/testing/selftests/nolibc/run-tests.sh

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,9 +15,10 @@ download_location="${cache_dir}/crosstools/"
1515
build_location="$(realpath "${cache_dir}"/nolibc-tests/)"
1616
perform_download=0
1717
test_mode=system
18+
CFLAGS_EXTRA="-Werror"
1819
archs="i386 x86_64 arm64 arm mips32le mips32be ppc ppc64 ppc64le riscv s390 loongarch"
1920

20-
TEMP=$(getopt -o 'j:d:c:b:a:m:ph' -n "$0" -- "$@")
21+
TEMP=$(getopt -o 'j:d:c:b:a:m:peh' -n "$0" -- "$@")
2122

2223
eval set -- "$TEMP"
2324
unset TEMP
@@ -40,6 +41,7 @@ Options:
4041
-a [ARCH] Host architecture of toolchains to use (default: ${hostarch})
4142
-b [DIR] Build location (default: ${build_location})
4243
-m [MODE] Test mode user/system (default: ${test_mode})
44+
-e Disable -Werror
4345
EOF
4446
}
4547

@@ -66,6 +68,9 @@ while true; do
6668
'-m')
6769
test_mode="$2"
6870
shift 2; continue ;;
71+
'-e')
72+
CFLAGS_EXTRA=""
73+
shift; continue ;;
6974
'-h')
7075
print_usage
7176
exit 0
@@ -153,7 +158,7 @@ test_arch() {
153158
exit 1
154159
esac
155160
printf '%-15s' "$arch:"
156-
swallow_output "${MAKE[@]}" "$test_target" V=1
161+
swallow_output "${MAKE[@]}" CFLAGS_EXTRA="$CFLAGS_EXTRA" "$test_target" V=1
157162
cp run.out run.out."${arch}"
158163
"${MAKE[@]}" report | grep passed
159164
}

0 commit comments

Comments
 (0)