aboutsummaryrefslogtreecommitdiff
path: root/stdio-common/tst-fmemopen2.c
diff options
context:
space:
mode:
authorAdhemerval Zanella <azanella@linux.vnet.ibm.com>2014-06-13 17:38:32 -0300
committerAdhemerval Zanella <adhemerval.zanella@linaro.com>2015-07-08 12:07:21 -0300
commitccfa271f8be0f7c210713e043246b2ece75c2a87 (patch)
treedc90f7bfc2ad7c0aa6c3036ed573e173b9e01c1f /stdio-common/tst-fmemopen2.c
parentfdb7d390dd0d96e4a8239c46f3aa64598b90842b (diff)
downloadglibc-ccfa271f8be0f7c210713e043246b2ece75c2a87.zip
glibc-ccfa271f8be0f7c210713e043246b2ece75c2a87.tar.gz
glibc-ccfa271f8be0f7c210713e043246b2ece75c2a87.tar.bz2
libio: Update tst-fmemopen2.c
This patch updates tst-fmemopen2 to check for fmemopen with NULL buffer inputs and also refactor the code a bit. The test relies on a POSIX compliant fmemopen implementation. * stdio-common/tst-fmemopen2.c (do_test): Add test for NULL and zero length buffers. * stdio-common/tst-fmemopen.c (do_test): Refactor to use test-skeleton.c.
Diffstat (limited to 'stdio-common/tst-fmemopen2.c')
-rw-r--r--stdio-common/tst-fmemopen2.c220
1 files changed, 203 insertions, 17 deletions
diff --git a/stdio-common/tst-fmemopen2.c b/stdio-common/tst-fmemopen2.c
index e9d8b63..2f26f20 100644
--- a/stdio-common/tst-fmemopen2.c
+++ b/stdio-common/tst-fmemopen2.c
@@ -1,71 +1,257 @@
+/* fmemopen tests.
+ Copyright (C) 2015 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
+#include <errno.h>
-
+/* Check fmemopen with user provided buffer open for write. */
static int
-do_test (void)
+do_test_with_buffer (void)
{
int result = 0;
char buf[100];
- FILE *fp = fmemopen (buf, sizeof (buf), "w");
+ const size_t nbuf = sizeof (buf);
+
+ FILE *fp = fmemopen (buf, nbuf, "w");
if (fp == NULL)
{
- puts ("fmemopen failed");
- return 0;
+ printf ("FAIL: fmemopen failedi (%s)\n", __FUNCTION__);
+ return 1;
}
+
+ /* Default write operation, check if file position is correct after it. */
static const char str[] = "hello world";
-#define nstr (sizeof (str) - 1)
+ const size_t nstr = sizeof (str) - 1;
fputs (str, fp);
off_t o = ftello (fp);
if (o != nstr)
{
- printf ("first ftello returned %jd, expected %zu\n",
- (intmax_t) o, nstr);
+ printf ("FAIL: first ftello returned %jd, expected %zu\n",
+ (intmax_t)o, nstr);
result = 1;
}
+
+ /* Rewind stream and seek tests, the position size should be equal to
+ buffer size provided in open function. */
rewind (fp);
o = ftello (fp);
if (o != 0)
{
- printf ("second ftello returned %jd, expected 0\n", (intmax_t) o);
+ printf ("FAIL: second ftello returned %jd, expected 0\n",
+ (intmax_t)o);
result = 1;
}
if (fseeko (fp, 0, SEEK_END) != 0)
{
- puts ("fseeko failed");
- return 1;
+ printf ("FAIL: fseeko failed\n");
+ result = 1;
}
o = ftello (fp);
if (o != nstr)
{
- printf ("third ftello returned %jd, expected %zu\n",
- (intmax_t) o, nstr);
+ printf ("FAIL: third ftello returned %jd, expected %zu\n",
+ (intmax_t)o, nbuf);
result = 1;
}
+
+ /* Rewind the stream and recheck by using a shorter string. */
rewind (fp);
static const char str2[] = "just hello";
-#define nstr2 (sizeof (str2) - 1)
+ const size_t nstr2 = sizeof (str2) - 1;
assert (nstr2 < nstr);
fputs (str2, fp);
o = ftello (fp);
if (o != nstr2)
{
- printf ("fourth ftello returned %jd, expected %zu\n",
- (intmax_t) o, nstr2);
+ printf ("FAIL: fourth ftello returned %jd, expected %zu\n",
+ (intmax_t)o, nstr2);
result = 1;
}
fclose (fp);
+
+ /* Again, but now with a larger string. */
static const char str3[] = "just hellod";
if (strcmp (buf, str3) != 0)
{
- printf ("final string is \"%s\", expected \"%s\"\n",
+ printf ("FAIL: final string is \"%s\", expected \"%s\"\n",
buf, str3);
result = 1;
}
return result;
}
+/* Check fmemopen without user provided buffer open for write. */
+static int
+do_test_without_buffer (void)
+{
+ int result = 0;
+ const size_t nbuf = 100;
+
+ FILE *fp = fmemopen (NULL, nbuf, "w");
+ if (fp == NULL)
+ {
+ printf ("FAIL: fmemopen failed (%s)\n", __FUNCTION__);
+ return 1;
+ }
+
+ static const char str[] = "hello world";
+ const size_t nstr = sizeof (str) - 1;
+
+ /* Default write operation, check if file position is correct after it. */
+ fputs (str, fp);
+ off_t o = ftello (fp);
+ if (o != nstr)
+ {
+ printf ("FAIL: first ftello returned %ld, expected %zu\n", o, nstr);
+ result = 1;
+ }
+ if (fseeko (fp, 0, SEEK_END) != 0)
+ {
+ printf ("FAIL: fseeko failed\n");
+ result = 1;
+ }
+ o = ftello (fp);
+ if (o != nstr)
+ {
+ printf ("FAIL: second ftello returned %ld, expected %zu\n", o, nbuf);
+ result = 1;
+ }
+
+ /* Rewind the stream and recheck by using a shorter string. */
+ rewind (fp);
+ static const char str2[] = "just hello";
+ const size_t nstr2 = sizeof (str2) - 1;
+ assert (nstr2 < nstr);
+ fputs (str2, fp);
+ o = ftello (fp);
+ if (o != nstr2)
+ {
+ printf ("FAIL: third ftello returned %ld, expected %zu\n", o, nstr2);
+ result = 1;
+ }
+ fclose (fp);
+
+ return result;
+}
+
+/* Check fmemopen with a buffer lenght of zero. */
+static int
+do_test_length_zero (void)
+{
+ int result = 0;
+ FILE *fp;
+#define BUFCONTENTS "testing buffer"
+ char buf[100] = BUFCONTENTS;
+ const size_t nbuf = 0;
+ int r;
+
+ fp = fmemopen (buf, nbuf, "r");
+ if (fp == NULL)
+ {
+ printf ("FAIL: fmemopen failed (%s)\n", __FUNCTION__);
+ return 1;
+ }
+
+ /* Reading any data on a zero-length buffer should return EOF. */
+ if ((r = fgetc (fp)) != EOF)
+ {
+ printf ("FAIL: fgetc on a zero-length returned: %d\n", r);
+ result = 1;
+ }
+ off_t o = ftello (fp);
+ if (o != 0)
+ {
+ printf ("FAIL: first ftello returned %ld, expected 0\n", o);
+ result = 1;
+ }
+ fclose (fp);
+
+ /* Writing any data shall start at current position and shall not pass
+ current buffer size beyond the size in fmemopen call. */
+ fp = fmemopen (buf, nbuf, "w");
+ if (fp == NULL)
+ {
+ printf ("FAIL: second fmemopen failed (%s)\n", __FUNCTION__);
+ return 1;
+ }
+
+ static const char str[] = "hello world";
+ /* Because of buffering, the fputs call itself will not fail. However the
+ final buffer should be not changed because length 0 was passed to the
+ fmemopen call. */
+ fputs (str, fp);
+ r = 0;
+ errno = 0;
+ if (fflush (fp) != EOF)
+ {
+ printf ("FAIL: fflush did not return EOF\n");
+ fclose (fp);
+ return 1;
+ }
+ if (errno != ENOSPC)
+ {
+ printf ("FAIL: errno is %i (expected ENOSPC)\n", errno);
+ fclose (fp);
+ return 1;
+ }
+
+ fclose (fp);
+
+ if (strcmp (buf, BUFCONTENTS) != 0)
+ {
+ printf ("FAIL: strcmp (%s, %s) failed\n", buf, BUFCONTENTS);
+ return 1;
+ }
+
+ /* Different than 'w' mode, 'w+' truncates the buffer. */
+ fp = fmemopen (buf, nbuf, "w+");
+ if (fp == NULL)
+ {
+ printf ("FAIL: third fmemopen failed (%s)\n", __FUNCTION__);
+ return 1;
+ }
+
+ fclose (fp);
+
+ if (strcmp (buf, "") != 0)
+ {
+ printf ("FAIL: strcmp (%s, \"\") failed\n", buf);
+ return 1;
+ }
+
+ return result;
+}
+
+static int
+do_test (void)
+{
+ int ret = 0;
+
+ ret += do_test_with_buffer ();
+ ret += do_test_without_buffer ();
+ ret += do_test_length_zero ();
+
+ return ret;
+}
+
#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"