d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Integrate tools/regression/lib/libc/stdio into the FreeBSD test suite

Browse Source 
as lib/libc/tests/stdio

- Fix some whitespace
- Convert the testcases to ATF
- Convert "/dev/null" to _PATH_DEVNULL

MFC after: 1 week
Sponsored by: EMC / Isilon Storage Division
This commit is contained in:
ngie 2015-11-08 06:37:50 +00:00
parent 6aaa32a3ad
commit 8ae95d701f
30 changed files with 1404 additions and 1109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
lib/libc/tests/stdio/Makefile
View File

@ -1,6 +1,20 @@
# $FreeBSD$
ATF_TESTS_C= fmemopen2_test
ATF_TESTS_C+= fdopen_test
ATF_TESTS_C+= fmemopen2_test
ATF_TESTS_C+= fopen2_test
ATF_TESTS_C+= freopen_test
ATF_TESTS_C+= getdelim_test
ATF_TESTS_C+= mkostemp_test
ATF_TESTS_C+= open_memstream_test
ATF_TESTS_C+= open_wmemstream_test
ATF_TESTS_C+= perror_test
ATF_TESTS_C+= print_positional_test
ATF_TESTS_C+= printbasic_test
ATF_TESTS_C+= printfloat_test
ATF_TESTS_C+= scanfloat_test
SRCS.fopen2_test= fopen_test.c
NETBSD_ATF_TESTS_C= clearerr_test
NETBSD_ATF_TESTS_C+= fflush_test

225
lib/libc/tests/stdio/fdopen_test.c Normal file
View File

@ -0,0 +1,225 @@
/*-
* Copyright (c) 2014 Jilles Tjoelker
* 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 AUTHOR 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 AUTHOR 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>
__FBSDID("$FreeBSD$");
#include <errno.h>
#include <fcntl.h>
#include <paths.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <atf-c.h>
static void
runtest(const char *fname, int intmode, const char *strmode, bool success)
{
FILE *fp;
int fd;
fd = open(fname, intmode);
ATF_REQUIRE_MSG(fd != -1,
"open(\"%s\", %#x) failed; errno=%d", fname, intmode, errno);
fp = fdopen(fd, strmode);
if (fp == NULL) {
close(fd);
ATF_REQUIRE_MSG(success == false,
"fdopen(open(\"%s\", %#x), \"%s\") succeeded unexpectedly",
fname, intmode, strmode);
return;
}
ATF_REQUIRE_MSG(success == true,
"fdopen(open(\"%s\", %#x), \"%s\") failed; errno=%d",
fname, intmode, strmode, errno);
fclose(fp);
}
ATF_TC_WITHOUT_HEAD(null__O_RDONLY__r_test);
ATF_TC_BODY(null__O_RDONLY__r_test, tc)
{
runtest(_PATH_DEVNULL, O_RDONLY, "r", true);
}
ATF_TC_WITHOUT_HEAD(null__O_WRONLY__r_test);
ATF_TC_BODY(null__O_WRONLY__r_test, tc)
{
runtest(_PATH_DEVNULL, O_WRONLY, "r", false);
}
ATF_TC_WITHOUT_HEAD(null__O_RDWR__r_test);
ATF_TC_BODY(null__O_RDWR__r_test, tc)
{
runtest(_PATH_DEVNULL, O_RDWR, "r", true);
}
ATF_TC_WITHOUT_HEAD(null__O_RDONLY__w_test);
ATF_TC_BODY(null__O_RDONLY__w_test, tc)
{
runtest(_PATH_DEVNULL, O_RDONLY, "w", false);
}
ATF_TC_WITHOUT_HEAD(null__O_WRONLY__w_test);
ATF_TC_BODY(null__O_WRONLY__w_test, tc)
{
runtest(_PATH_DEVNULL, O_WRONLY, "w", true);
}
ATF_TC_WITHOUT_HEAD(null__O_RDWR__w_test);
ATF_TC_BODY(null__O_RDWR__w_test, tc)
{
runtest(_PATH_DEVNULL, O_RDWR, "w", true);
}
ATF_TC_WITHOUT_HEAD(null__O_RDONLY__a_test);
ATF_TC_BODY(null__O_RDONLY__a_test, tc)
{
runtest(_PATH_DEVNULL, O_RDONLY, "a", false);
}
ATF_TC_WITHOUT_HEAD(null__O_WRONLY__a_test);
ATF_TC_BODY(null__O_WRONLY__a_test, tc)
{
runtest(_PATH_DEVNULL, O_WRONLY, "a", true);
}
ATF_TC_WITHOUT_HEAD(null__O_RDWR__test);
ATF_TC_BODY(null__O_RDWR__test, tc)
{
runtest(_PATH_DEVNULL, O_RDWR, "a", true);
}
ATF_TC_WITHOUT_HEAD(null__O_RDONLY__r_append);
ATF_TC_BODY(null__O_RDONLY__r_append, tc)
{
runtest(_PATH_DEVNULL, O_RDONLY, "r+", false);
}
ATF_TC_WITHOUT_HEAD(null__O_WRONLY__r_append);
ATF_TC_BODY(null__O_WRONLY__r_append, tc)
{
runtest(_PATH_DEVNULL, O_WRONLY, "r+", false);
}
ATF_TC_WITHOUT_HEAD(null__O_RDWR__r_append);
ATF_TC_BODY(null__O_RDWR__r_append, tc)
{
runtest(_PATH_DEVNULL, O_RDWR, "r+", true);
}
ATF_TC_WITHOUT_HEAD(null__O_RDONLY__w_append);
ATF_TC_BODY(null__O_RDONLY__w_append, tc)
{
runtest(_PATH_DEVNULL, O_RDONLY, "w+", false);
}
ATF_TC_WITHOUT_HEAD(null__O_WRONLY__w_append);
ATF_TC_BODY(null__O_WRONLY__w_append, tc)
{
runtest(_PATH_DEVNULL, O_WRONLY, "w+", false);
}
ATF_TC_WITHOUT_HEAD(null__O_RDWR__w_append);
ATF_TC_BODY(null__O_RDWR__w_append, tc)
{
runtest(_PATH_DEVNULL, O_RDWR, "w+", true);
}
ATF_TC_WITHOUT_HEAD(sh__O_EXEC__r);
ATF_TC_BODY(sh__O_EXEC__r, tc)
{
runtest("/bin/sh", O_EXEC, "r", false);
}
ATF_TC_WITHOUT_HEAD(sh__O_EXEC__w);
ATF_TC_BODY(sh__O_EXEC__w, tc)
{
runtest("/bin/sh", O_EXEC, "w", false);
}
ATF_TC_WITHOUT_HEAD(sh__O_EXEC__r_append);
ATF_TC_BODY(sh__O_EXEC__r_append, tc)
{
runtest("/bin/sh", O_EXEC, "r+", false);
}
ATF_TC_WITHOUT_HEAD(sh__O_EXEC__w_append);
ATF_TC_BODY(sh__O_EXEC__w_append, tc)
{
runtest("/bin/sh", O_EXEC, "w+", false);
}
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, null__O_RDONLY__r_test);
ATF_TP_ADD_TC(tp, null__O_WRONLY__r_test);
ATF_TP_ADD_TC(tp, null__O_RDWR__r_test);
ATF_TP_ADD_TC(tp, null__O_RDONLY__w_test);
ATF_TP_ADD_TC(tp, null__O_WRONLY__w_test);
ATF_TP_ADD_TC(tp, null__O_RDWR__w_test);
ATF_TP_ADD_TC(tp, null__O_RDONLY__a_test);
ATF_TP_ADD_TC(tp, null__O_WRONLY__a_test);
ATF_TP_ADD_TC(tp, null__O_RDWR__test);
ATF_TP_ADD_TC(tp, null__O_RDONLY__r_append);
ATF_TP_ADD_TC(tp, null__O_WRONLY__r_append);
ATF_TP_ADD_TC(tp, null__O_RDWR__r_append);
ATF_TP_ADD_TC(tp, null__O_RDONLY__w_append);
ATF_TP_ADD_TC(tp, null__O_WRONLY__w_append);
ATF_TP_ADD_TC(tp, null__O_RDWR__w_append);
ATF_TP_ADD_TC(tp, sh__O_EXEC__r);
ATF_TP_ADD_TC(tp, sh__O_EXEC__w);
ATF_TP_ADD_TC(tp, sh__O_EXEC__r_append);
ATF_TP_ADD_TC(tp, sh__O_EXEC__w_append);
return (atf_no_error());
}
/*
vim:ts=8:cin:sw=8
*/

30
lib/libc/tests/stdio/fmemopen2_test.c
View File

