| /* fmemopen tests for append and read mode. |
| Copyright (C) 2015-2018 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> |
| |
| static void |
| print_buffer (const char *s, size_t n) |
| { |
| size_t i; |
| printf ("{"); |
| for (i=0; i<n; ++i) |
| { |
| printf ("0x%02X (%c)", s[i], s[i]); |
| if (i != n) |
| printf (", "); |
| } |
| } |
| |
| /* This test check append mode initial position (a/a+) based on POSIX defition |
| (BZ#6544 and BZ#13151). */ |
| static int |
| do_test_write_append (const char *mode) |
| { |
| char buf[32] = "testing buffer"; |
| char exp[32] = "testing bufferXX"; |
| |
| FILE *fp = fmemopen (buf, sizeof (buf), mode); |
| |
| fflush (fp); |
| fprintf (fp, "X"); |
| fseek (fp, 0, SEEK_SET); |
| fprintf (fp, "X"); |
| fclose (fp); |
| |
| if (strcmp (buf, exp) != 0) |
| { |
| printf ("%s: check failed: %s != %s\n", __FUNCTION__, buf, exp); |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| /* This test check append mode initial position (a/a+) based on POSIX defition |
| (BZ#6544 and BZ#13151) for buffer without null byte end. */ |
| static int |
| do_test_write_append_without_null (const char *mode) |
| { |
| char buf[] = { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 }; |
| char exp[] = { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 }; |
| |
| /* If '\0' is not found in buffer, POSIX states that SEEK_SET should be |
| the size argument. */ |
| FILE *fp = fmemopen (buf, sizeof (buf) - 2, "a"); |
| |
| fflush (fp); |
| fputc (0x70, fp); |
| fseek (fp, 0, SEEK_SET); |
| fputc (0x70, fp); |
| fputc (0x70, fp); |
| fclose (fp); |
| |
| /* POSIX also states that a write operation on the stream shall not advance |
| the current buffer size beyond the size given in fmemopen, so the string |
| should be same. */ |
| if (memcmp (buf, exp, sizeof (buf)) != 0) |
| { |
| printf ("%s: check failed: ", __FUNCTION__); |
| print_buffer (buf, sizeof (buf)); |
| printf ("!= "); |
| print_buffer (exp, sizeof (exp)); |
| printf ("\n"); |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| /* This test check for initial position and feek value for fmemopen objects |
| opened with append mode. */ |
| static int |
| do_test_read_append (void) |
| { |
| char buf[32] = "testing buffer"; |
| size_t buflen = strlen (buf); |
| long fpos; |
| |
| /* POSIX defines for 'a+' the initial position is the first null byte. */ |
| FILE *fp = fmemopen (buf, sizeof (buf), "a+"); |
| |
| fpos = ftell (fp); |
| if (fpos != buflen) |
| { |
| printf ("%s: ftell|SEEK_SET (fp) %li != strlen (%s) %zu\n", |
| __FUNCTION__, fpos, buf, buflen); |
| fclose (fp); |
| return 1; |
| } |
| |
| fseek (fp, 0, SEEK_END); |
| |
| if (fpos != buflen) |
| { |
| printf ("%s: ftell|SEEK_END (fp) %li != strlen (%s) %zu\n", |
| __FUNCTION__, fpos, buf, buflen); |
| fclose (fp); |
| return 1; |
| } |
| fclose (fp); |
| |
| /* Check if attempting to read past the current size, defined as strlen (buf) |
| yield an EOF. */ |
| fp = fmemopen (buf, sizeof (buf), "a+"); |
| if (getc(fp) != EOF) |
| { |
| printf ("%s: getc(fp) != EOF\n", __FUNCTION__); |
| fclose (fp); |
| return -1; |
| } |
| |
| fclose (fp); |
| |
| return 0; |
| } |
| |
| /* This test check for fseek (SEEK_END) using negative offsets (BZ#14292). The |
| starting position of descriptor is different base on the opening mode. */ |
| static int |
| do_test_read_seek_neg (const char *mode, const char *expected) |
| { |
| char buf[] = "abcdefghijklmnopqrstuvxz0123456789"; |
| char tmp[10]; |
| size_t tmps = sizeof (tmps); |
| long offset = -11; |
| |
| FILE *fp = fmemopen (buf, sizeof (buf), mode); |
| fseek (fp, offset, SEEK_END); |
| fread (tmp, tmps, 1, fp); |
| |
| if (memcmp (tmp, expected, tmps) != 0) |
| { |
| printf ("%s: fmemopen(%s) - fseek (fp, %li, SEEK_END):\n", |
| __FUNCTION__, mode, offset); |
| printf (" returned: "); |
| print_buffer (tmp, tmps); |
| printf ("\n"); |
| printf (" expected: "); |
| print_buffer (expected, tmps); |
| printf ("\n"); |
| return 1; |
| } |
| |
| fclose (fp); |
| |
| return 0; |
| } |
| |
| static int |
| do_test_read_seek_negative (void) |
| { |
| int ret = 0; |
| |
| /* 'r' and 'w' modes defines the initial position at the buffer start and |
| seek with SEEK_END shall seek relative to its size give in fmemopen |
| call. The expected tmp result is 0 to 9 *without* the ending null */ |
| ret += do_test_read_seek_neg ("r", "0123456789"); |
| /* 'a+' mode sets the initial position at the first null byte in buffer and |
| SEEK_END shall seek relative to its size as well. The expected result is |
| z012345678, since SEEK_END plus a+ start at '\0', not size. */ |
| ret += do_test_read_seek_neg ("a+", "z012345678"); |
| |
| return ret; |
| } |
| |
| static int |
| do_test_write_append_2 (const char *str) |
| { |
| char buf[10]; |
| size_t strn = strlen (str); |
| strcpy (buf, str); |
| |
| FILE *fp = fmemopen (buf, sizeof (buf), "a+"); |
| size_t r = ftell (fp); |
| size_t e = strlen (buf); |
| if (r != e) |
| { |
| printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e); |
| return 1; |
| } |
| |
| if (fseek (fp, 0, SEEK_SET) == -1) |
| { |
| printf ("%s: fseek returned -1\n", __FUNCTION__); |
| return 1; |
| } |
| |
| int gr; |
| for (int i=0; i<strn; ++i) |
| { |
| if ((gr = getc (fp)) != str[i]) |
| { |
| printf ("%s: getc failed returned %d, expected %d\n", __FUNCTION__, |
| gr, str[i]); |
| return 1; |
| } |
| } |
| if ((gr = getc (fp)) != EOF) |
| { |
| printf ("%s: getc failed returned %d, expected EOF\n", __FUNCTION__, |
| gr); |
| return 1; |
| } |
| |
| if (fseek (fp, e+1, SEEK_SET) == -1) |
| { |
| printf ("%s: fseek returned -1\n", __FUNCTION__); |
| return 1; |
| } |
| |
| if ((r = ftell (fp)) != e+1) |
| { |
| printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e+1); |
| return 1; |
| } |
| |
| if ((gr = getc (fp)) != EOF) |
| { |
| printf ("%s: getc failed returned %i\n", __FUNCTION__, gr); |
| return 1; |
| } |
| |
| /* Check if internal position is not changed with a getc returning EOF. */ |
| if ((r = ftell (fp)) != e+1) |
| { |
| printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e+1); |
| return 1; |
| } |
| |
| if (fseek (fp, 0, SEEK_CUR) == -1) |
| { |
| printf ("%s: fseek returned -1\n", __FUNCTION__); |
| return 1; |
| } |
| |
| /* This should be overwritten by fprintf + fflush. */ |
| buf[e+2] = 'X'; |
| |
| if ((r = fprintf (fp, "%d", 101)) != 3) |
| { |
| printf ("%s: fprintf returned %zu, expected %d\n", __FUNCTION__, r, 3); |
| return 1; |
| } |
| |
| fflush (fp); |
| |
| /* Check if internal position is changed by 3 (strlen of '101'). */ |
| if ((r = ftell (fp)) != e+3) |
| { |
| printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e+3); |
| return 1; |
| } |
| |
| char exp[20]; |
| sprintf (exp, "%s%d", str, 101); |
| if (memcmp (buf, exp, strlen (exp)) != 0) |
| { |
| printf ("%s: check failed:", __FUNCTION__); |
| printf ("\nexpected: "); |
| print_buffer (buf, sizeof (buf)); |
| printf ("\nbuffer: "); |
| print_buffer (exp, sizeof (exp)); |
| printf ("\n"); |
| return 1; |
| } |
| |
| fclose(fp); |
| |
| return 0; |
| } |
| |
| static int |
| do_test (void) |
| { |
| int ret = 0; |
| |
| ret += do_test_write_append ("a"); |
| ret += do_test_write_append_without_null ("a"); |
| ret += do_test_write_append ("a+"); |
| ret += do_test_write_append_without_null ("a+"); |
| |
| ret += do_test_read_append (); |
| |
| ret += do_test_read_seek_negative (); |
| |
| /* First test plus addend will fit in the define buffer of size 10. */ |
| ret += do_test_write_append_2 ("test"); |
| /* The second test will also fit, but not the final '\0'. */ |
| ret += do_test_write_append_2 ("testing"); |
| |
| return ret; |
| } |
| |
| #define TEST_FUNCTION do_test () |
| #include "../test-skeleton.c" |