[J-u-boot.git] / test / str_ut.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright 2020 Google LLC
 */

#include <common.h>
#include <vsprintf.h>
#include <test/suites.h>
#include <test/test.h>
#include <test/ut.h>

/* This is large enough for any of the test strings */
#define TEST_STR_SIZE	200

static const char str1[] = "I'm sorry I'm late.";
static const char str2[] = "1099abNo, don't bother apologising.";
static const char str3[] = "0xbI'm sorry you're alive.";
static const char str4[] = "1234567890123 I lost closer friends";
static const char str5[] = "0x9876543210the last time I was deloused";
static const char str6[] = "0778octal is seldom used";
static const char str7[] = "707it is a piece of computing history";

/* Declare a new str test */
#define STR_TEST(_name, _flags)		UNIT_TEST(_name, _flags, str_test)

static int str_upper(struct unit_test_state *uts)
{
	char out[TEST_STR_SIZE];

	/* Make sure it adds a terminator */
	out[strlen(str1)] = 'a';
	str_to_upper(str1, out, SIZE_MAX);
	ut_asserteq_str("I'M SORRY I'M LATE.", out);

	/* In-place operation */
	strcpy(out, str2);
	str_to_upper(out, out, SIZE_MAX);
	ut_asserteq_str("1099ABNO, DON'T BOTHER APOLOGISING.", out);

	/* Limited length */
	str_to_upper(str1, out, 7);
	ut_asserteq_str("I'M SORO, DON'T BOTHER APOLOGISING.", out);

	/* In-place with limited length */
	strcpy(out, str2);
	str_to_upper(out, out, 7);
	ut_asserteq_str("1099ABNo, don't bother apologising.", out);

	/* Copy an empty string to a buffer with space*/
	out[1] = 0x7f;
	str_to_upper("", out, SIZE_MAX);
	ut_asserteq('\0', *out);
	ut_asserteq(0x7f, out[1]);

	/* Copy an empty string to a buffer with no space*/
	out[0] = 0x7f;
	str_to_upper("", out, 0);
	ut_asserteq(0x7f, out[0]);

	return 0;
}
STR_TEST(str_upper, 0);

static int run_strtoul(struct unit_test_state *uts, const char *str, int base,
		       ulong expect_val, int expect_endp_offset, bool upper)
{
	char out[TEST_STR_SIZE];
	char *endp;
	ulong val;

	strcpy(out, str);
	if (upper)
		str_to_upper(out, out, -1);

	val = simple_strtoul(out, &endp, base);
	ut_asserteq(expect_val, val);
	ut_asserteq(expect_endp_offset, endp - out);

	return 0;
}

static int str_simple_strtoul(struct unit_test_state *uts)
{
	int upper;

	/* Check that it is case-insentive */
	for (upper = 0; upper < 2; upper++) {
		/* Base 10 and base 16 */
		ut_assertok(run_strtoul(uts, str2, 10, 1099, 4, upper));
		ut_assertok(run_strtoul(uts, str2, 16, 0x1099ab, 6, upper));
		ut_assertok(run_strtoul(uts, str3, 16, 0xb, 3, upper));
		ut_assertok(run_strtoul(uts, str3, 10, 0xb, 3, upper));

		/* Octal */
		ut_assertok(run_strtoul(uts, str6, 0, 63, 3, upper));
		ut_assertok(run_strtoul(uts, str7, 8, 0x1c7, 3, upper));

		/* Invalid string */
		ut_assertok(run_strtoul(uts, str1, 10, 0, 0, upper));

		/* Base 0 */
		ut_assertok(run_strtoul(uts, str1, 0, 0, 0, upper));
		ut_assertok(run_strtoul(uts, str2, 0, 1099, 4, upper));
		ut_assertok(run_strtoul(uts, str3, 0, 0xb, 3, upper));

		/* Base 2 */
		ut_assertok(run_strtoul(uts, str1, 2, 0, 0, upper));
		ut_assertok(run_strtoul(uts, str2, 2, 2, 2, upper));
	}

	/* Check endp being NULL */
	ut_asserteq(1099, simple_strtoul(str2, NULL, 0));

	return 0;
}
STR_TEST(str_simple_strtoul, 0);

static int run_strtoull(struct unit_test_state *uts, const char *str, int base,
			unsigned long long expect_val, int expect_endp_offset,
			bool upper)
{
	char out[TEST_STR_SIZE];
	char *endp;
	unsigned long long val;

	strcpy(out, str);
	if (upper)
		str_to_upper(out, out, -1);

	val = simple_strtoull(out, &endp, base);
	ut_asserteq(expect_val, val);
	ut_asserteq(expect_endp_offset, endp - out);

	return 0;
}

