zephyr/tests/lib/c_lib/src/main.c

/*
 * 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);
}