Import the NetBSD test suite from ^/vendor/NetBSD/tests/09.30.2014_20.45 ,

minus the vendor Makefiles

Provide directions for how to bootstrap the vendor sources in
FREEBSD-upgrade

MFC after 2 weeks
Discussed with: rpaulo
Sponsored by: EMC / Isilon Storage Division

18 files changed, 2594 insertions, 0 deletions

diff --git a/contrib/netbsd-tests/lib/libc/string/t_bm.c b/contrib/netbsd-tests/lib/libc/string/t_bm.c
new file mode 100644
index 0000000..5ec4022
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_bm.c
@@ -0,0 +1,102 @@
+/* $Id: t_bm.c,v 1.1 2014/06/23 10:53:20 shm Exp $ */
+/*-
+ * Copyright (c) 2014 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Mateusz Kocielski.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__RCSID("$Id: t_bm.c,v 1.1 2014/06/23 10:53:20 shm Exp $");
+
+#include <atf-c.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <bm.h>
+#include <string.h>
+#include <stdlib.h>
+
+ATF_TC(bm);
+ATF_TC_HEAD(bm, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test bm(3)");
+}
+
+typedef struct {
+	const char *pattern;
+	const char *text;
+	const char *freq;
+	ssize_t match;
+} t_testcase;
+
+const t_testcase testcases[] = {
+	{"test", "test", NULL, 0},
+	{"test", "ttest", NULL, 1},
+	{"test", "tes", NULL, -1},
+	{"test", "testtesttest", NULL, 0},
+	{"test", "testtesttesttesttesttest", NULL, 0},
+	{"test", "------------------------", NULL, -1},
+	{"a", "a", NULL, 0},
+	{"a", "ba", NULL, 1},
+	{"a", "bba", NULL, 2},
+	{"bla", "bl", NULL, -1},
+	{"a", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", NULL, -1},
+	{"test", "qfwiofjqeiwofjioqewfjeiqwjfiqewjfioqewfjioewqjfioewqjfioewqjoi",
+	  NULL, -1},
+	{"needle", "haystack", NULL, -1},
+	{"netbsd", "freebsd netbsd openbsd", NULL, 8},
+};
+
+ATF_TC_BODY(bm, tc)
+{
+	size_t ts;
+	u_char *off;
+	char *text;
+	bm_pat *pattern;
+	
+	for (ts = 0; ts < sizeof(testcases)/sizeof(t_testcase); ts++) {
+		ATF_CHECK(pattern = bm_comp((const u_char *)testcases[ts].pattern,
+		  strlen(testcases[ts].pattern), (const u_char *)testcases[ts].freq));
+
+		ATF_REQUIRE(text = strdup(testcases[ts].text));
+		off = bm_exec(pattern, (u_char *)text, strlen(text));
+
+		if (testcases[ts].match == -1)
+			ATF_CHECK_EQ(off, NULL);
+		else
+			ATF_CHECK_EQ(testcases[ts].match,
+			  (off-(u_char *)text));
+
+		bm_free(pattern);
+		free(text);
+	}
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, bm);
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_memchr.c b/contrib/netbsd-tests/lib/libc/string/t_memchr.c
new file mode 100644
index 0000000..296f1f8
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_memchr.c
@@ -0,0 +1,194 @@
+/* $NetBSD: t_memchr.c,v 1.3 2012/04/06 07:53:10 jruoho Exp $ */
+
+/*
+ * Written by J.T. Conklin <jtc@acorntoolworks.com>
+ * Public domain.
+ */
+
+#include <atf-c.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+ATF_TC(memchr_basic);
+ATF_TC_HEAD(memchr_basic, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test memchr(3) results, #1");
+}
+
+ATF_TC_BODY(memchr_basic, tc)
+{
+	/* try to trick the compiler */
+	void * (*f)(const void *, int, size_t) = memchr;
+
+	unsigned int a, t;
+	void *off, *off2;
+	char buf[32];
+
+	struct tab {
+		const char	*val;
+		size_t  	 len;
+		char		 match;
+		ssize_t		 off;
+	};
+
+	const struct tab tab[] = {
+		{ "",			0, 0, 0 },
+
+		{ "/",			0, 0, 0 },
+		{ "/",			1, 1, 0 },
+		{ "/a",			2, 1, 0 },
+		{ "/ab",		3, 1, 0 },
+		{ "/abc",		4, 1, 0 },
+		{ "/abcd",		5, 1, 0 },
+		{ "/abcde",		6, 1, 0 },
+		{ "/abcdef",		7, 1, 0 },
+		{ "/abcdefg",		8, 1, 0 },
+
+		{ "a/",			1, 0, 0 },
+		{ "a/",			2, 1, 1 },
+		{ "a/b",		3, 1, 1 },
+		{ "a/bc",		4, 1, 1 },
+		{ "a/bcd",		5, 1, 1 },
+		{ "a/bcde",		6, 1, 1 },
+		{ "a/bcdef",		7, 1, 1 },
+		{ "a/bcdefg",		8, 1, 1 },
+
+		{ "ab/",		2, 0, 0 },
+		{ "ab/",		3, 1, 2 },
+		{ "ab/c",		4, 1, 2 },
+		{ "ab/cd",		5, 1, 2 },
+		{ "ab/cde",		6, 1, 2 },
+		{ "ab/cdef",		7, 1, 2 },
+		{ "ab/cdefg",		8, 1, 2 },
+
+		{ "abc/",		3, 0, 0 },
+		{ "abc/",		4, 1, 3 },
+		{ "abc/d",		5, 1, 3 },
+		{ "abc/de",		6, 1, 3 },
+		{ "abc/def",		7, 1, 3 },
+		{ "abc/defg",		8, 1, 3 },
+
+		{ "abcd/",		4, 0, 0 },
+		{ "abcd/",		5, 1, 4 },
+		{ "abcd/e",		6, 1, 4 },
+		{ "abcd/ef",		7, 1, 4 },
+		{ "abcd/efg",		8, 1, 4 },
+
+		{ "abcde/",		5, 0, 0 },
+		{ "abcde/",		6, 1, 5 },
+		{ "abcde/f",		7, 1, 5 },
+		{ "abcde/fg",		8, 1, 5 },
+
+		{ "abcdef/",		6, 0, 0 },
+		{ "abcdef/",		7, 1, 6 },
+		{ "abcdef/g",		8, 1, 6 },
+
+		{ "abcdefg/",		7, 0, 0 },
+		{ "abcdefg/",		8, 1, 7 },
+
+		{ "\xff\xff\xff\xff" "efg/",	8, 1, 7 },
+		{ "a" "\xff\xff\xff\xff" "fg/",	8, 1, 7 },
+		{ "ab" "\xff\xff\xff\xff" "g/",	8, 1, 7 },
+		{ "abc" "\xff\xff\xff\xff" "/",	8, 1, 7 },
+	};
+
+	for (a = 1; a < 1 + sizeof(long); ++a) {
+		for (t = 0; t < (sizeof(tab) / sizeof(tab[0])); ++t) {
+			buf[a-1] = '/';
+			strcpy(&buf[a], tab[t].val);
+
+			off = f(&buf[a], '/', tab[t].len);
+			if (tab[t].match == 0) {
+				if (off != 0) {
+					fprintf(stderr, "a = %d, t = %d\n",
+					    a, t);
+					atf_tc_fail("should not have found "
+					    " char past len");
+				}
+			} else if (tab[t].match == 1) {
+				if (tab[t].off != ((char*)off - &buf[a])) {
+					fprintf(stderr, "a = %d, t = %d\n",
+					    a, t);
+					atf_tc_fail("char not found at "
+					    "correct offset");
+				}
+	    		} else {
+				fprintf(stderr, "a = %d, t = %d\n", a, t);
+				atf_tc_fail("Corrupt test case data");
+			}
+
+			/* check zero extension of char arg */
+			off2 = f(&buf[a], 0xffffff00 | '/', tab[t].len);
+			if (off2 != off)
+				atf_tc_fail("zero extension of char arg "
+				    "failed");
+		}
+	}
+}
+
+ATF_TC(memchr_simple);
+ATF_TC_HEAD(memchr_simple, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test memchr(3) results, #2");
+}
+
+ATF_TC_BODY(memchr_simple, tc)
+{
+	char buf[] = "abcdefg";
+	short i = 7;
+
+	ATF_CHECK(memchr(buf, 'a', 0) == NULL);
+	ATF_CHECK(memchr(buf, 'g', 0) == NULL);
+	ATF_CHECK(memchr(buf, 'x', 7) == NULL);
+
+	ATF_CHECK(memchr("\0", 'x', 0) == NULL);
+	ATF_CHECK(memchr("\0", 'x', 1) == NULL);
+
+	while (i <= 14) {
+
+		ATF_CHECK(memchr(buf, 'a', i) == buf + 0);
+		ATF_CHECK(memchr(buf, 'b', i) == buf + 1);
+		ATF_CHECK(memchr(buf, 'c', i) == buf + 2);
+		ATF_CHECK(memchr(buf, 'd', i) == buf + 3);
+		ATF_CHECK(memchr(buf, 'e', i) == buf + 4);
+		ATF_CHECK(memchr(buf, 'f', i) == buf + 5);
+		ATF_CHECK(memchr(buf, 'g', i) == buf + 6);
+
+		i *= 2;
+	}
+}
+
+ATF_TC(memrchr_simple);
+ATF_TC_HEAD(memrchr_simple, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test memrchr(3) results");
+}
+
+ATF_TC_BODY(memrchr_simple, tc)
+{
+	char buf[] = "abcdabcd";
+
+	ATF_CHECK(memrchr(buf, 'a', 0) == NULL);
+	ATF_CHECK(memrchr(buf, 'g', 0) == NULL);
+	ATF_CHECK(memrchr(buf, 'x', 8) == NULL);
+
+	ATF_CHECK(memrchr("\0", 'x', 0) == NULL);
+	ATF_CHECK(memrchr("\0", 'x', 1) == NULL);
+
+	ATF_CHECK(memrchr(buf, 'a', 8) == buf + 4);
+	ATF_CHECK(memrchr(buf, 'b', 8) == buf + 5);
+	ATF_CHECK(memrchr(buf, 'c', 8) == buf + 6);
+	ATF_CHECK(memrchr(buf, 'd', 8) == buf + 7);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, memchr_basic);
+	ATF_TP_ADD_TC(tp, memchr_simple);
+	ATF_TP_ADD_TC(tp, memrchr_simple);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_memcpy.c b/contrib/netbsd-tests/lib/libc/string/t_memcpy.c
new file mode 100644
index 0000000..6485a88
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_memcpy.c
@@ -0,0 +1,150 @@
+/* $NetBSD: t_memcpy.c,v 1.5 2013/03/17 02:23:31 christos Exp $ */
+
+/*-
+ * Copyright (c) 2010 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <md5.h>
+
+#include <sys/types.h>
+
+#define	ALIGNMENTS 16
+#define	LENGTHS	    4
+#define BLOCKTYPES 4
+
+MD5_CTX mc[1];
+
+typedef	unsigned char testBlock_t[ALIGNMENTS * LENGTHS];
+
+testBlock_t bss1, bss2;
+
+unsigned char *start[BLOCKTYPES] = {
+		bss1, bss2
+};
+
+char result[100];
+const char goodResult[] = "7b405d24bc03195474c70ddae9e1f8fb";
+
+static void
+runTest(unsigned char *b1, unsigned char *b2)
+{
+	int	i, j, k, m;
+	size_t	n;
+
+	for (i = 0; i < ALIGNMENTS; ++i) {
+		for (j = 0; j < ALIGNMENTS; ++j) {
+			k = sizeof(testBlock_t) - (i > j ? i : j);
+			for (m = 0; m < k; ++m) {
+				for (n = 0; n < sizeof(testBlock_t); ++n) {
+					b1[n] = (unsigned char)random();
+					b2[n] = (unsigned char)random();
+				}
+				memcpy(b1 + i, b2 + j, m);
+				MD5Update(mc, b1, sizeof(testBlock_t));
+				MD5Update(mc, b2, sizeof(testBlock_t));
+			}
+		}
+	}
+}
+
+ATF_TC(memcpy_basic);
+ATF_TC_HEAD(memcpy_basic, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test memcpy results");
+}
+
+ATF_TC_BODY(memcpy_basic, tc)
+{
+	int i, j;
+	testBlock_t auto1, auto2;
+
+	start[2] = auto1;
+	start[3] = auto2;
+
+	srandom(0L);
+	MD5Init(mc);
+	for (i = 0; i < BLOCKTYPES; ++i)
+		for (j = 0; j < BLOCKTYPES; ++j)
+			if (i != j)
+				runTest(start[i], start[j]);
+	MD5End(mc, result);
+	ATF_REQUIRE_EQ(strcmp(result, goodResult), 0);
+}
+
+ATF_TC(memccpy_simple);
+ATF_TC_HEAD(memccpy_simple, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test memccpy(3) results");
+}
+
+ATF_TC_BODY(memccpy_simple, tc)
+{
+	char buf[100];
+	char c = ' ';
+
+	(void)memset(buf, c, sizeof(buf));
+
+	ATF_CHECK(memccpy(buf, "foo bar", c, sizeof(buf)) != NULL);
+	ATF_CHECK(buf[4] == c);
+
+	ATF_CHECK(memccpy(buf, "foo bar", '\0', sizeof(buf) - 1) != NULL);
+	ATF_CHECK(buf[8] == c);
+
+	ATF_CHECK(memccpy(buf, "foo bar", 'x', 7) == NULL);
+	ATF_CHECK(strncmp(buf, "foo bar", 7) == 0);
+
+	ATF_CHECK(memccpy(buf, "xxxxxxx", 'r', 7) == NULL);
+	ATF_CHECK(strncmp(buf, "xxxxxxx", 7) == 0);
+}
+
+ATF_TC(memcpy_return);
+ATF_TC_HEAD(memcpy_return, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test memcpy(3) return value");
+}
+
+ATF_TC_BODY(memcpy_return, tc)
+{
+	char *b = (char *)0x1;
+	char c[2];
+	ATF_REQUIRE_EQ(memcpy(b, b, 0), b);
+	ATF_REQUIRE_EQ(memcpy(c, "ab", sizeof(c)), c);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, memcpy_basic);
+	ATF_TP_ADD_TC(tp, memcpy_return);
+	ATF_TP_ADD_TC(tp, memccpy_simple);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_memmem.c b/contrib/netbsd-tests/lib/libc/string/t_memmem.c
new file mode 100644
index 0000000..1e87af8
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_memmem.c
@@ -0,0 +1,100 @@
+/*	$NetBSD: t_memmem.c,v 1.2 2011/07/07 08:27:36 jruoho Exp $ */
+
+/*-
+ * Copyright (c) 2005 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Perry E. Metzger of Metzger, Dowdeswell & Co. LLC.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char p0[] = "";
+int lp0 = 0;
+char p1[] = "0123";
+int lp1 = 4;
+char p2[] = "456";
+int lp2 = 3;
+char p3[] = "789";
+int lp3 = 3;
+char p4[] = "abc";
+int lp4 = 3;
+char p5[] = "0";
+int lp5 = 1;
+char p6[] = "9";
+int lp6 = 1;
+char p7[] = "654";
+int lp7 = 3;
+
+char b0[] = "";
+int lb0 = 0;
+char b1[] = "0";
+int lb1 = 1;
+char b2[] = "0123456789";
+int lb2 = 10;
+
+#define expect(b)							\
+	if (!(b)) {							\
+		fprintf(stderr, "failed on line %d\n", __LINE__);	\
+		atf_tc_fail("Check stderr for test id/line");		\
+	}
+
+ATF_TC(memmem_basic);
+ATF_TC_HEAD(memmem_basic, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test memmem results");
+}
+
+ATF_TC_BODY(memmem_basic, tc)
+{
+
+	expect(memmem(b2, lb2, p0, lp0) == b2);
+	expect(memmem(b0, lb0, p0, lp0) == b0);
+	expect(memmem(b0, lb0, p1, lp1) == NULL);
+	expect(memmem(b1, lb1, p1, lp1) == NULL);
+
+	expect(memmem(b2, lb2, p1, lp1) == b2);
+	expect(memmem(b2, lb2, p2, lp2) == (b2 + 4));
+	expect(memmem(b2, lb2, p3, lp3) == (b2 + 7));
+
+	expect(memmem(b2, lb2, p5, lp5) == b2);
+	expect(memmem(b2, lb2, p6, lp6) == (b2 + 9));
+
+	expect(memmem(b2, lb2, p4, lp4) == NULL);
+	expect(memmem(b2, lb2, p7, lp7) == NULL);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, memmem_basic);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_memset.c b/contrib/netbsd-tests/lib/libc/string/t_memset.c
new file mode 100644
index 0000000..c1fb385
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_memset.c
@@ -0,0 +1,207 @@
+/* $NetBSD: t_memset.c,v 1.3 2013/03/17 02:23:31 christos Exp $ */
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Jukka Ruohonen.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: t_memset.c,v 1.3 2013/03/17 02:23:31 christos Exp $");
+
+#include <sys/stat.h>
+
+#include <atf-c.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static long	page = 0;
+static void	fill(char *, size_t, char);
+static bool	check(char *, size_t, char);
+
+ATF_TC(memset_array);
+ATF_TC_HEAD(memset_array, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test memset(3) with arrays");
+}
+
+ATF_TC_BODY(memset_array, tc)
+{
+	char buf[1024];
+
+	(void)memset(buf, 0, sizeof(buf));
+
+	if (check(buf, sizeof(buf), 0) != true)
+		atf_tc_fail("memset(3) did not fill a static buffer");
+
+	(void)memset(buf, 'x', sizeof(buf));
+
+	if (check(buf, sizeof(buf), 'x') != true)
+		atf_tc_fail("memset(3) did not fill a static buffer");
+}
+
+ATF_TC(memset_return);
+ATF_TC_HEAD(memset_return, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test memset(3) return value");
+}
+
+ATF_TC_BODY(memset_return, tc)
+{
+	char *b = (char *)0x1;
+	char c[2];
+	ATF_REQUIRE_EQ(memset(b, 0, 0), b);
+	ATF_REQUIRE_EQ(memset(c, 2, sizeof(c)), c);
+}
+
+ATF_TC(memset_basic);
+ATF_TC_HEAD(memset_basic, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "A basic test of memset(3)");
+}
+
+ATF_TC_BODY(memset_basic, tc)
+{
+	char *buf, *ret;
+
+	buf = malloc(page);
+	ret = malloc(page);
+
+	ATF_REQUIRE(buf != NULL);
+	ATF_REQUIRE(ret != NULL);
+
+	fill(ret, page, 0);
+	memset(buf, 0, page);
+
+	ATF_REQUIRE(memcmp(ret, buf, page) == 0);
+
+	fill(ret, page, 'x');
+	memset(buf, 'x', page);
+
+	ATF_REQUIRE(memcmp(ret, buf, page) == 0);
+
+	free(buf);
+	free(ret);
+}
+
+ATF_TC(memset_nonzero);
+ATF_TC_HEAD(memset_nonzero, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test memset(3) with non-zero params");
+}
+
+ATF_TC_BODY(memset_nonzero, tc)
+{
+	const size_t n = 0x7f;
+	char *buf;
+	size_t i;
+
+	buf = malloc(page);
+	ATF_REQUIRE(buf != NULL);
+
+	for (i = 0x21; i < n; i++) {
+
+		(void)memset(buf, i, page);
+
+		if (check(buf, page, i) != true)
+			atf_tc_fail("memset(3) did not fill properly");
+	}
+
+	free(buf);
+}
+
+ATF_TC(memset_struct);
+ATF_TC_HEAD(memset_struct, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test memset(3) with a structure");
+}
+
+ATF_TC_BODY(memset_struct, tc)
+{
+	struct stat st;
+
+	st.st_dev = 0;
+	st.st_ino = 1;
+	st.st_mode = 2;
+	st.st_nlink = 3;
+	st.st_uid = 4;
+	st.st_gid = 5;
+	st.st_rdev = 6;
+	st.st_size = 7;
+	st.st_atime = 8;
+	st.st_mtime = 9;
+
+	(void)memset(&st, 0, sizeof(struct stat));
+
+	ATF_CHECK(st.st_dev == 0);
+	ATF_CHECK(st.st_ino == 0);
+	ATF_CHECK(st.st_mode == 0);
+	ATF_CHECK(st.st_nlink == 0);
+	ATF_CHECK(st.st_uid == 0);
+	ATF_CHECK(st.st_gid == 0);
+	ATF_CHECK(st.st_rdev == 0);
+	ATF_CHECK(st.st_size == 0);
+	ATF_CHECK(st.st_atime == 0);
+	ATF_CHECK(st.st_mtime == 0);
+}
+
+static void
+fill(char *buf, size_t len, char x)
+{
+	size_t i;
+
+	for (i = 0; i < len; i++)
+		buf[i] = x;
+}
+
+static bool
+check(char *buf, size_t len, char x)
+{
+	size_t i;
+
+	for (i = 0; i < len; i++) {
+
+		if (buf[i] != x)
+			return false;
+	}
+
+	return true;
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	page = sysconf(_SC_PAGESIZE);
+	ATF_REQUIRE(page >= 0);
+
+	ATF_TP_ADD_TC(tp, memset_array);
+	ATF_TP_ADD_TC(tp, memset_basic);
+	ATF_TP_ADD_TC(tp, memset_nonzero);
+	ATF_TP_ADD_TC(tp, memset_struct);
+	ATF_TP_ADD_TC(tp, memset_return);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_popcount.c b/contrib/netbsd-tests/lib/libc/string/t_popcount.c
new file mode 100644
index 0000000..2bae52f
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_popcount.c
@@ -0,0 +1,198 @@
+/*	$NetBSD: t_popcount.c,v 1.4 2011/07/07 08:27:36 jruoho Exp $	*/
+/*-
+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Joerg Sonnenberger.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: t_popcount.c,v 1.4 2011/07/07 08:27:36 jruoho Exp $");
+
+#include <atf-c.h>
+#include <strings.h>
+
+static unsigned int byte_count[256];
+
+static void
+popcount_init(const char *cfg_var)
+{
+	unsigned int i, j;
+
+	if (strcasecmp(cfg_var, "YES")  == 0 ||
+	    strcasecmp(cfg_var, "Y")    == 0 ||
+	    strcasecmp(cfg_var, "1")    == 0 ||
+	    strcasecmp(cfg_var, "T")    == 0 ||
+	    strcasecmp(cfg_var, "TRUE") == 0) {
+		for (i = 0; i < 256; ++i) {
+			byte_count[i] = 0;
+			for (j = i; j != 0; j >>= 1) {
+				if (j & 1)
+					++byte_count[i];
+			}
+		}
+		return;
+	}
+
+	atf_tc_skip("config variable \"run_popcount\" not set to YES/TRUE");
+}
+
+unsigned int test_parts[256] = {
+	0x318e53e6U, 0x11710316U, 0x62608ffaU, 0x67e0f562U,
+	0xe432e82cU, 0x9862e8b2U, 0x7d96a627U, 0x3f74ad31U,
+	0x3cecf906U, 0xcdc0dcb4U, 0x241dab64U, 0x31e6133eU,
+	0x23086ad4U, 0x721d5a91U, 0xc483da53U, 0x6a62af52U,
+	0xf3f5c386U, 0xe0de3f77U, 0x65afe528U, 0xf4816485U,
+	0x40ccbf08U, 0x25df49c1U, 0xae5a6ee0U, 0xab36ccadU,
+	0x87e1ec29U, 0x60ca2407U, 0x49d62e47U, 0xa09f2df5U,
+	0xaf4c1c68U, 0x8ef08d50U, 0x624cfd2fU, 0xa6a36f20U,
+	0x68aaf879U, 0x0fe9deabU, 0x5c9a4060U, 0x215d8f08U,
+	0x55e84712U, 0xea1f1681U, 0x3a10b8a1U, 0x08e06632U,
+	0xcbc875e2U, 0x31e53258U, 0xcd3807a4U, 0xb9d17516U,
+	0x8fbfd9abU, 0x6651b555U, 0x550fb381U, 0x05061b9dU,
+	0x35aef3f2U, 0x9175078cU, 0xae0f14daU, 0x92a2d5f8U,
+	0x70d968feU, 0xe86f41c5U, 0x5cfaf39fU, 0x8499b18dU,
+	0xb33f879aU, 0x0a68ad3dU, 0x9323ecc1U, 0x060037ddU,
+	0xb91a5051U, 0xa0dbebf6U, 0x3e6aa6f1U, 0x7b422b5bU,
+	0x599e811eU, 0x199f7594U, 0xca453365U, 0x1cda6f48U,
+	0xe9c75d2cU, 0x6a873217U, 0x79c45d72U, 0x143b8e37U,
+	0xa11df26eU, 0xaf31f80aU, 0x311bf759U, 0x2378563cU,
+	0x9ab95fa5U, 0xfcf4d47cU, 0x1f7db268U, 0xd64b09e1U,
+	0xad7936daU, 0x7a59005cU, 0x45b173d3U, 0xc1a71b32U,
+	0x7d9f0de2U, 0xa9ac3792U, 0x9e7f9966U, 0x7f0b8080U,
+	0xece6c06fU, 0x78d92a3cU, 0x6d5f8f6cU, 0xc50ca544U,
+	0x5d8ded27U, 0xd27a8462U, 0x4bcd13ccU, 0xd49075f2U,
+	0xa8d52acfU, 0x41915d97U, 0x564f7062U, 0xefb046e2U,
+	0xe296277aU, 0x605b0ea3U, 0x10b2c3a1U, 0x4e8e5c66U,
+	0x4bd8ec04U, 0x29935be9U, 0x381839f3U, 0x555d8824U,
+	0xd6befddbU, 0x5d8d6d6eU, 0xb2fdb7b4U, 0xb471c8fcU,
+	0xc2fd325bU, 0x932d2487U, 0xbdbbadefU, 0x66c8895dU,
+	0x5d77857aU, 0x259f1cc0U, 0x302037faU, 0xda9aa7a8U,
+	0xb112c6aaU, 0x78f74192U, 0xfd4da741U, 0xfa5765c1U,
+	0x6ea1bc5cU, 0xd283f39cU, 0x268ae67dU, 0xdedcd134U,
+	0xbbf92410U, 0x6b45fb55U, 0x2f75ac71U, 0x64bf2ca5U,
+	0x8b99675aU, 0x3f4923b6U, 0x7e610550U, 0x04b1c06dU,
+	0x8f92e7c6U, 0x45cb608bU, 0x2d06d1f2U, 0x79cf387aU,
+	0xfd3ed225U, 0x243eee20U, 0x2cbefc6fU, 0x8286cbaaU,
+	0x70d4c182U, 0x054e3cc6U, 0xb66c5362U, 0x0c73fa5dU,
+	0x539948feU, 0xec638563U, 0x0cf04ab6U, 0xec7b52f4U,
+	0x58eeffceU, 0x6fe8049aU, 0xb3b33332U, 0x2e33bfdbU,
+	0xcc817567U, 0x71ac57c8U, 0x4bab3ac7U, 0x327c558bU,
+	0x82a6d279U, 0x5adf71daU, 0x1074a656U, 0x3c533c1fU,
+	0x82fdbe69U, 0x21b4f6afU, 0xd59580e8U, 0x0de824ebU,
+	0xa510941bU, 0x7cd91144U, 0xa8c10631U, 0x4c839267U,
+	0x5d503c2fU, 0xe1567d55U, 0x23910cc7U, 0xdb1bdc34U,
+	0x2a866704U, 0x33e21f0cU, 0x5c7681b4U, 0x818651caU,
+	0xb1d18162U, 0x225ad014U, 0xadf7d6baU, 0xac548d9bU,
+	0xe94736e5U, 0x2279c5f1U, 0x33215d2cU, 0xdc8ab90eU,
+	0xf5e3d7f2U, 0xedcb15cfU, 0xc9a43c4cU, 0xfc678fc6U,
+	0x43796b95U, 0x3f8b700cU, 0x867bbc72U, 0x81f71fecU,
+	0xd00cad7dU, 0x302c458fU, 0x8ae21accU, 0x05850ce8U,
+	0x7764d8e8U, 0x8a36cd68U, 0x40b44bd7U, 0x1cffaeb7U,
+	0x2b248f34U, 0x1eefdbafU, 0x574d7437U, 0xe86cd935U,
+	0xf53dd1c8U, 0x1b022513U, 0xef2d249bU, 0x94fb2b08U,
+	0x15d3eff8U, 0x14245e1bU, 0x82aa8425U, 0x53959028U,
+	0x9c5f9b80U, 0x325e0c82U, 0x3e236c24U, 0x74e1dd36U,
+	0x9890df3fU, 0xaf9701a2U, 0x023b3413U, 0x7634c67eU,
+	0x55cf5e45U, 0x56d2a95bU, 0xb6db869bU, 0xac19e260U,
+	0xdd310740U, 0x26d68f84U, 0x45bebf17U, 0xe4a7728fU,
+	0xf082e66eU, 0xb2fe3c10U, 0x2db1fa2cU, 0x4b3dfcfaU,
+	0xc7b3a672U, 0xaeadc67bU, 0x6cce6f2bU, 0x8263dbbfU,
+	0xd9724d5bU, 0xbcc767b5U, 0x8d563798U, 0x2db764b4U,
+	0x76e0cee7U, 0xd34f9a67U, 0x035c810aU, 0x3f56bdc1U,
+	0x5b3f2c84U, 0x0baca8c0U, 0xfe979a77U, 0x484ca775U,
+	0xbdc7f104U, 0xc06c3efbU, 0xdbc5f32cU, 0x44b017e7U,
+};
+
+ATF_TC(popcount_basic);
+ATF_TC_HEAD(popcount_basic, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test popcount results");
+	atf_tc_set_md_var(tc, "timeout", "0");
+}
+
+ATF_TC_BODY(popcount_basic, tc)
+{
+	unsigned int i, r;
+
+	popcount_init(atf_tc_get_config_var_wd(tc, "run_popcount", "NO"));
+
+	for (i = 0; i < 0xffffffff; ++i) {
+		r = byte_count[i & 255] + byte_count[(i >> 8) & 255]
+		    + byte_count[(i >> 16) & 255]
+		    + byte_count[(i >> 24) & 255];
+
+		ATF_CHECK_EQ(r, popcount(i));
+	}
+	ATF_CHECK_EQ(popcount(0xffffffff), 32);
+}
+
+ATF_TC(popcountll_basic);
+ATF_TC_HEAD(popcountll_basic, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test popcountll results");
+	atf_tc_set_md_var(tc, "timeout", "0");
+}
+
+ATF_TC_BODY(popcountll_basic, tc)
+{
+	unsigned int i, j, r, r2, p;
+	unsigned long long v;
+
+	popcount_init(atf_tc_get_config_var_wd(tc, "run_popcount", "NO"));
+
+	for (j = 0; j < 256; ++j) {
+		p = test_parts[j];
+		r2 = byte_count[p & 255] + byte_count[(p >> 8) & 255]
+		    + byte_count[(p >> 16) & 255]
+		    + byte_count[(p >> 24) & 255];
+
+		for (i = 0; i < 0xffffffff; ++i) {
+			r = byte_count[i & 255] + byte_count[(i >> 8) & 255]
+			    + byte_count[(i >> 16) & 255]
+			    + byte_count[(i >> 24) & 255] + r2;
+
+			v = (((unsigned long long)i) << 32) + p;
+			ATF_CHECK_EQ(r, popcountll(v));
+			v = (((unsigned long long)p) << 32) + i;
+			ATF_CHECK_EQ(r, popcountll(v));
+		}
+	}
+
+	ATF_CHECK_EQ(popcountll(0xffffffffffffffffULL), 64);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+	ATF_TP_ADD_TC(tp, popcount_basic);
+	ATF_TP_ADD_TC(tp, popcountll_basic);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strcat.c b/contrib/netbsd-tests/lib/libc/string/t_strcat.c
new file mode 100644
index 0000000..bd98691
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strcat.c
@@ -0,0 +1,153 @@
+/* $NetBSD: t_strcat.c,v 1.2 2011/07/14 05:46:04 jruoho Exp $ */
+
+/*
+ * Written by J.T. Conklin <jtc@acorntoolworks.com>
+ * Public domain.
+ */
+
+#include <atf-c.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+ATF_TC(strcat_basic);
+ATF_TC_HEAD(strcat_basic, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test strcat(3) results");
+}
+
+ATF_TC_BODY(strcat_basic, tc)
+{
+	/* try to trick the compiler */
+	char * (*f)(char *, const char *s) = strcat;
+
+	unsigned int a0, a1, t0, t1;
+	char buf0[64];
+	char buf1[64];
+	char *ret;
+
+	struct tab {
+		const char*	val;
+		size_t		len;
+	};
+
+	const struct tab tab[] = {
+	/*
+	 * patterns that check for all combinations of leading and
+	 * trailing unaligned characters (on a 64 bit processor)
+	 */
+
+		{ "",				0 },
+		{ "a",				1 },
+		{ "ab",				2 },
+		{ "abc",			3 },
+		{ "abcd",			4 },
+		{ "abcde",			5 },
+		{ "abcdef",			6 },
+		{ "abcdefg",			7 },
+		{ "abcdefgh",			8 },
+		{ "abcdefghi",			9 },
+		{ "abcdefghij",			10 },
+		{ "abcdefghijk",		11 },
+		{ "abcdefghijkl",		12 },
+		{ "abcdefghijklm",		13 },
+		{ "abcdefghijklmn",		14 },
+		{ "abcdefghijklmno",		15 },
+		{ "abcdefghijklmnop",		16 },
+		{ "abcdefghijklmnopq",		17 },
+		{ "abcdefghijklmnopqr",		18 },
+		{ "abcdefghijklmnopqrs",	19 },
+		{ "abcdefghijklmnopqrst",	20 },
+		{ "abcdefghijklmnopqrstu",	21 },
+		{ "abcdefghijklmnopqrstuv",	22 },
+		{ "abcdefghijklmnopqrstuvw",	23 },
+
+		/*
+		 * patterns that check for the cases where the expression:
+		 *
+		 *	((word - 0x7f7f..7f) & 0x8080..80)
+		 *
+		 * returns non-zero even though there are no zero bytes in
+		 * the word.
+		 */
+
+		{ "" "\xff\xff\xff\xff\xff\xff\xff\xff" "abcdefgh",	16 },
+		{ "a" "\xff\xff\xff\xff\xff\xff\xff\xff" "bcdefgh",	16 },
+		{ "ab" "\xff\xff\xff\xff\xff\xff\xff\xff" "cdefgh",	16 },
+		{ "abc" "\xff\xff\xff\xff\xff\xff\xff\xff" "defgh",	16 },
+		{ "abcd" "\xff\xff\xff\xff\xff\xff\xff\xff" "efgh",	16 },
+		{ "abcde" "\xff\xff\xff\xff\xff\xff\xff\xff" "fgh",	16 },
+		{ "abcdef" "\xff\xff\xff\xff\xff\xff\xff\xff" "gh",	16 },
+		{ "abcdefg" "\xff\xff\xff\xff\xff\xff\xff\xff" "h",	16 },
+		{ "abcdefgh" "\xff\xff\xff\xff\xff\xff\xff\xff" "",	16 },
+	};
+
+	for (a0 = 0; a0 < sizeof(long); ++a0) {
+		for (a1 = 0; a1 < sizeof(long); ++a1) {
+			for (t0 = 0; t0 < __arraycount(tab); ++t0) {
+				for (t1 = 0; t1 < __arraycount(tab); ++t1) {
+
+					memcpy(&buf0[a0], tab[t0].val,
+					    tab[t0].len + 1);
+					memcpy(&buf1[a1], tab[t1].val,
+					    tab[t1].len + 1);
+
+					ret = f(&buf0[a0], &buf1[a1]);
+
+					/*
+					 * verify strcat returns address
+					 * of first parameter
+					 */
+					if (&buf0[a0] != ret) {
+						fprintf(stderr, "a0 %d, a1 %d, "
+						    "t0 %d, t1 %d\n",
+						    a0, a1, t0, t1);
+						atf_tc_fail("strcat did not "
+						    "return its first arg");
+					}
+
+					/* verify string copied correctly */
+					if (memcmp(&buf0[a0] + tab[t0].len,
+						   &buf1[a1],
+						   tab[t1].len + 1) != 0) {
+						fprintf(stderr, "a0 %d, a1 %d, "
+						    "t0 %d, t1 %d\n",
+						    a0, a1, t0, t1);
+						atf_tc_fail("string not copied "
+						    "correctly");
+					}
+				}
+			}
+		}
+	}
+}
+
+ATF_TC(strncat_simple);
+ATF_TC_HEAD(strncat_simple, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test strncat(3) results");
+}
+
+ATF_TC_BODY(strncat_simple, tc)
+{
+	char buf[100] = "abcdefg";
+
+	ATF_CHECK(strncat(buf, "xxx", 0) == buf);
+	ATF_CHECK(strcmp(buf, "abcdefg") == 0);
+	ATF_CHECK(strncat(buf, "xxx", 1) == buf);
+	ATF_CHECK(strcmp(buf, "abcdefgx") == 0);
+	ATF_CHECK(strncat(buf, "xxx", 2) == buf);
+	ATF_CHECK(strcmp(buf, "abcdefgxxx") == 0);
+	ATF_CHECK(strncat(buf, "\0", 1) == buf);
+	ATF_CHECK(strcmp(buf, "abcdefgxxx") == 0);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, strcat_basic);
+	ATF_TP_ADD_TC(tp, strncat_simple);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strchr.c b/contrib/netbsd-tests/lib/libc/string/t_strchr.c
new file mode 100644
index 0000000..958b186
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strchr.c
@@ -0,0 +1,292 @@
+/* $NetBSD: t_strchr.c,v 1.1 2011/07/07 08:59:33 jruoho Exp $ */
+
+/*
+ * Written by J.T. Conklin <jtc@acorntoolworks.com>
+ * Public domain.
+ */
+
+#include <atf-c.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+
+static char	*slow_strchr(char *, int);
+static void	 verify_strchr(char *, int, unsigned int, unsigned int);
+
+char * (*volatile strchr_fn)(const char *, int);
+
+static char *
+slow_strchr(char *buf, int ch)
+{
+	unsigned char c = 1;
+
+	ch &= 0xff;
+
+	for (; c != 0; buf++) {
+		c = *buf;
+		if (c == ch)
+			return buf;
+	}
+	return 0;
+}
+
+static void
+verify_strchr(char *buf, int ch, unsigned int t, unsigned int a)
+{
+	const char *off, *ok_off;
+
+	off = strchr_fn(buf, ch);
+	ok_off = slow_strchr(buf, ch);
+	if (off == ok_off)
+		return;
+
+	fprintf(stderr, "test_strchr(\"%s\", %#x) gave %zd not %zd (test %d, "
+	    "alignment %d)\n",
+	    buf, ch, off ? off - buf : -1, ok_off ? ok_off - buf : -1, t, a);
+
+	atf_tc_fail("Check stderr for details");
+}
+
+ATF_TC(strchr_basic);
+ATF_TC_HEAD(strchr_basic, tc)
+{
+
+        atf_tc_set_md_var(tc, "descr", "Test strchr(3) results");
+}
+
+ATF_TC_BODY(strchr_basic, tc)
+{
+	unsigned int t, a;
+	char *off;
+	char buf[32];
+
+	const char *tab[] = {
+		"",
+		"a",
+		"aa",
+		"abc",
+		"abcd",
+		"abcde",
+		"abcdef",
+		"abcdefg",
+		"abcdefgh",
+
+		"/",
+		"//",
+		"/a",
+		"/a/",
+		"/ab",
+		"/ab/",
+		"/abc",
+		"/abc/",
+		"/abcd",
+		"/abcd/",
+		"/abcde",
+		"/abcde/",
+		"/abcdef",
+		"/abcdef/",
+		"/abcdefg",
+		"/abcdefg/",
+		"/abcdefgh",
+		"/abcdefgh/",
+
+		"a/",
+		"a//",
+		"a/a",
+		"a/a/",
+		"a/ab",
+		"a/ab/",
+		"a/abc",
+		"a/abc/",
+		"a/abcd",
+		"a/abcd/",
+		"a/abcde",
+		"a/abcde/",
+		"a/abcdef",
+		"a/abcdef/",
+		"a/abcdefg",
+		"a/abcdefg/",
+		"a/abcdefgh",
+		"a/abcdefgh/",
+
+		"ab/",
+		"ab//",
+		"ab/a",
+		"ab/a/",
+		"ab/ab",
+		"ab/ab/",
+		"ab/abc",
+		"ab/abc/",
+		"ab/abcd",
+		"ab/abcd/",
+		"ab/abcde",
+		"ab/abcde/",
+		"ab/abcdef",
+		"ab/abcdef/",
+		"ab/abcdefg",
+		"ab/abcdefg/",
+		"ab/abcdefgh",
+		"ab/abcdefgh/",
+
+		"abc/",
+		"abc//",
+		"abc/a",
+		"abc/a/",
+		"abc/ab",
+		"abc/ab/",
+		"abc/abc",
+		"abc/abc/",
+		"abc/abcd",
+		"abc/abcd/",
+		"abc/abcde",
+		"abc/abcde/",
+		"abc/abcdef",
+		"abc/abcdef/",
+		"abc/abcdefg",
+		"abc/abcdefg/",
+		"abc/abcdefgh",
+		"abc/abcdefgh/",
+
+		"abcd/",
+		"abcd//",
+		"abcd/a",
+		"abcd/a/",
+		"abcd/ab",
+		"abcd/ab/",
+		"abcd/abc",
+		"abcd/abc/",
+		"abcd/abcd",
+		"abcd/abcd/",
+		"abcd/abcde",
+		"abcd/abcde/",
+		"abcd/abcdef",
+		"abcd/abcdef/",
+		"abcd/abcdefg",
+		"abcd/abcdefg/",
+		"abcd/abcdefgh",
+		"abcd/abcdefgh/",
+
+		"abcde/",
+		"abcde//",
+		"abcde/a",
+		"abcde/a/",
+		"abcde/ab",
+		"abcde/ab/",
+		"abcde/abc",
+		"abcde/abc/",
+		"abcde/abcd",
+		"abcde/abcd/",
+		"abcde/abcde",
+		"abcde/abcde/",
+		"abcde/abcdef",
+		"abcde/abcdef/",
+		"abcde/abcdefg",
+		"abcde/abcdefg/",
+		"abcde/abcdefgh",
+		"abcde/abcdefgh/",
+
+		"abcdef/",
+		"abcdef//",
+		"abcdef/a",
+		"abcdef/a/",
+		"abcdef/ab",
+		"abcdef/ab/",
+		"abcdef/abc",
+		"abcdef/abc/",
+		"abcdef/abcd",
+		"abcdef/abcd/",
+		"abcdef/abcde",
+		"abcdef/abcde/",
+		"abcdef/abcdef",
+		"abcdef/abcdef/",
+		"abcdef/abcdefg",
+		"abcdef/abcdefg/",
+		"abcdef/abcdefgh",
+		"abcdef/abcdefgh/",
+
+		"abcdefg/",
+		"abcdefg//",
+		"abcdefg/a",
+		"abcdefg/a/",
+		"abcdefg/ab",
+		"abcdefg/ab/",
+		"abcdefg/abc",
+		"abcdefg/abc/",
+		"abcdefg/abcd",
+		"abcdefg/abcd/",
+		"abcdefg/abcde",
+		"abcdefg/abcde/",
+		"abcdefg/abcdef",
+		"abcdefg/abcdef/",
+		"abcdefg/abcdefg",
+		"abcdefg/abcdefg/",
+		"abcdefg/abcdefgh",
+		"abcdefg/abcdefgh/",
+
+		"abcdefgh/",
+		"abcdefgh//",
+		"abcdefgh/a",
+		"abcdefgh/a/",
+		"abcdefgh/ab",
+		"abcdefgh/ab/",
+		"abcdefgh/abc",
+		"abcdefgh/abc/",
+		"abcdefgh/abcd",
+		"abcdefgh/abcd/",
+		"abcdefgh/abcde",
+		"abcdefgh/abcde/",
+		"abcdefgh/abcdef",
+		"abcdefgh/abcdef/",
+		"abcdefgh/abcdefg",
+		"abcdefgh/abcdefg/",
+		"abcdefgh/abcdefgh",
+		"abcdefgh/abcdefgh/",
+	};
+
+
+	strchr_fn = dlsym(dlopen(0, RTLD_LAZY), "test_strchr");
+	if (!strchr_fn)
+		strchr_fn = strchr;
+
+	for (a = 3; a < 3 + sizeof(long); ++a) {
+		/* Put char and a \0 before the buffer */
+		buf[a-1] = '/';
+		buf[a-2] = '0';
+		buf[a-3] = 0xff;
+		for (t = 0; t < (sizeof(tab) / sizeof(tab[0])); ++t) {
+			int len = strlen(tab[t]) + 1;
+			memcpy(&buf[a], tab[t], len);
+
+			/* Put the char we are looking for after the \0 */
+			buf[a + len] = '/';
+
+			/* Check search for NUL at end of string */
+			verify_strchr(buf + a, 0, t, a);
+
+			/* Then for the '/' in the strings */
+			verify_strchr(buf + a, '/', t, a);
+
+		   	/* check zero extension of char arg */
+		   	verify_strchr(buf + a, 0xffffff00 | '/', t, a);
+
+		   	/* Replace all the '/' with 0xff */
+		   	while ((off = slow_strchr(buf + a, '/')) != NULL)
+				*off = 0xff;
+
+			buf[a + len] = 0xff;
+
+			/* Check we can search for 0xff as well as '/' */
+			verify_strchr(buf + a, 0xff, t, a);
+		}
+	}
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, strchr_basic);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strcmp.c b/contrib/netbsd-tests/lib/libc/string/t_strcmp.c
new file mode 100644
index 0000000..14e2e9c
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strcmp.c
@@ -0,0 +1,136 @@
+/* $NetBSD: t_strcmp.c,v 1.4 2012/03/25 08:17:54 joerg Exp $ */
+
+/*
+ * Written by J.T. Conklin <jtc@acorntoolworks.com>
+ * Public domain.
+ */
+
+#include <atf-c.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+ATF_TC(strcmp_basic);
+ATF_TC_HEAD(strcmp_basic, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test strcmp(3) results, #1");
+}
+
+ATF_TC_BODY(strcmp_basic, tc)
+{
+	/* try to trick the compiler */
+	int (*f)(const char *, const char *s) = strcmp;
+
+	unsigned int a0, a1, t;
+	char buf0[64];
+	char buf1[64];
+	int ret;
+
+	struct tab {
+		const char*	val0;
+		const char*	val1;
+		int		ret;
+	};
+
+	const struct tab tab[] = {
+		{ "",			"",			0 },
+
+		{ "a",			"a",			0 },
+		{ "a",			"b",			-1 },
+		{ "b",			"a",			+1 },
+		{ "",			"a",			-1 },
+		{ "a",			"",			+1 },
+
+		{ "aa",			"aa",			0 },
+		{ "aa",			"ab",			-1 },
+		{ "ab",			"aa",			+1 },
+		{ "a",			"aa",			-1 },
+		{ "aa",			"a",			+1 },
+
+		{ "aaa",		"aaa",			0 },
+		{ "aaa",		"aab",			-1 },
+		{ "aab",		"aaa",			+1 },
+		{ "aa",			"aaa",			-1 },
+		{ "aaa",		"aa",			+1 },
+
+		{ "aaaa",		"aaaa",			0 },
+		{ "aaaa",		"aaab",			-1 },
+		{ "aaab",		"aaaa",			+1 },
+		{ "aaa",		"aaaa",			-1 },
+		{ "aaaa",		"aaa",			+1 },
+
+		{ "aaaaa",		"aaaaa",		0 },
+		{ "aaaaa",		"aaaab",		-1 },
+		{ "aaaab",		"aaaaa",		+1 },
+		{ "aaaa",		"aaaaa",		-1 },
+		{ "aaaaa",		"aaaa",			+1 },
+
+		{ "aaaaaa",		"aaaaaa",		0 },
+		{ "aaaaaa",		"aaaaab",		-1 },
+		{ "aaaaab",		"aaaaaa",		+1 },
+		{ "aaaaa",		"aaaaaa",		-1 },
+		{ "aaaaaa",		"aaaaa",		+1 },
+	};
+
+	for (a0 = 0; a0 < sizeof(long); ++a0) {
+		for (a1 = 0; a1 < sizeof(long); ++a1) {
+			for (t = 0; t < __arraycount(tab); ++t) {
+				memcpy(&buf0[a0], tab[t].val0,
+				       strlen(tab[t].val0) + 1);
+				memcpy(&buf1[a1], tab[t].val1,
+				       strlen(tab[t].val1) + 1);
+
+				ret = f(&buf0[a0], &buf1[a1]);
+
+				if ((ret == 0 && tab[t].ret != 0) ||
+				    (ret <  0 && tab[t].ret >= 0) ||
+				    (ret >  0 && tab[t].ret <= 0)) {
+					fprintf(stderr, "a0 %d, a1 %d, t %d\n",
+					    a0, a1, t);
+					fprintf(stderr, "\"%s\" \"%s\" %d\n",
+					    &buf0[a0], &buf1[a1], ret);
+					atf_tc_fail("Check stderr for details");
+				}
+			}
+		}
+	}
+}
+
+ATF_TC(strcmp_simple);
+ATF_TC_HEAD(strcmp_simple, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test strcmp(3) results, #2");
+}
+
+ATF_TC_BODY(strcmp_simple, tc)
+{
+	char buf1[10] = "xxx";
+	char buf2[10] = "xxy";
+
+	ATF_CHECK(strcmp(buf1, buf1) == 0);
+	ATF_CHECK(strcmp(buf2, buf2) == 0);
+
+	ATF_CHECK(strcmp("x\xf6x", "xox") > 0);
+	ATF_CHECK(strcmp("xxx", "xxxyyy") < 0);
+	ATF_CHECK(strcmp("xxxyyy", "xxx") > 0);
+
+	ATF_CHECK(strcmp(buf1 + 0, buf2 + 0) < 0);
+	ATF_CHECK(strcmp(buf1 + 1, buf2 + 1) < 0);
+	ATF_CHECK(strcmp(buf1 + 2, buf2 + 2) < 0);
+	ATF_CHECK(strcmp(buf1 + 3, buf2 + 3) == 0);
+
+	ATF_CHECK(strcmp(buf2 + 0, buf1 + 0) > 0);
+	ATF_CHECK(strcmp(buf2 + 1, buf1 + 1) > 0);
+	ATF_CHECK(strcmp(buf2 + 2, buf1 + 2) > 0);
+	ATF_CHECK(strcmp(buf2 + 3, buf1 + 3) == 0);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, strcmp_basic);
+	ATF_TP_ADD_TC(tp, strcmp_simple);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strcpy.c b/contrib/netbsd-tests/lib/libc/string/t_strcpy.c
new file mode 100644
index 0000000..285371e
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strcpy.c
@@ -0,0 +1,124 @@
+/* $NetBSD: t_strcpy.c,v 1.1 2011/07/07 08:59:33 jruoho Exp $ */
+
+/*
+ * Written by J.T. Conklin <jtc@acorntoolworks.com>
+ * Public domain.
+ */
+
+#include <atf-c.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+ATF_TC(strcpy_basic);
+ATF_TC_HEAD(strcpy_basic, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test strcpy(3) results");
+}
+
+ATF_TC_BODY(strcpy_basic, tc)
+{
+	/* try to trick the compiler */
+	char * (*f)(char *, const char *s) = strcpy;
+
+	unsigned int a0, a1, t;
+	char buf0[64];
+	char buf1[64];
+	char *ret;
+
+	struct tab {
+		const char*	val;
+		size_t		len;
+	};
+
+	const struct tab tab[] = {
+		/*
+		 * patterns that check for all combinations of leading and
+		 * trailing unaligned characters (on a 64 bit processor)
+		 */
+
+		{ "",				0 },
+		{ "a",				1 },
+		{ "ab",				2 },
+		{ "abc",			3 },
+		{ "abcd",			4 },
+		{ "abcde",			5 },
+		{ "abcdef",			6 },
+		{ "abcdefg",			7 },
+		{ "abcdefgh",			8 },
+		{ "abcdefghi",			9 },
+		{ "abcdefghij",			10 },
+		{ "abcdefghijk",		11 },
+		{ "abcdefghijkl",		12 },
+		{ "abcdefghijklm",		13 },
+		{ "abcdefghijklmn",		14 },
+		{ "abcdefghijklmno",		15 },
+		{ "abcdefghijklmnop",		16 },
+		{ "abcdefghijklmnopq",		17 },
+		{ "abcdefghijklmnopqr",		18 },
+		{ "abcdefghijklmnopqrs",	19 },
+		{ "abcdefghijklmnopqrst",	20 },
+		{ "abcdefghijklmnopqrstu",	21 },
+		{ "abcdefghijklmnopqrstuv",	22 },
+		{ "abcdefghijklmnopqrstuvw",	23 },
+
+		/*
+		 * patterns that check for the cases where the expression:
+		 *
+		 *	((word - 0x7f7f..7f) & 0x8080..80)
+		 *
+		 * returns non-zero even though there are no zero bytes in
+		 * the word.
+		 */
+
+		{ "" "\xff\xff\xff\xff\xff\xff\xff\xff" "abcdefgh",	16 },
+		{ "a" "\xff\xff\xff\xff\xff\xff\xff\xff" "bcdefgh",	16 },
+		{ "ab" "\xff\xff\xff\xff\xff\xff\xff\xff" "cdefgh",	16 },
+		{ "abc" "\xff\xff\xff\xff\xff\xff\xff\xff" "defgh",	16 },
+		{ "abcd" "\xff\xff\xff\xff\xff\xff\xff\xff" "efgh",	16 },
+		{ "abcde" "\xff\xff\xff\xff\xff\xff\xff\xff" "fgh",	16 },
+		{ "abcdef" "\xff\xff\xff\xff\xff\xff\xff\xff" "gh",	16 },
+		{ "abcdefg" "\xff\xff\xff\xff\xff\xff\xff\xff" "h",	16 },
+		{ "abcdefgh" "\xff\xff\xff\xff\xff\xff\xff\xff" "",	16 },
+	};
+
+	for (a0 = 0; a0 < sizeof(long); ++a0) {
+		for (a1 = 0; a1 < sizeof(long); ++a1) {
+			for (t = 0; t < (sizeof(tab) / sizeof(tab[0])); ++t) {
+
+				memcpy(&buf1[a1], tab[t].val, tab[t].len + 1);
+				ret = f(&buf0[a0], &buf1[a1]);
+
+				/*
+				 * verify strcpy returns address of
+				 * first parameter
+				 */
+			    	if (&buf0[a0] != ret) {
+					fprintf(stderr, "a0 %d, a1 %d, t %d\n",
+					    a0, a1, t);
+					atf_tc_fail("strcpy did not return "
+					    "its first arg");
+				}
+
+				/*
+				 * verify string was copied correctly
+				 */
+				if (memcmp(&buf0[a0], &buf1[a1],
+					   tab[t].len + 1) != 0) {
+					fprintf(stderr, "a0 %d, a1 %d, t %d\n",
+					    a0, a1, t);
+					atf_tc_fail("not correctly copied");
+				}
+			}
+		}
+	}
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, strcpy_basic);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strcspn.c b/contrib/netbsd-tests/lib/libc/string/t_strcspn.c
new file mode 100644
index 0000000..d38cdb4
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strcspn.c
@@ -0,0 +1,58 @@
+/*	$NetBSD: t_strcspn.c,v 1.1 2011/11/21 23:50:45 joerg Exp $	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Joerg Sonnenberger.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: t_strcspn.c,v 1.1 2011/11/21 23:50:45 joerg Exp $");
+
+#include <atf-c.h>
+#include <string.h>
+
+ATF_TC(strcspn);
+ATF_TC_HEAD(strcspn, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test strcspn(3)");
+}
+
+ATF_TC_BODY(strcspn, tc)
+{
+	ATF_CHECK_EQ(strcspn("abcdefghijklmnop", ""), 16);
+	ATF_CHECK_EQ(strcspn("abcdefghijklmnop", "a"), 0);
+	ATF_CHECK_EQ(strcspn("abcdefghijklmnop", "b"), 1);
+	ATF_CHECK_EQ(strcspn("abcdefghijklmnop", "cd"), 2);
+	ATF_CHECK_EQ(strcspn("abcdefghijklmnop", "qrstuvwxyz"), 16);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, strcspn);
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strerror.c b/contrib/netbsd-tests/lib/libc/string/t_strerror.c
new file mode 100644
index 0000000..c0e9c06
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strerror.c
@@ -0,0 +1,135 @@
+/* $NetBSD: t_strerror.c,v 1.3 2011/05/10 06:55:27 jruoho Exp $ */
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Jukka Ruohonen.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: t_strerror.c,v 1.3 2011/05/10 06:55:27 jruoho Exp $");
+
+#include <atf-c.h>
+#include <errno.h>
+#include <limits.h>
+#include <locale.h>
+#include <string.h>
+
+ATF_TC(strerror_basic);
+ATF_TC_HEAD(strerror_basic, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "A basic test of strerror(3)");
+}
+
+ATF_TC_BODY(strerror_basic, tc)
+{
+	int i;
+
+	for (i = 1; i < sys_nerr; i++)
+		ATF_REQUIRE(strstr(strerror(i), "Unknown error:") == NULL);
+
+	for (; i < sys_nerr + 10; i++)
+		ATF_REQUIRE(strstr(strerror(i), "Unknown error:") != NULL);
+}
+
+ATF_TC(strerror_err);
+ATF_TC_HEAD(strerror_err, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test errors from strerror(3)");
+}
+
+ATF_TC_BODY(strerror_err, tc)
+{
+
+	errno = 0;
+
+	ATF_REQUIRE(strstr(strerror(INT_MAX), "Unknown error:") != NULL);
+	ATF_REQUIRE(errno == EINVAL);
+
+	errno = 0;
+
+	ATF_REQUIRE(strstr(strerror(INT_MIN), "Unknown error:") != NULL);
+	ATF_REQUIRE(errno == EINVAL);
+}
+
+ATF_TC(strerror_r_basic);
+ATF_TC_HEAD(strerror_r_basic, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "A basic test of strerror_r(3)");
+}
+
+ATF_TC_BODY(strerror_r_basic, tc)
+{
+	char buf[512];
+	int i;
+
+	for (i = 1; i < sys_nerr; i++) {
+		ATF_REQUIRE(strerror_r(i, buf, sizeof(buf)) == 0);
+		ATF_REQUIRE(strstr(buf, "Unknown error:") == NULL);
+	}
+
+	for (; i < sys_nerr + 10; i++) {
+		ATF_REQUIRE(strerror_r(i, buf, sizeof(buf)) == EINVAL);
+		ATF_REQUIRE(strstr(buf, "Unknown error:") != NULL);
+	}
+}
+
+ATF_TC(strerror_r_err);
+ATF_TC_HEAD(strerror_r_err, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test errors from strerror_r(3)");
+}
+
+ATF_TC_BODY(strerror_r_err, tc)
+{
+	char buf[512];
+	int rv;
+
+	rv = strerror_r(EPERM, buf, 1);
+	ATF_REQUIRE(rv == ERANGE);
+
+	rv = strerror_r(INT_MAX, buf, sizeof(buf));
+
+	ATF_REQUIRE(rv == EINVAL);
+	ATF_REQUIRE(strstr(buf, "Unknown error:") != NULL);
+
+	rv = strerror_r(INT_MIN, buf, sizeof(buf));
+
+	ATF_REQUIRE(rv == EINVAL);
+	ATF_REQUIRE(strstr(buf, "Unknown error:") != NULL);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	(void)setlocale(LC_ALL, "C");
+
+	ATF_TP_ADD_TC(tp, strerror_basic);
+	ATF_TP_ADD_TC(tp, strerror_err);
+	ATF_TP_ADD_TC(tp, strerror_r_basic);
+	ATF_TP_ADD_TC(tp, strerror_r_err);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_stresep.c b/contrib/netbsd-tests/lib/libc/string/t_stresep.c
new file mode 100644
index 0000000..4678e55
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_stresep.c
@@ -0,0 +1,72 @@
+/*	$NetBSD: t_stresep.c,v 1.3 2013/02/15 23:56:32 christos Exp $ */
+
+/*-
+ * Copyright (c) 2005 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Christos Zoulas.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define expect(a)							\
+	if ((p = stresep(&q, " ", '\\')) == NULL || strcmp(p, a)) {	\
+		fprintf(stderr, "failed on line %d: %s != %s\n",	\
+		    __LINE__, p, a);					\
+		atf_tc_fail("Check stderr for test id/line");		\
+	}
+
+ATF_TC(stresep_basic);
+ATF_TC_HEAD(stresep_basic, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test stresep results");
+}
+
+ATF_TC_BODY(stresep_basic, tc)
+{
+	char brkstr[] = "foo\\ \\ bar baz bar\\ foo\\  bar\\ \\ foo \\ \\ \\ "
+		     "baz bar\\ \\ ";
+	char *p, *q = brkstr;
+
+	expect("foo  bar");
+	expect("baz");
+	expect("bar foo ");
+	expect("bar  foo");
+	expect("   baz");
+	expect("bar  ");
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, stresep_basic);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strlen.c b/contrib/netbsd-tests/lib/libc/string/t_strlen.c
new file mode 100644
index 0000000..66158fd
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strlen.c
@@ -0,0 +1,199 @@
+/* $NetBSD: t_strlen.c,v 1.5 2011/07/14 07:33:20 jruoho Exp $ */
+
+/*
+ * Written by J.T. Conklin <jtc@acorntoolworks.com>
+ * Public domain.
+ */
+
+#include <atf-c.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <unistd.h>
+
+static void	write_num(int);
+
+static void
+write_num(int val)
+{
+	char buf[20];
+	int i;
+
+	for (i = sizeof buf; --i >= 0;) {
+		buf[i] = '0' + val % 10;
+		val /= 10;
+		if (val == 0) {
+			write(2, buf + i, sizeof buf - i);
+			return;
+		}
+	}
+	write(2, "overflow", 8);
+}
+
+ATF_TC(strlen_basic);
+ATF_TC_HEAD(strlen_basic, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test strlen(3) results");
+}
+
+ATF_TC_BODY(strlen_basic, tc)
+{
+	/* try to trick the compiler */
+	size_t (*strlen_fn)(const char *);
+
+	unsigned int a, t;
+	size_t len;
+	char buf[64];
+
+	struct tab {
+		const char*	val;
+		size_t		len;
+	};
+
+	const struct tab tab[] = {
+		/*
+		 * patterns that check for all combinations of leading and
+		 * trailing unaligned characters (on a 64 bit processor)
+		 */
+
+		{ "",				0 },
+		{ "a",				1 },
+		{ "ab",				2 },
+		{ "abc",			3 },
+		{ "abcd",			4 },
+		{ "abcde",			5 },
+		{ "abcdef",			6 },
+		{ "abcdefg",			7 },
+		{ "abcdefgh",			8 },
+		{ "abcdefghi",			9 },
+		{ "abcdefghij",			10 },
+		{ "abcdefghijk",		11 },
+		{ "abcdefghijkl",		12 },
+		{ "abcdefghijklm",		13 },
+		{ "abcdefghijklmn",		14 },
+		{ "abcdefghijklmno",		15 },
+		{ "abcdefghijklmnop",		16 },
+		{ "abcdefghijklmnopq",		17 },
+		{ "abcdefghijklmnopqr",		18 },
+		{ "abcdefghijklmnopqrs",	19 },
+		{ "abcdefghijklmnopqrst",	20 },
+		{ "abcdefghijklmnopqrstu",	21 },
+		{ "abcdefghijklmnopqrstuv",	22 },
+		{ "abcdefghijklmnopqrstuvw",	23 },
+
+		/*
+		 * patterns that check for the cases where the expression:
+		 *
+		 *	((word - 0x7f7f..7f) & 0x8080..80)
+		 *
+		 * returns non-zero even though there are no zero bytes in
+		 * the word.
+		 */
+
+		{ "" "\xff\xff\xff\xff\xff\xff\xff\xff" "abcdefgh",	16 },
+		{ "a" "\xff\xff\xff\xff\xff\xff\xff\xff" "bcdefgh",	16 },
+		{ "ab" "\xff\xff\xff\xff\xff\xff\xff\xff" "cdefgh",	16 },
+		{ "abc" "\xff\xff\xff\xff\xff\xff\xff\xff" "defgh",	16 },
+		{ "abcd" "\xff\xff\xff\xff\xff\xff\xff\xff" "efgh",	16 },
+		{ "abcde" "\xff\xff\xff\xff\xff\xff\xff\xff" "fgh",	16 },
+		{ "abcdef" "\xff\xff\xff\xff\xff\xff\xff\xff" "gh",	16 },
+		{ "abcdefg" "\xff\xff\xff\xff\xff\xff\xff\xff" "h",	16 },
+		{ "abcdefgh" "\xff\xff\xff\xff\xff\xff\xff\xff" "",	16 },
+	};
+
+	/*
+	 * During testing it is useful have the rest of the program
+	 * use a known good version!
+	 */
+	strlen_fn = dlsym(dlopen(NULL, RTLD_LAZY), "test_strlen");
+	if (!strlen_fn)
+		strlen_fn = strlen;
+
+	for (a = 0; a < sizeof(long); ++a) {
+		for (t = 0; t < (sizeof(tab) / sizeof(tab[0])); ++t) {
+
+			memcpy(&buf[a], tab[t].val, tab[t].len + 1);
+			len = strlen_fn(&buf[a]);
+
+			if (len != tab[t].len) {
+				/* Write error without using printf / strlen */
+				write(2, "alignment ", 10);
+				write_num(a);
+				write(2, ", test ", 7);
+				write_num(t);
+				write(2, ", got len ", 10);
+				write_num(len);
+				write(2, ", not ", 6);
+				write_num(tab[t].len);
+				write(2, ", for '", 7);
+				write(2, tab[t].val, tab[t].len);
+				write(2, "'\n", 2);
+				atf_tc_fail("See stderr for details");
+			}
+		}
+	}
+}
+
+ATF_TC(strlen_huge);
+ATF_TC_HEAD(strlen_huge, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test strlen(3) with huge strings");
+}
+
+ATF_TC_BODY(strlen_huge, tc)
+{
+	long page;
+	char *str;
+	size_t i;
+
+	page = sysconf(_SC_PAGESIZE);
+	ATF_REQUIRE(page >= 0);
+
+	for (i = 1; i < 1000; i = i + 100) {
+
+		str = malloc(i * page + 1);
+
+		if (str == NULL)
+			continue;
+
+		(void)memset(str, 'x', i * page);
+		str[i * page] = '\0';
+
+		ATF_REQUIRE(strlen(str) == i * page);
+		free(str);
+	}
+}
+
+ATF_TC(strnlen_basic);
+ATF_TC_HEAD(strnlen_basic, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "A naive test of strnlen(3)");
+}
+
+ATF_TC_BODY(strnlen_basic, tc)
+{
+	char buf[1];
+
+	buf[0] = '\0';
+
+	ATF_CHECK(strnlen(buf, 000) == 0);
+	ATF_CHECK(strnlen(buf, 111) == 0);
+
+	ATF_CHECK(strnlen("xxx", 0) == 0);
+	ATF_CHECK(strnlen("xxx", 1) == 1);
+	ATF_CHECK(strnlen("xxx", 2) == 2);
+	ATF_CHECK(strnlen("xxx", 3) == 3);
+	ATF_CHECK(strnlen("xxx", 9) == 3);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, strlen_basic);
+	ATF_TP_ADD_TC(tp, strlen_huge);
+	ATF_TP_ADD_TC(tp, strnlen_basic);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strpbrk.c b/contrib/netbsd-tests/lib/libc/string/t_strpbrk.c
new file mode 100644
index 0000000..d0f2d9b
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strpbrk.c
@@ -0,0 +1,62 @@
+/*	$NetBSD: t_strpbrk.c,v 1.1 2011/11/21 23:50:45 joerg Exp $	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Joerg Sonnenberger.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: t_strpbrk.c,v 1.1 2011/11/21 23:50:45 joerg Exp $");
+
+#include <atf-c.h>
+#include <string.h>
+
+ATF_TC(strpbrk);
+ATF_TC_HEAD(strpbrk, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test strpbrk(3)");
+}
+
+ATF_TC_BODY(strpbrk, tc)
+{
+	static const char s[] = "abcdefghijklmnop";
+
+	ATF_CHECK_EQ(strpbrk(s, ""), NULL);
+	ATF_CHECK_EQ(strpbrk(s, "qrst"), NULL);
+	ATF_CHECK_EQ(strpbrk(s, "a"), s);
+	ATF_CHECK_EQ(strpbrk(s, "b"), s + 1);
+	ATF_CHECK_EQ(strpbrk(s, "ab"), s);
+	ATF_CHECK_EQ(strpbrk(s, "cdef"), s + 2);
+	ATF_CHECK_EQ(strpbrk(s, "fedc"), s + 2);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, strpbrk);
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strrchr.c b/contrib/netbsd-tests/lib/libc/string/t_strrchr.c
new file mode 100644
index 0000000..038daff
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strrchr.c
@@ -0,0 +1,257 @@
+/* $NetBSD: t_strrchr.c,v 1.1 2011/07/07 08:59:33 jruoho Exp $ */
+
+/*
+ * Written by J.T. Conklin <jtc@acorntoolworks.com>
+ * Public domain.
+ */
+
+#include <atf-c.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+ATF_TC(strrchr_basic);
+ATF_TC_HEAD(strrchr_basic, tc)
+{
+        atf_tc_set_md_var(tc, "descr", "Test strrchr(3) results");
+}
+
+ATF_TC_BODY(strrchr_basic, tc)
+{
+	/* try to trick the compiler */
+	char * (*f)(const char *, int) = strrchr;
+
+	unsigned int a, t;
+	char *off, *off2;
+	char buf[32];
+
+	struct tab {
+		const char*	val;
+		char		match;
+		ssize_t		f_off;	/* offset of first match */
+		ssize_t		l_off;	/* offset of last match */
+	};
+
+	const struct tab tab[] = {
+		{ "",			0, 0, 0 },
+		{ "a",			0, 0, 0 },
+		{ "aa",			0, 0, 0 },
+		{ "abc",		0, 0, 0 },
+		{ "abcd",		0, 0, 0 },
+		{ "abcde",		0, 0, 0 },
+		{ "abcdef",		0, 0, 0 },
+		{ "abcdefg",		0, 0, 0 },
+		{ "abcdefgh",		0, 0, 0 },
+
+		{ "/",			1, 0, 0 },
+		{ "//",                 1, 0, 1 },
+		{ "/a",                 1, 0, 0 },
+		{ "/a/",                1, 0, 2 },
+		{ "/ab",                1, 0, 0 },
+		{ "/ab/",               1, 0, 3 },
+		{ "/abc",               1, 0, 0 },
+		{ "/abc/",              1, 0, 4 },
+		{ "/abcd",              1, 0, 0 },
+		{ "/abcd/",             1, 0, 5 },
+		{ "/abcde",             1, 0, 0 },
+		{ "/abcde/",            1, 0, 6 },
+		{ "/abcdef",            1, 0, 0 },
+		{ "/abcdef/",           1, 0, 7 },
+		{ "/abcdefg",           1, 0, 0 },
+		{ "/abcdefg/",          1, 0, 8 },
+		{ "/abcdefgh",          1, 0, 0 },
+		{ "/abcdefgh/",         1, 0, 9 },
+
+		{ "a/",                 1, 1, 1 },
+		{ "a//",                1, 1, 2 },
+		{ "a/a",                1, 1, 1 },
+		{ "a/a/",               1, 1, 3 },
+		{ "a/ab",               1, 1, 1 },
+		{ "a/ab/",              1, 1, 4 },
+		{ "a/abc",              1, 1, 1 },
+		{ "a/abc/",             1, 1, 5 },
+		{ "a/abcd",             1, 1, 1 },
+		{ "a/abcd/",            1, 1, 6 },
+		{ "a/abcde",            1, 1, 1 },
+		{ "a/abcde/",           1, 1, 7 },
+		{ "a/abcdef",           1, 1, 1 },
+		{ "a/abcdef/",          1, 1, 8 },
+		{ "a/abcdefg",          1, 1, 1 },
+		{ "a/abcdefg/",         1, 1, 9 },
+		{ "a/abcdefgh",         1, 1, 1 },
+		{ "a/abcdefgh/",        1, 1, 10 },
+
+		{ "ab/",                1, 2, 2 },
+		{ "ab//",               1, 2, 3 },
+		{ "ab/a",               1, 2, 2 },
+		{ "ab/a/",              1, 2, 4 },
+		{ "ab/ab",              1, 2, 2 },
+		{ "ab/ab/",             1, 2, 5 },
+		{ "ab/abc",             1, 2, 2 },
+		{ "ab/abc/",            1, 2, 6 },
+		{ "ab/abcd",            1, 2, 2 },
+		{ "ab/abcd/",           1, 2, 7 },
+		{ "ab/abcde",           1, 2, 2 },
+		{ "ab/abcde/",          1, 2, 8 },
+		{ "ab/abcdef",          1, 2, 2 },
+		{ "ab/abcdef/",         1, 2, 9 },
+		{ "ab/abcdefg",         1, 2, 2 },
+		{ "ab/abcdefg/",        1, 2, 10 },
+		{ "ab/abcdefgh",        1, 2, 2 },
+		{ "ab/abcdefgh/",       1, 2, 11 },
+
+		{ "abc/",               1, 3, 3 },
+		{ "abc//",              1, 3, 4 },
+		{ "abc/a",              1, 3, 3 },
+		{ "abc/a/",             1, 3, 5 },
+		{ "abc/ab",             1, 3, 3 },
+		{ "abc/ab/",            1, 3, 6 },
+		{ "abc/abc",            1, 3, 3 },
+		{ "abc/abc/",           1, 3, 7 },
+		{ "abc/abcd",           1, 3, 3 },
+		{ "abc/abcd/",          1, 3, 8 },
+		{ "abc/abcde",          1, 3, 3 },
+		{ "abc/abcde/",         1, 3, 9 },
+		{ "abc/abcdef",         1, 3, 3 },
+		{ "abc/abcdef/",        1, 3, 10 },
+		{ "abc/abcdefg",        1, 3, 3 },
+		{ "abc/abcdefg/",       1, 3, 11 },
+		{ "abc/abcdefgh",       1, 3, 3 },
+		{ "abc/abcdefgh/",      1, 3, 12 },
+
+		{ "abcd/",              1, 4, 4 },
+		{ "abcd//",             1, 4, 5 },
+		{ "abcd/a",             1, 4, 4 },
+		{ "abcd/a/",            1, 4, 6 },
+		{ "abcd/ab",            1, 4, 4 },
+		{ "abcd/ab/",           1, 4, 7 },
+		{ "abcd/abc",           1, 4, 4 },
+		{ "abcd/abc/",          1, 4, 8 },
+		{ "abcd/abcd",          1, 4, 4 },
+		{ "abcd/abcd/",         1, 4, 9 },
+		{ "abcd/abcde",         1, 4, 4 },
+		{ "abcd/abcde/",        1, 4, 10 },
+		{ "abcd/abcdef",        1, 4, 4 },
+		{ "abcd/abcdef/",       1, 4, 11 },
+		{ "abcd/abcdefg",       1, 4, 4 },
+		{ "abcd/abcdefg/",      1, 4, 12 },
+		{ "abcd/abcdefgh",      1, 4, 4 },
+		{ "abcd/abcdefgh/",     1, 4, 13 },
+
+		{ "abcde/",             1, 5, 5 },
+		{ "abcde//",            1, 5, 6 },
+		{ "abcde/a",            1, 5, 5 },
+		{ "abcde/a/",           1, 5, 7 },
+		{ "abcde/ab",           1, 5, 5 },
+		{ "abcde/ab/",          1, 5, 8 },
+		{ "abcde/abc",          1, 5, 5 },
+		{ "abcde/abc/",         1, 5, 9 },
+		{ "abcde/abcd",         1, 5, 5 },
+		{ "abcde/abcd/",        1, 5, 10 },
+		{ "abcde/abcde",        1, 5, 5 },
+		{ "abcde/abcde/",       1, 5, 11 },
+		{ "abcde/abcdef",       1, 5, 5 },
+		{ "abcde/abcdef/",      1, 5, 12 },
+		{ "abcde/abcdefg",      1, 5, 5 },
+		{ "abcde/abcdefg/",     1, 5, 13 },
+		{ "abcde/abcdefgh",     1, 5, 5 },
+		{ "abcde/abcdefgh/",    1, 5, 14 },
+
+		{ "abcdef/",            1, 6, 6 },
+		{ "abcdef//",           1, 6, 7 },
+		{ "abcdef/a",           1, 6, 6 },
+		{ "abcdef/a/",          1, 6, 8 },
+		{ "abcdef/ab",          1, 6, 6 },
+		{ "abcdef/ab/",         1, 6, 9 },
+		{ "abcdef/abc",         1, 6, 6 },
+		{ "abcdef/abc/",        1, 6, 10 },
+		{ "abcdef/abcd",        1, 6, 6 },
+		{ "abcdef/abcd/",       1, 6, 11 },
+		{ "abcdef/abcde",       1, 6, 6 },
+		{ "abcdef/abcde/",      1, 6, 12 },
+		{ "abcdef/abcdef",      1, 6, 6 },
+		{ "abcdef/abcdef/",     1, 6, 13 },
+		{ "abcdef/abcdefg",     1, 6, 6 },
+		{ "abcdef/abcdefg/",    1, 6, 14 },
+		{ "abcdef/abcdefgh",    1, 6, 6 },
+		{ "abcdef/abcdefgh/",   1, 6, 15 },
+
+		{ "abcdefg/",           1, 7, 7 },
+		{ "abcdefg//",          1, 7, 8 },
+		{ "abcdefg/a",          1, 7, 7 },
+		{ "abcdefg/a/",         1, 7, 9 },
+		{ "abcdefg/ab",         1, 7, 7 },
+		{ "abcdefg/ab/",        1, 7, 10 },
+		{ "abcdefg/abc",        1, 7, 7 },
+		{ "abcdefg/abc/",       1, 7, 11 },
+		{ "abcdefg/abcd",       1, 7, 7 },
+		{ "abcdefg/abcd/",      1, 7, 12 },
+		{ "abcdefg/abcde",      1, 7, 7 },
+		{ "abcdefg/abcde/",     1, 7, 13 },
+		{ "abcdefg/abcdef",     1, 7, 7 },
+		{ "abcdefg/abcdef/",    1, 7, 14 },
+		{ "abcdefg/abcdefg",    1, 7, 7 },
+		{ "abcdefg/abcdefg/",   1, 7, 15 },
+		{ "abcdefg/abcdefgh",   1, 7, 7 },
+		{ "abcdefg/abcdefgh/",  1, 7, 16 },
+
+		{ "abcdefgh/",          1, 8, 8 },
+		{ "abcdefgh//",         1, 8, 9 },
+		{ "abcdefgh/a",         1, 8, 8 },
+		{ "abcdefgh/a/",        1, 8, 10 },
+		{ "abcdefgh/ab",        1, 8, 8 },
+		{ "abcdefgh/ab/",       1, 8, 11 },
+		{ "abcdefgh/abc",       1, 8, 8 },
+		{ "abcdefgh/abc/",      1, 8, 12 },
+		{ "abcdefgh/abcd",      1, 8, 8 },
+		{ "abcdefgh/abcd/",     1, 8, 13 },
+		{ "abcdefgh/abcde",     1, 8, 8 },
+		{ "abcdefgh/abcde/",    1, 8, 14 },
+		{ "abcdefgh/abcdef",    1, 8, 8 },
+		{ "abcdefgh/abcdef/",   1, 8, 15 },
+		{ "abcdefgh/abcdefg",   1, 8, 8 },
+		{ "abcdefgh/abcdefg/",  1, 8, 16 },
+		{ "abcdefgh/abcdefgh",  1, 8, 8 },
+		{ "abcdefgh/abcdefgh/", 1, 8, 17 },
+	};
+
+	for (a = 0; a < sizeof(long); ++a) {
+		for (t = 0; t < (sizeof(tab) / sizeof(tab[0])); ++t) {
+			strcpy(&buf[a], tab[t].val);
+
+			off = f(&buf[a], '/');
+			if (tab[t].match == 0) {
+				if (off != 0) {
+					fprintf(stderr, "a %d, t %d\n", a, t);
+					atf_tc_fail("strrchr should not have "
+					    "found the character");
+				}
+			} else if (tab[t].match == 1) {
+				 if (tab[t].l_off != (off - &buf[a])) {
+					fprintf(stderr, "a %d, t %d\n", a, t);
+					atf_tc_fail("strrchr returns wrong "
+					    "offset");
+				}
+			} else {
+				fprintf(stderr, "a %d, t %d\n", a, t);
+				atf_tc_fail("bad test case data");
+			}
+
+			/* check zero extension of char arg */
+			off2 = f(&buf[a], 0xffffff00 | '/');
+			if (off != off2) {
+				fprintf(stderr, "a %d, t %d\n", a, t);
+				atf_tc_fail("zero extension of char arg fails");
+			}
+		}
+	}
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, strrchr_basic);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_strspn.c b/contrib/netbsd-tests/lib/libc/string/t_strspn.c
new file mode 100644
index 0000000..6782181
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_strspn.c
@@ -0,0 +1,60 @@
+/*	$NetBSD: t_strspn.c,v 1.1 2011/11/21 23:50:45 joerg Exp $	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Joerg Sonnenberger.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: t_strspn.c,v 1.1 2011/11/21 23:50:45 joerg Exp $");
+
+#include <atf-c.h>
+#include <string.h>
+
+ATF_TC(strspn);
+ATF_TC_HEAD(strspn, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test strspn(3)");
+}
+
+ATF_TC_BODY(strspn, tc)
+{
+	ATF_CHECK_EQ(strspn("abcdefghijklmnop", ""), 0);
+	ATF_CHECK_EQ(strspn("abcdefghijklmnop", "a"), 1);
+	ATF_CHECK_EQ(strspn("abcdefghijklmnop", "b"), 0);
+	ATF_CHECK_EQ(strspn("abcdefghijklmnop", "ab"), 2);
+	ATF_CHECK_EQ(strspn("abcdefghijklmnop", "abc"), 3);
+	ATF_CHECK_EQ(strspn("abcdefghijklmnop", "abce"), 3);
+	ATF_CHECK_EQ(strspn("abcdefghijklmnop", "abcdefghijklmnop"), 16);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, strspn);
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libc/string/t_swab.c b/contrib/netbsd-tests/lib/libc/string/t_swab.c
new file mode 100644
index 0000000..797397a
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libc/string/t_swab.c
@@ -0,0 +1,95 @@
+/*	$NetBSD: t_swab.c,v 1.2 2011/07/07 08:27:36 jruoho Exp $ */
+
+/*-
+ * Copyright (c) 2001 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code was contributed to The NetBSD Foundation by Christos Zoulas.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <atf-c.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <err.h>
+
+#define MAXCHK	100
+
+static void
+build(char *a, char *b, size_t n) {
+	size_t i;
+
+	n >>= 1;
+	for (i = 0; i < n; i += 2) {
+		b[i+1] = a[i] = (char)i;
+		b[i] = a[i+1] = (char)(i+1);
+	}
+	for (n <<= 1; n < MAXCHK; n++)
+		a[n] = b[n] = (char)~0;
+}
+
+static void
+dump(const char *f, char *b, size_t l)
+{
+
+	printf("%s ", f);
+	while (l--)
+		printf("%.2x ", (unsigned char)*b++);
+	printf("\n");
+}
+
+ATF_TC(swab_basic);
+ATF_TC_HEAD(swab_basic, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test swab results");
+}
+
+ATF_TC_BODY(swab_basic, tc)
+{
+	char a[MAXCHK], b[MAXCHK], r[MAXCHK];
+	size_t i;
+
+	for (i = 0; i < MAXCHK; i += 2) {
+		build(a, b, i);
+		(void)memset(r, ~0, MAXCHK);
+		swab(a, r, i);
+		if (memcmp(b, r, MAXCHK) != 0) {
+			fprintf(stderr, "pattern mismatch at %lu bytes",
+			    (unsigned long)i);
+			dump("expect:", b, MAXCHK);
+			dump("result:", r, MAXCHK);
+			atf_tc_fail("Check stderr for details");
+		}
+	}
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+	ATF_TP_ADD_TC(tp, swab_basic);
+
+	return atf_no_error();
+}