Integrate tools/regression/lib/libc/stdio into the FreeBSD test suite
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:
parent
ebb62474ab
commit
1ee0219205
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=290537
@ -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
225
lib/libc/tests/stdio/fdopen_test.c
Normal 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
|
||||
*/
|
@ -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";
|
||||
@ -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
205
lib/libc/tests/stdio/fopen_test.c
Normal 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
224
lib/libc/tests/stdio/freopen_test.c
Normal 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
|
||||
*/
|
@ -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());
|
||||
}
|
@ -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());
|
||||
}
|
@ -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());
|
||||
}
|
@ -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());
|
||||
}
|
@ -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());
|
||||
}
|
@ -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());
|
||||
}
|
@ -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());
|
||||
}
|
@ -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());
|
||||
}
|
@ -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}
|
@ -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
|
||||
* */
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
@ -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
|
||||
* */
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
@ -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
|
||||
* */
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
@ -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
|
@ -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
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
# $FreeBSD$
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
executable=`basename $0 .t`
|
||||
|
||||
make $executable 2>&1 > /dev/null
|
||||
|
||||
exec ./$executable
|
Loading…
Reference in New Issue
Block a user