From patchwork Mon Jun 30 12:56:18 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 1817 X-Patchwork-Delegate: azanella@linux.vnet.ibm.com Received: (qmail 19890 invoked by alias); 30 Jun 2014 12:56:27 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 19874 invoked by uid 89); 30 Jun 2014 12:56:26 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.6 required=5.0 tests=AWL, BAYES_00, T_RP_MATCHES_RCVD, UNSUBSCRIBE_BODY autolearn=no version=3.3.2 X-HELO: e24smtp04.br.ibm.com Message-ID: <53B15E72.3070304@linux.vnet.ibm.com> Date: Mon, 30 Jun 2014 09:56:18 -0300 From: Adhemerval Zanella User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Thunderbird/24.5.0 MIME-Version: 1.0 To: libc-alpha@sourceware.org Subject: Re: [PATCH v2 2/3] libio: Update tst-fmemopen2.c References: <53AD653D.8070504@linux.vnet.ibm.com> <87zjgw6106.fsf@rasmusvillemoes.dk> In-Reply-To: <87zjgw6106.fsf@rasmusvillemoes.dk> X-TM-AS-MML: disable X-Content-Scanned: Fidelis XPS MAILER x-cbid: 14063012-1820-0000-0000-000000ED282E On 28-06-2014 20:57, Rasmus Villemoes wrote: > Adhemerval Zanella writes: > >> + r = 0; >> + if (fflush (fp) != EOF) >> + { >> + printf ("%s: fflush did not return EOF\n", __FUNCTION__); >> + fclose (fp); >> + return 1; >> + } >> + if (errno != ENOSPC) >> + { >> + printf ("%s: errno != ENOSPC\n", __FUNCTION__); >> + fclose (fp); >> + return 1; >> + } >> + > Maybe it would make debugging easier if you printed the value of errno, > e.g. "%s: errno = %d != ENOSPC", and making sure to set it to 0 before > fflush(), so that one can see if errno is even set. Is there a way to > convert errno values to strings representing the symbolic tokens? I have added the errno printing as integer, I really won't bother to add a functionality to map the errno to string on such case. > >> + fclose (fp); >> + >> + if (strcmp (buf, "") != 0) > Don't you need to compare to the original contents of buf, i.e. "testing > buffer"? I don't suppose even a '\0' should be written when fmemopen() > is told that it can write to 0 bytes. Thanks for catching it. In fact this is an implementation issue I was adding: it was truncating the buffer for both 'w' and 'w+' open mode, where it should truncate only for 'w+'. I have fixed it and added antoher test. > >> + { >> + printf ("%s: strcmp (%s, "") failed\n", __FUNCTION__, buf); > Missing escapes of those inner quotes (I suppose). Fixed. What about the following patch? I will send the updated fmemopen implementation shortly. --- * stdio-common/tst-fmemopen2.c (do_test): Add test for NULL and zero length buffers. --- diff --git a/stdio-common/tst-fmemopen2.c b/stdio-common/tst-fmemopen2.c index c2a4baa..4ba9ca9 100644 --- a/stdio-common/tst-fmemopen2.c +++ b/stdio-common/tst-fmemopen2.c @@ -1,68 +1,252 @@ +/* fmemopen tests. + Copyright (C) 2014 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 + . */ + + #include #include #include #include - +#include 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 ("%s: fmemopen failed\n", __FUNCTION__); + return 1; } + 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 %ld, expected %zu\n", o, nstr); + printf ("%s: first ftello returned %ld, expected %zu\n", + __FUNCTION__, o, nstr); result = 1; } + rewind (fp); o = ftello (fp); if (o != 0) { - printf ("second ftello returned %ld, expected 0\n", o); + printf ("%s: second ftello returned %ld, expected 0\n", + __FUNCTION__, o); result = 1; } if (fseeko (fp, 0, SEEK_END) != 0) { - puts ("fseeko failed"); - return 1; + printf ("%s: fseeko failed\n", __FUNCTION__); + result = 1; } o = ftello (fp); if (o != nstr) { - printf ("third ftello returned %ld, expected %zu\n", o, nstr); + printf ("%s: third ftello returned %ld, expected %zu\n", + __FUNCTION__, o, nbuf); result = 1; } + 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 %ld, expected %zu\n", o, nstr2); + printf ("%s: fourth ftello returned %ld, expected %zu\n", + __FUNCTION__, o, nstr2); result = 1; } fclose (fp); + static const char str3[] = "just hellod"; if (strcmp (buf, str3) != 0) { - printf ("final string is \"%s\", expected \"%s\"\n", - buf, str3); + printf ("%s: final string is \"%s\", expected \"%s\"\n", + __FUNCTION__, buf, str3); + result = 1; + } + return result; +} + +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 ("%s: fmemopen failed\n", __FUNCTION__); + return 1; + } + + static const char str[] = "hello world"; + const size_t nstr = sizeof (str) - 1; + + fputs (str, fp); + off_t o = ftello (fp); + if (o != nstr) + { + printf ("%s: first ftello returned %ld, expected %zu\n", + __FUNCTION__, o, nstr); + result = 1; + } + if (fseeko (fp, 0, SEEK_END) != 0) + { + printf ("%s: fseeko failed\n", __FUNCTION__); + result = 1; + } + o = ftello (fp); + if (o != nstr) + { + printf ("%s: second ftello returned %ld, expected %zu\n", + __FUNCTION__, o, nbuf); result = 1; } + 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 ("%s: third ftello returned %ld, expected %zu\n", + __FUNCTION__, o, nstr2); + result = 1; + } + fclose (fp); + return result; } +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 ("%s: fmemopen failed\n", __FUNCTION__); + return 1; + } + + /* Reading any data on a zero-length buffer should return EOF. */ + if ((r = fgetc (fp)) != EOF) + { + printf ("%s: fgetc on a zero-length returned: %d\n", + __FUNCTION__, r); + result = 1; + } + off_t o = ftello (fp); + if (o != 0) + { + printf ("%s: first ftello returned %ld, expected 0\n", + __FUNCTION__, 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 ("%s: second fmemopen failed\n", __FUNCTION__); + return 1; + } + + static const char str[] = "hello world"; + /* Because of buffering, fputs call itself don't fail, however the final + buffer should be not changed because of length 0 passed in fmemopen + call. */ + fputs (str, fp); + r = 0; + if (fflush (fp) != EOF) + { + printf ("%s: fflush did not return EOF\n", __FUNCTION__); + fclose (fp); + return 1; + } + if (errno != ENOSPC) + { + printf ("%s: errno is %i (expected %i - ENOSPC)\n", __FUNCTION__, + errno, ENOSPC); + fclose (fp); + return 1; + } + + fclose (fp); + + if (strcmp (buf, BUFCONTENTS) != 0) + { + printf ("%s: strcmp (%s, %s) failed\n", __FUNCTION__, buf, + BUFCONTENTS); + return 1; + } + + /* Different than 'w' mode, 'w+' truncates the buffer. */ + fp = fmemopen (buf, nbuf, "w+"); + if (fp == NULL) + { + printf ("%s: second fmemopen failed\n", __FUNCTION__); + return 1; + } + + fclose (fp); + + if (strcmp (buf, "") != 0) + { + printf ("%s: strcmp (%s, \"\") failed\n", __FUNCTION__, 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"