static int str_simple_strtoull(struct unit_test_state *uts)
{
	int upper;

	/* Check that it is case-insentive */
	for (upper = 0; upper < 2; upper++) {
		/* Base 10 and base 16 */
		ut_assertok(run_strtoull(uts, str2, 10, 1099, 4, upper));
		ut_assertok(run_strtoull(uts, str2, 16, 0x1099ab, 6, upper));
		ut_assertok(run_strtoull(uts, str3, 16, 0xb, 3, upper));
		ut_assertok(run_strtoull(uts, str3, 10, 0xb, 3, upper));

		/* Octal */
		ut_assertok(run_strtoull(uts, str6, 0, 63, 3, upper));
		ut_assertok(run_strtoull(uts, str7, 8, 0x1c7, 3, upper));

		/* Large values */
		ut_assertok(run_strtoull(uts, str4, 10, 1234567890123, 13,
					 upper));
		ut_assertok(run_strtoull(uts, str4, 16, 0x1234567890123, 13,
					 upper));
		ut_assertok(run_strtoull(uts, str5, 0, 0x9876543210, 12,
					 upper));

		/* Invalid string */
		ut_assertok(run_strtoull(uts, str1, 10, 0, 0, upper));

		/* Base 0 */
		ut_assertok(run_strtoull(uts, str1, 0, 0, 0, upper));
		ut_assertok(run_strtoull(uts, str2, 0, 1099, 4, upper));
		ut_assertok(run_strtoull(uts, str3, 0, 0xb, 3, upper));

		/* Base 2 */
		ut_assertok(run_strtoull(uts, str1, 2, 0, 0, upper));
		ut_assertok(run_strtoull(uts, str2, 2, 2, 2, upper));
	}

	/* Check endp being NULL */
	ut_asserteq(1099, simple_strtoull(str2, NULL, 0));

	return 0;
}
STR_TEST(str_simple_strtoull, 0);

static int str_hextoul(struct unit_test_state *uts)
{
	char *endp;

	/* Just a simple test, since we know this uses simple_strtoul() */
	ut_asserteq(0x1099ab, hextoul(str2, &endp));
	ut_asserteq(6, endp - str2);

	return 0;
}
STR_TEST(str_hextoul, 0);

static int str_dectoul(struct unit_test_state *uts)
{
	char *endp;

	/* Just a simple test, since we know this uses simple_strtoul() */
	ut_asserteq(1099, dectoul(str2, &endp));
	ut_asserteq(4, endp - str2);

	return 0;
}
STR_TEST(str_dectoul, 0);

static int str_itoa(struct unit_test_state *uts)
{
	ut_asserteq_str("123", simple_itoa(123));
	ut_asserteq_str("0", simple_itoa(0));
	ut_asserteq_str("2147483647", simple_itoa(0x7fffffff));
	ut_asserteq_str("4294967295", simple_itoa(0xffffffff));

	/* Use #ifdef here to avoid a compiler warning on 32-bit machines */
#ifdef CONFIG_PHYS_64BIT
	if (sizeof(ulong) == 8) {
		ut_asserteq_str("9223372036854775807",
				simple_itoa((1UL << 63) - 1));
		ut_asserteq_str("18446744073709551615", simple_itoa(-1));
	}
#endif /* CONFIG_PHYS_64BIT */

	return 0;
}
STR_TEST(str_itoa, 0);

static int str_xtoa(struct unit_test_state *uts)
{
	ut_asserteq_str("7f", simple_xtoa(127));
	ut_asserteq_str("00", simple_xtoa(0));
	ut_asserteq_str("7fffffff", simple_xtoa(0x7fffffff));
	ut_asserteq_str("ffffffff", simple_xtoa(0xffffffff));

	/* Use #ifdef here to avoid a compiler warning on 32-bit machines */
#ifdef CONFIG_PHYS_64BIT
	if (sizeof(ulong) == 8) {
		ut_asserteq_str("7fffffffffffffff",
				simple_xtoa((1UL << 63) - 1));
		ut_asserteq_str("ffffffffffffffff", simple_xtoa(-1));
	}
#endif /* CONFIG_PHYS_64BIT */

	return 0;
}
STR_TEST(str_xtoa, 0);