@ -35,15 +35,13 @@ __FBSDID("$FreeBSD$");
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <atf-c.h>
ATF_TC_WITHOUT_HEAD(test_preexisting);
ATF_TC_BODY(test_preexisting, tc)
{
/*
* Use a pre-existing buffer.
*/
/* Use a pre-existing buffer. */
char buf[512];
char buf2[512];
char str[] = "Test writing some stuff";
@ -74,7 +72,7 @@ ATF_TC_BODY(test_preexisting, tc)
nofr = fread(buf2, 1, sizeof(buf2), fp);
ATF_REQUIRE(nofr == sizeof(buf2));
/*
/*
* Since a write on a FILE * retrieved by fmemopen
* will add a '\0' (if there's space), we can check
* the strings for equality.
@ -106,10 +104,7 @@ ATF_TC_BODY(test_preexisting, tc)
ATF_TC_WITHOUT_HEAD(test_autoalloc);
ATF_TC_BODY(test_autoalloc, tc)
{
/*
* Let fmemopen allocate the buffer.
*/
/* Let fmemopen allocate the buffer. */
char str[] = "A quick test";
FILE *fp;
long pos;
@ -130,9 +125,7 @@ ATF_TC_BODY(test_autoalloc, tc)
pos = ftell(fp);
ATF_REQUIRE(pos == 512);
/*
* Try to write past the end, we should get a short object count (0)
*/
/* Try to write past the end, we should get a short object count (0) */
nofw = fwrite("a", 1, 1, fp);
ATF_REQUIRE(nofw == 0);
@ -173,10 +166,7 @@ ATF_TC_BODY(test_data_length, tc)
nofw = fwrite(str, 1, sizeof(str), fp);
ATF_REQUIRE(nofw == sizeof(str));
/*
* Now seek to the end and check that ftell
* gives us sizeof(str).
*/
/* Now seek to the end and check that ftell gives us sizeof(str). */
rc = fseek(fp, 0, SEEK_END);
ATF_REQUIRE(rc == 0);
pos = ftell(fp);
@ -264,9 +254,7 @@ ATF_TC_BODY(test_append_binary_pos, tc)
ATF_REQUIRE(ftell(fp) == 0L);
fclose(fp);
/*
* Make sure that a pre-allocated buffer behaves correctly.
*/
/* Make sure that a pre-allocated buffer behaves correctly. */
char buf[] = "Hello";
fp = fmemopen(buf, sizeof(buf), "ab+");
ATF_REQUIRE(ftell(fp) == strlen(buf));
@ -276,9 +264,7 @@ ATF_TC_BODY(test_append_binary_pos, tc)
ATF_TC_WITHOUT_HEAD(test_size_0);
ATF_TC_BODY(test_size_0, tc)
{
/*
* POSIX mandates that we return EINVAL if size is 0.
*/
/* POSIX mandates that we return EINVAL if size is 0. */
FILE *fp;

205
lib/libc/tests/stdio/fopen_test.c Normal file
View File

@ -0,0 +1,205 @@
/*-
* Copyright (c) 2013 Jilles Tjoelker
* 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 AUTHOR 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 AUTHOR 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>
__FBSDID("$FreeBSD$");
#include <fcntl.h>
#include <paths.h>
#include <stdio.h>
#include <string.h>
#include <atf-c.h>
/*
* O_ACCMODE is currently defined incorrectly. This is what it should be.
* Various code depends on the incorrect value.
*/
#define CORRECT_O_ACCMODE (O_ACCMODE | O_EXEC)
static void
runtest(const char *fname, const char *mode)
{
FILE *fp;
int exp_fget_ret, fget_ret, fd, flags, wantedflags;
fp = fopen(fname, mode);
ATF_REQUIRE_MSG(fp != NULL,
"fopen(\"%s\", \"%s\") failed", fname, mode);
fd = fileno(fp);
ATF_REQUIRE_MSG(fd >= 0, "fileno() failed for fopen");
exp_fget_ret = strchr(mode, 'e') != NULL ? FD_CLOEXEC : 0;
ATF_REQUIRE_MSG((fget_ret = fcntl(fd, F_GETFD)) == exp_fget_ret,
"fcntl(.., F_GETFD) didn't FD_CLOEXEC as expected %d != %d",
exp_fget_ret, fget_ret);
flags = fcntl(fd, F_GETFL);
if (strchr(mode, '+'))
wantedflags = O_RDWR | (*mode == 'a' ? O_APPEND : 0);
else if (*mode == 'r')
wantedflags = O_RDONLY;
else if (*mode == 'w')
wantedflags = O_WRONLY;
else if (*mode == 'a')
wantedflags = O_WRONLY | O_APPEND;
else
wantedflags = -1;
fclose(fp);
if (wantedflags == -1)
atf_tc_fail("unrecognized mode: %s", mode);
else if ((flags & (CORRECT_O_ACCMODE | O_APPEND)) != wantedflags)
atf_tc_fail("incorrect access mode: %s", mode);
}
ATF_TC_WITHOUT_HEAD(fopen_r_test);
ATF_TC_BODY(fopen_r_test, tc)
{
runtest(_PATH_DEVNULL, "r");
}
ATF_TC_WITHOUT_HEAD(fopen_r_append_test);
ATF_TC_BODY(fopen_r_append_test, tc)
{
runtest(_PATH_DEVNULL, "r+");
}
ATF_TC_WITHOUT_HEAD(fopen_w_test);
ATF_TC_BODY(fopen_w_test, tc)
{
runtest(_PATH_DEVNULL, "w");
}
ATF_TC_WITHOUT_HEAD(fopen_w_append_test);
ATF_TC_BODY(fopen_w_append_test, tc)
{
runtest(_PATH_DEVNULL, "w+");
}
ATF_TC_WITHOUT_HEAD(fopen_a_test);
ATF_TC_BODY(fopen_a_test, tc)
{
runtest(_PATH_DEVNULL, "a");
}
ATF_TC_WITHOUT_HEAD(fopen_a_append_test);
ATF_TC_BODY(fopen_a_append_test, tc)
{
runtest(_PATH_DEVNULL, "a+");
}
ATF_TC_WITHOUT_HEAD(fopen_re_test);
ATF_TC_BODY(fopen_re_test, tc)
{
runtest(_PATH_DEVNULL, "re");
}
ATF_TC_WITHOUT_HEAD(fopen_r_append_e_test);
ATF_TC_BODY(fopen_r_append_e_test, tc)
{
runtest(_PATH_DEVNULL, "r+e");
}
ATF_TC_WITHOUT_HEAD(fopen_we_test);
ATF_TC_BODY(fopen_we_test, tc)
{
runtest(_PATH_DEVNULL, "we");
}
ATF_TC_WITHOUT_HEAD(fopen_w_append_e_test);
ATF_TC_BODY(fopen_w_append_e_test, tc)
{
runtest(_PATH_DEVNULL, "w+e");
}
ATF_TC_WITHOUT_HEAD(fopen_ae_test);
ATF_TC_BODY(fopen_ae_test, tc)
{
runtest(_PATH_DEVNULL, "ae");
}
ATF_TC_WITHOUT_HEAD(fopen_a_append_e_test);
ATF_TC_BODY(fopen_a_append_e_test, tc)
{
runtest(_PATH_DEVNULL, "a+e");
}
ATF_TC_WITHOUT_HEAD(fopen_re_append_test);
ATF_TC_BODY(fopen_re_append_test, tc)
{
runtest(_PATH_DEVNULL, "re+");
}
ATF_TC_WITHOUT_HEAD(fopen_we_append_test);
ATF_TC_BODY(fopen_we_append_test, tc)
{
runtest(_PATH_DEVNULL, "we+");
}
ATF_TC_WITHOUT_HEAD(fopen_ae_append_test);
ATF_TC_BODY(fopen_ae_append_test, tc)
{
runtest(_PATH_DEVNULL, "ae+");
}
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, fopen_r_test);
ATF_TP_ADD_TC(tp, fopen_r_append_test);
ATF_TP_ADD_TC(tp, fopen_w_test);
ATF_TP_ADD_TC(tp, fopen_w_append_test);
ATF_TP_ADD_TC(tp, fopen_a_test);
ATF_TP_ADD_TC(tp, fopen_a_append_test);
ATF_TP_ADD_TC(tp, fopen_re_test);
ATF_TP_ADD_TC(tp, fopen_r_append_e_test);
ATF_TP_ADD_TC(tp, fopen_we_test);
ATF_TP_ADD_TC(tp, fopen_w_append_e_test);
ATF_TP_ADD_TC(tp, fopen_ae_test);
ATF_TP_ADD_TC(tp, fopen_a_append_e_test);
ATF_TP_ADD_TC(tp, fopen_re_append_test);
ATF_TP_ADD_TC(tp, fopen_we_append_test);
ATF_TP_ADD_TC(tp, fopen_ae_append_test);
return (atf_no_error());
}
/*
vim:ts=8:cin:sw=8
*/

224
lib/libc/tests/stdio/freopen_test.c Normal file
View File

@ -0,0 +1,224 @@
/*-
* Copyright (c) 2014 Jilles Tjoelker
* 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 AUTHOR 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 AUTHOR 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>
__FBSDID("$FreeBSD$");
#include <errno.h>
#include <paths.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <atf-c.h>
static void
runtest(const char *fname1, const char *mode1, const char *fname2,
const char *mode2, bool success)
{
FILE *fp1, *fp2;
const char *fname2_print;
fname2_print = fname2 != NULL ? fname2 : "<NULL>";
fp1 = fopen(fname1, mode1);
ATF_REQUIRE_MSG(fp1 != NULL,
"fopen(\"%s\", \"%s\") failed; errno=%d", fname1, mode1, errno);
fp2 = freopen(fname2, mode2, fp1);
if (fp2 == NULL) {
fclose(fp1);
ATF_REQUIRE_MSG(success == false,
"freopen(\"%s\", \"%s\", fopen(\"%s\", \"%s\")) succeeded "
"unexpectedly", fname2_print, mode2, fname1, mode1);
return;
}
ATF_REQUIRE_MSG(success == true,
"freopen(\"%s\", \"%s\", fopen(\"%s\", \"%s\")) failed: %d",
fname2_print, mode2, fname1, mode1, errno);
fclose(fp2);
}
ATF_TC_WITHOUT_HEAD(null__r__r__test);
ATF_TC_BODY(null__r__r__test, tc)
{
runtest(_PATH_DEVNULL, "r", NULL, "r", true);
}
ATF_TC_WITHOUT_HEAD(null__w__r__test);
ATF_TC_BODY(null__w__r__test, tc)
{
runtest(_PATH_DEVNULL, "w", NULL, "r", false);
}
ATF_TC_WITHOUT_HEAD(null__r_append__r__test);
ATF_TC_BODY(null__r_append__r__test, tc)
{
runtest(_PATH_DEVNULL, "r+", NULL, "r", true);
}
ATF_TC_WITHOUT_HEAD(null__r__w__test);
ATF_TC_BODY(null__r__w__test, tc)
{
runtest(_PATH_DEVNULL, "r", NULL, "w", false);
}
ATF_TC_WITHOUT_HEAD(null__w__w__test);
ATF_TC_BODY(null__w__w__test, tc)
{
runtest(_PATH_DEVNULL, "w", NULL, "w", true);
}
ATF_TC_WITHOUT_HEAD(null__r_append__w__test);
ATF_TC_BODY(null__r_append__w__test, tc)
{
runtest(_PATH_DEVNULL, "r+", NULL, "w", true);
}
ATF_TC_WITHOUT_HEAD(null__r__a__test);
ATF_TC_BODY(null__r__a__test, tc)
{
runtest(_PATH_DEVNULL, "r", NULL, "a", false);
}
ATF_TC_WITHOUT_HEAD(null__w__a__test);
ATF_TC_BODY(null__w__a__test, tc)
{
runtest(_PATH_DEVNULL, "w", NULL, "a", true);
}
ATF_TC_WITHOUT_HEAD(null__r_append__a__test);
ATF_TC_BODY(null__r_append__a__test, tc)
{
runtest(_PATH_DEVNULL, "r+", NULL, "a", true);
}
ATF_TC_WITHOUT_HEAD(null__r__r_append__test);
ATF_TC_BODY(null__r__r_append__test, tc)
{
runtest(_PATH_DEVNULL, "r", NULL, "r+", false);
}
ATF_TC_WITHOUT_HEAD(null__w__r_append__test);
ATF_TC_BODY(null__w__r_append__test, tc)
{
runtest(_PATH_DEVNULL, "w", NULL, "r+", false);
}
ATF_TC_WITHOUT_HEAD(null__r_append__r_append__test);
ATF_TC_BODY(null__r_append__r_append__test, tc)
{
runtest(_PATH_DEVNULL, "r+", NULL, "r+", true);
}
ATF_TC_WITHOUT_HEAD(null__r__w_append__test);
ATF_TC_BODY(null__r__w_append__test, tc)
{
runtest(_PATH_DEVNULL, "r", NULL, "w+", false);
}
ATF_TC_WITHOUT_HEAD(null__w__w_append__test);
ATF_TC_BODY(null__w__w_append__test, tc)
{
runtest(_PATH_DEVNULL, "w", NULL, "w+", false);
}
ATF_TC_WITHOUT_HEAD(null__r_append__w_append__test);
ATF_TC_BODY(null__r_append__w_append__test, tc)
{
runtest(_PATH_DEVNULL, "r+", NULL, "w+", true);
}
ATF_TC_WITHOUT_HEAD(sh__r__r__test);
ATF_TC_BODY(sh__r__r__test, tc)
{
runtest("/bin/sh", "r", NULL, "r", true);
}
ATF_TC_WITHOUT_HEAD(sh__sh__r__r__test);
ATF_TC_BODY(sh__sh__r__r__test, tc)
{
runtest("/bin/sh", "r", "/bin/sh", "r", true);
}
ATF_TC_WITHOUT_HEAD(sh__null__r__r__test);
ATF_TC_BODY(sh__null__r__r__test, tc)
{
runtest("/bin/sh", "r", _PATH_DEVNULL, "r", true);
}
ATF_TC_WITHOUT_HEAD(sh__null__r__w__test);
ATF_TC_BODY(sh__null__r__w__test, tc)
{
runtest("/bin/sh", "r", _PATH_DEVNULL, "w", true);
}
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, null__r__r__test);
ATF_TP_ADD_TC(tp, null__w__r__test);
ATF_TP_ADD_TC(tp, null__r_append__r__test);
ATF_TP_ADD_TC(tp, null__r__w__test);
ATF_TP_ADD_TC(tp, null__w__w__test);
ATF_TP_ADD_TC(tp, null__r_append__w__test);
ATF_TP_ADD_TC(tp, null__r__a__test);
ATF_TP_ADD_TC(tp, null__w__a__test);
ATF_TP_ADD_TC(tp, null__r_append__a__test);
ATF_TP_ADD_TC(tp, null__r__r_append__test);
ATF_TP_ADD_TC(tp, null__w__r_append__test);
ATF_TP_ADD_TC(tp, null__r_append__r_append__test);
ATF_TP_ADD_TC(tp, null__r__w_append__test);
ATF_TP_ADD_TC(tp, null__w__w_append__test);
ATF_TP_ADD_TC(tp, null__r_append__w_append__test);
ATF_TP_ADD_TC(tp, sh__r__r__test);
ATF_TP_ADD_TC(tp, sh__sh__r__r__test);
ATF_TP_ADD_TC(tp, sh__null__r__r__test);
ATF_TP_ADD_TC(tp, sh__null__r__w__test);
return (atf_no_error());
}
/*
vim:ts=8:cin:sw=8
*/

