# [v2,2/3] libio: Update tst-fmemopen2.c

Message ID 53B15E72.3070304@linux.vnet.ibm.com Superseded Adhemerval Zanella Netto show

## Commit Message

Adhemerval Zanella Netto June 30, 2014, 12:56 p.m. UTC
```On 28-06-2014 20:57, Rasmus Villemoes wrote:
>
>> +  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.

---
```

## Patch

```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
+   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 <assert.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
-
+#include <errno.h>

static int
-do_test (void)
+do_test_with_buffer (void)
{
int result = 0;
char buf;
-  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 = 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"

```
{"ft_lang_label":"__label__en","ft_lang_prob":0.52264416,"math_prob":0.9718389,"size":5976,"snap":"2021-43-2021-49","text_gpt3_token_len":1946,"char_repetition_ratio":0.16594106,"word_repetition_ratio":0.38333333,"special_character_ratio":0.41382197,"punctuation_ratio":0.24600355,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.9736634,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2021-12-06T18:38:47Z\",\"WARC-Record-ID\":\"<urn:uuid:62b232dc-ab20-4dcb-894b-b7379157a96b>\",\"Content-Length\":\"23845\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:d36523e9-9baa-4b98-8db1-aeebc9bcef5a>\",\"WARC-Concurrent-To\":\"<urn:uuid:cae4cc78-7f1c-4dac-95c2-96abdc85d965>\",\"WARC-IP-Address\":\"8.43.85.97\",\"WARC-Target-URI\":\"https://patchwork.sourceware.org/project/glibc/patch/53B15E72.3070304@linux.vnet.ibm.com/\",\"WARC-Payload-Digest\":\"sha1:PYK7Z7NGX6RSSRKYFBQLZKTOJXH5HQOS\",\"WARC-Block-Digest\":\"sha1:ETAMJAAVVAOXZ7AGQL3TJU5ZJDXDGK3B\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2021/CC-MAIN-2021-49/CC-MAIN-2021-49_segments_1637964363309.86_warc_CC-MAIN-20211206163944-20211206193944-00291.warc.gz\"}"}