1  /* SPDX-License-Identifier: GPL-2.0-only */
  2  
  3  #include <commonlib/bsd/string.h>
  4  #include <stddef.h>
  5  #include <string.h>
  6  #include <tests/test.h>
  7  
  8  static void test_strlen(void **state)
  9  {
 10  	const char *str;
 11  
 12  	str = "coreboot";
 13  	assert_int_equal(__builtin_strlen(str), strlen(str));
 14  
 15  	str = "is\0very";
 16  	assert_int_equal(__builtin_strlen(str), strlen(str));
 17  
 18  	str = "nice\n";
 19  	assert_int_equal(__builtin_strlen(str), strlen(str));
 20  
 21  	assert_int_equal(0, strlen(""));
 22  }
 23  
 24  static void test_strnlen(void **state)
 25  {
 26  	/* maxlen is SIZE_MAX */
 27  	assert_int_equal(8, strnlen("coreboot", SIZE_MAX));
 28  
 29  	/* maxlen larger than string len */
 30  	assert_int_equal(8, strnlen("coreboot", 100));
 31  
 32  	/* maxlen equal to string len */
 33  	assert_int_equal(8, strnlen("coreboot", 8));
 34  
 35  	/* maxlen smaller than string len */
 36  	assert_int_equal(5, strnlen("coreboot", 5));
 37  
 38  	/* maxlen is 0 */
 39  	assert_int_equal(0, strnlen("coreboot", 0));
 40  
 41  	/* Empty string */
 42  	assert_int_equal(0, strnlen("", 3));
 43  }
 44  
 45  static void test_strcat(void **state)
 46  {
 47  	static const char str[] = "Hello ";
 48  	size_t len = __builtin_strlen(str);
 49  	static const char src[] = "World";
 50  	static const char expected[] = "Hello World";
 51  	size_t expected_len = __builtin_strlen(expected);
 52  	char dst[100];
 53  	char *ret;
 54  
 55  	/* Empty src & dst */
 56  	dst[0] = '\0';
 57  	memset(dst + 1, 0xee, sizeof(dst) - 1);
 58  	ret = strcat(dst, "");
 59  	assert_ptr_equal(dst, ret);
 60  	assert_int_equal('\0', dst[0]);
 61  
 62  	/* Empty src */
 63  	memcpy(dst, str, len + 1);
 64  	memset(dst + len + 1, 0xee, sizeof(dst) - len - 1);
 65  	ret = strcat(dst, "");
 66  	assert_memory_equal(str, dst, len + 1);
 67  
 68  	/* Empty dst */
 69  	memset(dst, 0x0, sizeof(dst));
 70  	memset(dst + 1, 0xee, sizeof(dst) - 1);
 71  	ret = strcat(dst, src);
 72  	assert_ptr_equal(dst, ret);
 73  	assert_memory_equal(src, dst, __builtin_strlen(src) + 1);
 74  
 75  	/* Non-empty str & dst */
 76  	memcpy(dst, str, len + 1);
 77  	memset(dst + len + 1, 0xee, sizeof(dst) - len - 1);
 78  	ret = strcat(dst, src);
 79  	assert_ptr_equal(dst, ret);
 80  	assert_memory_equal(expected, dst, expected_len + 1);
 81  }
 82  
 83  static void test_strncat(void **state)
 84  {
 85  	static const char str[] = "Hello ";
 86  	size_t len = __builtin_strlen(str);
 87  	static const char src[] = "World";
 88  	size_t src_len = __builtin_strlen(src);
 89  	static const char expected[] = "Hello World";
 90  	size_t expected_len = __builtin_strlen(expected);
 91  	char dst[100];
 92  	char *ret;
 93  
 94  	/* n larger than src len */
 95  	memcpy(dst, str, len + 1);
 96  	memset(dst + len + 1, 0xee, sizeof(dst) - len - 1);
 97  	ret = strncat(dst, src, src_len + 5);
 98  	assert_ptr_equal(dst, ret);
 99  	assert_memory_equal(expected, dst, expected_len + 1);
100  
101  	/* n smaller than src len */
102  	memcpy(dst, str, len + 1);
103  	memset(dst + len + 1, 0xee, sizeof(dst) - len - 1);
104  	ret = strncat(dst, src, src_len - 2);
105  	assert_ptr_equal(dst, ret);
106  	assert_memory_equal("Hello Wor", dst, expected_len - 2 + 1);
107  
108  	/* n is 0 */
109  	memcpy(dst, str, len + 1);
110  	memset(dst + len + 1, 0xee, sizeof(dst) - len - 1);
111  	ret = strncat(dst, src, 0);
112  	assert_ptr_equal(dst, ret);
113  	assert_memory_equal(str, dst, len + 1);
114  }
115  
116  static void test_skip_atoi(void **state)
117  {
118  	int i;
119  	char *ptr, *copy;
120  	const struct str_with_u_val_t {
121  		char *str;
122  		uint32_t value;
123  		uint32_t offset;
124  	} str_with_u_val[] = {
125  		{"42aa", 42, 2},
126  		{"a", 0, 0},
127  		{"0", 0, 1},
128  		{"4a2", 4, 1},
129  	};
130  
131  	for (i = 0; i < ARRAY_SIZE(str_with_u_val); i++) {
132  		ptr = str_with_u_val[i].str;
133  		copy = ptr;
134  		assert_true(str_with_u_val[i].value == skip_atoi(&ptr));
135  		assert_int_equal(str_with_u_val[i].offset, ptr - copy);
136  	}
137  }
138  
139  int main(void)
140  {
141  	const struct CMUnitTest tests[] = {
142  		cmocka_unit_test(test_strlen),
143  		cmocka_unit_test(test_strnlen),
144  		cmocka_unit_test(test_strcat),
145  		cmocka_unit_test(test_strncat),
146  		cmocka_unit_test(test_skip_atoi),
147  	};
148  
149  	return cb_run_group_tests(tests, NULL, NULL);
150  }