160
tools/regression/lib/libc/stdio/test-getdelim.c → lib/libc/tests/stdio/getdelim_test.c
View File

@ -28,12 +28,13 @@
__FBSDID("$FreeBSD$");
#define _WITH_GETLINE
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <atf-c.h>
#define CHUNK_MAX 10
/* The assertions depend on this string. */
@ -70,18 +71,16 @@ mkfilebuf(void)
return (fropen(offp, _reader));
}
int
main(int argc, char *argv[])
ATF_TC_WITHOUT_HEAD(getline_basic);
ATF_TC_BODY(getline_basic, tc)
{
FILE *fp;
char *line;
size_t linecap;
int i, n;
int i;
srandom(0);
printf("1..6\n");
/*
* Test multiple times with different buffer sizes
* and different _reader() return values.
@ -92,96 +91,147 @@ main(int argc, char *argv[])
linecap = i;
line = malloc(i);
/* First line: the full apothegm */
assert(getline(&line, &linecap, fp) == sizeof(apothegm) - 1);
assert(memcmp(line, apothegm, sizeof(apothegm)) == 0);
assert(linecap >= sizeof(apothegm));
ATF_REQUIRE(getline(&line, &linecap, fp) == sizeof(apothegm) - 1);
ATF_REQUIRE(memcmp(line, apothegm, sizeof(apothegm)) == 0);
ATF_REQUIRE(linecap >= sizeof(apothegm));
/* Second line: the NUL terminator following the newline */
assert(getline(&line, &linecap, fp) == 1);
assert(line[0] == '\0' && line[1] == '\0');
ATF_REQUIRE(getline(&line, &linecap, fp) == 1);
ATF_REQUIRE(line[0] == '\0' && line[1] == '\0');
/* Third line: EOF */
line[0] = 'X';
assert(getline(&line, &linecap, fp) == -1);
assert(line[0] == '\0');
ATF_REQUIRE(getline(&line, &linecap, fp) == -1);
ATF_REQUIRE(line[0] == '\0');
free(line);
line = NULL;
assert(feof(fp));
assert(!ferror(fp));
ATF_REQUIRE(feof(fp));
ATF_REQUIRE(!ferror(fp));
fclose(fp);
}
assert(errno == 0);
printf("ok 1 - getline basic\n");
ATF_REQUIRE(errno == 0);
}
ATF_TC_WITHOUT_HEAD(stream_error);
ATF_TC_BODY(stream_error, tc)
{
FILE *fp;
char *line;
size_t linecap;
/* Make sure read errors are handled properly. */
line = NULL;
linecap = 0;
errno = 0;
assert(getline(&line, &linecap, stdout) == -1);
assert(errno == EBADF);
ATF_REQUIRE(getline(&line, &linecap, stdout) == -1);
ATF_REQUIRE(errno == EBADF);
errno = 0;
assert(getdelim(&line, &linecap, 'X', stdout) == -1);
assert(errno == EBADF);
assert(ferror(stdout));
printf("ok 2 - stream error\n");
ATF_REQUIRE(getdelim(&line, &linecap, 'X', stdout) == -1);
ATF_REQUIRE(errno == EBADF);
ATF_REQUIRE(ferror(stdout));
}
ATF_TC_WITHOUT_HEAD(invalid_params);
ATF_TC_BODY(invalid_params, tc)
{
FILE *fp;
char *line;
size_t linecap;
/* Make sure NULL linep or linecapp pointers are handled. */
fp = mkfilebuf();
assert(getline(NULL, &linecap, fp) == -1);
assert(errno == EINVAL);
assert(getline(&line, NULL, fp) == -1);
assert(errno == EINVAL);
assert(ferror(fp));
ATF_REQUIRE(getline(NULL, &linecap, fp) == -1);
ATF_REQUIRE(errno == EINVAL);
ATF_REQUIRE(getline(&line, NULL, fp) == -1);
ATF_REQUIRE(errno == EINVAL);
ATF_REQUIRE(ferror(fp));
fclose(fp);
printf("ok 3 - invalid params\n");
}
ATF_TC_WITHOUT_HEAD(eof);
ATF_TC_BODY(eof, tc)
{
FILE *fp;
char *line;
size_t linecap;
/* Make sure getline() allocates memory as needed if fp is at EOF. */
errno = 0;
fp = mkfilebuf();
while (!feof(fp)) /* advance to EOF; can't fseek this stream */
getc(fp);
free(line);
line = NULL;
linecap = 0;
assert(getline(&line, &linecap, fp) == -1);
assert(line[0] == '\0');
assert(linecap > 0);
assert(errno == 0);
assert(feof(fp));
assert(!ferror(fp));
printf("getline\n");
ATF_REQUIRE(getline(&line, &linecap, fp) == -1);
ATF_REQUIRE(line[0] == '\0');
ATF_REQUIRE(linecap > 0);
ATF_REQUIRE(errno == 0);
printf("feof\n");
ATF_REQUIRE(feof(fp));
ATF_REQUIRE(!ferror(fp));
fclose(fp);
printf("ok 4 - eof\n");
}
ATF_TC_WITHOUT_HEAD(nul);
ATF_TC_BODY(nul, tc)
{
FILE *fp;
char *line;
size_t linecap, n;
line = NULL;
linecap = 0;
/* Make sure a NUL delimiter works. */
fp = mkfilebuf();
n = strlen(apothegm);
assert(getdelim(&line, &linecap, '\0', fp) == n + 1);
assert(strcmp(line, apothegm) == 0);
assert(line[n + 1] == '\0');
assert(linecap > n + 1);
printf("getdelim\n");
ATF_REQUIRE(getdelim(&line, &linecap, '\0', fp) == n + 1);
ATF_REQUIRE(strcmp(line, apothegm) == 0);
ATF_REQUIRE(line[n + 1] == '\0');
ATF_REQUIRE(linecap > n + 1);
n = strlen(apothegm + n + 1);
assert(getdelim(&line, &linecap, '\0', fp) == n + 1);
assert(line[n + 1] == '\0');
assert(linecap > n + 1);
assert(errno == 0);
assert(!ferror(fp));
printf("getdelim 2\n");
ATF_REQUIRE(getdelim(&line, &linecap, '\0', fp) == n + 1);
ATF_REQUIRE(line[n + 1] == '\0');
ATF_REQUIRE(linecap > n + 1);
ATF_REQUIRE(errno == 0);
ATF_REQUIRE(!ferror(fp));
fclose(fp);
printf("ok 5 - nul\n");
}
ATF_TC_WITHOUT_HEAD(empty_NULL_buffer);
ATF_TC_BODY(empty_NULL_buffer, tc)
{
FILE *fp;
char *line;
size_t linecap;
/* Make sure NULL *linep and zero *linecapp are handled. */
fp = mkfilebuf();
free(line);
line = NULL;
linecap = 42;
assert(getline(&line, &linecap, fp) == sizeof(apothegm) - 1);
assert(memcmp(line, apothegm, sizeof(apothegm)) == 0);
ATF_REQUIRE(getline(&line, &linecap, fp) == sizeof(apothegm) - 1);
ATF_REQUIRE(memcmp(line, apothegm, sizeof(apothegm)) == 0);
fp = mkfilebuf();
free(line);
line = malloc(100);
linecap = 0;
assert(getline(&line, &linecap, fp) == sizeof(apothegm) - 1);
assert(memcmp(line, apothegm, sizeof(apothegm)) == 0);
ATF_REQUIRE(getline(&line, &linecap, fp) == sizeof(apothegm) - 1);
ATF_REQUIRE(memcmp(line, apothegm, sizeof(apothegm)) == 0);
free(line);
assert(!ferror(fp));
ATF_REQUIRE(!ferror(fp));
fclose(fp);
printf("ok 6 - empty/NULL initial buffer\n");
exit(0);
}
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, getline_basic);
ATF_TP_ADD_TC(tp, stream_error);
ATF_TP_ADD_TC(tp, eof);
ATF_TP_ADD_TC(tp, invalid_params);
ATF_TP_ADD_TC(tp, nul);
ATF_TP_ADD_TC(tp, empty_NULL_buffer);
return (atf_no_error());
}

65
tools/regression/lib/libc/stdio/test-mkostemp.c → lib/libc/tests/stdio/mkostemp_test.c
View File

@ -41,7 +41,9 @@ __FBSDID("$FreeBSD$");
#include <string.h>
#include <unistd.h>
static const char template[] = _PATH_TMP "mkostemp.XXXXXXXX";
#include <atf-c.h>
static const char template[] = "mkostemp.XXXXXXXX";
static int testnum;
#define MISCFLAGS (O_APPEND | O_DIRECT | O_SHLOCK | O_EXLOCK | O_SYNC)
@ -131,34 +133,53 @@ test_one(int oflags)
(void)unlink(tmpf);
}
static void
test_badflags(void)
ATF_TC_WITHOUT_HEAD(zero);
ATF_TC_BODY(zero, tc)
{
test_one(0);
}
ATF_TC_WITHOUT_HEAD(O_CLOEXEC);
ATF_TC_BODY(O_CLOEXEC, tc)
{
test_one(O_CLOEXEC);
}
ATF_TC_WITHOUT_HEAD(O_APPEND);
ATF_TC_BODY(O_APPEND, tc)
{
test_one(O_APPEND);
}
ATF_TC_WITHOUT_HEAD(O_APPEND__O_CLOEXEC);
ATF_TC_BODY(O_APPEND__O_CLOEXEC, tc)
{
test_one(O_APPEND|O_CLOEXEC);
}
ATF_TC_WITHOUT_HEAD(bad_flags);
ATF_TC_BODY(bad_flags, tc)
{
char tmpf[sizeof(template)];
memcpy(tmpf, template, sizeof(tmpf));
if (mkostemp(tmpf, O_CREAT) == -1)
printf("ok %d - mkostemp(O_CREAT) correctly failed\n",
testnum++);
else
printf("not ok %d - mkostemp(O_CREAT) wrongly succeeded\n",
testnum++);
ATF_REQUIRE_MSG(mkostemp(tmpf, O_CREAT) == -1,
"mkostemp(O_CREAT) succeeded unexpectedly");
}
int
main(int argc, char *argv[])
ATF_TP_ADD_TCS(tp)
{
int i;
const char *e;
printf("1..5\n");
testnum = 1;
ATF_TP_ADD_TC(tp, zero);
ATF_TP_ADD_TC(tp, O_CLOEXEC);
ATF_TP_ADD_TC(tp, O_APPEND);
ATF_TP_ADD_TC(tp, O_APPEND__O_CLOEXEC);
ATF_TP_ADD_TC(tp, bad_flags);
test_one(0);
test_one(O_CLOEXEC);
test_one(O_APPEND);
test_one(O_APPEND | O_CLOEXEC);
test_badflags();
return (0);
return (atf_no_error());
}

86
tools/regression/lib/libc/stdio/test-open_memstream.c → lib/libc/tests/stdio/open_memstream_test.c
View File