static int str_trailing(struct unit_test_state *uts)
{
	char str1[] = "abc123def";

	ut_asserteq(-1, trailing_strtol(""));
	ut_asserteq(-1, trailing_strtol("123"));
	ut_asserteq(123, trailing_strtol("abc123"));
	ut_asserteq(4, trailing_strtol("12c4"));
	ut_asserteq(-1, trailing_strtol("abd"));
	ut_asserteq(-1, trailing_strtol("abc123def"));

	ut_asserteq(-1, trailing_strtoln(str1, NULL));
	ut_asserteq(123, trailing_strtoln(str1, str1 + 6));
	ut_asserteq(-1, trailing_strtoln(str1, str1 + 9));

	return 0;
}
STR_TEST(str_trailing, 0);

int do_ut_str(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	struct unit_test *tests = UNIT_TEST_SUITE_START(str_test);
	const int n_ents = UNIT_TEST_SUITE_COUNT(str_test);

	return cmd_ut_category("str", "str_", tests, n_ents, argc, argv);
}
Commit	Line	Data
4f04d549 SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright 2020 Google LLC
	4	*/
	5
	6	#include <common.h>
	7	#include <vsprintf.h>
	8	#include <test/suites.h>
	9	#include <test/test.h>
	10	#include <test/ut.h>
	11
	12	/* This is large enough for any of the test strings */
	13	#define TEST_STR_SIZE 200
	14
	15	static const char str1[] = "I'm sorry I'm late.";
	16	static const char str2[] = "1099abNo, don't bother apologising.";
	17	static const char str3[] = "0xbI'm sorry you're alive.";
4d3177d3 SG	18	static const char str4[] = "1234567890123 I lost closer friends";
4d3177d3 SG	19	static const char str5[] = "0x9876543210the last time I was deloused";
ab833ef6 SG	20	static const char str6[] = "0778octal is seldom used";
ab833ef6 SG	21	static const char str7[] = "707it is a piece of computing history";
4f04d549 SG	22
	23	/* Declare a new str test */
	24	#define STR_TEST(_name, _flags) UNIT_TEST(_name, _flags, str_test)
	25
76fde138	26	static int str_upper(struct unit_test_state *uts)
fdc79a6b SG	27	{
	28	char out[TEST_STR_SIZE];
	29
	30	/* Make sure it adds a terminator */
	31	out[strlen(str1)] = 'a';
	32	str_to_upper(str1, out, SIZE_MAX);
	33	ut_asserteq_str("I'M SORRY I'M LATE.", out);
	34
	35	/* In-place operation */
	36	strcpy(out, str2);
	37	str_to_upper(out, out, SIZE_MAX);
	38	ut_asserteq_str("1099ABNO, DON'T BOTHER APOLOGISING.", out);
	39
	40	/* Limited length */
	41	str_to_upper(str1, out, 7);
	42	ut_asserteq_str("I'M SORO, DON'T BOTHER APOLOGISING.", out);
	43
	44	/* In-place with limited length */
	45	strcpy(out, str2);
	46	str_to_upper(out, out, 7);
	47	ut_asserteq_str("1099ABNo, don't bother apologising.", out);
	48
	49	/* Copy an empty string to a buffer with space*/
	50	out[1] = 0x7f;
	51	str_to_upper("", out, SIZE_MAX);
	52	ut_asserteq('\0', *out);
	53	ut_asserteq(0x7f, out[1]);
	54
	55	/* Copy an empty string to a buffer with no space*/
	56	out[0] = 0x7f;
	57	str_to_upper("", out, 0);
	58	ut_asserteq(0x7f, out[0]);
	59
	60	return 0;
	61	}
