Minix/minix
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Importing NetBSD "Kyua" test framework

Browse Source 
To do so, a few dependencies have been imported:

 * external/bsd/lutok
 * external/mit/lua
 * external/public-domain/sqlite
 * external/public-domain/xz

The Kyua framework is the new generation of ATF (Automated Test
Framework), it is composed of:

 * external/bsd/atf
 * external/bsd/kyua-atf-compat
 * external/bsd/kyua-cli
 * external/bsd/kyua-tester
 * tests

Kyua/ATF being written in C++, it depends on libstdc++ which is
provided by GCC. As this is not part of the sources, Kyua is only
compiled when the native GCC utils are installed.

To install Kyua do the following:

 * In a cross-build enviromnent, add the following to the build.sh
   commandline: -V MKBINUTILS=yes -V MKGCCCMDS=yes

WARNING:
  At this point the import is still experimental, and not supported
  on native builds (a.k.a make build).

Change-Id: I26aee23c5bbd2d64adcb7c1beb98fe0d479d7ada
This commit is contained in:
Lionel Sambuc
2013-02-26 09:24:42 +01:00
committed by Gerrit Code Review
parent 003ff52ebb
commit 11be35a165
2893 changed files with 502052 additions and 2630 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
tests/lib/libc/string/Makefile Normal file
View File

@@ -0,0 +1,27 @@
# $NetBSD: Makefile,v 1.8 2011/11/21 23:50:45 joerg Exp $
.include <bsd.own.mk>
TESTSDIR= ${TESTSBASE}/lib/libc/string
TESTS_C+= t_memchr
TESTS_C+= t_memcpy
TESTS_C+= t_memmem
TESTS_C+= t_memset
TESTS_C+= t_popcount
TESTS_C+= t_strcat
TESTS_C+= t_strchr
TESTS_C+= t_strcmp
TESTS_C+= t_strcpy
TESTS_C+= t_strcspn
TESTS_C+= t_strerror
TESTS_C+= t_stresep
TESTS_C+= t_strlen
TESTS_C+= t_strpbrk
TESTS_C+= t_strrchr
TESTS_C+= t_strspn
TESTS_C+= t_swab
WARNS= 4
.include <bsd.test.mk>

194
tests/lib/libc/string/t_memchr.c Normal file
View File

@@ -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();
}

150
tests/lib/libc/string/t_memcpy.c Normal file
View File

@@ -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();
}

100
tests/lib/libc/string/t_memmem.c Normal file
View File

@@ -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();
}

207
tests/lib/libc/string/t_memset.c Normal file
View File

@@ -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();
}

198
tests/lib/libc/string/t_popcount.c Normal file
View File

@@ -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();
}

153
tests/lib/libc/string/t_strcat.c Normal file
View File

@@ -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();
}

292
tests/lib/libc/string/t_strchr.c Normal file
View File

@@ -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();
}

136
tests/lib/libc/string/t_strcmp.c Normal file
View File

@@ -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();
}

124
tests/lib/libc/string/t_strcpy.c Normal file
View File

@@ -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();
}

58
tests/lib/libc/string/t_strcspn.c Normal file
View File

@@ -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();
}

135
tests/lib/libc/string/t_strerror.c Normal file
View File

@@ -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();
}

72
tests/lib/libc/string/t_stresep.c Normal file
View File

@@ -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();
}

199
tests/lib/libc/string/t_strlen.c Normal file
View File

@@ -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();
}

62
tests/lib/libc/string/t_strpbrk.c Normal file
View File

@@ -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();
}

257
tests/lib/libc/string/t_strrchr.c Normal file
View File

@@ -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();
}

60
tests/lib/libc/string/t_strspn.c Normal file
View File

@@ -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();
}

95
tests/lib/libc/string/t_swab.c Normal file
View File

@@ -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();
}