Update upstream source from tag 'upstream/15.3'debian/15.3-1

Update to upstream version '15.3'
with Debian dir 1b484f1c1ac270604a5a1451b34de4b0865c6211

1 files changed, 1493 insertions, 0 deletions

diff --git a/test-str.c b/test-str.c
new file mode 100644
index 00000000..70d1637c
--- /dev/null
+++ b/test-str.c
@@ -0,0 +1,1493 @@
+// SPDX-License-Identifier: BSD-2-Clause-Patent
+/*
+ * test-str.c - test our string functions.
+ */
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic error "-Wnonnull"
+#pragma GCC diagnostic error "-Wunused-function"
+
+#pragma GCC diagnostic warning "-Wcpp"
+
+#ifndef SHIM_UNIT_TEST
+#define SHIM_UNIT_TEST
+#endif
+#include "shim.h"
+
+#include <stdio.h>
+
+static int
+test_strlen(void)
+{
+	const char s1[] = "abcd";
+	const char s2[] = "";
+
+	assert_equal_return(shim_strlen(s1), 4, -1, "got %d expected %d\n");
+	assert_equal_return(strlen(s1), 4, -1, "got %d expected %d\n");
+	assert_equal_return(shim_strlen(s2), 0, -1, "got %d expected %d\n");
+	assert_equal_return(strlen(s2), 0, -1, "got %d expected %d\n");
+
+	return 0;
+}
+
+static int
+test_strnlen(void)
+{
+	const char s1[] = "abcd";
+	const char s2[] = "";
+
+	assert_equal_return(shim_strnlen(s1, 0), 0, -1, "got %d expected %d\n");
+	assert_equal_return(strnlen(s1, 0), 0, -1, "got %d expected %d\n");
+	assert_equal_return(shim_strnlen(s1, 1), 1, -1, "got %d expected %d\n");
+	assert_equal_return(strnlen(s1, 1), 1, -1, "got %d expected %d\n");
+	assert_equal_return(shim_strnlen(s1, 3), 3, -1, "got %d expected %d\n");
+	assert_equal_return(strnlen(s1, 3), 3, -1, "got %d expected %d\n");
+	assert_equal_return(shim_strnlen(s1, 4), 4, -1, "got %d expected %d\n");
+	assert_equal_return(strnlen(s1, 4), 4, -1, "got %d expected %d\n");
+	assert_equal_return(shim_strnlen(s1, 5), 4, -1, "got %d expected %d\n");
+	assert_equal_return(strnlen(s1, 5), 4, -1, "got %d expected %d\n");
+	assert_equal_return(shim_strnlen(s2, 0), 0, -1, "got %d expected %d\n");
+	assert_equal_return(strnlen(s2, 0), 0, -1, "got %d expected %d\n");
+	assert_equal_return(shim_strnlen(s2, 1), 0, -1, "got %d expected %d\n");
+	assert_equal_return(strnlen(s2, 1), 0, -1, "got %d expected %d\n");
+
+	return 0;
+}
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+
+/*
+ * these are constants so that the failures are readable if you get
+ * it wrong.
+ */
+#define s0 "sbat,"
+#define s0sz 6
+#define s0len 5
+#define s1 "sbat,1,2021030218"
+#define s1sz 18
+#define s1len 17
+#define s2 "sbat,1,20210302"
+#define s2sz 16
+#define s2len 15
+#define s3 "sbat,1,20210303"
+#define s3sz 16
+#define s3len 15
+#define s4 "sbat\314\234\014,"
+#define s4sz 9
+#define s4len 8
+/*
+ * same as s4 but with a UTF8 encoding error; one bit is cleared.
+ */
+#define s5 "sbat\314\034\014,"
+#define s5sz 9
+#define s5len 8
+
+#define test_strcmp_helper(fn, invert_sign_errors, invert_encoding_errors)   \
+	({                                                                   \
+		printf("testing %s\n", #fn);                                 \
+		int status_ = 0, rc_;                                        \
+                                                                             \
+		rc_ = assert_zero_as_expr(fn(s0, s0), -1, "\n");             \
+		status_ = MIN(status_, rc_);                                 \
+                                                                             \
+		if (invert_sign_errors)                                      \
+			rc_ = assert_positive_as_expr(fn(s0, s1), -1, "\n"); \
+		else                                                         \
+			rc_ = assert_negative_as_expr(fn(s0, s1), -1, "\n"); \
+		status_ = MIN(status_, rc_);                                 \
+		rc_ = assert_positive_as_expr(fn(s1, s0), -1, "\n");         \
+		status_ = MIN(status_, rc_);                                 \
+                                                                             \
+		rc_ = assert_positive_as_expr(fn(s1, s2), -1, "\n");         \
+		status_ = MIN(status_, rc_);                                 \
+		if (invert_sign_errors)                                      \
+			rc_ = assert_positive_as_expr(fn(s2, s1), -1, "\n"); \
+		else                                                         \
+			rc_ = assert_negative_as_expr(fn(s2, s1), -1, "\n"); \
+		status_ = MIN(status_, rc_);                                 \
+                                                                             \
+		if (invert_sign_errors)                                      \
+			rc_ = assert_positive_as_expr(fn(s2, s3), -1, "\n"); \
+		else                                                         \
+			rc_ = assert_negative_as_expr(fn(s2, s3), -1, "\n"); \
+		status_ = MIN(status_, rc_);                                 \
+		rc_ = assert_positive_as_expr(fn(s3, s2), -1, "\n");         \
+		status_ = MIN(status_, rc_);                                 \
+                                                                             \
+		if (invert_encoding_errors)                                  \
+			rc_ = assert_negative_as_expr(fn(s4, s5), -1, "\n"); \
+		else                                                         \
+			rc_ = assert_positive_as_expr(fn(s4, s5), -1, "\n"); \
+		status_ = MIN(status_, rc_);                                 \
+                                                                             \
+		if (status_ < 0)                                             \
+			printf("%s failed\n", #fn);                          \
+		status_;                                                     \
+	})
+
+static int
+test_strcmp(void)
+{
+	int status = 0;
+	int rc;
+
+	/*
+	 * shim's strcmp
+	 */
+	rc = test_strcmp_helper(shim_strcmp, false, false);
+	status = MIN(rc, status);
+
+	/*
+	 * libc's strcmp
+	 */
+	rc = test_strcmp_helper(strcmp, false, false);
+	status = MIN(rc, status);
+
+	return status;
+}
+
+#undef s0
+#undef s0sz
+#undef s0len
+#undef s1
+#undef s1sz
+#undef s1len
+#undef s2
+#undef s2sz
+#undef s2len
+#undef s3
+#undef s3sz
+#undef s3len
+#undef s4
+#undef s4sz
+#undef s4len
+#undef s5
+#undef s5sz
+#undef s5len
+
+/*
+ * these are constants so that the failures are readable if you get
+ * it wrong.
+ */
+#define s0 "sbAt,"
+#define s0sz 6
+#define s0len 5
+#define s1 "sbaT,1,2021030218"
+#define s1sz 18
+#define s1len 17
+#define s2 "sbAt,1,20210302"
+#define s2sz 16
+#define s2len 15
+#define s3 "sbaT,1,20210303"
+#define s3sz 16
+#define s3len 15
+#define s4 "sbat\314\234\014,"
+#define s4sz 9
+#define s4len 8
+/*
+ * same as s4 but with a UTF8 encoding error; one bit is cleared.
+ */
+#define s5 "sbat\314\034\014,"
+#define s5sz 9
+#define s5len 8
+
+#define test_strcasecmp_helper(fn, invert_sign_errors, invert_encoding_errors) \
+	({                                                                     \
+		printf("testing %s\n", #fn);                                   \
+		int status_ = 0, rc_;                                          \
+                                                                               \
+		rc_ = assert_zero_as_expr(fn(s0, s0), -1, "\n");               \
+		status_ = MIN(status_, rc_);                                   \
+                                                                               \
+		if (invert_sign_errors)                                        \
+			rc_ = assert_positive_as_expr(fn(s0, s1), -1, "\n");   \
+		else                                                           \
+			rc_ = assert_negative_as_expr(fn(s0, s1), -1, "\n");   \
+		status_ = MIN(status_, rc_);                                   \
+		rc_ = assert_positive_as_expr(fn(s1, s0), -1, "\n");           \
+		status_ = MIN(status_, rc_);                                   \
+                                                                               \
+		rc_ = assert_positive_as_expr(fn(s1, s2), -1, "\n");           \
+		status_ = MIN(status_, rc_);                                   \
+		if (invert_sign_errors)                                        \
+			rc_ = assert_positive_as_expr(fn(s2, s1), -1, "\n");   \
+		else                                                           \
+			rc_ = assert_negative_as_expr(fn(s2, s1), -1, "\n");   \
+		status_ = MIN(status_, rc_);                                   \
+                                                                               \
+		if (invert_sign_errors)                                        \
+			rc_ = assert_positive_as_expr(fn(s2, s3), -1, "\n");   \
+		else                                                           \
+			rc_ = assert_negative_as_expr(fn(s2, s3), -1, "\n");   \
+		status_ = MIN(status_, rc_);                                   \
+		rc_ = assert_positive_as_expr(fn(s3, s2), -1, "\n");           \
+		status_ = MIN(status_, rc_);                                   \
+                                                                               \
+		if (invert_encoding_errors)                                    \
+			rc_ = assert_negative_as_expr(fn(s4, s5), -1, "\n");   \
+		else                                                           \
+			rc_ = assert_positive_as_expr(fn(s4, s5), -1, "\n");   \
+		status_ = MIN(status_, rc_);                                   \
+                                                                               \
+		if (status_ < 0)                                               \
+			printf("%s failed\n", #fn);                            \
+		status_;                                                       \
+	})
+
+static int
+test_strcasecmp(void)
+{
+	int status = 0;
+	int rc;
+
+	/*
+	 * shim's strcasecmp
+	 */
+	rc = test_strcasecmp_helper(shim_strcasecmp, false, false);
+	status = MIN(rc, status);
+
+	/*
+	 * libc's strcasecmp
+	 */
+	rc = test_strcasecmp_helper(strcasecmp, false, false);
+	status = MIN(rc, status);
+
+	return status;
+}
+
+#undef s0
+#undef s0sz
+#undef s0len
+#undef s1
+#undef s1sz
+#undef s1len
+#undef s2
+#undef s2sz
+#undef s2len
+#undef s3
+#undef s3sz
+#undef s3len
+#undef s4
+#undef s4sz
+#undef s4len
+#undef s5
+#undef s5sz
+#undef s5len
+
+/*
+ * these are constants so that the failures are readable if you get
+ * it wrong.
+ */
+#define s0 "sbAt,"
+#define s0sz 6
+#define s0len 5
+#define s1 "sbaT,1,2021030218"
+#define s1sz 18
+#define s1len 17
+#define s2 "sbAt,1,20210302"
+#define s2sz 16
+#define s2len 15
+#define s3 "sbaT,1,20210303"
+#define s3sz 16
+#define s3len 15
+#define s4 "sbat\314\234\014,"
+#define s4sz 9
+#define s4len 8
+/*
+ * same as s4 but with a UTF8 encoding error; one bit is cleared.
+ */
+#define s5 "sbat\314\034\014,"
+#define s5sz 9
+#define s5len 8
+
+#define test_strncasecmp_helper(fn, test_cmp_magnitude, invert_sign_errors,   \
+                                invert_encoding_errors)                       \
+	({                                                                    \
+		printf("testing %s\n", #fn);                                  \
+		int status_ = 0, rc_;                                         \
+                                                                              \
+		rc_ = assert_zero_as_expr(fn(s0, s0, s0len), -1, "\n");       \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_zero_as_expr(fn(s0, s0, s0sz), -1, "\n");        \
+		status_ = MIN(status_, rc_);                                  \
+                                                                              \
+		rc_ = assert_zero_as_expr(fn(s0, s1, s0len), -1, "\n");       \
+		status_ = MIN(status_, rc_);                                  \
+		if (invert_sign_errors)                                       \
+			rc_ = assert_positive_as_expr(fn(s0, s1, s0sz), -1,   \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_negative_as_expr(fn(s0, s1, s0sz), -1,   \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s0, s1, s0sz),          \
+			                           s0[s0len] - s1[s0len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+		rc_ = assert_positive_as_expr(fn(s1, s0, s0sz), -1, "\n");    \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s1, s0, s0sz),          \
+			                           s1[s0len] - s0[s0len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+                                                                              \
+		rc_ = assert_positive_as_expr(fn(s1, s2, s1sz), -1, "\n");    \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s1, s2, s2sz),          \
+			                           s1[s2len] - s2[s2len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+		rc_ = assert_positive_as_expr(fn(s1, s2, s1len), -1, "\n");   \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(                           \
+				fn(s1, s2, s2len),                            \
+				s1[s2len - 1] - s2[s2len - 1], -1,            \
+				"expected %d got %d\n");                      \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+		if (invert_sign_errors)                                       \
+			rc_ = assert_positive_as_expr(fn(s2, s1, s1sz), -1,   \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_negative_as_expr(fn(s2, s1, s1sz), -1,   \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s2, s1, s1sz),          \
+			                           s2[s2len] - s1[s2len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+                                                                              \
+		rc_ = assert_zero_as_expr(fn(s1, s2, s2len), -1, "\n");       \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_positive_as_expr(fn(s1, s2, s2sz), -1, "\n");    \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s1, s2, s2sz),          \
+			                           s1[s2len] - s2[s2len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+                                                                              \
+		if (invert_sign_errors)                                       \
+			rc_ = assert_positive_as_expr(fn(s2, s3, s2sz), -1,   \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_negative_as_expr(fn(s2, s3, s2sz), -1,   \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_equal_as_expr(fn(s2, s3, s2sz),                  \
+		                           s2[s2len - 1] - s3[s2len - 1], -1, \
+		                           "expected %d got %d\n");           \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_equal_as_expr(fn(s2, s3, s2len),                 \
+		                           s2[s2len - 1] - s3[s2len - 1], -1, \
+		                           "expected %d got %d\n");           \
+		status_ = MIN(status_, rc_);                                  \
+		if (invert_sign_errors)                                       \
+			rc_ = assert_positive_as_expr(fn(s2, s3, s2len), -1,  \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_negative_as_expr(fn(s2, s3, s2len), -1,  \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_zero_as_expr(fn(s2, s3, s2len - 1), -1, "\n");   \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_false_as_expr(fn(s1, s2, s2len), -1, "\n");      \
+		status_ = MIN(status_, rc_);                                  \
+                                                                              \
+		if (invert_encoding_errors)                                   \
+			rc_ = assert_negative_as_expr(fn(s4, s5, s4sz), -1,   \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_positive_as_expr(fn(s4, s5, s4sz), -1,   \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+                                                                              \
+		if (status_ < 0)                                              \
+			printf("%s failed\n", #fn);                           \
+		status_;                                                      \
+	})
+
+static int
+test_strncasecmp(void)
+{
+	int status = 0;
+	int rc;
+
+	/*
+	 * shim's strncasecmp
+	 */
+	rc = test_strncasecmp_helper(shim_strncasecmp, true, false, false);
+	status = MIN(rc, status);
+
+	/*
+	 * libc's strncasecmp
+	 */
+	rc = test_strncasecmp_helper(strncasecmp, false, false, false);
+	status = MIN(rc, status);
+
+	return status;
+}
+
+#undef s0
+#undef s0sz
+#undef s0len
+#undef s1
+#undef s1sz
+#undef s1len
+#undef s2
+#undef s2sz
+#undef s2len
+#undef s3
+#undef s3sz
+#undef s3len
+#undef s4
+#undef s4sz
+#undef s4len
+#undef s5
+#undef s5sz
+#undef s5len
+
+/*
+ * copy-pasta from gnu-efi
+ */
+static inline UINTN
+gnuefi_strncmp (
+    IN CONST CHAR8    *s1,
+    IN CONST CHAR8    *s2,
+    IN UINTN    len
+    )
+{
+    while (*s1  &&  len) {
+        if (*s1 != *s2) {
+            break;
+        }
+
+        s1  += 1;
+        s2  += 1;
+        len -= 1;
+    }
+
+    return len ? *s1 - *s2 : 0;
+}
+
+/*
+ * This is still broken, and fails the test case as written on arm.
+ * We no longer use this, so we do not strictly need to run it.
+ */
+#if !defined(__arm__) && !defined(__aarch64__)
+static inline INTN
+gnuefi_signed_strncmp (
+    IN CONST CHAR8    *s1,
+    IN CONST CHAR8    *s2,
+    IN UINTN    len
+    )
+{
+    while (*s1  &&  len) {
+        if (*s1 != *s2) {
+            break;
+        }
+
+        s1  += 1;
+        s2  += 1;
+        len -= 1;
+    }
+
+    return len ? *s1 - *s2 : 0;
+}
+#endif
+
+static inline INTN
+gnuefi_good_strncmp (
+    IN CONST CHAR8    *s1p,
+    IN CONST CHAR8    *s2p,
+    IN UINTN    len
+    )
+{
+    CONST UINT8 *s1 = (CONST UINT8 *)s1p;
+    CONST UINT8 *s2 = (CONST UINT8 *)s2p;
+
+    while (*s1  &&  len) {
+        if (*s1 != *s2) {
+            break;
+        }
+
+        s1  += 1;
+        s2  += 1;
+        len -= 1;
+    }
+
+    return len ? *s1 - *s2 : 0;
+}
+
+/*
+ * these are constants so that the failures are readable if you get
+ * it wrong.
+ */
+#define s0 "sbat,"
+#define s0sz 6
+#define s0len 5
+#define s1 "sbat,1,2021030218"
+#define s1sz 18
+#define s1len 17
+#define s2 "sbat,1,20210302"
+#define s2sz 16
+#define s2len 15
+#define s3 "sbat,1,20210303"
+#define s3sz 16
+#define s3len 15
+#define s4 "sbat\314\234\014,"
+#define s4sz 9
+#define s4len 8
+/*
+ * same as s4 but with a UTF8 encoding error; one bit is cleared.
+ */
+#define s5 "sbat\314\034\014,"
+#define s5sz 9
+#define s5len 8
+
+#define test_strncmp_helper(fn, test_cmp_magnitude, invert_sign_errors,       \
+                            invert_encoding_errors)                           \
+	({                                                                    \
+		printf("testing %s\n", #fn);                                  \
+		int status_ = 0, rc_;                                         \
+                                                                              \
+		rc_ = assert_zero_as_expr(fn(s0, s0, s0len), -1, "\n");       \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_zero_as_expr(fn(s0, s0, s0sz), -1, "\n");        \
+		status_ = MIN(status_, rc_);                                  \
+                                                                              \
+		rc_ = assert_zero_as_expr(fn(s0, s1, s0len), -1, "\n");       \
+		status_ = MIN(status_, rc_);                                  \
+		if (invert_sign_errors)                                       \
+			rc_ = assert_positive_as_expr(fn(s0, s1, s0sz), -1,   \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_negative_as_expr(fn(s0, s1, s0sz), -1,   \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s0, s1, s0sz),          \
+			                           s0[s0len] - s1[s0len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+		rc_ = assert_positive_as_expr(fn(s1, s0, s0sz), -1, "\n");    \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s1, s0, s0sz),          \
+			                           s1[s0len] - s0[s0len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+                                                                              \
+		rc_ = assert_positive_as_expr(fn(s1, s2, s1sz), -1, "\n");    \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s1, s2, s2sz),          \
+			                           s1[s2len] - s2[s2len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+		rc_ = assert_positive_as_expr(fn(s1, s2, s1len), -1, "\n");   \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(                           \
+				fn(s1, s2, s2len),                            \
+				s1[s2len - 1] - s2[s2len - 1], -1,            \
+				"expected %d got %d\n");                      \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+		if (invert_sign_errors)                                       \
+			rc_ = assert_positive_as_expr(fn(s2, s1, s1sz), -1,   \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_negative_as_expr(fn(s2, s1, s1sz), -1,   \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s2, s1, s1sz),          \
+			                           s2[s2len] - s1[s2len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+                                                                              \
+		rc_ = assert_zero_as_expr(fn(s1, s2, s2len), -1, "\n");       \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_positive_as_expr(fn(s1, s2, s2sz), -1, "\n");    \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(fn(s1, s2, s2sz),          \
+			                           s1[s2len] - s2[s2len], -1, \
+			                           "expected %d got %d\n");   \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+                                                                              \
+		if (invert_sign_errors)                                       \
+			rc_ = assert_positive_as_expr(fn(s2, s3, s2sz), -1,   \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_negative_as_expr(fn(s2, s3, s2sz), -1,   \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+		if (test_cmp_magnitude) {                                     \
+			rc_ = assert_equal_as_expr(                           \
+				fn(s2, s3, s2sz),                             \
+				s2[s2len - 1] - s3[s2len - 1], -1,            \
+				"expected %d got %d\n");                      \
+			status_ = MIN(status_, rc_);                          \
+			rc_ = assert_equal_as_expr(                           \
+				fn(s2, s3, s2len),                            \
+				s2[s2len - 1] - s3[s2len - 1], -1,            \
+				"expected %d got %d\n");                      \
+			status_ = MIN(status_, rc_);                          \
+		}                                                             \
+		if (invert_sign_errors)                                       \
+			rc_ = assert_positive_as_expr(fn(s2, s3, s2len), -1,  \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_negative_as_expr(fn(s2, s3, s2len), -1,  \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_zero_as_expr(fn(s2, s3, s2len - 1), -1, "\n");   \
+		status_ = MIN(status_, rc_);                                  \
+		rc_ = assert_false_as_expr(fn(s1, s2, s2len), -1, "\n");      \
+		status_ = MIN(status_, rc_);                                  \
+                                                                              \
+		if (invert_encoding_errors)                                   \
+			rc_ = assert_negative_as_expr(fn(s4, s5, s4sz), -1,   \
+			                              "\n");                  \
+		else                                                          \
+			rc_ = assert_positive_as_expr(fn(s4, s5, s4sz), -1,   \
+			                              "\n");                  \
+		status_ = MIN(status_, rc_);                                  \
+                                                                              \
+		if (status_ < 0)                                              \
+			printf("%s failed\n", #fn);                           \
+		status_;                                                      \
+	})
+
+static int
+test_strncmp(void)
+{
+	int status = 0;
+	int rc;
+
+	/*
+	 * shim's strncmp
+	 */
+	rc = test_strncmp_helper(shim_strncmp, true, false, false);
+	status = MIN(rc, status);
+
+	/*
+	 * libc's strncmp
+	 */
+	/*
+	 * Deliberately not testing the difference between these two
+	 * comparisons for the symbol named "strncmp":
+	 *   strncmp("b", "a", 1)
+	 *   strncmp("c", "a", 1)
+	 * glibc, shim_strncmp(), and even the gnuefi ones will give you 1
+	 * and 2, respectively, as will glibc's, but valgrind swaps in its
+	 * own implementation, in case you're doing something that's both
+	 * clever and dumb with the result, and it'll return 1 for both of
+	 * them.
+	 */
+	rc = test_strncmp_helper(strncmp, false, false, false);
+	status = MIN(rc, status);
+
+	/*
+	 * gnu-efi's broken strncmpa
+	 */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtype-limits"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+	rc = test_strncmp_helper(gnuefi_strncmp, true, true, false);
+	status = MIN(rc, status);
+#pragma GCC diagnostic pop
+
+	/*
+	 * This is still broken, and fails the test case as written on arm.
+	 * We no longer use this, so we do not strictly need to run it.
+	 */
+#if !defined(__arm__) && !defined(__aarch64__)
+	/*
+	 * gnu-efi's broken strncmpa with the return type fixed
+	 */
+	rc = test_strncmp_helper(gnuefi_signed_strncmp, true, false, true);
+	status = MIN(rc, status);
+#endif
+
+	/*
+	 * gnu-efi's strncmpa with the return type fixed and unsigned
+	 * comparisons internally
+	 */
+	rc = test_strncmp_helper(gnuefi_good_strncmp, true, false, false);
+	status = MIN(rc, status);
+
+	return status;
+}
+
+#undef s0
+#undef s0sz
+#undef s0len
+#undef s1
+#undef s1sz
+#undef s1len
+#undef s2
+#undef s2sz
+#undef s2len
+#undef s3
+#undef s3sz
+#undef s3len
+#undef s4
+#undef s4sz
+#undef s4len
+#undef s5
+#undef s5sz
+#undef s5len
+
+/*
+ * Put -Wshadow back how it was
+ */
+#pragma GCC diagnostic pop
+
+static int
+test_strchr(void)
+{
+	char s0[] = "abcbdbeb\0fbgb";
+
+	assert_equal_return(strchr(s0, 'a'), s0, -1, "got %p expected %p\n");
+	assert_equal_return(strchr(s0, 'b'), &s0[1], -1, "got %p expected %p\n");
+	assert_equal_return(strchr(&s0[1], 'b'), &s0[1], -1, "got %p expected %p\n");
+	assert_equal_return(strchr(&s0[2], 'b'), &s0[3], -1, "got %p expected %p\n");
+	assert_equal_return(strchr(&s0[4], 'b'), &s0[5], -1, "got %p expected %p\n");
+	assert_equal_return(strchr(&s0[6], 'b'), &s0[7], -1, "got %p expected %p\n");
+	assert_equal_return(strchr(&s0[8], 'b'), NULL, -1, "got %p expected %p\n");
+
+	assert_equal_return(shim_strchr(s0, 'a'), s0, -1, "got %p expected %p\n");
+	assert_equal_return(shim_strchr(s0, 'b'), &s0[1], -1, "got %p expected %p\n");
+	assert_equal_return(shim_strchr(&s0[1], 'b'), &s0[1], -1, "got %p expected %p\n");
+	assert_equal_return(shim_strchr(&s0[2], 'b'), &s0[3], -1, "got %p expected %p\n");
+	assert_equal_return(shim_strchr(&s0[4], 'b'), &s0[5], -1, "got %p expected %p\n");
+	assert_equal_return(shim_strchr(&s0[6], 'b'), &s0[7], -1, "got %p expected %p\n");
+	assert_equal_return(shim_strchr(&s0[8], 'b'), NULL, -1, "got %p expected %p\n");
+	return 0;
+}
+
+static int
+test_stpcpy(void)
+{
+	char s0[] = "0123456789abcdef";
+	char s1[] = "xxxxxxxxxxxxxxxx";
+	char *s;
+
+	s0[0xa] = 0;
+	assert_equal_return(stpcpy(s1, s0), &s1[0xa], -1, "got %p expected %p\n");
+	assert_zero_return(memcmp(s0, s1, 11), -1, "\n");
+	assert_zero_return(memcmp(&s1[11], "xxxxx", sizeof("xxxxx")), -1, "\n");
+
+	memset(s1, 'x', sizeof(s1));
+	s1[16] = 0;
+	assert_equal_return(shim_stpcpy(s1, s0), &s1[0xa], -1, "got %p expected %p\n");
+	assert_zero_return(memcmp(s0, s1, 11), -1, "\n");
+	assert_zero_return(memcmp(&s1[11], "xxxxx", sizeof("xxxxx")), -1, "\n");
+
+	return 0;
+}
+
+static int
+test_strdup(void)
+{
+	char s0[] = "0123456789abcdef";
+	char *s = NULL;
+
+	s = strdup(s0);
+	assert_equal_goto(strcmp(s0, s), 0, err, "\n");
+	free(s);
+
+	s = shim_strdup(s0);
+	assert_equal_goto(strcmp(s0, s), 0, err, "\n");
+	free(s);
+
+	return 0;
+err:
+	if (s)
+		free(s);
+	return -1;
+}
+
+static int
+test_strndup(void)
+{
+	char s0[] = "0123456789abcdef";
+	char *s = NULL;
+
+	s = strndup(s0, 18);
+	assert_equal_goto(strcmp(s0, s), 0, err, "\n");
+	free(s);
+	s = strndup(s0, 15);
+	assert_positive_goto(strcmp(s0, s), err, "\n");
+	free(s);
+
+	s = shim_strndup(s0, 18);
+	assert_equal_goto(strcmp(s0, s), 0, err, "\n");
+	free(s);
+	s = strndup(s0, 15);
+	assert_positive_goto(shim_strcmp(s0, s), err, "\n");
+	free(s);
+
+	return 0;
+err:
+	if (s)
+		free(s);
+	return -1;
+}
+
+static int
+test_strchrnul_helper(__typeof__(strchrnul) fn)
+{
+	const char s0[] = "abcd\0fghi";
+
+	assert_equal_return(fn(s0, 'a'), &s0[0], -1, "got %p expected %p\n");
+	assert_equal_return(fn(s0, 'd'), &s0[3], -1, "got %p expected %p\n");
+	assert_equal_return(fn(s0, '\000'), &s0[4], -1, "got %p expected %p\n");
+	assert_equal_return(fn(s0, 'i'), &s0[4], -1, "got %p expected %p\n");
+
+	return 0;
+}
+
+static int
+test_strchrnul(void)
+{
+	const char s0[] = "abcd\0fghi";
+
+	assert_equal_return(test_strchrnul_helper(shim_strchrnul),
+			    test_strchrnul_helper(strchrnul),
+			    -1, "got %d expected %d\n");
+
+	assert_equal_return(strnchrnul(s0, 0, 'b'), &s0[0], -1, "got %p expected %p\n");
+	assert_equal_return(strnchrnul(s0, -1, 'b'), &s0[1], 1, "got %p expected %p\n");
+	assert_equal_return(strnchrnul(s0, 2, 'b'), &s0[1], -1, "got %p expected %p\n");
+	assert_equal_return(strnchrnul(s0, 4, 'f'), &s0[3], -1, "got %p expected %p\n");
+	assert_equal_return(strnchrnul(s0, 5, 'f'), &s0[4], -1, "got %p expected %p\n");
+	assert_equal_return(strnchrnul(s0, 8, 'f'), &s0[4], -1, "got %p expected %p\n");
+
+	assert_equal_return(strnchrnul(&s0[4], 1, 'f'), &s0[4], -1, "got %p expected %p\n");
+
+	return 0;
+}
+
+static int
+test_strrchr(void) {
+	char s0[] = "abcbebfb";
+
+	assert_equal_return(shim_strrchr(s0, '\n'), NULL, -1, "got %p expected %p\n");
+	assert_equal_return(strrchr(s0, '\n'), NULL, -1, "got %p expected %p\n");
+	assert_equal_return(shim_strrchr(s0, 'b'), &s0[7], -1, "got %p expected %p\n");
+	assert_equal_return(strrchr(s0, 'b'), &s0[7], -1, "got %p expected %p\n");
+	assert_equal_return(shim_strrchr(s0, 'c'), &s0[2], -1, "got %p expected %p\n");
+	assert_equal_return(strrchr(s0, 'c'), &s0[2], -1, "got %p expected %p\n");
+
+	return 0;
+}
+
+static int
+test_strcpy(void)
+{
+	char s0[] = "0123456789abcdef\0000";
+	char s1[sizeof(s0)];
+
+	memset(s1, 0, sizeof(s1));
+	assert_equal_return(strcpy(s1, s0), s1, -1, "got %p expected %p\n");
+	assert_equal_return(strlen(s0), strlen(s1), -1, "got %d expected %d\n");
+
+	memset(s1, 0, sizeof(s1));
+	assert_equal_return(shim_strcpy(s1, s0), s1, -1, "got %p expected %p\n");
+	assert_equal_return(strlen(s0), strlen(s1), -1, "got %d expected %d\n");
+
+	memset(s1, 0, sizeof(s1));
+	assert_equal_return(shim_strcpy(s1, s0), s1, -1, "got %p expected %p\n");
+	assert_equal_return(strlen(s0), strlen(s1), -1, "got %d expected %d\n");
+
+	return 0;
+}
+
+static int
+test_strncpy(void)
+{
+	char s[] = "0123456789abcdef\0000";
+	char s0[4096+4096];
+	char *s1 = &s0[4096];
+
+	memset(s0, 0, sizeof(s0));
+	memcpy(s0, s, sizeof(s));
+
+	memset(s1, 0, 4096);
+	assert_equal_return(strncpy(s1, s0, 0), s1, -1, "got %p expected %p\n");
+	assert_equal_return(strlen(s1), 0, -1, "got %d expected %d\n");
+	memset(s1, 0, 4096);
+	assert_equal_return(shim_strncpy(s1, s0, 0), s1, -1, "got %p expected %p\n");
+	assert_equal_return(strlen(s1), 0, -1, "got %d expected %d\n");
+
+	memset(s1, 0, 4096);
+	assert_equal_return(strncpy(s1, s0, 1), s1, -1, "got %p expected %p\n");
+	assert_equal_return(strlen(s1), 1, -1, "got %d expected %d\n");
+	assert_equal_return(s1[0], s0[0], -1, "got %#02hhx, expected %#02hhx\n");
+	assert_equal_return(s0[1], '1', -1, "got %#02hhx, expected %#02hhx\n");
+	assert_equal_return(s1[1], '\0', -1, "got %#02hhx, expected %#02hhx\n");
+	memset(s1, 0, 4096);
+	assert_equal_return(shim_strncpy(s1, s0, 1), s1, -1, "got %p expected %p\n");
+	assert_equal_return(strlen(s1), 1, -1, "got %d expected %d\n");
+	assert_equal_return(s1[0], s0[0], -1, "got %#02hhx, expected %#02hhx\n");
+	assert_equal_return(s0[1], '1', -1, "got %#02hhx, expected %#02hhx\n");
+	assert_equal_return(s1[1], '\0', -1, "got %#02hhx, expected %#02hhx\n");
+
+	memset(s1, 0, 4096);
+	assert_equal_return(strncpy(s1, s0, 15), s1, -1, "got %p expected %p\n");
+	assert_equal_return(s0[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[17], '0', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[15], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[17], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+	memset(s1, 0, 4096);
+	assert_equal_return(shim_strncpy(s1, s0, 15), s1, -1, "got %p expected %p\n");
+	assert_equal_return(s0[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[17], '0', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[15], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[17], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+
+	memset(s1, 0, 4096);
+	assert_equal_return(strncpy(s1, s0, 16), s1, -1, "got %p expected %p\n");
+	assert_equal_return(s0[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[17], '0', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[17], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+	memset(s1, 0, 4096);
+	assert_equal_return(shim_strncpy(s1, s0, 16), s1, -1, "got %p expected %p\n");
+	assert_equal_return(s0[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[17], '0', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[17], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+
+	memset(s1, 0, 4096);
+	s1[17] = '0';
+	s1[18] = '1';
+	assert_equal_return(strncpy(s1, s0, 4096), s1, -1, "got %p expected %p\n");
+	assert_equal_return(s0[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[17], '0', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[17], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+	memset(s1, 0, 4096);
+	s1[17] = '0';
+	s1[18] = '1';
+	assert_equal_return(shim_strncpy(s1, s0, 4096), s1, -1, "got %p expected %p\n");
+	assert_equal_return(s0[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[17], '0', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s0[18], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[14], 'e', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[15], 'f', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[16], '\000', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[17], '0', -1, "got %#02hhx expected %02hhx\n");
+	assert_equal_return(s1[18], '1', -1, "got %#02hhx expected %02hhx\n");
+
+	return 0;
+}
+
+static int
+test_strcat(void)
+{
+	char s[] = "0123456789abcdef\0000";
+	char s0[8192];
+	char *s1 = &s0[4096];
+	char *s2;
+	char s3[] = "0123456789abcdef0123456789abcdef\000\000\000\000\000";
+
+	memset(s0, 0, 8192);
+	memcpy(s0, s, sizeof(s));
+
+	memset(s1, 0, 4096);
+	assert_equal_return(strcat(s1, s0), s1, -1, "got %p expected %p\n");
+	/* For unknown reasons, gcc 4.8.5 gives us this here:
+	 * | In file included from shim.h:64:0,
+	 * |                  from test-str.c:14:
+	 * | test-str.c: In function 'test_strcat':
+	 * | include/test.h:85:10: warning: array subscript is below array bounds [-Warray-bounds]
+	 * |     printf("%s:%d:got %lld, expected zero " fmt, __func__, \
+	 * |           ^
+	 * | include/test.h:112:10: warning: array subscript is below array bounds [-Warray-bounds]
+	 * |     printf("%s:%d:got %lld, expected < 0 " fmt, __func__, \
+	 * |           ^
+	 *
+	 * This clearly isn't a useful error message, as it doesn't tell us
+	 * /anything about the problem/, but also it isn't reported on
+	 * later compilers, and it isn't clear that there's any problem
+	 * when examining these functions.
+	 *
+	 * I don't know.
+	 */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic warning "-Warray-bounds"
+	assert_zero_return(strncmp(s1, s0, sizeof(s)-1), 0, -1, "\n");
+	assert_negative_return(memcmp(s1, s0, sizeof(s)), 0, -1, "\n");
+#pragma GCC diagnostic pop
+
+	memset(s1, 0, 4096);
+	assert_equal_return(strcat(s1, s0), s1, -1, "got %p expected %p\n");
+	s2 = s1 + strlen(s1);
+	assert_equal_return(s2, &s1[16], -1, "got %p expected %p\n");
+	assert_equal_return(strcat(s2, s0), s2, -1, "got %p expected %p\n");
+	assert_zero_return(strncmp(s1, s0, strlen(s)), -1, "got %p expected %p\n");
+	assert_zero_return(strncmp(s2, s0, 2*(sizeof(s)-1)), -1, "\n");
+	assert_positive_return(memcmp(s1, s0, 2*sizeof(s)-2), -1, "\n");
+	assert_equal_return(memcmp(s1, s3, sizeof(s3)), 0,  -1, "expected %d got %d\n");
+
+	return 0;
+}
+
+static int
+test_strntoken_null(void) {
+	bool ret;
+	char *token = NULL;
+	char state;
+
+	char *delims = alloca(3);
+	memcpy(delims, ",.", 3);
+
+	ret = strntoken(NULL, 1, delims, &token, &state);
+	assert_equal_return(ret, false, -1, "got %d expected %d\n");
+	return 0;
+}
+
+static int
+test_strntoken_size_0(void)
+{
+	const char s1[] = "abc,def,.,gh,";
+	char s2[] = "abc,def,.,gh,";
+	char *token = NULL;
+	bool ret;
+	size_t max;
+	char *s = s2;
+	size_t tokensz;
+	char state;
+
+	ret = strntoken(s, 0, ",.", &token, &state);
+	assert_equal_return(ret, false, -1, "got %d expected %d\n");
+	assert_equal_return(token, NULL, -1, "got %p expected %p\n");
+	assert_equal_return(memcmp(s, "abc,def,.,gh,", sizeof(s2)), 0, 1, "got %d expected %d\n");
+
+	return 0;
+}
+
+static int
+test_strntoken_empty_size_1(void)
+{
+	char s1[] = "";
+	char *s;
+	bool ret;
+	char *token = NULL;
+	char *prevtok = NULL;
+	size_t max;
+	size_t tokensz;
+	char state;
+
+	s = s1;
+	max = 1;
+
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, -1, "got %d expected %d\n");
+	assert_equal_return(token[0], '\0', -1, "got %#hhx expected %#hhx\n");
+	prevtok = token;
+
+	tokensz = strlen(token) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(s, &s1[1], -1, "got %p expected %p\n");
+	assert_equal_return(max, 0, -1, "got %d expected %d\n");
+
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, false, -1, "got %d expected %d\n");
+	assert_equal_return(token, prevtok, -1, "got %p expected %p\n");
+
+	return 0;
+}
+
+static int
+test_strntoken_size_1(void)
+{
+	char s1[] = ",";
+	char *s;
+	bool ret;
+	char *token = NULL;
+	char *prevtok = NULL;
+	size_t max;
+	size_t tokensz;
+	char state;
+
+	s = s1;
+	max = 1;
+
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, -1, "got %d expected %d\n");
+	assert_equal_return(token[0], '\0', -1, "got %#hhx expected %#hhx\n");
+	prevtok = token;
+
+	tokensz = strlen(token) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(s, &s1[1], -1, "got %p expected %p\n");
+	assert_equal_return(max, 0, -1, "got %d expected %d\n");
+
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, false, -1, "got %d expected %d\n");
+	assert_equal_return(token, prevtok, -1, "got %p expected %p\n");
+	assert_equal_return(token[0], '\0', -1, "got %#hhx expected %#hhx\n");
+
+	return 0;
+}
+
+static int
+test_strntoken_size_2(void)
+{
+	char s1[] = ",";
+	char *s;
+	bool ret;
+	char *token = NULL;
+	char *prevtok = NULL;
+	size_t max;
+	size_t tokensz;
+	char state;
+
+	s = s1;
+	max = 2;
+
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, -1, "got %d expected %d\n");
+	assert_equal_return(token[0], '\0', -1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strlen(token) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(s, &s1[1], -1, "got %p expected %p\n");
+	assert_equal_return(max, 1, -1, "got %d expected %d\n");
+
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, -1, "got %d expected %d\n");
+	assert_equal_return(token[0], '\0', -1, "got %#hhx expected %#hhx\n");
+	prevtok = token;
+
+	tokensz = strlen(token) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(s, &s1[2], -1, "got %p expected %p\n");
+	assert_equal_return(max, 0, -1, "got %d expected %d\n");
+
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, false, -1, "got %d expected %d\n");
+	assert_equal_return(token, prevtok, -1, "got %#hhx expected %#hhx\n");
+
+	return 0;
+}
+
+static int
+test_strntoken_no_ascii_nul(void)
+{
+	const char s1[] = "abc,def,.,gh,";
+	char s2[] = "abc,def,.,gh,";
+	char *token = NULL;
+	bool ret;
+	size_t max;
+	char *s = s2;
+	size_t tokensz;
+	char state;
+
+	s = s2;
+	max = sizeof(s2) - 1;
+	assert_equal_return(max, 13, -1, "got %d expected %d\n");
+	/*
+	 * s="abc,def,.,gh," -> "abc\0def,.,gh,"
+	 *                       ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, -1, "got %d expected %d\n");
+	assert_equal_return(token, s, -1, "got %p expected %p\n");
+	assert_equal_return(s[2], 'c', -1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[3], '\0', -1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[4], 'd', -1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 9, -1, "got %d expected %d\n");
+
+	/*
+	 * s="def,.,gh," -> "def\0.,gh,"
+	 *                   ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, -1, "got %d expected %d\n");
+	assert_equal_return(token, s, -1, "got %p expected %p\n");
+	assert_equal_return(s[2], 'f', -1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[3], '\0', -1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[4], '.', -1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 5, -1, "got %d expected %d\n");
+
+	/*
+	 * s=".,gh," -> "\0,gh,"
+	 *               ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, -1, "got %d expected %d\n");
+	assert_equal_return(token, s, -1, "got %p expected %p\n");
+	assert_equal_return(s[0], '\0', -1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[1], ',', -1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 4, -1, "got %d expected %d\n");
+
+	/*
+	 * s=",gh," -> "\0gh,"
+	 *              ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, -1, "got %d expected %d\n");
+	assert_equal_return(token, s, -1, "got %p expected %p\n");
+	assert_equal_return(s[0], '\0', -1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[1], 'g', -1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 3, -1, "got %d expected %d\n");
+
+	/*
+	 * s="gh," -> "gh\0"
+	 *             ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, -1, "got %d expected %d\n");
+	assert_equal_return(token, s, -1, "got %p expected %p\n");
+	assert_equal_return(s[0], 'g', -1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[1], 'h', -1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[2], '\0', -1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 0, -1, "got %d expected %d\n");
+
+	char *prevtok = token;
+
+	/*
+	 * s="" -> ""
+	 *          ^ token, but max is 0
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, false, -1, "got %d expected %d\n");
+	assert_equal_return(token, prevtok, -1, "got %p expected %p\n");
+	assert_equal_return(s[0], '\0', -1, "got %#hhx expected %#hhx\n");
+
+	s[0] = 'x';
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, false, -1, "got %d expected %d\n");
+	assert_equal_return(token, prevtok, -1, "got %p expected %p\n");
+	assert_equal_return(s[0], 'x', -1, "got %#hhx expected %#hhx\n");
+
+	return 0;
+}
+
+static int
+test_strntoken_with_ascii_nul(void)
+{
+	const char s1[] = "abc,def,.,gh,";
+	char s2[] = "abc,def,.,gh,";
+	char *token = NULL;
+	bool ret;
+	size_t max;
+	char *s = s2;
+	size_t tokensz;
+	char s3[] = "abc,def,.,gh,";
+	char state;
+
+	s = s2;
+	max = sizeof(s2);
+	assert_equal_return(max, 14, 1, "got %d expected %d\n");
+	/*
+	 * s="abc,def,.,gh," -> "abc\0def,.,gh,"
+	 *                       ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, 1, "got %d expected %d\n");
+	assert_equal_return(s[2], 'c', 1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[3], '\0', 1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[4], 'd', 1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 10, 1, "got %d expected %d\n");
+
+	/*
+	 * s="def,.,gh," -> "def\0.,gh,"
+	 *                   ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, 1, "got %d expected %d\n");
+	assert_equal_return(token, s, 1, "got %p expected %p\n");
+	assert_equal_return(s[2], 'f', 1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[3], '\0', 1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[4], '.', 1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 6, 1, "got %d expected %d\n");
+
+	/*
+	 * s=".,gh," -> "\0,gh,"
+	 *               ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, 1, "got %d expected %d\n");
+	assert_equal_return(token, s, 1, "got %p expected %p\n");
+	assert_equal_return(s[0], '\0', 1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[1], ',', 1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 5, 1, "got %d expected %d\n");
+
+	/*
+	 * s=",gh," -> "\0gh,"
+	 *              ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, 1, "got %d expected %d\n");
+	assert_equal_return(token, s, 1, "got %p expected %p\n");
+	assert_equal_return(s[0], '\0', 1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[1], 'g', 1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 4, 1, "got %d expected %d\n");
+
+	/*
+	 * s="gh," -> "gh\0"
+	 *             ^ token
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, 1, "got %d expected %d\n");
+	assert_equal_return(token, s, 1, "got %p expected %p\n");
+	assert_equal_return(s[0], 'g', 1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[1], 'h', 1, "got %#hhx expected %#hhx\n");
+	assert_equal_return(s[2], '\0', 1, "got %#hhx expected %#hhx\n");
+
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 1, 1, "got %d expected %d\n");
+
+	/*
+	 * s="" -> ""
+	 *          ^ token, max is 1
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, true, 1, "got %d expected %d\n");
+	assert_equal_return(token, s, 1, "got %p expected %p\n");
+	assert_equal_return(s[0], '\0', 1, "got %#hhx expected %#hhx\n");
+
+	char *prevtok = token;
+	tokensz = strnlen(token, max) + 1;
+	s += tokensz;
+	max -= tokensz;
+	assert_equal_return(max, 0, 1, "got %d expected %d\n");
+
+	/*
+	 * s="" -> ""
+	 *          ^ token, max is 0
+	 */
+	ret = strntoken(s, max, ",.", &token, &state);
+	assert_equal_return(ret, false, 1, "got %d expected %d\n");
+	assert_equal_return(token, prevtok, 1, "got %p expected %p\n");
+
+	return 0;
+}
+
+int
+main(void)
+{
+	int status = 0;
+	test(test_strlen);
+	test(test_strnlen);
+	test(test_strcmp);
+	test(test_strncmp);
+	test(test_strcasecmp);
+	test(test_strncasecmp);
+	test(test_strrchr);
+	test(test_strcpy);
+	test(test_strncpy);
+	test(test_strcat);
+	test(test_stpcpy);
+	test(test_strdup);
+	test(test_strndup);
+	test(test_strchr);
+	test(test_strchrnul);
+	test(test_strntoken_null);
+	test(test_strntoken_size_0);
+	test(test_strntoken_empty_size_1);
+	test(test_strntoken_size_1);
+	test(test_strntoken_size_2);
+	test(test_strntoken_no_ascii_nul);
+	test(test_strntoken_with_ascii_nul);
+	return status;
+}
+
+// vim:fenc=utf-8:tw=75:noet