76fde138	62	STR_TEST(str_upper, 0);
fdc79a6b	63
4f04d549	64	static int run_strtoul(struct unit_test_state uts, const char str, int base,
fdc79a6b	65	ulong expect_val, int expect_endp_offset, bool upper)
4f04d549	66	{
fdc79a6b	67	char out[TEST_STR_SIZE];
4f04d549 SG	68	char *endp;
	69	ulong val;
	70
fdc79a6b SG	71	strcpy(out, str);
	72	if (upper)
	73	str_to_upper(out, out, -1);
	74
	75	val = simple_strtoul(out, &endp, base);
4f04d549	76	ut_asserteq(expect_val, val);
fdc79a6b	77	ut_asserteq(expect_endp_offset, endp - out);
4f04d549 SG	78
	79	return 0;
	80	}
	81
	82	static int str_simple_strtoul(struct unit_test_state *uts)
	83	{
fdc79a6b SG	84	int upper;
	85
	86	/* Check that it is case-insentive */
	87	for (upper = 0; upper < 2; upper++) {
	88	/* Base 10 and base 16 */
	89	ut_assertok(run_strtoul(uts, str2, 10, 1099, 4, upper));
	90	ut_assertok(run_strtoul(uts, str2, 16, 0x1099ab, 6, upper));
96b23440	91	ut_assertok(run_strtoul(uts, str3, 16, 0xb, 3, upper));
e6951139	92	ut_assertok(run_strtoul(uts, str3, 10, 0xb, 3, upper));
4f04d549	93
ab833ef6 SG	94	/* Octal */
	95	ut_assertok(run_strtoul(uts, str6, 0, 63, 3, upper));
	96	ut_assertok(run_strtoul(uts, str7, 8, 0x1c7, 3, upper));
	97
fdc79a6b SG	98	/* Invalid string */
fdc79a6b SG	99	ut_assertok(run_strtoul(uts, str1, 10, 0, 0, upper));
4f04d549	100
fdc79a6b SG	101	/* Base 0 */
	102	ut_assertok(run_strtoul(uts, str1, 0, 0, 0, upper));
	103	ut_assertok(run_strtoul(uts, str2, 0, 1099, 4, upper));
	104	ut_assertok(run_strtoul(uts, str3, 0, 0xb, 3, upper));
4f04d549	105
fdc79a6b SG	106	/* Base 2 */
	107	ut_assertok(run_strtoul(uts, str1, 2, 0, 0, upper));
	108	ut_assertok(run_strtoul(uts, str2, 2, 2, 2, upper));
	109	}
4f04d549 SG	110
	111	/* Check endp being NULL */
	112	ut_asserteq(1099, simple_strtoul(str2, NULL, 0));
	113
	114	return 0;
	115	}
	116	STR_TEST(str_simple_strtoul, 0);
	117
4d3177d3 SG	118	static int run_strtoull(struct unit_test_state uts, const char str, int base,
	119	unsigned long long expect_val, int expect_endp_offset,
	120	bool upper)
	121	{
	122	char out[TEST_STR_SIZE];
	123	char *endp;
	124	unsigned long long val;
	125
	126	strcpy(out, str);
	127	if (upper)
	128	str_to_upper(out, out, -1);
	129
	130	val = simple_strtoull(out, &endp, base);
	131	ut_asserteq(expect_val, val);
	132	ut_asserteq(expect_endp_offset, endp - out);
	133
	134	return 0;
	135	}
	136
	137	static int str_simple_strtoull(struct unit_test_state *uts)
	138	{
	139	int upper;
	140
	141	/* Check that it is case-insentive */
	142	for (upper = 0; upper < 2; upper++) {
	143	/* Base 10 and base 16 */
	144	ut_assertok(run_strtoull(uts, str2, 10, 1099, 4, upper));
	145	ut_assertok(run_strtoull(uts, str2, 16, 0x1099ab, 6, upper));
	146	ut_assertok(run_strtoull(uts, str3, 16, 0xb, 3, upper));
e6951139	147	ut_assertok(run_strtoull(uts, str3, 10, 0xb, 3, upper));
4d3177d3	148
ab833ef6 SG	149	/* Octal */
	150	ut_assertok(run_strtoull(uts, str6, 0, 63, 3, upper));
	151	ut_assertok(run_strtoull(uts, str7, 8, 0x1c7, 3, upper));
	152
4d3177d3 SG	153	/* Large values */
	154	ut_assertok(run_strtoull(uts, str4, 10, 1234567890123, 13,
	155	upper));
	156	ut_assertok(run_strtoull(uts, str4, 16, 0x1234567890123, 13,
	157	upper));
	158	ut_assertok(run_strtoull(uts, str5, 0, 0x9876543210, 12,
	159	upper));
	160
	161	/* Invalid string */
	162	ut_assertok(run_strtoull(uts, str1, 10, 0, 0, upper));
	163
	164	/* Base 0 */
	165	ut_assertok(run_strtoull(uts, str1, 0, 0, 0, upper));
	166	ut_assertok(run_strtoull(uts, str2, 0, 1099, 4, upper));
	167	ut_assertok(run_strtoull(uts, str3, 0, 0xb, 3, upper));
	168
	169	/* Base 2 */
	170	ut_assertok(run_strtoull(uts, str1, 2, 0, 0, upper));
	171	ut_assertok(run_strtoull(uts, str2, 2, 2, 2, upper));
	172	}
	173
	174	/* Check endp being NULL */
	175	ut_asserteq(1099, simple_strtoull(str2, NULL, 0));
	176
	177	return 0;
	178	}
	179	STR_TEST(str_simple_strtoull, 0);
	180
