Merge pull request managarm#1836 from Dennisbonke/tests

options/ansi: strengthen qsort and string function coverage

Author: no92

options/ansi/generic/stdlib.cpp

@@ -344,24 +344,12 @@ void *bsearch(const void *key, const void *base, size_t count, size_t size,
 	return nullptr;
 }
 
-static int qsort_callback(const void *a, const void *b, void *arg) {
-	auto compare = reinterpret_cast<int (*)(const void *, const void *)>(arg);
-
-	return compare(a, b);
-}
-
-void qsort(void *base, size_t count, size_t size,
-		int (*compare)(const void *, const void *)) {
-	return qsort_r(base, count, size, qsort_callback, (void *) compare);
-}
-
-void qsort_r(void *base, size_t count, size_t size,
-		int (*compare)(const void *, const void *, void *),
-		void *arg) {
+template<typename Compare>
+static void qsort_impl(void *base, size_t count, size_t size, Compare compare) {
 	auto compare_idx = [&] (size_t i, size_t j) -> int {
 		auto *pi = reinterpret_cast<uint8_t *>(base) + i * size;
 		auto *pj = reinterpret_cast<uint8_t *>(base) + j * size;
-		return compare(pi, pj, arg);
+		return compare(pi, pj);
 	};
 
 	auto swap_idx = [&] (size_t i, size_t j) {
@@ -403,6 +391,21 @@ void qsort_r(void *base, size_t count, size_t size,
 	quick_sort(0, count);
 }
 
+void qsort(void *base, size_t count, size_t size,
+		int (*compare)(const void *, const void *)) {
+	qsort_impl(base, count, size, [compare] (const void *a, const void *b) {
+		return compare(a, b);
+	});
+}
+
+void qsort_r(void *base, size_t count, size_t size,
+		int (*compare)(const void *, const void *, void *),
+		void *arg) {
+	qsort_impl(base, count, size, [compare, arg] (const void *a, const void *b) {
+		return compare(a, b, arg);
+	});
+}
+
 int abs(int num) {
 	return num < 0 ? -num : num;
 }

options/ansi/generic/string.cpp

@@ -191,17 +191,17 @@ size_t strspn(const char *s, const char *chrs) {
 	}
 }
 char *strstr(const char *s, const char *pattern) {
-	for(size_t i = 0; s[i]; i++) {
-		bool found = true;
-		for(size_t j = 0; pattern[j]; j++) {
-			if(!pattern[j] || s[i + j] == pattern[j])
-				continue;
+	// The empty pattern matches at the beginning of every string, including
+	// the empty string.
+	if(!*pattern)
+		return const_cast<char *>(s);
 
-			found = false;
-			break;
-		}
+	for(size_t i = 0; s[i]; i++) {
+		size_t j = 0;
+		while(pattern[j] && s[i + j] && s[i + j] == pattern[j])
+			j++;
 
-		if(found)
+		if(!pattern[j])
 			return const_cast<char *>(&s[i]);
 	}
 
@@ -248,9 +248,10 @@ char *strtok(char *__restrict s, const char *__restrict delimiter) {
 
 // This is a GNU extension.
 char *strchrnul(const char *s, int c) {
+	const unsigned char target = static_cast<unsigned char>(c);
 	size_t i = 0;
 	while(s[i]) {
-		if(s[i] == c)
+		if(static_cast<unsigned char>(s[i]) == target)
 			return const_cast<char *>(s + i);
 		i++;
 	}

tests/ansi/qsort.c

@@ -3,29 +3,168 @@
 #include <stdio.h>
 #include <string.h>
 
-static const char *arr[] = { "xyz", "abc", "ghi", "def" };
+struct record {
+	int key;
+	char value[12];
+};
 
-static const size_t magic = 0xDEADBEEF;
+struct sort_context {
+	int descending;
+	unsigned int calls;
+	unsigned int magic;
+};
 
-static int cmpstringp(const void *p1, const void *p2, void *ctx) {
-	/* The actual arguments to this function are "pointers to
-	 * pointers to char", but strcmp(3) arguments are "pointers
-	 * to char", hence the following cast plus dereference. */
-	assert(*(size_t *) ctx == magic);
-	return strcmp(*(const char **) p1, *(const char **) p2);
+static int compare_ints(const void *p1, const void *p2) {
+	int a = *(const int *) p1;
+	int b = *(const int *) p2;
+	if (a < b)
+		return -100;
+	if (a > b)
+		return 100;
+	return 0;
 }
 
-int main() {
-	qsort_r(&arr[0], sizeof(arr) / sizeof(*arr), sizeof(char *), cmpstringp, (void *) &magic);
+static int compare_bytes(const void *p1, const void *p2) {
+	unsigned char a = *(const unsigned char *) p1;
+	unsigned char b = *(const unsigned char *) p2;
+	if (a < b)
+		return -100;
+	if (a > b)
+		return 100;
+	return 0;
+}
+
+static int compare_records(const void *p1, const void *p2, void *ctx) {
+	const struct record *a = p1;
+	const struct record *b = p2;
+	struct sort_context *context = ctx;
+	assert(context->magic == 0xDEADBEEF);
+	context->calls++;
+
+	if (a->key == b->key)
+		return 0;
+	if (context->descending)
+		return a->key < b->key ? 100 : -100;
+	return a->key < b->key ? -100 : 100;
+}
+
+static int compare_strings(const void *p1, const void *p2, void *ctx) {
+	struct sort_context *context = ctx;
+	assert(context->magic == 0xDEADBEEF);
+	context->calls++;
+	return strcmp(*(const char *const *) p1, *(const char *const *) p2);
+}
+
+static void assert_record_values(const struct record *records, size_t count) {
+	static const char *expected[] = { "seven", "minus3", "four", "four-b", "zero", "nineteen" };
+	for (size_t i = 0; i < sizeof(expected) / sizeof(expected[0]); i++) {
+		int found = 0;
+		for (size_t j = 0; j < count; j++) {
+			if (!strcmp(records[j].value, expected[i])) {
+				found = 1;
+				break;
+			}
+		}
+		assert(found);
+	}
+}
+
+static void test_qsort(void) {
+	// ISO C qsort(): ordinary integer ordering, duplicates, and non-trivial
+	// comparator return values (the comparator need not return +/-1).
+	int values[] = { 7, -3, 4, 4, 0, 19, -10, 2 };
+	const int expected[] = { -10, -3, 0, 2, 4, 4, 7, 19 };
+	qsort(values, sizeof(values) / sizeof(values[0]), sizeof(values[0]), compare_ints);
+	assert(!memcmp(values, expected, sizeof(values)));
+
+	// Sorting an already reverse-ordered input exercises repeated partitioning.
+	int reverse[] = { 5, 4, 3, 2, 1, 0 };
+	qsort(reverse, sizeof(reverse) / sizeof(reverse[0]), sizeof(reverse[0]), compare_ints);
+	for (size_t i = 0; i < sizeof(reverse) / sizeof(reverse[0]); i++)
+		assert(reverse[i] == (int) i);
 
-	assert(!strcmp(arr[0], "abc"));
-	assert(!strcmp(arr[1], "def"));
-	assert(!strcmp(arr[2], "ghi"));
-	assert(!strcmp(arr[3], "xyz"));
+	// qsort() must honor arbitrary element sizes, including one-byte objects.
+	unsigned char bytes[] = { 3, 1, 2, 0, 255 };
+	qsort(bytes, sizeof(bytes), sizeof(bytes[0]), compare_bytes);
+	assert(bytes[0] == 0 && bytes[1] == 1 && bytes[2] == 2 && bytes[3] == 3 && bytes[4] == 255);
+
+	// A one-element range requires no comparisons or swaps.
+	int one[] = { 42 };
+	qsort(one, 1, sizeof(one[0]), compare_ints);
+	assert(one[0] == 42);
+
+	// A zero-count call must not access or modify the base object.
+	int empty[1] = { 42 };
+	qsort(empty, 0, sizeof(empty[0]), compare_ints);
+	assert(empty[0] == 42);
+}
 
-	for(size_t i = 0; i < sizeof(arr) / sizeof(*arr); i++) {
-		fprintf(stderr, "%s\n", arr[i]);
+static void test_qsort_r(void) {
+	// POSIX qsort_r(): the callback receives a caller-provided
+	// context, and sorting must move complete multi-field records.
+	struct {
+		unsigned char before[16];
+		struct record records[6];
+		unsigned char after[16];
+	} guarded = {
+		{ 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5,
+		  0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5 },
+		{
+			{ 7, "seven" }, { -3, "minus3" }, { 4, "four" },
+			{ 4, "four-b" }, { 0, "zero" }, { 19, "nineteen" }
+		},
+		{ 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A,
+		  0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A }
+	};
+	struct sort_context context = { 0, 0, 0xDEADBEEF };
+	qsort_r(guarded.records, sizeof(guarded.records) / sizeof(guarded.records[0]),
+			sizeof(guarded.records[0]),
+			compare_records, &context);
+	assert(context.calls > 0);
+	for (size_t i = 1; i < sizeof(guarded.records) / sizeof(guarded.records[0]); i++)
+		assert(guarded.records[i - 1].key <= guarded.records[i].key);
+	assert_record_values(guarded.records, sizeof(guarded.records) / sizeof(guarded.records[0]));
+
+	// Reuse the same context to verify that callback state can select a
+	// different ordering direction.
+	context.descending = 1;
+	context.calls = 0;
+	qsort_r(guarded.records, sizeof(guarded.records) / sizeof(guarded.records[0]),
+			sizeof(guarded.records[0]),
+			compare_records, &context);
+	assert(context.calls > 0);
+	for (size_t i = 1; i < sizeof(guarded.records) / sizeof(guarded.records[0]); i++)
+		assert(guarded.records[i - 1].key >= guarded.records[i].key);
+	assert_record_values(guarded.records, sizeof(guarded.records) / sizeof(guarded.records[0]));
+	for (size_t i = 0; i < sizeof(guarded.before); i++) {
+		assert(guarded.before[i] == 0xA5);
+		assert(guarded.after[i] == 0x5A);
 	}
 
+	// qsort_r() also handles pointer-sized elements and string comparators.
+	char *strings[] = { "xyz", "abc", "ghi", "def" };
+	context.descending = 0;
+	context.calls = 0;
+	qsort_r(strings, sizeof(strings) / sizeof(strings[0]), sizeof(strings[0]),
+			compare_strings, &context);
+	assert(context.calls > 0);
+	assert(!strcmp(strings[0], "abc"));
+	assert(!strcmp(strings[1], "def"));
+	assert(!strcmp(strings[2], "ghi"));
+	assert(!strcmp(strings[3], "xyz"));
+
+	// As with qsort(), a zero-count range must not invoke the comparator or
+	// modify the element passed as the base address.
+	struct record empty[] = { { 42, "unchanged" } };
+	context.calls = 0;
+	qsort_r(empty, 0, sizeof(empty[0]), compare_records, &context);
+	assert(context.calls == 0);
+	assert(empty[0].key == 42);
+	assert(!strcmp(empty[0].value, "unchanged"));
+}
+
+int main() {
+	test_qsort();
+	test_qsort_r();
 	return 0;
 }

tests/ansi/string-search.c

@@ -0,0 +1,102 @@
+#include <assert.h>
+#include <stddef.h>
+#include <string.h>
+
+// ISO C string-search functions:
+// https://en.cppreference.com/w/c/string/byte
+// GNU strchrnul() extension:
+// https://man7.org/linux/man-pages/man3/strchrnul.3.html
+
+static void test_strstr(void) {
+	// A nonempty needle matches at the first occurrence and returns a pointer
+	// into the original haystack.
+	char haystack[] = "abcabc";
+	assert(strstr(haystack, "abc") == haystack);
+	assert(strstr(haystack + 1, "abc") == haystack + 3);
+
+	// A missing needle and a needle longer than the remaining suffix return NULL.
+	assert(strstr(haystack, "abd") == NULL);
+	assert(strstr(haystack + 4, "abc") == NULL);
+
+	// The empty needle matches at the beginning, including for an empty string.
+	char empty[] = "";
+	assert(strstr(haystack, "") == haystack);
+	assert(strstr(empty, "") == empty);
+
+	// String functions stop at the first embedded null byte.
+	char embedded[] = { 'a', 'b', '\0', 'c', 'd', '\0' };
+	assert(strstr(embedded, "ab") == embedded);
+	assert(strstr(embedded, "cd") == NULL);
+}
+
+static void test_strpbrk(void) {
+	// strpbrk() returns the first character from the accept set.
+	char text[] = "hello world";
+	assert(strpbrk(text, "ow") == text + 4);
+	assert(strpbrk(text, "d") == text + 10);
+
+	// No matching character and an empty accept set both produce NULL.
+	assert(strpbrk(text, "xyz") == NULL);
+	assert(strpbrk(text, "") == NULL);
+
+	// Search sets are byte-oriented, including bytes with the high bit set.
+	char high_byte[] = { 'a', (char) 0xff, 'b', '\0' };
+	char high_set[] = { (char) 0xff, '\0' };
+	assert(strpbrk(high_byte, high_set) == high_byte + 1);
+}
+
+static void test_strcspn(void) {
+	// strcspn() counts the prefix containing no character from the reject set.
+	assert(strcspn("abc:def", ":") == 3);
+	assert(strcspn("abc", "a") == 0);
+	assert(strcspn("abc", "xyz") == 3);
+
+	// An empty reject set accepts the whole string, and embedded nulls end it.
+	assert(strcspn("abc", "") == 3);
+	char embedded[] = { 'a', 'b', '\0', ':', '\0' };
+	assert(strcspn(embedded, ":") == 2);
+
+	char high_byte[] = { 'a', (char) 0xff, 'b', '\0' };
+	char high_set[] = { (char) 0xff, '\0' };
+	assert(strcspn(high_byte, high_set) == 1);
+}
+
+static void test_strspn(void) {
+	// strspn() counts the initial prefix containing only accepted characters.
+	assert(strspn("12345abc", "0123456789") == 5);
+	assert(strspn("abc123", "abc") == 3);
+	assert(strspn("x123", "0123456789") == 0);
+
+	// An empty accept set accepts nothing, while an embedded null ends the scan.
+	assert(strspn("abc", "") == 0);
+	char embedded[] = { '1', '2', '\0', '3', '\0' };
+	assert(strspn(embedded, "0123456789") == 2);
+
+	char high_prefix[] = { (char) 0xff, (char) 0xff, 'a', '\0' };
+	char high_set[] = { (char) 0xff, '\0' };
+	assert(strspn(high_prefix, high_set) == 2);
+}
+
+static void test_strchrnul(void) {
+	// GNU strchrnul() returns the matching character, or the terminating null
+	// byte when no match exists.
+	char text[] = "abc";
+	assert(strchrnul(text, 'b') == text + 1);
+	assert(strchrnul(text, 'x') == text + 3);
+	assert(strchrnul(text, '\0') == text + 3);
+
+	// The search value is converted to unsigned char, so high-bit bytes and
+	// values outside the unsigned-char range are handled consistently.
+	char high_byte[] = { 'a', (char) 0xff, 'b', '\0' };
+	assert(strchrnul(high_byte, 0xff) == high_byte + 1);
+	assert(strchrnul(high_byte, 0x1ff) == high_byte + 1);
+}
+
+int main(void) {
+	test_strstr();
+	test_strpbrk();
+	test_strcspn();
+	test_strspn();
+	test_strchrnul();
+	return 0;
+}

tests/meson.build

@@ -60,6 +60,7 @@ all_test_cases = [
 	'ansi/threads-once',
 	'ansi/threads-tss',
 	'ansi/threads-thrd',
+	'ansi/string-search',
 	'bsd/ns_get_put',
 	'bsd/reallocarray',
 	'bsd/strl',
@@ -168,6 +169,7 @@ all_test_cases = [
 	'posix/getwchar',
 	'posix/strcoll_l',
 	'posix/strxfrm_l',
+	'posix/strtok',
 	'posix/wcscoll_l',
 	'posix/wcsxfrm_l',
 	'posix/aio',