@ -37,6 +37,8 @@ __FBSDID("$FreeBSD$");
#include <string.h>
#include <wchar.h>
#include <atf-c.h>
static char *buf;
static size_t len;
@ -49,15 +51,14 @@ assert_stream(const char *contents)
printf("bad buffer \"%s\" for \"%s\"\n", buf, contents);
}
static void
open_group_test(void)
ATF_TC_WITHOUT_HEAD(open_group_test);
ATF_TC_BODY(open_group_test, tc)
{
FILE *fp;
off_t eob;
fp = open_memstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
ATF_REQUIRE_MSG(fp != NULL, "open_memstream failed");
fprintf(fp, "hello my world");
fflush(fp);
@ -71,8 +72,8 @@ open_group_test(void)
free(buf);
}
static void
simple_tests(void)
ATF_TC_WITHOUT_HEAD(simple_tests);
ATF_TC_BODY(simple_tests, tc)
{
static const char zerobuf[] =
{ 'f', 'o', 'o', 0, 0, 0, 0, 'b', 'a', 'r', 0 };
@ -80,18 +81,15 @@ simple_tests(void)
FILE *fp;
fp = open_memstream(&buf, NULL);
if (fp != NULL)
errx(1, "did not fail to open stream");
else if (errno != EINVAL)
err(1, "incorrect error for bad length pointer");
ATF_REQUIRE_MSG(fp == NULL, "open_memstream did not fail");
ATF_REQUIRE_MSG(errno == EINVAL,
"open_memstream didn't fail with EINVAL");
fp = open_memstream(NULL, &len);
if (fp != NULL)
errx(1, "did not fail to open stream");
else if (errno != EINVAL)
err(1, "incorrect error for bad buffer pointer");
ATF_REQUIRE_MSG(fp == NULL, "open_memstream did not fail");
ATF_REQUIRE_MSG(errno == EINVAL,
"open_memstream didn't fail with EINVAL");
fp = open_memstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
ATF_REQUIRE_MSG(fp != NULL, "open_memstream failed; errno=%d", errno);
fflush(fp);
assert_stream("");
if (fwide(fp, 0) >= 0)
@ -150,34 +148,34 @@ simple_tests(void)
free(buf);
}
static void
seek_tests(void)
ATF_TC_WITHOUT_HEAD(seek_tests);
ATF_TC_BODY(seek_tests, tc)
{
FILE *fp;
fp = open_memstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
#define SEEK_FAIL(offset, whence, error) do { \
errno = 0; \
if (fseeko(fp, (offset), (whence)) == 0) \
printf("fseeko(%s, %s) did not fail, set pos to %jd\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp)); \
else if (errno != (error)) \
printf("fseeko(%s, %s) failed with %d rather than %s\n",\
__STRING(offset), __STRING(whence), errno, \
__STRING(error)); \
ATF_REQUIRE_MSG(fp != NULL, "open_memstream failed: %d", errno);
#define SEEK_FAIL(offset, whence, error) do { \
errno = 0; \
ATF_REQUIRE_MSG(fseeko(fp, (offset), (whence)) != 0, \
"fseeko(%s, %s) did not fail, set pos to %jd\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp)); \
ATF_REQUIRE_MSG(errno == (error), \
"fseeko(%s, %s) failed with %d rather than %s\n", \
__STRING(offset), __STRING(whence), errno, \
__STRING(error)); \
} while (0)
#define SEEK_OK(offset, whence, result) do { \
if (fseeko(fp, (offset), (whence)) != 0) \
printf("fseeko(%s, %s) failed: %s\n", \
__STRING(offset), __STRING(whence), strerror(errno)); \
else if (ftello(fp) != (result)) \
printf("fseeko(%s, %s) seeked to %jd rather than %s\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp), __STRING(result)); \
#define SEEK_OK(offset, whence, result) do { \
ATF_REQUIRE_MSG(fseeko(fp, (offset), (whence)) == 0, \
"fseeko(%s, %s) failed: %s", \
__STRING(offset), __STRING(whence), strerror(errno)); \
ATF_REQUIRE_MSG(ftello(fp) == (result), \
"fseeko(%s, %s) seeked to %jd rather than %s\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp), __STRING(result)); \
} while (0)
SEEK_FAIL(-1, SEEK_SET, EINVAL);
@ -192,12 +190,12 @@ seek_tests(void)
fclose(fp);
}
int
main(int ac, char **av)
ATF_TP_ADD_TCS(tp)
{
open_group_test();
simple_tests();
seek_tests();
return (0);
ATF_TP_ADD_TC(tp, open_group_test);
ATF_TP_ADD_TC(tp, simple_tests);
ATF_TP_ADD_TC(tp, seek_tests);
return (atf_no_error());
}

86
tools/regression/lib/libc/stdio/test-open_wmemstream.c → lib/libc/tests/stdio/open_wmemstream_test.c
View File