7e5f460e SG	181	static int str_hextoul(struct unit_test_state *uts)
	182	{
	183	char *endp;
	184
	185	/* Just a simple test, since we know this uses simple_strtoul() */
	186	ut_asserteq(0x1099ab, hextoul(str2, &endp));
	187	ut_asserteq(6, endp - str2);
	188
	189	return 0;
	190	}
	191	STR_TEST(str_hextoul, 0);
	192
0b1284eb SG	193	static int str_dectoul(struct unit_test_state *uts)
	194	{
	195	char *endp;
	196
	197	/* Just a simple test, since we know this uses simple_strtoul() */
	198	ut_asserteq(1099, dectoul(str2, &endp));
	199	ut_asserteq(4, endp - str2);
	200
	201	return 0;
	202	}
	203	STR_TEST(str_dectoul, 0);
	204
2fa4756d SG	205	static int str_itoa(struct unit_test_state *uts)
	206	{
	207	ut_asserteq_str("123", simple_itoa(123));
	208	ut_asserteq_str("0", simple_itoa(0));
	209	ut_asserteq_str("2147483647", simple_itoa(0x7fffffff));
	210	ut_asserteq_str("4294967295", simple_itoa(0xffffffff));
	211
	212	/* Use #ifdef here to avoid a compiler warning on 32-bit machines */
	213	#ifdef CONFIG_PHYS_64BIT
	214	if (sizeof(ulong) == 8) {
	215	ut_asserteq_str("9223372036854775807",
	216	simple_itoa((1UL << 63) - 1));
	217	ut_asserteq_str("18446744073709551615", simple_itoa(-1));
	218	}
	219	#endif /* CONFIG_PHYS_64BIT */
	220
	221	return 0;
	222	}
	223	STR_TEST(str_itoa, 0);
	224
	225	static int str_xtoa(struct unit_test_state *uts)
	226	{
	227	ut_asserteq_str("7f", simple_xtoa(127));
	228	ut_asserteq_str("00", simple_xtoa(0));
	229	ut_asserteq_str("7fffffff", simple_xtoa(0x7fffffff));
	230	ut_asserteq_str("ffffffff", simple_xtoa(0xffffffff));
	231
	232	/* Use #ifdef here to avoid a compiler warning on 32-bit machines */
	233	#ifdef CONFIG_PHYS_64BIT
	234	if (sizeof(ulong) == 8) {
	235	ut_asserteq_str("7fffffffffffffff",
	236	simple_xtoa((1UL << 63) - 1));
	237	ut_asserteq_str("ffffffffffffffff", simple_xtoa(-1));
	238	}
	239	#endif /* CONFIG_PHYS_64BIT */
	240
	241	return 0;
	242	}
	243	STR_TEST(str_xtoa, 0);
	244
18436c74 SG	245	static int str_trailing(struct unit_test_state *uts)
	246	{
	247	char str1[] = "abc123def";
	248
	249	ut_asserteq(-1, trailing_strtol(""));
	250	ut_asserteq(-1, trailing_strtol("123"));
	251	ut_asserteq(123, trailing_strtol("abc123"));
	252	ut_asserteq(4, trailing_strtol("12c4"));
	253	ut_asserteq(-1, trailing_strtol("abd"));
	254	ut_asserteq(-1, trailing_strtol("abc123def"));
	255
	256	ut_asserteq(-1, trailing_strtoln(str1, NULL));
	257	ut_asserteq(123, trailing_strtoln(str1, str1 + 6));
	258	ut_asserteq(-1, trailing_strtoln(str1, str1 + 9));
	259
	260	return 0;
	261	}
	262	STR_TEST(str_trailing, 0);
	263
09140113	264	int do_ut_str(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
4f04d549	265	{
a7a98755 SG	266	struct unit_test *tests = UNIT_TEST_SUITE_START(str_test);
a7a98755 SG	267	const int n_ents = UNIT_TEST_SUITE_COUNT(str_test);
4f04d549 SG	268
	269	return cmd_ut_category("str", "str_", tests, n_ents, argc, argv);
	270	}