blob: b5ac88725d655e8faaf95eef760dee553c3e9454 [file] [log] [blame]
/*
* Copyright (c) 2017 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
/*
* @file test access to the minimal C libraries
*
* This module verifies that the various minimal C libraries can be used.
*
* IMPORTANT: The module only ensures that each supported library is present,
* and that a bare minimum of its functionality is operating correctly. It does
* NOT guarantee that ALL standards-defined functionality is present, nor does
* it guarantee that ALL functionality provided is working correctly.
*/
#include <zephyr.h>
#include <sys/__assert.h>
#include <ztest.h>
#include <limits.h>
#include <sys/types.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <time.h>
#include <ztest_error_hook.h>
#define STACK_SIZE (512 + CONFIG_TEST_EXTRA_STACKSIZE)
#define LIST_LEN 2
static K_THREAD_STACK_DEFINE(tstack, STACK_SIZE);
static struct k_thread tdata;
/* Recent GCC's are issuing a warning for the truncated strncpy()
* below (the static source string is longer than the locally-defined
* destination array). That's exactly the case we're testing, so turn
* it off.
*/
#if defined(__GNUC__) && __GNUC__ >= 8
#pragma GCC diagnostic ignored "-Wstringop-truncation"
#endif
/*
* variables used during limits library testing; must be marked as "volatile"
* to prevent compiler from computing results at compile time
*/
volatile long long_max = LONG_MAX;
volatile long long_one = 1L;
/**
*
* @brief Test implementation-defined constants library
* @defgroup libc_api
* @ingroup all_tests
* @{
*
*/
void test_limits(void)
{
zassert_true((long_max + long_one == LONG_MIN), NULL);
}
static ssize_t foobar(void)
{
return -1;
}
void test_ssize_t(void)
{
zassert_true(foobar() < 0, NULL);
}
/**
*
* @brief Test boolean types and values library
*
*/
void test_stdbool(void)
{
zassert_true((true == 1), "true value");
zassert_true((false == 0), "false value");
}
/*
* variables used during stddef library testing; must be marked as "volatile"
* to prevent compiler from computing results at compile time
*/
volatile long long_variable;
volatile size_t size_of_long_variable = sizeof(long_variable);
/**
*
* @brief Test standard type definitions library
*
*/
void test_stddef(void)
{
#ifdef CONFIG_64BIT
zassert_true((size_of_long_variable == 8), "sizeof");
#else
zassert_true((size_of_long_variable == 4), "sizeof");
#endif
}
/*
* variables used during stdint library testing; must be marked as "volatile"
* to prevent compiler from computing results at compile time
*/
volatile uint8_t unsigned_byte = 0xff;
volatile uint32_t unsigned_int = 0xffffff00;
/**
*
* @brief Test integer types library
*
*/
void test_stdint(void)
{
zassert_true((unsigned_int + unsigned_byte + 1u == 0U), NULL);
#if (UINT8_C(1) == 1) \
&& (INT8_C(-1) == -1) \
&& (UINT16_C(2) == 2) \
&& (INT16_C(-2) == -2) \
&& (UINT32_C(4) == 4) \
&& (INT32_C(-4) == -4) \
&& (UINT64_C(8) == 8) \
&& (INT64_C(-8) == -8) \
&& (UINTMAX_C(11) == 11) \
&& (INTMAX_C(-11) == -11)
zassert_true(true, NULL);
#else
zassert_true(false, "const int expr values ...");
#endif
}
/*
* variables used during string library testing
*/
#define BUFSIZE 10
char buffer[BUFSIZE];
/**
*
* @brief Test string memset
*
*/
void test_memset(void)
{
int i, ret;
const char set = 'a';
int size = 0;
memset(buffer, 0, 10);
for (i = 0; i < 10; i++) {
memset(buffer + i, set, size);
memset(buffer + i, set, 1);
ret = memcmp(buffer + i, &set, 1);
zassert_true((ret == 0), "memset buffer a failed");
}
}
/**
*
* @brief Test string length function
*
*/
void test_strlen(void)
{
(void)memset(buffer, '\0', BUFSIZE);
(void)memset(buffer, 'b', 5); /* 5 is BUFSIZE / 2 */
zassert_equal(strlen(buffer), 5, "strlen failed");
zassert_equal(strnlen(buffer, 6), 5, "strnlen failed");
zassert_equal(strnlen(buffer, 4), 4, "strnlen failed");
}
/**
*
* @brief Test string compare function
*
* @see strcmp(), strncasecmp().
*
*/
void test_strcmp(void)
{
strcpy(buffer, "eeeee");
char test = 0;
zassert_true((strcmp(buffer, "fffff") < 0), "strcmp less ...");
zassert_true((strcmp(buffer, "eeeee") == 0), "strcmp equal ...");
zassert_true((strcmp(buffer, "ddddd") > 0), "strcmp greater ...");
zassert_true((strncasecmp(buffer, "ddddd", 3) > 0), "strncasecmp failed");
zassert_true((strncasecmp(buffer, "eeeee", 3) == 0), "strncasecmp failed");
zassert_true((strncasecmp(&test, &test, 1) == 0), "strncasecmp failed");
}
/**
*
* @brief Test string N compare function
*
*/
void test_strncmp(void)
{
int ret;
static const char pattern[] = "eeeeeeeeeeee";
/* Note we don't want to count the final \0 that sizeof will */
__ASSERT_NO_MSG(sizeof(pattern) - 1 > BUFSIZE);
memcpy(buffer, pattern, BUFSIZE);
ret = strncmp(buffer, "fffff", 0);
zassert_true((ret == 0), "strncmp zero characters failed");
ret = strncmp(buffer, "effff", 0);
zassert_true((ret == 0), "strncmp zero character failed");
ret = strncmp("", "", 0);
zassert_true((ret == 0), "strncmp zero character failed");
ret = strncmp("", "", 3);
zassert_true((ret == 0), "strncmp zero character failed");
ret = strncmp(buffer, "eeeff", 4);
zassert_true((ret != 0), "strncmp four characters failed");
ret = strncmp(buffer, "ff", BUFSIZE);
zassert_true((ret != 0), "strncmp ten characters failed");
ret = strncmp(buffer, "eee", 4);
zassert_true((ret != 0), "strncmp four characters failed");
}
/**
*
* @brief Test string copy function
*
*/
void test_strcpy(void)
{
(void)memset(buffer, '\0', BUFSIZE);
strcpy(buffer, "10 chars!\0");
zassert_true((strcmp(buffer, "10 chars!\0") == 0), "strcpy");
}
/**
*
* @brief Test string N copy function
*
*/
void test_strncpy(void)
{
int ret;
(void)memset(buffer, '\0', BUFSIZE);
strncpy(buffer, "This is over 10 characters", BUFSIZE);
/* Purposely different values */
ret = strncmp(buffer, "This is over 20 characters", BUFSIZE);
zassert_true((ret == 0), "strncpy");
}
/**
*
* @brief Test string scanning function
*
*/
void test_strchr(void)
{
char *rs = NULL;
int ret;
(void)memset(buffer, '\0', BUFSIZE);
strncpy(buffer, "Copy 10", BUFSIZE);
rs = strchr(buffer, '1');
zassert_not_null(rs, "strchr");
ret = strncmp(rs, "10", 2);
zassert_true((ret == 0), "strchr");
}
/**
*
* @brief Test string prefix match functions
*
*/
void test_strxspn(void)
{
const char *empty = "";
const char *cset = "abc";
zassert_true(strspn("", empty) == 0U, "strspn empty empty");
zassert_true(strcspn("", empty) == 0U, "strcspn empty empty");
zassert_true(strspn("abde", cset) == 2U, "strspn match");
zassert_true(strcspn("abde", cset) == 0U, "strcspn nomatch");
zassert_true(strspn("da", cset) == 0U, "strspn nomatch");
zassert_true(strcspn("da", cset) == 1U, "strcspn match");
zassert_true(strspn("abac", cset) == 4U, "strspn all");
zassert_true(strcspn("defg", cset) == 4U, "strcspn all");
}
/**
*
* @brief Test memory comparison function
*
*/
void test_memcmp(void)
{
int ret;
unsigned char m1[] = "abcdef";
unsigned char m2[] = "abcdhj";
ret = memcmp(m1, m2, 4);
zassert_true((ret == 0), "memcmp four characters failed");
ret = memcmp(m1, m2, 5);
zassert_true((ret != 0), "memcmp five characters failed");
ret = memcmp(m1, m2, 0);
zassert_true((ret == 0), "memcmp zero character failed");
ret = memcmp(m1, m2, 6);
zassert_true((ret != 0), "memcmp six characters failed");
}
/**
*
* @brief Test binary search function
*
*/
int cmp_func(const void *a, const void *b)
{
return (*(int *)a - *(int *)b);
}
void test_bsearch(void)
{
void *result = NULL;
int arr[5] = { 2, 5, 20, 50, 60 };
size_t size = ARRAY_SIZE(arr);
int key = 30;
result = (int *)bsearch(&key, arr, size, sizeof(int), cmp_func);
zassert_is_null(result, "bsearch -key not found");
key = 60;
result = (int *)bsearch(&key, arr, size, sizeof(int), cmp_func);
zassert_not_null(result, "bsearch -key found");
}
/**
*
* @brief Test abs function
*
*/
void test_abs(void)
{
int val = -5, value = 5;
zassert_equal(abs(val), 5, "abs -5");
zassert_equal(abs(value), 5, "abs 5");
}
/**
*
* @brief Test atoi function
*
*/
void test_atoi(void)
{
zassert_equal(atoi("123"), 123, "atoi error");
zassert_equal(atoi("2c5"), 2, "atoi error");
zassert_equal(atoi("acd"), 0, "atoi error");
zassert_equal(atoi(" "), 0, "atoi error");
zassert_equal(atoi(""), 0, "atoi error");
zassert_equal(atoi("3-4e"), 3, "atoi error");
zassert_equal(atoi("8+1c"), 8, "atoi error");
zassert_equal(atoi("+3"), 3, "atoi error");
zassert_equal(atoi("-1"), -1, "atoi error");
}
/**
*
* @brief Test value type
*
* @details This function check the char type,
* and verify the return value.
*
* @see isalnum(), isalpha(), isdigit(), isgraph(),
* isprint(), isspace(), isupper(), isxdigit().
*
*/
void test_checktype(void)
{
static const char exp_alnum[] =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static const char exp_alpha[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static const char exp_digit[] = "0123456789";
static const char exp_graph[] =
"!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
static const char exp_print[] =
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
static const char exp_space[] = {"\x9\xa\xb\xc\xd\x20"};
static const char exp_upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static const char exp_xdigit[] = "0123456789ABCDEFabcdef";
char buf[128];
char *ptr = buf;
for (int i = 0; i < 128; i++) {
if (isalnum(i))
*ptr++ = i;
}
*ptr = '\0';
zassert_equal(strcmp(buf, exp_alnum), 0, "isalnum error");
ptr = buf;
for (int i = 0; i < 128; i++) {
if (isalpha(i))
*ptr++ = i;
}
*ptr = '\0';
zassert_equal(strcmp(buf, exp_alpha), 0, "isalpha error");
ptr = buf;
for (int i = 0; i < 128; i++) {
if (isdigit(i))
*ptr++ = i;
}
*ptr = '\0';
zassert_equal(strcmp(buf, exp_digit), 0, "isdigit error");
ptr = buf;
for (int i = 0; i < 128; i++) {
if (isgraph(i))
*ptr++ = i;
}
*ptr = '\0';
zassert_equal(strcmp(buf, exp_graph), 0, "isgraph error");
ptr = buf;
for (int i = 0; i < 128; i++) {
if (isprint(i))
*ptr++ = i;
}
*ptr = '\0';
zassert_equal(strcmp(buf, exp_print), 0, "isprint error");
ptr = buf;
for (int i = 0; i < 128; i++) {
if (isupper(i))
*ptr++ = i;
}
*ptr = '\0';
zassert_equal(strcmp(buf, exp_upper), 0, "isupper error");
ptr = buf;
for (int i = 0; i < 128; i++) {
if (isspace(i))
*ptr++ = i;
}
*ptr = '\0';
zassert_equal(strcmp(buf, exp_space), 0, "isspace error");
ptr = buf;
for (int i = 0; i < 128; i++) {
if (isxdigit(i))
*ptr++ = i;
}
*ptr = '\0';
zassert_equal(strcmp(buf, exp_xdigit), 0, "isxdigit error");
}
/**
*
* @brief Test character operation
*
* @see memchr(), memcpy(), memmove().
*
*/
void test_memstr(void)
{
int i, j, ret;
static const char str[] = "testfunction";
char arr[100], move_arr[] = "12123";
static const char num[] = "1234567891234567891234";
zassert_is_null(memchr(str, 'a', 0), "memchr 0 error");
zassert_not_null(memchr(str, 'e', 10), "memchr serach e");
zassert_is_null(memchr(str, 'e', 1), "memchr e error");
for (i = 0; i < 20; i++) {
for (j = 0; j < 20; j++) {
memcpy(&arr[i], num, 0);
ret = memcmp(&num[j], &arr[i], 0);
zassert_true((ret == 0), "memcpy failed");
memcpy(&arr[i], &num[j], 1);
ret = memcmp(&num[j], &arr[i], 1);
zassert_true((ret == 0), "memcpy failed");
}
}
memmove(move_arr + 2, move_arr, 3);
memmove(move_arr, num, 3);
ret = memcmp(move_arr, num, 3);
zassert_true((ret == 0), "memmove failed");
}
/**
*
* @brief test str operate functions
*
* @see strcat(), strcspn(), strncat().
*
*/
void test_str_operate(void)
{
char str1[10] = "aabbcc", ncat[10] = "ddee";
char *str2 = "b";
char *str3 = "d";
int ret;
char *ptr;
zassert_not_null(strcat(str1, str3), "strcat false");
zassert_equal(strcmp(str1, "aabbccd"), 0, "test strcat failed");
ret = strcspn(str1, str2);
zassert_equal(ret, 2, "strcspn failed");
ret = strcspn(str1, str3);
zassert_equal(ret, 6, "strcspn not found str");
zassert_true(strncat(ncat, str1, 2), "strncat failed");
zassert_not_null(strncat(str1, str3, 2), "strncat failed");
zassert_not_null(strncat(str1, str3, 1), "strncat failed");
zassert_equal(strcmp(ncat, "ddeeaa"), 0, "strncat failed");
zassert_is_null(strrchr(ncat, 'z'),
"strrchr not found this word. failed");
ptr = strrchr(ncat, 'e');
zassert_equal(strcmp(ptr, "eaa"), 0, "strrchr failed");
zassert_is_null(strstr(str1, "ayz"), "strstr aabbccd with ayz failed");
zassert_not_null(strstr(str1, str2), "strstr aabbccd with b succeed");
zassert_not_null(strstr(str1, "bb"), "strstr aabbccd with bb succeed");
zassert_not_null(strstr(str1, ""), "strstr aabbccd with \0 failed");
}
/**
*
* @brief test strtol function
*
*/
void test_strtoxl(void)
{
char buf1[] = "+10379aegi";
char buf2[] = " -10379aegi";
char buf3[] = "-010379aegi";
char buf4[] = "0x10379aegi";
char buf5[] = "0X10379aegi";
char buf6[] = "01037aegi";
char buf7[] = "1037aegi";
char buf8[] = "++1037aegi";
char buf9[] = "A1037aegi";
char buf10[] = "a1037aegi";
char buf11[] = "9223372036854775819";
char buf17[] = "-92233720368547758199";
char *stop;
char **stop1 = NULL;
long ret;
unsigned long retul;
ret = strtol(buf3, &stop, 8);
zassert_equal(ret, -543, "strtol base = 8 failed");
ret = strtol(buf1, &stop, 10);
zassert_equal(ret, 10379, "strtol base = 10 failed");
ret = strtol(buf2, &stop, 10);
zassert_equal(ret, -10379, "strtol base = 10 failed");
ret = strtol(buf4, &stop, 16);
zassert_equal(ret, 17004974, "strtol base = 16 failed");
ret = strtol(buf4, &stop, 0);
zassert_equal(ret, 17004974, "strtol base = 16 failed");
ret = strtol(buf5, &stop, 0);
zassert_equal(ret, 17004974, "strtol base = 16 failed");
ret = strtol(buf6, &stop, 0);
zassert_equal(ret, 543, "strtol base = 8 failed");
ret = strtol(buf7, &stop, 0);
zassert_equal(ret, 1037, "strtol base = 10 failed");
ret = strtol(buf8, &stop, 10);
zassert_not_equal(ret, 1037, "strtol base = 10 failed");
ret = strtol(buf9, &stop, 10);
zassert_not_equal(ret, 1037, "strtol base = 10 failed");
ret = strtol(buf10, &stop, 10);
zassert_not_equal(ret, 1037, "strtol base = 10 failed");
ret = strtol(buf11, stop1, 10);
zassert_equal(ret, LONG_MAX, "strtol base = 10 failed");
ret = strtol(buf17, stop1, 10);
zassert_equal(ret, LONG_MIN, "strtol base = 10 failed");
retul = strtoul(buf3, &stop, 8);
zassert_equal(retul, -543, "strtoul base = 8 failed");
retul = strtoul(buf1, &stop, 10);
zassert_equal(retul, 10379, "strtoul base = 10 failed");
retul = strtoul(buf2, &stop, 10);
zassert_equal(retul, -10379, "strtol base = 10 failed");
retul = strtoul(buf1, &stop, 10);
zassert_equal(retul, 10379, "strtoul base = 10 failed");
retul = strtoul(buf4, &stop, 16);
zassert_equal(retul, 17004974, "strtoul base = 16 failed");
retul = strtoul(buf4, &stop, 0);
zassert_equal(retul, 17004974, "strtoul base = 16 failed");
retul = strtoul(buf5, &stop, 0);
zassert_equal(retul, 17004974, "strtoul base = 16 failed");
retul = strtoul(buf6, &stop, 0);
zassert_equal(retul, 543, "strtoul base = 8 failed");
retul = strtoul(buf7, &stop, 0);
zassert_equal(retul, 1037, "strtoul base = 10 failed");
retul = strtoul(buf8, &stop, 10);
zassert_not_equal(retul, 1037, "strtoul base = 10 failed");
retul = strtoul(buf9, &stop, 10);
zassert_not_equal(retul, 1037, "strtoul base = 10 failed");
retul = strtoul(buf10, &stop, 10);
zassert_not_equal(retul, 1037, "strtoul base = 10 failed");
retul = strtoul(buf17, stop1, 10);
zassert_not_equal(retul, 4294967299, "strtoul base = 10 failed");
#if LONG_MAX > 2147483647
char buf12[] = "-9223372036854775809";
char buf13[] = "9223372036854775800";
char buf14[] = "18446744073709551719";
char buf15[] = "-184467440737095516190";
char buf16[] = "18446744073709551610";
ret = strtol(buf12, &stop, 10);
zassert_not_equal((ret + LONG_MAX), 0, "strtol base = 10 failed");
ret = strtol(buf13, &stop, 10);
zassert_equal((ret - 9223372036854775800), 0, "strtol base = 10 failed");
retul = strtoul(buf14, &stop, 10);
zassert_not_equal((retul + LONG_MAX), 0, "strtoul base = 10 failed");
retul = strtoul(buf15, &stop, 10);
zassert_not_equal((retul + LONG_MAX), 0, "strtoul base = 10 failed");
retul = strtoul(buf16, &stop, 10);
zassert_not_equal((retul - 1844674407370955161), 0, "strtoul base = 10 failed");
#else
char buf12[] = "-2147483649";
char buf13[] = "2147483640";
char buf14[] = "4294967299";
char buf15[] = "-42949673990";
char buf16[] = "4294967290";
ret = strtol(buf12, &stop, 10);
zassert_not_equal(ret, -2147483649, "strtol base = 10 failed");
ret = strtol(buf13, &stop, 10);
zassert_equal(ret, 2147483640, "strtol base = 10 failed");
retul = strtoul(buf14, stop1, 10);
zassert_not_equal(retul, 4294967299, "strtoul base = 10 failed");
retul = strtoul(buf15, &stop, 10);
zassert_not_equal(retul, -42949673990, "strtoul base = 10 failed");
retul = strtoul(buf16, &stop, 10);
zassert_equal(retul, 4294967290, "strtoul base = 10 failed");
#endif
}
/**
*
* @brief test convert function
*
*/
void test_tolower_toupper(void)
{
static const char test[] = "Az09Za{#!";
static const char toup[] = "AZ09ZA{#!";
static const char tolw[] = "az09za{#!";
char up[11];
char lw[11];
int i = 0;
for (; i < strlen(test); i++) {
up[i] = toupper(test[i]);
lw[i] = tolower(test[i]);
}
lw[i] = up[i] = '\0';
zassert_equal(strcmp(up, toup), 0, "toupper error");
zassert_equal(strcmp(lw, tolw), 0, "tolower error");
}
void test_strtok_r_do(char *str, char *sep, int tlen,
const char * const *toks, bool expect)
{
int len = 0;
char *state, *tok, buf[64+1] = {0};
strncpy(buf, str, 64);
tok = strtok_r(buf, sep, &state);
while (tok && len < tlen) {
if (strcmp(tok, toks[len]) != 0) {
break;
}
tok = strtok_r(NULL, sep, &state);
len++;
}
if (expect) {
zassert_equal(len, tlen,
"strtok_r error '%s' / '%s'", str, sep);
} else {
zassert_not_equal(len, tlen,
"strtok_r error '%s' / '%s'", str, sep);
}
}
void test_strtok_r(void)
{
static const char * const tc01[] = { "1", "2", "3", "4", "5" };
test_strtok_r_do("1,2,3,4,5", ",", 5, tc01, true);
test_strtok_r_do(",, 1 ,2 ,3 4,5 ", ", ", 5, tc01, true);
test_strtok_r_do("1,,,2 3,,,4 5", ", ", 5, tc01, true);
test_strtok_r_do("1,2 3,,,4 5 ", ", ", 5, tc01, true);
test_strtok_r_do("0,1,,,2 3,,,4 5", ", ", 5, tc01, false);
test_strtok_r_do("1,,,2 3,,,4 5", ",", 5, tc01, false);
test_strtok_r_do("A,,,2,3,,,4 5", ",", 5, tc01, false);
test_strtok_r_do("1,,,2,3,,,", ",", 5, tc01, false);
test_strtok_r_do("1|2|3,4|5", "| ", 5, tc01, false);
}
/**
*
* @brief Test time function
*
*/
void test_time(void)
{
time_t tests1 = 0;
time_t tests2 = -5;
time_t tests3 = -214748364800;
time_t tests4 = 951868800;
struct tm tp;
zassert_not_null(gmtime(&tests1), "gmtime failed");
zassert_not_null(gmtime(&tests2), "gmtime failed");
tp.tm_wday = -5;
zassert_not_null(gmtime_r(&tests3, &tp), "gmtime_r failed");
zassert_not_null(gmtime_r(&tests4, &tp), "gmtime_r failed");
}
/**
*
* @brief test abort functions
*
*/
void test_abort(void)
{
int a = 0;
ztest_set_fault_valid(true);
abort();
zassert_equal(a, 0, "abort failed");
}
/**
*
* @brief test _exit functions
*
*/
static void exit_program(void *p1, void *p2, void *p3)
{
_exit(1);
}
void test_exit(void)
{
int a = 0;
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, exit_program,
NULL, NULL, NULL, K_PRIO_PREEMPT(0), 0, K_NO_WAIT);
k_sleep(K_MSEC(10));
k_thread_abort(tid);
zassert_equal(a, 0, "exit failed");
}
/**
* @}
*/
void test_main(void)
{
ztest_test_suite(test_c_lib,
ztest_unit_test(test_limits),
ztest_unit_test(test_ssize_t),
ztest_unit_test(test_stdbool),
ztest_unit_test(test_stddef),
ztest_unit_test(test_stdint),
ztest_unit_test(test_memcmp),
ztest_unit_test(test_strchr),
ztest_unit_test(test_strcpy),
ztest_unit_test(test_strncpy),
ztest_unit_test(test_memset),
ztest_unit_test(test_strlen),
ztest_unit_test(test_strcmp),
ztest_unit_test(test_strxspn),
ztest_unit_test(test_bsearch),
ztest_unit_test(test_abs),
ztest_unit_test(test_atoi),
ztest_unit_test(test_strncmp),
ztest_unit_test(test_strtoxl),
ztest_unit_test(test_checktype),
ztest_unit_test(test_memstr),
ztest_unit_test(test_time),
ztest_unit_test(test_abort),
ztest_unit_test(test_exit),
ztest_unit_test(test_str_operate),
ztest_unit_test(test_tolower_toupper),
ztest_unit_test(test_strtok_r)
);
ztest_run_test_suite(test_c_lib);
}