diff mbox

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

Message ID 53A82999.3040108@linux.vnet.ibm.com
State Superseded
Headers show

Commit Message

Adhemerval Zanella Netto June 23, 2014, 1:20 p.m. UTC
This patch updates tst-fmemopen2 to check for fmemopen with NULL buffer
inputs and also refactor the code a bit.

--

	* stdio-common/tst-fmemopen2.c (do_test): Add test for NULL and zero
	length buffers.

---

Comments

Rasmus Villemoes June 23, 2014, 6:39 p.m. UTC | #1
Adhemerval Zanella <azanella@linux.vnet.ibm.com> writes:

> This patch updates tst-fmemopen2 to check for fmemopen with NULL buffer
> inputs and also refactor the code a bit.
>
> --
>
> 	* 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..652c412 100644
> --- a/stdio-common/tst-fmemopen2.c
> +++ b/stdio-common/tst-fmemopen2.c

[snip]

> +}
> +
> +static int
> +do_test_length_zero (void)
> +{
> +  int result = 0;
> +  FILE *fp;
> +  char buf[] = "";
> +  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  */

Missing full stop.

> +  if ((r = fgetc (fp)) != EOF)
> +    {
> +      printf ("%s: fgetc on a zero-lenght returned: %d\n",

s/lenght/length/

> 
> +	      __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 lenght 0 passed in fmemopen

s/lenght/length/

> +     call.  */
> +  fputs (str, fp);

I think it would be useful to do an fflush(fp) and check that the error
flag is set, and perhaps also to check that errno is set to ENOSPC.

> +  fclose (fp);
> +
> +  if (strcmp (buf, "") != 0)
> +    {
> +      printf ("%s: strcmp (%s, "") failed\n", __FUNCTION__, buf);
> +      return 1;
> +    }
> +

Maybe it would be a bit more robust if buf was declared with a somewhat
larger size than the 1 implied from its initialization with "", so that
if the write test fails, adjacent stack variables are not necessarily
overwritten.


Rasmus

PS: Thanks for allowing len==0 :-)
Adhemerval Zanella Netto June 25, 2014, 2:54 p.m. UTC | #2
On 23-06-2014 15:39, Rasmus Villemoes wrote:
> Adhemerval Zanella <azanella@linux.vnet.ibm.com> writes:
>
>> This patch updates tst-fmemopen2 to check for fmemopen with NULL buffer
>> inputs and also refactor the code a bit.
>>
>> --
>>
>> 	* 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..652c412 100644
>> --- a/stdio-common/tst-fmemopen2.c
>> +++ b/stdio-common/tst-fmemopen2.c
> [snip]
>
>> +}
>> +
>> +static int
>> +do_test_length_zero (void)
>> +{
>> +  int result = 0;
>> +  FILE *fp;
>> +  char buf[] = "";
>> +  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  */
> Missing full stop.
>
>> +  if ((r = fgetc (fp)) != EOF)
>> +    {
>> +      printf ("%s: fgetc on a zero-lenght returned: %d\n",
> s/lenght/length/
>
>> +	      __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 lenght 0 passed in fmemopen
> s/lenght/length/
>
>> +     call.  */
>> +  fputs (str, fp);
> I think it would be useful to do an fflush(fp) and check that the error
> flag is set, and perhaps also to check that errno is set to ENOSPC.
>
>> +  fclose (fp);
>> +
>> +  if (strcmp (buf, "") != 0)
>> +    {
>> +      printf ("%s: strcmp (%s, "") failed\n", __FUNCTION__, buf);
>> +      return 1;
>> +    }
>> +
> Maybe it would be a bit more robust if buf was declared with a somewhat
> larger size than the 1 implied from its initialization with "", so that
> if the write test fails, adjacent stack variables are not necessarily
> overwritten.
>
>
> Rasmus
>
> PS: Thanks for allowing len==0 :-)
>
Thanks, I have added all the comments in my patch set.  I will send them again shortly.
diff mbox

Patch

diff --git a/stdio-common/tst-fmemopen2.c b/stdio-common/tst-fmemopen2.c
index c2a4baa..652c412 100644
--- a/stdio-common/tst-fmemopen2.c
+++ b/stdio-common/tst-fmemopen2.c
@@ -5,64 +5,196 @@ 
 
 
 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;
+  char buf[] = "";
+  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-lenght 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 lenght 0 passed in fmemopen
+     call.  */
+  fputs (str, fp);
+  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"