@ -37,6 +37,8 @@ __FBSDID("$FreeBSD$");
#include <string.h>
#include <wchar.h>
#include <atf-c.h>
static wchar_t *buf;
static size_t len;
@ -49,15 +51,14 @@ assert_stream(const wchar_t *contents)
printf("bad buffer \"%ls\" for \"%ls\"\n", buf, contents);
}
static void
open_group_test(void)
ATF_TC_WITHOUT_HEAD(open_group_test);
ATF_TC_BODY(open_group_test, tc)
{
FILE *fp;
off_t eob;
fp = open_wmemstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
ATF_REQUIRE_MSG(fp != NULL, "open_wmemstream failed");
fwprintf(fp, L"hello my world");
fflush(fp);
@ -71,8 +72,8 @@ open_group_test(void)
free(buf);
}
static void
simple_tests(void)
ATF_TC_WITHOUT_HEAD(simple_tests);
ATF_TC_BODY(simple_tests, tc)
{
static const wchar_t zerobuf[] =
{ L'f', L'o', L'o', 0, 0, 0, 0, L'b', L'a', L'r', 0 };
@ -80,18 +81,15 @@ simple_tests(void)
FILE *fp;
fp = open_wmemstream(&buf, NULL);
if (fp != NULL)
errx(1, "did not fail to open stream");
else if (errno != EINVAL)
err(1, "incorrect error for bad length pointer");
ATF_REQUIRE_MSG(fp == NULL, "open_wmemstream did not fail");
ATF_REQUIRE_MSG(errno == EINVAL,
"open_wmemstream didn't fail with EINVAL");
fp = open_wmemstream(NULL, &len);
if (fp != NULL)
errx(1, "did not fail to open stream");
else if (errno != EINVAL)
err(1, "incorrect error for bad buffer pointer");
ATF_REQUIRE_MSG(fp == NULL, "open_wmemstream did not fail");
ATF_REQUIRE_MSG(errno == EINVAL,
"open_wmemstream didn't fail with EINVAL");
fp = open_wmemstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
ATF_REQUIRE_MSG(fp != NULL, "open_memstream failed; errno=%d", errno);
fflush(fp);
assert_stream(L"");
if (fwide(fp, 0) <= 0)
@ -150,34 +148,34 @@ simple_tests(void)
free(buf);
}
static void
seek_tests(void)
ATF_TC_WITHOUT_HEAD(seek_tests);
ATF_TC_BODY(seek_tests, tc)
{
FILE *fp;
fp = open_wmemstream(&buf, &len);
if (fp == NULL)
err(1, "failed to open stream");
#define SEEK_FAIL(offset, whence, error) do { \
errno = 0; \
if (fseeko(fp, (offset), (whence)) == 0) \
printf("fseeko(%s, %s) did not fail, set pos to %jd\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp)); \
else if (errno != (error)) \
printf("fseeko(%s, %s) failed with %d rather than %s\n",\
__STRING(offset), __STRING(whence), errno, \
__STRING(error)); \
ATF_REQUIRE_MSG(fp != NULL, "open_wmemstream failed; errno=%d", errno);
#define SEEK_FAIL(offset, whence, error) do { \
errno = 0; \
ATF_REQUIRE_MSG(fseeko(fp, (offset), (whence)) != 0, \
"fseeko(%s, %s) did not fail, set pos to %jd\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp)); \
ATF_REQUIRE_MSG(errno == (error), \
"fseeko(%s, %s) failed with %d rather than %s\n", \
__STRING(offset), __STRING(whence), errno, \
__STRING(error)); \
} while (0)
#define SEEK_OK(offset, whence, result) do { \
if (fseeko(fp, (offset), (whence)) != 0) \
printf("fseeko(%s, %s) failed: %s\n", \
__STRING(offset), __STRING(whence), strerror(errno)); \
else if (ftello(fp) != (result)) \
printf("fseeko(%s, %s) seeked to %jd rather than %s\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp), __STRING(result)); \
#define SEEK_OK(offset, whence, result) do { \
ATF_REQUIRE_MSG(fseeko(fp, (offset), (whence)) == 0, \
"fseeko(%s, %s) failed: %s", \
__STRING(offset), __STRING(whence), strerror(errno)); \
ATF_REQUIRE_MSG(ftello(fp) == (result), \
"fseeko(%s, %s) seeked to %jd rather than %s\n", \
__STRING(offset), __STRING(whence), \
(intmax_t)ftello(fp), __STRING(result)); \
} while (0)
SEEK_FAIL(-1, SEEK_SET, EINVAL);
@ -192,12 +190,12 @@ seek_tests(void)
fclose(fp);
}
int
main(int ac, char **av)
ATF_TP_ADD_TCS(tp)
{
open_group_test();
simple_tests();
seek_tests();
return (0);
ATF_TP_ADD_TC(tp, open_group_test);
ATF_TP_ADD_TC(tp, simple_tests);
ATF_TP_ADD_TC(tp, seek_tests);
return (atf_no_error());
}

57
tools/regression/lib/libc/stdio/test-perror.c → lib/libc/tests/stdio/perror_test.c
View File

@ -32,7 +32,6 @@
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <limits.h>
@ -42,28 +41,24 @@ __FBSDID("$FreeBSD$");
#include <string.h>
#include <unistd.h>
static void cleanup(void);
#include <atf-c.h>
static char tmpfil[PATH_MAX];
int
main(int argc, char *argv[])
ATF_TC_WITHOUT_HEAD(perror_test);
ATF_TC_BODY(perror_test, tc)
{
char lbuf[512];
char buf[512], lbuf[512];
int i;
char *s;
printf("1..1\n");
strcpy(tmpfil, _PATH_TMP "perror.XXXXXXXX");
if (mkstemp(tmpfil) < 0)
err(1, "mkstemp");
atexit(cleanup);
strcpy(tmpfil, "perror.XXXXXXXX");
ATF_REQUIRE(mkstemp(tmpfil) >= 0);
/* Reopen stderr on a file descriptor other than 2. */
fclose(stderr);
for (i = 0; i < 3; i++)
dup(0);
if (freopen(tmpfil, "r+", stderr) == NULL)
err(1, "%s", tmpfil);
ATF_REQUIRE(freopen(tmpfil, "r+", stderr) != NULL);
/*
* Test that perror() doesn't call strerror() (4.4BSD bug),
@ -71,38 +66,42 @@ main(int argc, char *argv[])
* a program name is specified.
*/
s = strerror(ENOENT);
assert(strcmp(s, "No such file or directory") == 0);
ATF_REQUIRE_MSG(strcmp(s, "No such file or directory") == 0,
"message obtained was: %s", s);
errno = EPERM;
perror(NULL);
perror("");
perror("test-perror");
assert(strcmp(s, "No such file or directory") == 0);
perror("perror_test");
ATF_REQUIRE_MSG(strcmp(s, "No such file or directory") == 0,
"message obtained was: %s", s);
/*
* Read it back to check...
*/
rewind(stderr);
s = fgets(lbuf, sizeof(lbuf), stderr);
assert(s != NULL);
assert(strcmp(s, "Operation not permitted\n") == 0);
ATF_REQUIRE(s != NULL);
ATF_REQUIRE_MSG(strcmp(s, "Operation not permitted\n") == 0,
"message obtained was: %s", s);
s = fgets(lbuf, sizeof(lbuf), stderr);
assert(s != NULL);
assert(strcmp(s, "Operation not permitted\n") == 0);
ATF_REQUIRE(s != NULL);
ATF_REQUIRE_MSG(strcmp(s, "Operation not permitted\n") == 0,
"message obtained was: %s", s);
s = fgets(lbuf, sizeof(lbuf), stderr);
assert(s != NULL);
assert(strcmp(s, "test-perror: Operation not permitted\n") == 0);
ATF_REQUIRE(s != NULL);
ATF_REQUIRE_MSG(
strcmp(s, "perror_test: Operation not permitted\n") == 0,
"message obtained was: %s", s);
s = fgets(lbuf, sizeof(lbuf), stderr);
assert(s == NULL);
ATF_REQUIRE(s == NULL);
fclose(stderr);
printf("ok 1 - perror()\n");
return (0);
}
static void
cleanup(void)
ATF_TP_ADD_TCS(tp)
{
unlink(tmpfil);
ATF_TP_ADD_TC(tp, perror_test);
return (atf_no_error());
}

0
tools/regression/lib/libc/stdio/test-print-positional.c → lib/libc/tests/stdio/print_positional_test.c
View File

124
tools/regression/lib/libc/stdio/test-printbasic.c → lib/libc/tests/stdio/printbasic_test.c
View File

@ -31,7 +31,6 @@
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <err.h>
#include <limits.h>
#include <locale.h>
@ -43,10 +42,7 @@ __FBSDID("$FreeBSD$");
#include <string.h>
#include <wchar.h>
#define testfmt(result, fmt, ...) \
_testfmt((result), __LINE__, #__VA_ARGS__, fmt, __VA_ARGS__)
void _testfmt(const char *, int, const char *, const char *, ...);
void smash_stack(void);
#include <atf-c.h>
#define S_UINT64MAX "18446744073709551615"
#define S_UINT32MAX "4294967295"
@ -57,22 +53,62 @@ void smash_stack(void);
#define S_ULONGMAX (ULONG_MAX == UINT64_MAX ? S_UINT64MAX : S_UINT32MAX)
#define S_ULLONGMAX (ULLONG_MAX == UINT64_MAX ? S_UINT64MAX : S_UINT32MAX)
int
main(int argc, char *argv[])
static void
smash_stack(void)
{
static uint32_t junk = 0xdeadbeef;
uint32_t buf[512];
int i;
for (i = 0; i < sizeof(buf) / sizeof(buf[0]); i++)
buf[i] = junk;
}
#define testfmt(result, fmt, ...) \
_testfmt((result), #__VA_ARGS__, fmt, __VA_ARGS__)
static void
_testfmt(const char *result, const char *argstr, const char *fmt,...)
{
#define BUF 100
wchar_t ws[BUF], wfmt[BUF], wresult[BUF];
char s[BUF];
va_list ap, ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
smash_stack();
vsnprintf(s, sizeof(s), fmt, ap);
if (strcmp(result, s) != 0) {
atf_tc_fail(
"printf(\"%s\", %s) ==> [%s], expected [%s]\n",
fmt, argstr, s, result);
}
smash_stack();
mbstowcs(ws, s, BUF - 1);
mbstowcs(wfmt, fmt, BUF - 1);
mbstowcs(wresult, result, BUF - 1);
vswprintf(ws, sizeof(ws) / sizeof(ws[0]), wfmt, ap2);
if (wcscmp(wresult, ws) != 0) {
atf_tc_fail(
"wprintf(\"%ls\", %s) ==> [%ls], expected [%ls]\n",
wfmt, argstr, ws, wresult);
}
}
ATF_TC_WITHOUT_HEAD(int_within_limits);
ATF_TC_BODY(int_within_limits, tc)
{
printf("1..2\n");
assert(setlocale(LC_NUMERIC, "C"));
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/* The test requires these to be true. */
assert(UINTMAX_MAX == UINT64_MAX);
assert(UINT_MAX == UINT32_MAX);
assert(USHRT_MAX == 0xffff);
assert(UCHAR_MAX == 0xff);
ATF_REQUIRE(UINTMAX_MAX == UINT64_MAX);
ATF_REQUIRE(UINT_MAX == UINT32_MAX);
ATF_REQUIRE(USHRT_MAX == 0xffff);
ATF_REQUIRE(UCHAR_MAX == 0xff);
/*
* Make sure we handle signed vs. unsigned args correctly.
*/
/* Make sure we handle signed vs. unsigned args correctly. */
testfmt("-1", "%jd", (intmax_t)-1);
testfmt(S_UINT64MAX, "%ju", UINT64_MAX);
@ -96,8 +132,13 @@ main(int argc, char *argv[])
testfmt("-1", "%hhd", -1);
testfmt("255", "%hhu", UCHAR_MAX);
}
printf("ok 1 - printbasic signed/unsigned\n");
ATF_TC_WITHOUT_HEAD(int_limits);
ATF_TC_BODY(int_limits, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Check that printing the largest negative number does not cause
@ -105,52 +146,13 @@ main(int argc, char *argv[])
*/
testfmt(S_INT32MIN, "%d", INT_MIN);
testfmt(S_INT64MIN, "%jd", INTMAX_MIN);
printf("ok 2 - printbasic INT_MIN\n");
return (0);
}
void
smash_stack(void)
ATF_TP_ADD_TCS(tp)
{
static uint32_t junk = 0xdeadbeef;
uint32_t buf[512];
int i;
for (i = 0; i < sizeof(buf) / sizeof(buf[0]); i++)
buf[i] = junk;
}
void
_testfmt(const char *result, int line, const char *argstr, const char *fmt,...)
{
#define BUF 100
wchar_t ws[BUF], wfmt[BUF], wresult[BUF];
char s[BUF];
va_list ap, ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
smash_stack();
vsnprintf(s, sizeof(s), fmt, ap);
if (strcmp(result, s) != 0) {
fprintf(stderr,
"%d: printf(\"%s\", %s) ==> [%s], expected [%s]\n",
line, fmt, argstr, s, result);
abort();
}
smash_stack();
mbstowcs(ws, s, BUF - 1);
mbstowcs(wfmt, fmt, BUF - 1);
mbstowcs(wresult, result, BUF - 1);
vswprintf(ws, sizeof(ws) / sizeof(ws[0]), wfmt, ap2);
if (wcscmp(wresult, ws) != 0) {
fprintf(stderr,
"%d: wprintf(\"%ls\", %s) ==> [%ls], expected [%ls]\n",
line, wfmt, argstr, ws, wresult);
abort();
}
ATF_TP_ADD_TC(tp, int_within_limits);
ATF_TP_ADD_TC(tp, int_limits);
return (atf_no_error());
}

225
tools/regression/lib/libc/stdio/test-printfloat.c → lib/libc/tests/stdio/printfloat_test.c
View File

@ -31,7 +31,6 @@
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <err.h>
#include <fenv.h>
#include <float.h>
@ -44,21 +43,58 @@ __FBSDID("$FreeBSD$");
#include <string.h>
#include <wchar.h>
#define testfmt(result, fmt, ...) \
_testfmt((result), __LINE__, #__VA_ARGS__, fmt, __VA_ARGS__)
void _testfmt(const char *, int, const char *, const char *, ...);
void smash_stack(void);
#include <atf-c.h>
int
main(int argc, char *argv[])
static void
smash_stack(void)
{
static uint32_t junk = 0xdeadbeef;
uint32_t buf[512];
int i;
for (i = 0; i < sizeof(buf) / sizeof(buf[0]); i++)
buf[i] = junk;
}
#define testfmt(result, fmt, ...) \
_testfmt((result), #__VA_ARGS__, fmt, __VA_ARGS__)
static void
_testfmt(const char *result, const char *argstr, const char *fmt,...)
{
#define BUF 100
wchar_t ws[BUF], wfmt[BUF], wresult[BUF];
char s[BUF];
va_list ap, ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
smash_stack();
vsnprintf(s, sizeof(s), fmt, ap);
if (strcmp(result, s) != 0) {
atf_tc_fail(
"printf(\"%s\", %s) ==> [%s], expected [%s]\n",
fmt, argstr, s, result);
}
smash_stack();
mbstowcs(ws, s, BUF - 1);
mbstowcs(wfmt, fmt, BUF - 1);
mbstowcs(wresult, result, BUF - 1);
vswprintf(ws, sizeof(ws) / sizeof(ws[0]), wfmt, ap2);
if (wcscmp(wresult, ws) != 0) {
atf_tc_fail(
"wprintf(\"%ls\", %s) ==> [%ls], expected [%ls]\n",
wfmt, argstr, ws, wresult);
}
}
ATF_TC_WITHOUT_HEAD(float_within_limits);
ATF_TC_BODY(float_within_limits, tc)
{
printf("1..11\n");
assert(setlocale(LC_NUMERIC, "C"));
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Basic tests of decimal output functionality.
*/
/* Basic tests of decimal output functionality. */
testfmt(" 1.000000E+00", "%13E", 1.0);
testfmt(" 1.000000", "%13f", 1.0);
testfmt(" 1", "%13G", 1.0);
@ -82,12 +118,14 @@ main(int argc, char *argv[])
testfmt(" 3.141592653589793238e-4000", "%L27.18Le",
3.14159265358979323846e-4000L);
#endif
}
printf("ok 1 - printfloat\n");
ATF_TC_WITHOUT_HEAD(infinities_and_nans);
ATF_TC_BODY(infinities_and_nans, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Infinities and NaNs
*/
testfmt("nan", "%e", NAN);
testfmt("NAN", "%F", NAN);
testfmt("nan", "%g", NAN);
@ -101,59 +139,69 @@ main(int argc, char *argv[])
testfmt("-inf", "%Lf", -HUGE_VALL);
testfmt(" inf", "%05e", HUGE_VAL);
testfmt(" -inf", "%05e", -HUGE_VAL);
}
printf("ok 2 - printfloat\n");
ATF_TC_WITHOUT_HEAD(padding);
ATF_TC_BODY(padding, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Padding
*/
testfmt("0.000000e+00", "%e", 0.0);
testfmt("0.000000", "%F", (double)0.0);
testfmt("0", "%G", 0.0);
testfmt(" 0", "%3.0Lg", 0.0L);
testfmt(" 0", "%5.0f", 0.001);
printf("ok 3 - printfloat\n");
}
ATF_TC_WITHOUT_HEAD(precision_specifiers);
ATF_TC_BODY(precision_specifiers, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Precision specifiers
*/
testfmt("1.0123e+00", "%.4e", 1.0123456789);
testfmt("1.0123", "%.4f", 1.0123456789);
testfmt("1.012", "%.4g", 1.0123456789);
testfmt("1.2346e-02", "%.4e", 0.0123456789);
testfmt("0.0123", "%.4f", 0.0123456789);
testfmt("0.01235", "%.4g", 0.0123456789);
printf("ok 4 - printfloat\n");
}
ATF_TC_WITHOUT_HEAD(thousands_separator_and_other_locale_tests);
ATF_TC_BODY(thousands_separator_and_other_locale_tests, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Thousands' separators and other locale fun
*/
testfmt("12345678.0625", "%'.04f", 12345678.0625);
testfmt("0012345678.0625", "%'015.4F", 12345678.0625);
assert(setlocale(LC_NUMERIC, "hi_IN.ISCII-DEV")); /* grouping == 2;3 */
ATF_REQUIRE(setlocale(LC_NUMERIC, "hi_IN.ISCII-DEV")); /* grouping == 2;3 */
testfmt("123,456,78.0625", "%'.4f", 12345678.0625);
testfmt("00123,456,78.0625", "%'017.4F", 12345678.0625);
testfmt(" 90,00", "%'6.0f", 9000.0);
testfmt("90,00.0", "%'.1f", 9000.0);
assert(setlocale(LC_NUMERIC, "ru_RU.ISO8859-5")); /* decimalpoint==, */
ATF_REQUIRE(setlocale(LC_NUMERIC, "ru_RU.ISO8859-5")); /* decimalpoint==, */
testfmt("3,1415", "%g", 3.1415);
/* thousands=. decimalpoint=, grouping=3;3 */
assert(setlocale(LC_NUMERIC, "el_GR.ISO8859-7")); /* decimalpoint==, */
ATF_REQUIRE(setlocale(LC_NUMERIC, "el_GR.ISO8859-7")); /* decimalpoint==, */
testfmt("1.234,00", "%'.2f", 1234.00);
testfmt("123.456,789", "%'.3f", 123456.789);
assert(setlocale(LC_NUMERIC, "C"));
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
testfmt("12345678.062500", "%'f", 12345678.0625);
testfmt("9000.000000", "%'f", 9000.0);
}
printf("ok 5 - printfloat\n");
ATF_TC_WITHOUT_HEAD(signed_conversions);
ATF_TC_BODY(signed_conversions, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Signed conversions
*/
testfmt("+2.500000e-01", "%+e", 0.25);
testfmt("+0.000000", "%+F", 0.0);
testfmt("-1", "%+g", -1.0);
@ -162,22 +210,27 @@ main(int argc, char *argv[])
testfmt("+1.000000", "% +f", 1.0);
testfmt(" 1", "% g", 1.0);
testfmt(" 0", "% g", 0.0);
}
printf("ok 6 - printfloat\n");
ATF_TC_WITHOUT_HEAD(alternate_form);
ATF_TC_BODY(alternate_form, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* ``Alternate form''
*/
testfmt("1.250e+00", "%#.3e", 1.25);
testfmt("123.000000", "%#f", 123.0);
testfmt(" 12345.", "%#7.5g", 12345.0);
testfmt(" 1.00000", "%#8g", 1.0);
testfmt("0.0", "%#.2g", 0.0);
printf("ok 7 - printfloat\n");
}
ATF_TC_WITHOUT_HEAD(padding_and_decimal_point_placement);
ATF_TC_BODY(padding_and_decimal_point_placement, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Padding and decimal point placement
*/
testfmt("03.2E+00", "%08.1E", 3.25);
testfmt("003.25", "%06.2F", 3.25);
testfmt("0003.25", "%07.4G", 3.25);
@ -205,12 +258,14 @@ main(int argc, char *argv[])
testfmt(" 100", "%4.0f", 100.0);
testfmt("9.0e+01", "%4.1e", 90.0);
testfmt("1e+02", "%4.0e", 100.0);
}
printf("ok 8 - printfloat\n");
ATF_TC_WITHOUT_HEAD(decimal_rounding);
ATF_TC_BODY(decimal_rounding, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Decimal rounding
*/
fesetround(FE_DOWNWARD);
testfmt("4.437", "%.3f", 4.4375);
testfmt("-4.438", "%.3f", -4.4375);
@ -234,8 +289,13 @@ main(int argc, char *argv[])
testfmt("-4.438", "%.3f", -4.4375);
testfmt("4.438", "%.3Lf", 4.4375L);
testfmt("-4.438", "%.3Lf", -4.4375L);
}
printf("ok 9 - printfloat\n");
ATF_TC_WITHOUT_HEAD(hexadecimal_floating_point);
ATF_TC_BODY(hexadecimal_floating_point, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Hexadecimal floating point (%a, %A) tests. Some of these
@ -270,12 +330,14 @@ main(int argc, char *argv[])
testfmt("0x1p-1074", "%La", 0x1p-1074L);
testfmt("0x1.30ecap-1021", "%La", 0x9.8765p-1024L);
#endif
}
printf("ok 10 - printfloat\n");
ATF_TC_WITHOUT_HEAD(hexadecimal_rounding);
ATF_TC_BODY(hexadecimal_rounding, tc)
{
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
/*
* Hexadecimal rounding
*/
fesetround(FE_TOWARDZERO);
testfmt("0X1.23456789ABCP+0", "%.11A", 0x1.23456789abcdep0);
testfmt("-0x1.23456p+0", "%.5a", -0x1.23456789abcdep0);
@ -307,51 +369,22 @@ main(int argc, char *argv[])
testfmt("0x1.00p-1029", "%.2a", 0x1.fffp-1030);
testfmt("0x1.00p-1026", "%.2a", 0xf.fffp-1030);
testfmt("0x1.83p+0", "%.2a", 1.51);
printf("ok 11 - printfloat\n");
return (0);
}
void
smash_stack(void)
ATF_TP_ADD_TCS(tp)
{
static uint32_t junk = 0xdeadbeef;
uint32_t buf[512];
int i;
for (i = 0; i < sizeof(buf) / sizeof(buf[0]); i++)
buf[i] = junk;
}
void
_testfmt(const char *result, int line, const char *argstr, const char *fmt,...)
{
#define BUF 100
wchar_t ws[BUF], wfmt[BUF], wresult[BUF];
char s[BUF];
va_list ap, ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
smash_stack();
vsnprintf(s, sizeof(s), fmt, ap);
if (strcmp(result, s) != 0) {
fprintf(stderr,
"%d: printf(\"%s\", %s) ==> [%s], expected [%s]\n",
line, fmt, argstr, s, result);
abort();
}
smash_stack();
mbstowcs(ws, s, BUF - 1);
mbstowcs(wfmt, fmt, BUF - 1);
mbstowcs(wresult, result, BUF - 1);
vswprintf(ws, sizeof(ws) / sizeof(ws[0]), wfmt, ap2);
if (wcscmp(wresult, ws) != 0) {
fprintf(stderr,
"%d: wprintf(\"%ls\", %s) ==> [%ls], expected [%ls]\n",
line, wfmt, argstr, ws, wresult);
abort();
}
ATF_TP_ADD_TC(tp, float_within_limits);
ATF_TP_ADD_TC(tp, infinities_and_nans);
ATF_TP_ADD_TC(tp, padding);
ATF_TP_ADD_TC(tp, precision_specifiers);
ATF_TP_ADD_TC(tp, thousands_separator_and_other_locale_tests);
ATF_TP_ADD_TC(tp, signed_conversions);
ATF_TP_ADD_TC(tp, alternate_form);
ATF_TP_ADD_TC(tp, padding_and_decimal_point_placement);
ATF_TP_ADD_TC(tp, decimal_rounding);
ATF_TP_ADD_TC(tp, hexadecimal_floating_point);
ATF_TP_ADD_TC(tp, hexadecimal_rounding);
return (atf_no_error());
}

530
tools/regression/lib/libc/stdio/test-scanfloat.c → lib/libc/tests/stdio/scanfloat_test.c
View File

@ -31,7 +31,6 @@
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <assert.h>
#include <fenv.h>
#include <float.h>
#include <locale.h>
@ -40,261 +39,9 @@ __FBSDID("$FreeBSD$");
#include <stdlib.h>
#include <string.h>
#include <atf-c.h>
#define eq(type, a, b) _eq(type##_EPSILON, (a), (b))
static int _eq(long double epsilon, long double a, long double b);
int
main(int argc, char *argv[])
{
char buf[128];
long double ld = 0.0;
double d = 0.0;
float f = 0.0;
char *endp;
printf("1..4\n");
buf[0] = '\0';
assert(setlocale(LC_NUMERIC, ""));
/*
* Various tests for normalized numbers
*/
sscanf("3.141592", "%e", &f);
assert(eq(FLT, f, 3.141592));
sscanf("3.141592653589793", "%lf", &d);
assert(eq(DBL, d, 3.141592653589793));
sscanf("1.234568e+06", "%E", &f);
assert(eq(FLT, f, 1.234568e+06));
sscanf("-1.234568e6", "%lF", &d);
assert(eq(DBL, d, -1.234568e6));
sscanf("+1.234568e-52", "%LG", &ld);
assert(eq(LDBL, ld, 1.234568e-52L));
sscanf("0.1", "%la", &d);
assert(eq(DBL, d, 0.1));
sscanf("00.2", "%lA", &d);
assert(eq(DBL, d, 0.2));
sscanf("123456", "%5le%s", &d, buf);
assert(eq(DBL, d, 12345.));
assert(strcmp(buf, "6") == 0);
sscanf("1.0Q", "%*5le%s", buf);
assert(strcmp(buf, "Q") == 0);
sscanf("-1.23e", "%e%s", &f, buf);
assert(eq(FLT, f, -1.23));
assert(strcmp(buf, "e") == 0);
sscanf("1.25e+", "%le%s", &d, buf);
assert(eq(DBL, d, 1.25));
assert(strcmp(buf, "e+") == 0);
sscanf("1.23E4E5", "%le%s", &d, buf);
assert(eq(DBL, d, 1.23e4));
assert(strcmp(buf, "E5") == 0);
sscanf("12e6", "%le", &d);
assert(eq(DBL, d, 12e6));
sscanf("1.a", "%le%s", &d, buf);
assert(eq(DBL, d, 1.0));
assert(strcmp(buf, "a") == 0);
sscanf(".0p4", "%le%s", &d, buf);
assert(eq(DBL, d, 0.0));
assert(strcmp(buf, "p4") == 0);
d = 0.25;
assert(sscanf(".", "%le", &d) == 0);
assert(d == 0.25);
sscanf("0x08", "%le", &d);
assert(d == 0x8p0);
sscanf("0x90a.bcdefP+09a", "%le%s", &d, buf);
assert(d == 0x90a.bcdefp+09);
assert(strcmp(buf, "a") == 0);
#if (LDBL_MANT_DIG > DBL_MANT_DIG) && !defined(__i386__)
sscanf("3.14159265358979323846", "%Lg", &ld);
assert(eq(LDBL, ld, 3.14159265358979323846L));
sscanf(" 0X.0123456789abcdefffp-3g", "%Le%s", &ld, buf);
assert(ld == 0x0.0123456789abcdefffp-3L);
assert(strcmp(buf, "g") == 0);
#endif
sscanf("0xg", "%le%s", &d, buf);
assert(d == 0.0);
assert(strcmp(buf, "xg") == 0);
assert(setlocale(LC_NUMERIC, "ru_RU.ISO8859-5")); /* decimalpoint==, */
sscanf("1.23", "%le%s", &d, buf);
assert(d == 1.0);
assert(strcmp(buf, ".23") == 0);
sscanf("1,23", "%le", &d);
assert(d == 1.23);
assert(setlocale(LC_NUMERIC, ""));
printf("ok 1 - scanfloat\n");
/*
* Infinity and NaN tests
*/
sscanf("-Inf", "%le", &d);
assert(d < 0.0 && isinf(d));
sscanf("iNfInItY and beyond", "%le%s", &d, buf);
assert(d > 0.0 && isinf(d));
assert(strcmp(buf, " and beyond"));
sscanf("NaN", "%le", &d);
assert(isnan(d));
sscanf("NAN(123Y", "%le%s", &d, buf);
assert(isnan(d));
assert(strcmp(buf, "(123Y") == 0);
sscanf("nan(f00f)plugh", "%le%s", &d, buf);
assert(isnan(d));
assert(strcmp(buf, "plugh") == 0);
sscanf("-nan", "%le", &d);
assert(isnan(d));
/* Only quiet NaNs should be returned. */
sscanf("NaN", "%e", &f);
sscanf("nan", "%le", &d);
sscanf("nan", "%Le", &ld);
feclearexcept(FE_ALL_EXCEPT);
assert(f != f);
assert(d != d);
assert(ld != ld);
assert(fetestexcept(FE_INVALID) == 0);
sscanf("nan(1234)", "%e", &f);
sscanf("nan(1234)", "%le", &d);
sscanf("nan(1234)", "%Le", &ld);
feclearexcept(FE_ALL_EXCEPT);
assert(f != f);
assert(d != d);
assert(ld != ld);
/* POSIX says we should only generate quiet NaNs. */
assert(fetestexcept(FE_INVALID) == 0);
printf("ok 2 - scanfloat\n");
/*
* Rounding tests
*/
fesetround(FE_DOWNWARD);
sscanf("1.999999999999999999999999999999999", "%le", &d);
assert(d < 2.0);
sscanf("0x1.ffffffffffffffp0", "%le", &d);
assert(d < 2.0);
sscanf("1.999999999999999999999999999999999", "%Le", &ld);
assert(ld < 2.0);
sscanf("1.0571892669084007", "%le", &d);
assert(d == 0x1.0ea3f4af0dc59p0);
sscanf("-1.0571892669084007", "%le", &d);
assert(d == -0x1.0ea3f4af0dc5ap0);
sscanf("1.0571892669084010", "%le", &d);
assert(d == 0x1.0ea3f4af0dc5ap0);
sscanf("0x1.23p-5000", "%le", &d);
assert(d == 0.0);
sscanf("0x1.2345678p-1050", "%le", &d);
assert(d == 0x1.234567p-1050);
fesetround(FE_UPWARD);
sscanf("1.0571892669084007", "%le", &d);
assert(d == 0x1.0ea3f4af0dc5ap0);
sscanf("-1.0571892669084007", "%le", &d);
assert(d == -0x1.0ea3f4af0dc59p0);
sscanf("1.0571892669084010", "%le", &d);
assert(d == 0x1.0ea3f4af0dc5bp0);
sscanf("0x1.23p-5000", "%le", &d);
assert(d == 0x1p-1074);
sscanf("0x1.2345678p-1050", "%le", &d);
assert(d == 0x1.234568p-1050);
fesetround(FE_TOWARDZERO);
sscanf("1.0571892669084007", "%le", &d);
assert(d == 0x1.0ea3f4af0dc59p0);
sscanf("-1.0571892669084007", "%le", &d);
assert(d == -0x1.0ea3f4af0dc59p0);
sscanf("1.0571892669084010", "%le", &d);
assert(d == 0x1.0ea3f4af0dc5ap0);
sscanf("0x1.23p-5000", "%le", &d);
assert(d == 0.0);
sscanf("0x1.2345678p-1050", "%le", &d);
assert(d == 0x1.234567p-1050);
fesetround(FE_TONEAREST);
/* 1.0571892669084007 is slightly closer to 0x1.0ea3f4af0dc59p0 */
sscanf("1.0571892669084007", "%le", &d);
assert(d == 0x1.0ea3f4af0dc59p0);
sscanf("-1.0571892669084007", "%le", &d);
assert(d == -0x1.0ea3f4af0dc59p0);
sscanf("1.0571892669084010", "%le", &d);
assert(d == 0x1.0ea3f4af0dc5bp0);
/* strtod() should round small numbers to 0. */
sscanf("0x1.23p-5000", "%le", &d);
assert(d == 0.0);
/* Extra digits in a denormal shouldn't break anything. */
sscanf("0x1.2345678p-1050", "%le", &d);
assert(d == 0x1.234568p-1050);
printf("ok 3 - scanfloat\n");
/*
* Tests specific to strtod().
*/
assert(strtod("0xy", &endp) == 0);
assert(strcmp("xy", endp) == 0);
/* This used to cause an infinite loop and round the wrong way. */
fesetround(FE_DOWNWARD);
assert(strtof("3.5e38", &endp) == FLT_MAX);
assert(strtod("2e308", &endp) == DBL_MAX);
fesetround(FE_UPWARD);
assert(strtof("3.5e38", &endp) == INFINITY);
assert(strtod("2e308", &endp) == INFINITY);
fesetround(FE_TOWARDZERO);
assert(strtof("3.5e38", &endp) == FLT_MAX);
assert(strtod("2e308", &endp) == DBL_MAX);
fesetround(FE_TONEAREST);
assert(strtof("3.5e38", &endp) == INFINITY);
assert(strtod("2e308", &endp) == INFINITY);
printf("ok 4 - scanfloat\n");
return (0);
}
static int
_eq(long double epsilon, long double a, long double b)
{
@ -303,3 +50,276 @@ _eq(long double epsilon, long double a, long double b)
delta = fabsl(a - b);
return (delta <= epsilon);
}
ATF_TC_WITHOUT_HEAD(normalized_numbers);
ATF_TC_BODY(normalized_numbers, tc)
{
char buf[128];
long double ld = 0.0;
double d = 0.0;
float f = 0.0;
char *endp;
buf[0] = '\0';
ATF_REQUIRE(setlocale(LC_NUMERIC, ""));
sscanf("3.141592", "%e", &f);
ATF_REQUIRE(eq(FLT, f, 3.141592));
sscanf("3.141592653589793", "%lf", &d);
ATF_REQUIRE(eq(DBL, d, 3.141592653589793));
sscanf("1.234568e+06", "%E", &f);
ATF_REQUIRE(eq(FLT, f, 1.234568e+06));
sscanf("-1.234568e6", "%lF", &d);
ATF_REQUIRE(eq(DBL, d, -1.234568e6));
sscanf("+1.234568e-52", "%LG", &ld);
ATF_REQUIRE(eq(LDBL, ld, 1.234568e-52L));
sscanf("0.1", "%la", &d);
ATF_REQUIRE(eq(DBL, d, 0.1));
sscanf("00.2", "%lA", &d);
ATF_REQUIRE(eq(DBL, d, 0.2));
sscanf("123456", "%5le%s", &d, buf);
ATF_REQUIRE(eq(DBL, d, 12345.));
ATF_REQUIRE(strcmp(buf, "6") == 0);
sscanf("1.0Q", "%*5le%s", buf);
ATF_REQUIRE(strcmp(buf, "Q") == 0);
sscanf("-1.23e", "%e%s", &f, buf);
ATF_REQUIRE(eq(FLT, f, -1.23));
ATF_REQUIRE(strcmp(buf, "e") == 0);
sscanf("1.25e+", "%le%s", &d, buf);
ATF_REQUIRE(eq(DBL, d, 1.25));
ATF_REQUIRE(strcmp(buf, "e+") == 0);
sscanf("1.23E4E5", "%le%s", &d, buf);
ATF_REQUIRE(eq(DBL, d, 1.23e4));
ATF_REQUIRE(strcmp(buf, "E5") == 0);
sscanf("12e6", "%le", &d);
ATF_REQUIRE(eq(DBL, d, 12e6));
sscanf("1.a", "%le%s", &d, buf);
ATF_REQUIRE(eq(DBL, d, 1.0));
ATF_REQUIRE(strcmp(buf, "a") == 0);
sscanf(".0p4", "%le%s", &d, buf);
ATF_REQUIRE(eq(DBL, d, 0.0));
ATF_REQUIRE(strcmp(buf, "p4") == 0);
d = 0.25;
ATF_REQUIRE(sscanf(".", "%le", &d) == 0);
ATF_REQUIRE(d == 0.25);
sscanf("0x08", "%le", &d);
ATF_REQUIRE(d == 0x8p0);
sscanf("0x90a.bcdefP+09a", "%le%s", &d, buf);
ATF_REQUIRE(d == 0x90a.bcdefp+09);
ATF_REQUIRE(strcmp(buf, "a") == 0);
#if (LDBL_MANT_DIG > DBL_MANT_DIG) && !defined(__i386__)
sscanf("3.14159265358979323846", "%Lg", &ld);
ATF_REQUIRE(eq(LDBL, ld, 3.14159265358979323846L));
sscanf(" 0X.0123456789abcdefffp-3g", "%Le%s", &ld, buf);
ATF_REQUIRE(ld == 0x0.0123456789abcdefffp-3L);
ATF_REQUIRE(strcmp(buf, "g") == 0);
#endif
sscanf("0xg", "%le%s", &d, buf);
ATF_REQUIRE(d == 0.0);
ATF_REQUIRE(strcmp(buf, "xg") == 0);
ATF_REQUIRE(setlocale(LC_NUMERIC, "ru_RU.ISO8859-5")); /* decimalpoint==, */
sscanf("1.23", "%le%s", &d, buf);
ATF_REQUIRE(d == 1.0);
ATF_REQUIRE(strcmp(buf, ".23") == 0);
sscanf("1,23", "%le", &d);
ATF_REQUIRE(d == 1.23);
ATF_REQUIRE(setlocale(LC_NUMERIC, ""));
}
ATF_TC_WITHOUT_HEAD(infinities_and_nans);
ATF_TC_BODY(infinities_and_nans, tc)
{
char buf[128];
long double ld = 0.0;
double d = 0.0;
float f = 0.0;
char *endp;
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
sscanf("-Inf", "%le", &d);
ATF_REQUIRE(d < 0.0 && isinf(d));
sscanf("iNfInItY and beyond", "%le%s", &d, buf);
ATF_REQUIRE(d > 0.0 && isinf(d));
ATF_REQUIRE(strcmp(buf, " and beyond"));
sscanf("NaN", "%le", &d);
ATF_REQUIRE(isnan(d));
sscanf("NAN(123Y", "%le%s", &d, buf);
ATF_REQUIRE(isnan(d));
ATF_REQUIRE(strcmp(buf, "(123Y") == 0);
sscanf("nan(f00f)plugh", "%le%s", &d, buf);
ATF_REQUIRE(isnan(d));
ATF_REQUIRE(strcmp(buf, "plugh") == 0);
sscanf("-nan", "%le", &d);
ATF_REQUIRE(isnan(d));
/* Only quiet NaNs should be returned. */
sscanf("NaN", "%e", &f);
sscanf("nan", "%le", &d);
sscanf("nan", "%Le", &ld);
feclearexcept(FE_ALL_EXCEPT);
ATF_REQUIRE(f != f);
ATF_REQUIRE(d != d);
ATF_REQUIRE(ld != ld);
ATF_REQUIRE(fetestexcept(FE_INVALID) == 0);
sscanf("nan(1234)", "%e", &f);
sscanf("nan(1234)", "%le", &d);
sscanf("nan(1234)", "%Le", &ld);
feclearexcept(FE_ALL_EXCEPT);
ATF_REQUIRE(f != f);
ATF_REQUIRE(d != d);
ATF_REQUIRE(ld != ld);
/* POSIX says we should only generate quiet NaNs. */
ATF_REQUIRE(fetestexcept(FE_INVALID) == 0);
}
ATF_TC_WITHOUT_HEAD(rounding_tests);
ATF_TC_BODY(rounding_tests, tc)
{
char buf[128];
long double ld = 0.0;
double d = 0.0;
float f = 0.0;
char *endp;
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
fesetround(FE_DOWNWARD);
sscanf("1.999999999999999999999999999999999", "%le", &d);
ATF_REQUIRE(d < 2.0);
sscanf("0x1.ffffffffffffffp0", "%le", &d);
ATF_REQUIRE(d < 2.0);
sscanf("1.999999999999999999999999999999999", "%Le", &ld);
ATF_REQUIRE(ld < 2.0);
sscanf("1.0571892669084007", "%le", &d);
ATF_REQUIRE(d == 0x1.0ea3f4af0dc59p0);
sscanf("-1.0571892669084007", "%le", &d);
ATF_REQUIRE(d == -0x1.0ea3f4af0dc5ap0);
sscanf("1.0571892669084010", "%le", &d);
ATF_REQUIRE(d == 0x1.0ea3f4af0dc5ap0);
sscanf("0x1.23p-5000", "%le", &d);
ATF_REQUIRE(d == 0.0);
sscanf("0x1.2345678p-1050", "%le", &d);
ATF_REQUIRE(d == 0x1.234567p-1050);
fesetround(FE_UPWARD);
sscanf("1.0571892669084007", "%le", &d);
ATF_REQUIRE(d == 0x1.0ea3f4af0dc5ap0);
sscanf("-1.0571892669084007", "%le", &d);
ATF_REQUIRE(d == -0x1.0ea3f4af0dc59p0);
sscanf("1.0571892669084010", "%le", &d);
ATF_REQUIRE(d == 0x1.0ea3f4af0dc5bp0);
sscanf("0x1.23p-5000", "%le", &d);
ATF_REQUIRE(d == 0x1p-1074);
sscanf("0x1.2345678p-1050", "%le", &d);
ATF_REQUIRE(d == 0x1.234568p-1050);
fesetround(FE_TOWARDZERO);
sscanf("1.0571892669084007", "%le", &d);
ATF_REQUIRE(d == 0x1.0ea3f4af0dc59p0);
sscanf("-1.0571892669084007", "%le", &d);
ATF_REQUIRE(d == -0x1.0ea3f4af0dc59p0);
sscanf("1.0571892669084010", "%le", &d);
ATF_REQUIRE(d == 0x1.0ea3f4af0dc5ap0);
sscanf("0x1.23p-5000", "%le", &d);
ATF_REQUIRE(d == 0.0);
sscanf("0x1.2345678p-1050", "%le", &d);
ATF_REQUIRE(d == 0x1.234567p-1050);
fesetround(FE_TONEAREST);
/* 1.0571892669084007 is slightly closer to 0x1.0ea3f4af0dc59p0 */
sscanf("1.0571892669084007", "%le", &d);
ATF_REQUIRE(d == 0x1.0ea3f4af0dc59p0);
sscanf("-1.0571892669084007", "%le", &d);
ATF_REQUIRE(d == -0x1.0ea3f4af0dc59p0);
sscanf("1.0571892669084010", "%le", &d);
ATF_REQUIRE(d == 0x1.0ea3f4af0dc5bp0);
/* strtod() should round small numbers to 0. */
sscanf("0x1.23p-5000", "%le", &d);
ATF_REQUIRE(d == 0.0);
/* Extra digits in a denormal shouldn't break anything. */
sscanf("0x1.2345678p-1050", "%le", &d);
ATF_REQUIRE(d == 0x1.234568p-1050);
}
ATF_TC_WITHOUT_HEAD(strtod);
ATF_TC_BODY(strtod, tc)
{
char buf[128];
long double ld = 0.0;
double d = 0.0;
float f = 0.0;
char *endp;
ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
ATF_REQUIRE(strtod("0xy", &endp) == 0);
ATF_REQUIRE(strcmp("xy", endp) == 0);
/* This used to cause an infinite loop and round the wrong way. */
fesetround(FE_DOWNWARD);
ATF_REQUIRE(strtof("3.5e38", &endp) == FLT_MAX);
ATF_REQUIRE(strtod("2e308", &endp) == DBL_MAX);
fesetround(FE_UPWARD);
ATF_REQUIRE(strtof("3.5e38", &endp) == INFINITY);
ATF_REQUIRE(strtod("2e308", &endp) == INFINITY);
fesetround(FE_TOWARDZERO);
ATF_REQUIRE(strtof("3.5e38", &endp) == FLT_MAX);
ATF_REQUIRE(strtod("2e308", &endp) == DBL_MAX);
fesetround(FE_TONEAREST);
ATF_REQUIRE(strtof("3.5e38", &endp) == INFINITY);
ATF_REQUIRE(strtod("2e308", &endp) == INFINITY);
}
ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, normalized_numbers);
ATF_TP_ADD_TC(tp, infinities_and_nans);
ATF_TP_ADD_TC(tp, rounding_tests);
ATF_TP_ADD_TC(tp, strtod);
return (atf_no_error());
}

23
tools/regression/lib/libc/stdio/Makefile
View File

@ -1,23 +0,0 @@
# $FreeBSD$
TESTS= test-fdopen \
test-fopen \
test-freopen \
test-getdelim \
test-mkostemp \
test-open_memstream \
test-open_wmemstream \
test-perror \
test-print-positional \
test-printbasic \
test-printfloat \
test-scanfloat
CFLAGS+= -lm
.PHONY: tests
tests: ${TESTS}
for p in ${TESTS}; do ${.OBJDIR}/$$p; done
.PHONY: clean
clean:
-rm -f ${TESTS}

105
tools/regression/lib/libc/stdio/test-fdopen.c
View File

@ -1,105 +0,0 @@
/*-
* Copyright (c) 2014 Jilles Tjoelker
* 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 AUTHOR 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 AUTHOR 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>
__FBSDID("$FreeBSD$");
#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
static int testnum = 1;
static void
runtest(const char *fname, int intmode, const char *strmode, bool success)
{
FILE *fp;
int fd;
fd = open(fname, intmode);
if (fd == -1) {
printf("not ok %d - open(\"%s\", %#x) failed\n",
testnum++, fname, intmode);
return;
}
fp = fdopen(fd, strmode);
if (fp == NULL) {
close(fd);
if (success)
printf("not ok %d - "
"fdopen(open(\"%s\", %#x), \"%s\") failed\n",
testnum++, fname, intmode, strmode);
else
printf("ok %d - "
"fdopen(open(\"%s\", %#x), \"%s\") failed\n",
testnum++, fname, intmode, strmode);
return;
}
if (success)
printf("ok %d - "
"fdopen(open(\"%s\", %#x), \"%s\") succeeded\n",
testnum++, fname, intmode, strmode);
else
printf("not ok %d - "
"fdopen(open(\"%s\", %#x), \"%s\") succeeded\n",
testnum++, fname, intmode, strmode);
fclose(fp);
}
/*
* Test program for fdopen().
*/
int
main(int argc, char *argv[])
{
printf("1..19\n");
runtest("/dev/null", O_RDONLY, "r", true);
runtest("/dev/null", O_WRONLY, "r", false);
runtest("/dev/null", O_RDWR, "r", true);
runtest("/dev/null", O_RDONLY, "w", false);
runtest("/dev/null", O_WRONLY, "w", true);
runtest("/dev/null", O_RDWR, "w", true);
runtest("/dev/null", O_RDONLY, "a", false);
runtest("/dev/null", O_WRONLY, "a", true);
runtest("/dev/null", O_RDWR, "a", true);
runtest("/dev/null", O_RDONLY, "r+", false);
runtest("/dev/null", O_WRONLY, "r+", false);
runtest("/dev/null", O_RDWR, "r+", true);
runtest("/dev/null", O_RDONLY, "w+", false);
runtest("/dev/null", O_WRONLY, "w+", false);
runtest("/dev/null", O_RDWR, "w+", true);
runtest("/bin/sh", O_EXEC, "r", false);
runtest("/bin/sh", O_EXEC, "w", false);
runtest("/bin/sh", O_EXEC, "r+", false);
runtest("/bin/sh", O_EXEC, "w+", false);
return 0;
}
/* vim:ts=8:cin:sw=8
* */

10
tools/regression/lib/libc/stdio/test-fdopen.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

113
tools/regression/lib/libc/stdio/test-fopen.c
View File

@ -1,113 +0,0 @@
/*-
* Copyright (c) 2013 Jilles Tjoelker
* 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 AUTHOR 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 AUTHOR 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>
__FBSDID("$FreeBSD$");
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
/*
* O_ACCMODE is currently defined incorrectly. This is what it should be.
* Various code depends on the incorrect value.
*/
#define CORRECT_O_ACCMODE (O_ACCMODE | O_EXEC)
static int testnum = 1;
static void
runtest(const char *fname, const char *mode)
{
FILE *fp;
int fd, flags, wantedflags;
fp = fopen(fname, mode);
if (fp == NULL) {
printf("not ok %d - fopen(\"%s\", \"%s\") failed\n",
testnum++, fname, mode);
printf("not ok %d - FD_CLOEXEC # SKIP\n",
testnum++);
return;
}
fd = fileno(fp);
if (fd < 0)
printf("not ok %d - fileno() failed\n", testnum++);
else
printf("ok %d - fopen(\"%s\", \"%s\") and fileno() succeeded\n",
testnum++, fname, mode);
if (fcntl(fd, F_GETFD) == (strchr(mode, 'e') != NULL ? FD_CLOEXEC : 0))
printf("ok %d - FD_CLOEXEC flag correct\n", testnum++);
else
printf("not ok %d - FD_CLOEXEC flag incorrect\n", testnum++);
flags = fcntl(fd, F_GETFL);
if (strchr(mode, '+'))
wantedflags = O_RDWR | (*mode == 'a' ? O_APPEND : 0);
else if (*mode == 'r')
wantedflags = O_RDONLY;
else if (*mode == 'w')
wantedflags = O_WRONLY;
else if (*mode == 'a')
wantedflags = O_WRONLY | O_APPEND;
else
wantedflags = -1;
if (wantedflags == -1)
printf("not ok %d - unrecognized mode\n", testnum++);
else if ((flags & (CORRECT_O_ACCMODE | O_APPEND)) == wantedflags)
printf("ok %d - correct access mode\n", testnum++);
else
printf("not ok %d - incorrect access mode\n", testnum++);
fclose(fp);
}
/*
* Test program for fopen().
*/
int
main(int argc, char *argv[])
{
printf("1..45\n");
runtest("/dev/null", "r");
runtest("/dev/null", "r+");
runtest("/dev/null", "w");
runtest("/dev/null", "w+");
runtest("/dev/null", "a");
runtest("/dev/null", "a+");
runtest("/dev/null", "re");
runtest("/dev/null", "r+e");
runtest("/dev/null", "we");
runtest("/dev/null", "w+e");
runtest("/dev/null", "ae");
runtest("/dev/null", "a+e");
runtest("/dev/null", "re+");
runtest("/dev/null", "we+");
runtest("/dev/null", "ae+");
return 0;
}
/* vim:ts=8:cin:sw=8
* */

10
tools/regression/lib/libc/stdio/test-fopen.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

109
tools/regression/lib/libc/stdio/test-freopen.c
View File

@ -1,109 +0,0 @@
/*-
* Copyright (c) 2014 Jilles Tjoelker
* 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 AUTHOR 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 AUTHOR 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>
__FBSDID("$FreeBSD$");
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
static int testnum = 1;
static void
runtest(const char *fname1, const char *mode1, const char *fname2,
const char *mode2, bool success)
{
FILE *fp1, *fp2;
const char *fname2_print;
fname2_print = fname2 != NULL ? fname2 : "<NULL>";
fp1 = fopen(fname1, mode1);
if (fp1 == NULL) {
printf("not ok %d - fopen(\"%s\", \"%s\") failed\n",
testnum++, fname1, mode1);
return;
}
fp2 = freopen(fname2, mode2, fp1);
if (fp2 == NULL) {
fclose(fp1);
if (success)
printf("not ok %d - "
"freopen(\"%s\", \"%s\", fopen(\"%s\", \"%s\")) "
"failed\n",
testnum++, fname2_print, mode2, fname1, mode1);
else
printf("ok %d - "
"freopen(\"%s\", \"%s\", fopen(\"%s\", \"%s\")) "
"failed\n",
testnum++, fname2_print, mode2, fname1, mode1);
return;
}
if (success)
printf("ok %d - "
"freopen(\"%s\", \"%s\", fopen(\"%s\", \"%s\")) "
"succeeded\n",
testnum++, fname2_print, mode2, fname1, mode1);
else
printf("not ok %d - "
"freopen(\"%s\", \"%s\", fopen(\"%s\", \"%s\")) "
"succeeded\n",
testnum++, fname2_print, mode2, fname1, mode1);
fclose(fp2);
}
/*
* Test program for freopen().
*/
int
main(int argc, char *argv[])
{
printf("1..19\n");
runtest("/dev/null", "r", NULL, "r", true);
runtest("/dev/null", "w", NULL, "r", false);
runtest("/dev/null", "r+", NULL, "r", true);
runtest("/dev/null", "r", NULL, "w", false);
runtest("/dev/null", "w", NULL, "w", true);
runtest("/dev/null", "r+", NULL, "w", true);
runtest("/dev/null", "r", NULL, "a", false);
runtest("/dev/null", "w", NULL, "a", true);
runtest("/dev/null", "r+", NULL, "a", true);
runtest("/dev/null", "r", NULL, "r+", false);
runtest("/dev/null", "w", NULL, "r+", false);
runtest("/dev/null", "r+", NULL, "r+", true);
runtest("/dev/null", "r", NULL, "w+", false);
runtest("/dev/null", "w", NULL, "w+", false);
runtest("/dev/null", "r+", NULL, "w+", true);
runtest("/bin/sh", "r", NULL, "r", true);
runtest("/bin/sh", "r", "/bin/sh", "r", true);
runtest("/bin/sh", "r", "/dev/null", "r", true);
runtest("/bin/sh", "r", "/dev/null", "w", true);
return 0;
}
/* vim:ts=8:cin:sw=8
* */

10
tools/regression/lib/libc/stdio/test-freopen.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

10
tools/regression/lib/libc/stdio/test-getdelim.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

10
tools/regression/lib/libc/stdio/test-mkostemp.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

15
tools/regression/lib/libc/stdio/test-open_memstream.t
View File

@ -1,15 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
echo 1..1
if ./$executable; then
echo ok 1 - $executable successful
else
echo not ok 1 - $executable failed
fi

15
tools/regression/lib/libc/stdio/test-open_wmemstream.t
View File

@ -1,15 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
echo 1..1
if ./$executable; then
echo ok 1 - $executable successful
else
echo not ok 1 - $executable failed
fi

10
tools/regression/lib/libc/stdio/test-perror.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

10
tools/regression/lib/libc/stdio/test-print-positional.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

10
tools/regression/lib/libc/stdio/test-printbasic.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

10
tools/regression/lib/libc/stdio/test-printfloat.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable

10
tools/regression/lib/libc/stdio/test-scanfloat.t
View File

@ -1,10 +0,0 @@
#!/bin/sh
# $FreeBSD$
cd `dirname $0`
executable=`basename $0 .t`
make $executable 2>&1 > /dev/null
exec ./$executable