LCOV - code coverage report
Current view: top level - gio/tests - data-input-stream.c (source / functions) Coverage Total Hit
Test: unnamed Lines: 98.5 % 275 271
Test Date: 2024-11-26 05:23:01 Functions: 100.0 % 15 15
Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* GLib testing framework examples and tests
       2                 :             :  * Copyright (C) 2008 Red Hat, Inc.
       3                 :             :  * Authors: Tomas Bzatek <tbzatek@redhat.com>
       4                 :             :  *
       5                 :             :  * SPDX-License-Identifier: LicenseRef-old-glib-tests
       6                 :             :  *
       7                 :             :  * This work is provided "as is"; redistribution and modification
       8                 :             :  * in whole or in part, in any medium, physical or electronic is
       9                 :             :  * permitted without restriction.
      10                 :             :  *
      11                 :             :  * This work is distributed in the hope that it will be useful,
      12                 :             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
      14                 :             :  *
      15                 :             :  * In no event shall the authors or contributors be liable for any
      16                 :             :  * direct, indirect, incidental, special, exemplary, or consequential
      17                 :             :  * damages (including, but not limited to, procurement of substitute
      18                 :             :  * goods or services; loss of use, data, or profits; or business
      19                 :             :  * interruption) however caused and on any theory of liability, whether
      20                 :             :  * in contract, strict liability, or tort (including negligence or
      21                 :             :  * otherwise) arising in any way out of the use of this software, even
      22                 :             :  * if advised of the possibility of such damage.
      23                 :             :  */
      24                 :             : 
      25                 :             : #include <glib/glib.h>
      26                 :             : #include <gio/gio.h>
      27                 :             : #include <stdlib.h>
      28                 :             : #include <string.h>
      29                 :             : 
      30                 :             : #define MAX_LINES       0xFFF
      31                 :             : #define MAX_BYTES       0x10000 
      32                 :             : 
      33                 :             : static void
      34                 :           1 : test_basic (void)
      35                 :             : {
      36                 :             :   GInputStream *stream;
      37                 :             :   GInputStream *base_stream;
      38                 :             :   gint val;
      39                 :             : 
      40                 :           1 :   base_stream = g_memory_input_stream_new ();
      41                 :           1 :   stream = G_INPUT_STREAM (g_data_input_stream_new (base_stream));
      42                 :             : 
      43                 :           1 :   g_object_get (stream, "byte-order", &val, NULL);
      44                 :           1 :   g_assert_cmpint (val, ==, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
      45                 :           1 :   g_object_set (stream, "byte-order", G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN, NULL);
      46                 :           1 :   g_assert_cmpint (g_data_input_stream_get_byte_order (G_DATA_INPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
      47                 :             : 
      48                 :           1 :   g_object_get (stream, "newline-type", &val, NULL);
      49                 :           1 :   g_assert_cmpint (val, ==, G_DATA_STREAM_NEWLINE_TYPE_LF);
      50                 :           1 :   g_object_set (stream, "newline-type", G_DATA_STREAM_NEWLINE_TYPE_CR_LF, NULL);
      51                 :           1 :   g_assert_cmpint (g_data_input_stream_get_newline_type (G_DATA_INPUT_STREAM (stream)), ==, G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
      52                 :             : 
      53                 :           1 :   g_object_unref (stream);
      54                 :           1 :   g_object_unref (base_stream);
      55                 :           1 : }
      56                 :             : 
      57                 :             : static void
      58                 :          25 : test_seek_to_start (GInputStream *stream)
      59                 :             : {
      60                 :          25 :   GError *error = NULL;
      61                 :          25 :   gboolean res = g_seekable_seek (G_SEEKABLE (stream), 0, G_SEEK_SET, NULL, &error);
      62                 :          25 :   g_assert_cmpint (res, ==, TRUE);
      63                 :          25 :   g_assert_no_error (error);
      64                 :          25 : }
      65                 :             : 
      66                 :             : static void
      67                 :           4 : test_read_lines (GDataStreamNewlineType newline_type)
      68                 :             : {
      69                 :             :   GInputStream *stream;
      70                 :             :   GInputStream *base_stream;
      71                 :           4 :   GError *error = NULL;
      72                 :             :   char *data;
      73                 :             :   int line;
      74                 :             :   const char* lines[MAX_LINES];
      75                 :           4 :   const char* endl[4] = {"\n", "\r", "\r\n", "\n"};
      76                 :             :   
      77                 :             :   /*  prepare data */
      78                 :             :   int i;
      79                 :       16384 :   for (i = 0; i < MAX_LINES; i++)
      80                 :       16380 :     lines[i] = "some_text";
      81                 :             :         
      82                 :           4 :   base_stream = g_memory_input_stream_new ();
      83                 :           4 :   g_assert_nonnull (base_stream);
      84                 :           4 :   stream = G_INPUT_STREAM (g_data_input_stream_new (base_stream));
      85                 :           4 :   g_assert_nonnull (stream);
      86                 :             :         
      87                 :             :   /*  Byte order testing */
      88                 :           4 :   g_data_input_stream_set_byte_order (G_DATA_INPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
      89                 :           4 :   g_assert_cmpint (g_data_input_stream_get_byte_order (G_DATA_INPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
      90                 :           4 :   g_data_input_stream_set_byte_order (G_DATA_INPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
      91                 :           4 :   g_assert_cmpint (g_data_input_stream_get_byte_order (G_DATA_INPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
      92                 :             :   
      93                 :             :   /*  Line ends testing */
      94                 :           4 :   g_data_input_stream_set_newline_type (G_DATA_INPUT_STREAM (stream), newline_type);
      95                 :           4 :   g_assert_cmpint (g_data_input_stream_get_newline_type (G_DATA_INPUT_STREAM (stream)), ==, newline_type);
      96                 :             :         
      97                 :             : 
      98                 :             :   /*  Add sample data */
      99                 :       16384 :   for (i = 0; i < MAX_LINES; i++) 
     100                 :       16380 :     g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (base_stream),
     101                 :       16380 :                                     g_strconcat (lines[i], endl[newline_type], NULL), -1, g_free);
     102                 :             : 
     103                 :             :   /*  Seek to the start */
     104                 :           4 :   test_seek_to_start (base_stream);
     105                 :             :         
     106                 :             :   /*  Test read line */
     107                 :           4 :   error = NULL;
     108                 :           4 :   data = (char*)1;
     109                 :           4 :   line = 0;
     110                 :       16388 :   while (data)
     111                 :             :     {
     112                 :       16384 :       gsize length = -1;
     113                 :       16384 :       data = g_data_input_stream_read_line (G_DATA_INPUT_STREAM (stream), &length, NULL, &error);
     114                 :       16384 :       if (data)
     115                 :             :         {
     116                 :       16380 :           g_assert_cmpstr (data, ==, lines[line]);
     117                 :       16380 :           g_free (data);
     118                 :       16380 :           g_assert_no_error (error);
     119                 :       16380 :           line++;
     120                 :             :         }
     121                 :       16384 :       if (error)
     122                 :           0 :         g_error_free (error);
     123                 :             :     }
     124                 :           4 :   g_assert_cmpint (line, ==, MAX_LINES);
     125                 :             :   
     126                 :             :   
     127                 :           4 :   g_object_unref (base_stream);
     128                 :           4 :   g_object_unref (stream);
     129                 :           4 : }
     130                 :             : 
     131                 :             : static void
     132                 :           1 : test_read_lines_LF (void)
     133                 :             : {
     134                 :           1 :   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_LF);
     135                 :           1 : }
     136                 :             : 
     137                 :             : static void
     138                 :           1 : test_read_lines_CR (void)
     139                 :             : {
     140                 :           1 :   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_CR);
     141                 :           1 : }
     142                 :             : 
     143                 :             : static void
     144                 :           1 : test_read_lines_CR_LF (void)
     145                 :             : {
     146                 :           1 :   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
     147                 :           1 : }
     148                 :             : 
     149                 :             : static void
     150                 :           1 : test_read_lines_any (void)
     151                 :             : {
     152                 :           1 :   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_ANY);
     153                 :           1 : }
     154                 :             : 
     155                 :             : static void
     156                 :           1 : test_read_lines_LF_valid_utf8 (void)
     157                 :             : {
     158                 :             :   GInputStream *stream;
     159                 :             :   GInputStream *base_stream;
     160                 :           1 :   GError *error = NULL;
     161                 :             :   char *line;
     162                 :           1 :   guint n_lines = 0;
     163                 :             :         
     164                 :           1 :   base_stream = g_memory_input_stream_new ();
     165                 :           1 :   stream = G_INPUT_STREAM (g_data_input_stream_new (base_stream));
     166                 :             :         
     167                 :           1 :   g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (base_stream),
     168                 :             :                                   "foo\nthis is valid UTF-8 ☺!\nbar\n", -1, NULL);
     169                 :             : 
     170                 :             :   /*  Test read line */
     171                 :           1 :   error = NULL;
     172                 :             :   while (TRUE)
     173                 :           3 :     {
     174                 :           4 :       gsize length = -1;
     175                 :           4 :       line = g_data_input_stream_read_line_utf8 (G_DATA_INPUT_STREAM (stream), &length, NULL, &error);
     176                 :           4 :       g_assert_no_error (error);
     177                 :             : 
     178                 :           4 :       if (line == NULL)
     179                 :             :         {
     180                 :           1 :           g_assert_cmpuint (length, ==, 0);
     181                 :           1 :           break;
     182                 :             :         }
     183                 :             :       else
     184                 :             :         {
     185                 :           3 :           g_assert_cmpuint (length, >, 0);
     186                 :             :         }
     187                 :             : 
     188                 :           3 :       n_lines++;
     189                 :           3 :       g_free (line);
     190                 :             :     }
     191                 :           1 :   g_assert_cmpint (n_lines, ==, 3);
     192                 :             :   
     193                 :           1 :   g_object_unref (base_stream);
     194                 :           1 :   g_object_unref (stream);
     195                 :           1 : }
     196                 :             : 
     197                 :             : static void
     198                 :           1 : test_read_lines_LF_invalid_utf8 (void)
     199                 :             : {
     200                 :             :   GInputStream *stream;
     201                 :             :   GInputStream *base_stream;
     202                 :           1 :   GError *error = NULL;
     203                 :             :   char *line;
     204                 :           1 :   guint n_lines = 0;
     205                 :             :         
     206                 :           1 :   base_stream = g_memory_input_stream_new ();
     207                 :           1 :   stream = G_INPUT_STREAM (g_data_input_stream_new (base_stream));
     208                 :             :         
     209                 :           1 :   g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (base_stream),
     210                 :             :                                   "foo\nthis is not valid UTF-8 \xE5 =(\nbar\n", -1, NULL);
     211                 :             : 
     212                 :             :   /*  Test read line */
     213                 :           1 :   error = NULL;
     214                 :             :   while (TRUE)
     215                 :           1 :     {
     216                 :           2 :       gsize length = -1;
     217                 :           2 :       line = g_data_input_stream_read_line_utf8 (G_DATA_INPUT_STREAM (stream), &length, NULL, &error);
     218                 :           2 :       if (n_lines == 0)
     219                 :             :         {
     220                 :             :           /* First line is valid UTF-8 */
     221                 :           1 :           g_assert_no_error (error);
     222                 :           1 :           g_assert_cmpuint (length, ==, 3);
     223                 :             :         }
     224                 :             :       else
     225                 :             :         {
     226                 :           1 :           g_assert_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_ILLEGAL_SEQUENCE);
     227                 :           1 :           g_clear_error (&error);
     228                 :           1 :           g_assert_cmpuint (length, ==, 0);
     229                 :           1 :           g_free (line);
     230                 :           1 :           break;
     231                 :             :         }
     232                 :           1 :       n_lines++;
     233                 :           1 :       g_free (line);
     234                 :             :     }
     235                 :           1 :   g_assert_cmpint (n_lines, ==, 1);
     236                 :             :   
     237                 :           1 :   g_object_unref (base_stream);
     238                 :           1 :   g_object_unref (stream);
     239                 :           1 : }
     240                 :             : 
     241                 :             : G_GNUC_BEGIN_IGNORE_DEPRECATIONS
     242                 :             : 
     243                 :             : static void
     244                 :           1 : test_read_until (void)
     245                 :             : {
     246                 :             :   GInputStream *stream;
     247                 :             :   GInputStream *base_stream;
     248                 :           1 :   GError *error = NULL;
     249                 :             :   char *data;
     250                 :             :   int line;
     251                 :             :   int i;
     252                 :             :   
     253                 :             : #define REPEATS                 10   /* number of rounds */
     254                 :             : #define DATA_STRING             " part1 # part2 $ part3 % part4 ^"
     255                 :             : #define DATA_PART_LEN           7    /* number of characters between separators */
     256                 :             : #define DATA_SEP                "#$%^"
     257                 :             : #define DATA_SEP_LEN            4
     258                 :           1 :   const int DATA_PARTS_NUM = DATA_SEP_LEN * REPEATS;
     259                 :             :   
     260                 :           1 :   base_stream = g_memory_input_stream_new ();
     261                 :           1 :   stream = G_INPUT_STREAM (g_data_input_stream_new (base_stream));
     262                 :             :   
     263                 :          11 :   for (i = 0; i < REPEATS; i++)
     264                 :          10 :     g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (base_stream), DATA_STRING, -1, NULL);
     265                 :             :   
     266                 :             :   /*  Test stop characters */
     267                 :           1 :   error = NULL;
     268                 :           1 :   data = (char*)1;
     269                 :           1 :   line = 0;
     270                 :          42 :   while (data)
     271                 :             :     {
     272                 :          41 :       gsize length = -1;
     273                 :          41 :       data = g_data_input_stream_read_until (G_DATA_INPUT_STREAM (stream), DATA_SEP, &length, NULL, &error);
     274                 :          41 :       if (data)
     275                 :             :         {
     276                 :          40 :           g_assert_cmpint (strlen (data), ==, DATA_PART_LEN);
     277                 :          40 :           g_free (data);
     278                 :          40 :           g_assert_no_error (error);
     279                 :          40 :           line++;
     280                 :             :         }
     281                 :             :     }
     282                 :           1 :   g_assert_no_error (error);
     283                 :           1 :   g_assert_cmpint (line, ==, DATA_PARTS_NUM);
     284                 :             : 
     285                 :           1 :   g_object_unref (base_stream);
     286                 :           1 :   g_object_unref (stream);
     287                 :           1 : }
     288                 :             : 
     289                 :             : G_GNUC_END_IGNORE_DEPRECATIONS
     290                 :             : 
     291                 :             : static char *
     292                 :           4 : escape_data_string (const char *str,
     293                 :             :                     size_t      len)
     294                 :             : {
     295                 :           4 :   char *escaped = g_memdup2 (str, len + 1);
     296                 :             : 
     297                 :          58 :   for (size_t i = 0; i < len; i++)
     298                 :             :     {
     299                 :          54 :       if (escaped[i] == '\0')
     300                 :           5 :         escaped[i] = '?';
     301                 :             :     }
     302                 :             : 
     303                 :           4 :   return escaped;
     304                 :             : }
     305                 :             : 
     306                 :             : static void
     307                 :           1 : test_read_upto (void)
     308                 :             : {
     309                 :             :   const struct {
     310                 :             :     int n_repeats;
     311                 :             :     const char *data_string;
     312                 :             :     size_t data_string_len;
     313                 :             :     size_t data_part_len;
     314                 :             :     const char *data_sep;
     315                 :             :     size_t data_sep_len;
     316                 :           1 :   } vectors[] = {
     317                 :             :     { 10, " part1 # part2 $ part3 \0 part4 \0", 32, 7, "#$\0^", 4 },
     318                 :             :     { 20, "{\"key\": \"value\"}\0", 17, 16, "\0", 1 },
     319                 :             :   };
     320                 :             : 
     321                 :             : #undef REPEATS
     322                 :             : #undef DATA_STRING
     323                 :             : #undef DATA_PART_LEN
     324                 :             : #undef DATA_SEP
     325                 :             : #undef DATA_SEP_LEN
     326                 :             : #define REPEATS                     vectors[n].n_repeats
     327                 :             : #define DATA_STRING               vectors[n].data_string
     328                 :             : #define DATA_STRING_LEN vectors[n].data_string_len
     329                 :             : #define DATA_PART_LEN     vectors[n].data_part_len
     330                 :             : #define DATA_SEP              vectors[n].data_sep
     331                 :             : #define DATA_SEP_LEN    vectors[n].data_sep_len
     332                 :             : 
     333                 :           3 :   for (guint n = 0; n < G_N_ELEMENTS (vectors); n++)
     334                 :             :     {
     335                 :           2 :       const int DATA_PARTS_NUM = DATA_SEP_LEN * REPEATS;
     336                 :             :       GInputStream *stream;
     337                 :             :       GInputStream *base_stream;
     338                 :           2 :       GError *error = NULL;
     339                 :             :       char *data;
     340                 :             :       int line;
     341                 :             :       int i;
     342                 :             :       guchar stop_char;
     343                 :             : 
     344                 :           2 :       char *escaped_data = escape_data_string (DATA_STRING, DATA_STRING_LEN);
     345                 :           2 :       char *escaped_sep = escape_data_string (DATA_SEP, DATA_SEP_LEN);
     346                 :           2 :       g_test_message ("Test vector %u: %s and %s", n, escaped_data, escaped_sep);
     347                 :           2 :       g_free (escaped_data);
     348                 :           2 :       g_free (escaped_sep);
     349                 :             : 
     350                 :           2 :       base_stream = g_memory_input_stream_new ();
     351                 :           2 :       stream = G_INPUT_STREAM (g_data_input_stream_new (base_stream));
     352                 :             : 
     353                 :          32 :       for (i = 0; i < REPEATS; i++)
     354                 :          30 :         g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (base_stream), DATA_STRING, DATA_STRING_LEN, NULL);
     355                 :             : 
     356                 :             :       /*  Test stop characters */
     357                 :           2 :       error = NULL;
     358                 :           2 :       data = (char*)1;
     359                 :           2 :       line = 0;
     360                 :          64 :       while (data)
     361                 :             :         {
     362                 :          62 :           gsize length = -1;
     363                 :          62 :           data = g_data_input_stream_read_upto (G_DATA_INPUT_STREAM (stream), DATA_SEP, DATA_SEP_LEN, &length, NULL, &error);
     364                 :          62 :           if (data)
     365                 :             :             {
     366                 :          60 :               g_assert_cmpint (strlen (data), ==, DATA_PART_LEN);
     367                 :          60 :               g_assert_no_error (error);
     368                 :          60 :               line++;
     369                 :             : 
     370                 :          60 :               stop_char = g_data_input_stream_read_byte (G_DATA_INPUT_STREAM (stream), NULL, &error);
     371                 :          60 :               g_assert_nonnull (memchr (DATA_SEP, stop_char, DATA_SEP_LEN));
     372                 :          60 :               g_assert_no_error (error);
     373                 :             :             }
     374                 :          62 :           g_free (data);
     375                 :             :         }
     376                 :           2 :       g_assert_no_error (error);
     377                 :           2 :       g_assert_cmpint (line, ==, DATA_PARTS_NUM);
     378                 :             : 
     379                 :           2 :       g_object_unref (base_stream);
     380                 :           2 :       g_object_unref (stream);
     381                 :             :     }
     382                 :           1 : }
     383                 :             : 
     384                 :             : enum TestDataType {
     385                 :             :   TEST_DATA_BYTE = 0,
     386                 :             :   TEST_DATA_INT16,
     387                 :             :   TEST_DATA_UINT16,
     388                 :             :   TEST_DATA_INT32,
     389                 :             :   TEST_DATA_UINT32,
     390                 :             :   TEST_DATA_INT64,
     391                 :             :   TEST_DATA_UINT64
     392                 :             : };
     393                 :             : 
     394                 :             : /* The order is reversed to avoid -Wduplicated-branches. */
     395                 :             : #define TEST_DATA_RETYPE_BUFF(a, t, v)  \
     396                 :             :          (a == TEST_DATA_UINT64 ? (t) *(guint64*)v :    \
     397                 :             :          (a == TEST_DATA_INT64  ? (t) *(gint64*)v :     \
     398                 :             :          (a == TEST_DATA_UINT32 ? (t) *(guint32*)v :    \
     399                 :             :          (a == TEST_DATA_INT32  ? (t) *(gint32*)v :     \
     400                 :             :          (a == TEST_DATA_UINT16 ? (t) *(guint16*)v :    \
     401                 :             :          (a == TEST_DATA_INT16  ? (t) *(gint16*)v :     \
     402                 :             :          (t) *(guchar*)v ))))))
     403                 :             : 
     404                 :             : 
     405                 :             : static void
     406                 :          21 : test_data_array (GInputStream *stream, GInputStream *base_stream,
     407                 :             :                  gpointer buffer, int len,
     408                 :             :                  enum TestDataType data_type, GDataStreamByteOrder byte_order)
     409                 :             : {
     410                 :          21 :   GError *error = NULL;
     411                 :          21 :   int pos = 0;
     412                 :          21 :   int data_size = 1;
     413                 :             :   gint64 data;
     414                 :             :   GDataStreamByteOrder native;
     415                 :             :   gboolean swap;
     416                 :             :   
     417                 :             :   /*  Seek to start */
     418                 :          21 :   test_seek_to_start (base_stream);
     419                 :             : 
     420                 :             :   /*  Set correct data size */
     421                 :          21 :   switch (data_type)
     422                 :             :     {
     423                 :           3 :     case TEST_DATA_BYTE:
     424                 :           3 :       data_size = 1;
     425                 :           3 :       break;
     426                 :           6 :     case TEST_DATA_INT16:
     427                 :             :     case TEST_DATA_UINT16:
     428                 :           6 :       data_size = 2;
     429                 :           6 :       break;
     430                 :           6 :     case TEST_DATA_INT32:
     431                 :             :     case TEST_DATA_UINT32:
     432                 :           6 :       data_size = 4;
     433                 :           6 :       break;
     434                 :           6 :     case TEST_DATA_INT64:
     435                 :             :     case TEST_DATA_UINT64:
     436                 :           6 :       data_size = 8;
     437                 :           6 :       break; 
     438                 :           0 :     default:
     439                 :             :       g_assert_not_reached ();
     440                 :             :       break;
     441                 :             :     }
     442                 :             : 
     443                 :             :   /*  Set flag to swap bytes if needed */
     444                 :          21 :   native = (G_BYTE_ORDER == G_BIG_ENDIAN) ? G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN : G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
     445                 :          21 :   swap = (byte_order != G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN) && (byte_order != native);
     446                 :             : 
     447                 :          21 :   data = 1;
     448                 :      540714 :   while (data != 0)
     449                 :             :     {
     450                 :      540693 :       switch (data_type)
     451                 :             :         {
     452                 :      196611 :         case TEST_DATA_BYTE:
     453                 :      196611 :           data = g_data_input_stream_read_byte (G_DATA_INPUT_STREAM (stream), NULL, &error);
     454                 :      196611 :           break;
     455                 :       98307 :         case TEST_DATA_INT16:
     456                 :       98307 :           data = g_data_input_stream_read_int16 (G_DATA_INPUT_STREAM (stream), NULL, &error);
     457                 :       98307 :           if (swap)
     458                 :       32769 :             data = (gint16)GUINT16_SWAP_LE_BE((gint16)data);
     459                 :       98307 :           break;
     460                 :       98307 :         case TEST_DATA_UINT16:
     461                 :       98307 :           data = g_data_input_stream_read_uint16 (G_DATA_INPUT_STREAM (stream), NULL, &error);
     462                 :       98307 :           if (swap)
     463                 :       32769 :             data = (guint16)GUINT16_SWAP_LE_BE((guint16)data);
     464                 :       98307 :           break;
     465                 :       49155 :         case TEST_DATA_INT32:
     466                 :       49155 :           data = g_data_input_stream_read_int32 (G_DATA_INPUT_STREAM (stream), NULL, &error);
     467                 :       49155 :           if (swap)
     468                 :       16385 :             data = (gint32)GUINT32_SWAP_LE_BE((gint32)data);
     469                 :       49155 :           break;
     470                 :       49155 :         case TEST_DATA_UINT32:
     471                 :       49155 :           data = g_data_input_stream_read_uint32 (G_DATA_INPUT_STREAM (stream), NULL, &error);
     472                 :       49155 :           if (swap)
     473                 :       16385 :             data = (guint32)GUINT32_SWAP_LE_BE((guint32)data);
     474                 :       49155 :           break;
     475                 :       24579 :         case TEST_DATA_INT64:
     476                 :       24579 :           data = g_data_input_stream_read_int64 (G_DATA_INPUT_STREAM (stream), NULL, &error);
     477                 :       24579 :           if (swap)
     478                 :        8193 :             data = (gint64)GUINT64_SWAP_LE_BE((gint64)data);
     479                 :       24579 :           break;
     480                 :       24579 :         case TEST_DATA_UINT64:
     481                 :       24579 :           data = g_data_input_stream_read_uint64 (G_DATA_INPUT_STREAM (stream), NULL, &error);
     482                 :       24579 :           if (swap)
     483                 :        8193 :             data = (guint64)GUINT64_SWAP_LE_BE((guint64)data);
     484                 :       24579 :           break;
     485                 :           0 :         default:
     486                 :             :           g_assert_not_reached ();
     487                 :             :           break;
     488                 :             :         }
     489                 :      540693 :       if (!error)
     490                 :      540672 :         g_assert_cmpint (data, ==, TEST_DATA_RETYPE_BUFF(data_type, gint64, ((guchar*)buffer + pos)));
     491                 :             :       
     492                 :      540693 :       pos += data_size;
     493                 :             :     }
     494                 :          21 :   if (pos < len + 1)
     495                 :           0 :     g_assert_no_error (error);
     496                 :          21 :   if (error)
     497                 :          21 :     g_error_free (error);
     498                 :          21 :   g_assert_cmpint (pos - data_size, ==, len);
     499                 :          21 : }
     500                 :             : 
     501                 :             : static void
     502                 :           1 : test_read_int (void)
     503                 :             : {
     504                 :             :   GInputStream *stream;
     505                 :             :   GInputStream *base_stream;
     506                 :             :   GRand *randomizer;
     507                 :             :   int i;
     508                 :             :   gpointer buffer;
     509                 :             :   
     510                 :           1 :   randomizer = g_rand_new ();
     511                 :           1 :   buffer = g_malloc0 (MAX_BYTES);
     512                 :             :   
     513                 :             :   /*  Fill in some random data */
     514                 :       65537 :   for (i = 0; i < MAX_BYTES; i++)
     515                 :             :     {
     516                 :       65536 :       guchar x = 0;
     517                 :      131345 :       while (! x)
     518                 :       65809 :         x = (guchar)g_rand_int (randomizer);
     519                 :       65536 :       *(guchar*)((guchar*)buffer + sizeof(guchar) * i) = x; 
     520                 :             :     }
     521                 :             : 
     522                 :           1 :   base_stream = g_memory_input_stream_new ();
     523                 :           1 :   stream = G_INPUT_STREAM (g_data_input_stream_new (base_stream));
     524                 :           1 :   g_memory_input_stream_add_data (G_MEMORY_INPUT_STREAM (base_stream), buffer, MAX_BYTES, NULL);
     525                 :             :   
     526                 :             :   
     527                 :           4 :   for (i = 0; i < 3; i++)
     528                 :             :     {
     529                 :             :       int j;
     530                 :           3 :       g_data_input_stream_set_byte_order (G_DATA_INPUT_STREAM (stream), i);
     531                 :             :       
     532                 :          24 :       for (j = 0; j <= TEST_DATA_UINT64; j++)
     533                 :          21 :         test_data_array (stream, base_stream, buffer, MAX_BYTES, j, i);
     534                 :             :     }
     535                 :             : 
     536                 :           1 :   g_object_unref (base_stream);
     537                 :           1 :   g_object_unref (stream);
     538                 :           1 :   g_rand_free (randomizer);
     539                 :           1 :   g_free (buffer);
     540                 :           1 : }
     541                 :             : 
     542                 :             : 
     543                 :             : int
     544                 :           1 : main (int   argc,
     545                 :             :       char *argv[])
     546                 :             : {
     547                 :           1 :   g_test_init (&argc, &argv, NULL);
     548                 :             : 
     549                 :           1 :   g_test_add_func ("/data-input-stream/basic", test_basic);
     550                 :           1 :   g_test_add_func ("/data-input-stream/read-lines-LF", test_read_lines_LF);
     551                 :           1 :   g_test_add_func ("/data-input-stream/read-lines-LF-valid-utf8", test_read_lines_LF_valid_utf8);
     552                 :           1 :   g_test_add_func ("/data-input-stream/read-lines-LF-invalid-utf8", test_read_lines_LF_invalid_utf8);
     553                 :           1 :   g_test_add_func ("/data-input-stream/read-lines-CR", test_read_lines_CR);
     554                 :           1 :   g_test_add_func ("/data-input-stream/read-lines-CR-LF", test_read_lines_CR_LF);
     555                 :           1 :   g_test_add_func ("/data-input-stream/read-lines-any", test_read_lines_any);
     556                 :           1 :   g_test_add_func ("/data-input-stream/read-until", test_read_until);
     557                 :           1 :   g_test_add_func ("/data-input-stream/read-upto", test_read_upto);
     558                 :           1 :   g_test_add_func ("/data-input-stream/read-int", test_read_int);
     559                 :             : 
     560                 :           1 :   return g_test_run();
     561                 :             : }
        

Generated by: LCOV version 2.0-1