gio/tests/data-output-stream.c

   1 /* GLib testing framework examples and tests
   2  * Copyright (C) 2008 Red Hat, Inc.
   3  * Authors: Tomas Bzatek <tbzatek@redhat.com>
   4  *
   5  * This work is provided "as is"; redistribution and modification
   6  * in whole or in part, in any medium, physical or electronic is
   7  * permitted without restriction.
   8  *
   9  * This work is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12  *
  13  * In no event shall the authors or contributors be liable for any
  14  * direct, indirect, incidental, special, exemplary, or consequential
  15  * damages (including, but not limited to, procurement of substitute
  16  * goods or services; loss of use, data, or profits; or business
  17  * interruption) however caused and on any theory of liability, whether
  18  * in contract, strict liability, or tort (including negligence or
  19  * otherwise) arising in any way out of the use of this software, even
  20  * if advised of the possibility of such damage.
  21  */
  22 #include <glib/gtestutils.h>
  23 #include <glib/glib.h>
  24 #include <gio/gio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #define MAX_LINES               0xFFF
  29 #define MAX_LINES_BUFF          0xFFFFFF
  30 #define MAX_BYTES_BINARY        0x100
  31
  32 static void
  33 test_read_lines (GDataStreamNewlineType newline_type)
  34 {
  35   GOutputStream *stream;
  36   GOutputStream *base_stream;
  37   GError *error = NULL;
  38   gpointer data;
  39   char *lines;
  40   int i;
  41
  42 #define TEST_STRING     "some_text"
  43
  44   const char* endl[4] = {"\n", "\r", "\r\n", "\n"};
  45
  46
  47   data = g_malloc0 (MAX_LINES_BUFF);
  48   lines = g_malloc0 ((strlen (TEST_STRING) + strlen (endl[newline_type])) * MAX_LINES + 1);
  49
  50   /* initialize objects */
  51   base_stream = g_memory_output_stream_new (data, MAX_LINES_BUFF, NULL, NULL);
  52   stream = G_OUTPUT_STREAM (g_data_output_stream_new (base_stream));
  53
  54
  55   /*  fill data */
  56   for (i = 0; i < MAX_LINES; i++)
  57     {
  58       gboolean res;
  59       char *s = g_strconcat (TEST_STRING, endl[newline_type], NULL);
  60       res = g_data_output_stream_put_string (G_DATA_OUTPUT_STREAM (stream), s, NULL, &error);
  61       g_stpcpy ((char*)(lines + i*strlen(s)), s);
  62       g_assert (error == NULL);
  63       g_assert (res == TRUE);
  64     }
  65
  66   /*  Byte order testing */
  67   g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
  68   g_assert_cmpint (g_data_output_stream_get_byte_order (G_DATA_OUTPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
  69   g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
  70   g_assert_cmpint (g_data_output_stream_get_byte_order (G_DATA_OUTPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
  71
  72   /*  compare data */
  73   int size = strlen(data);
  74   g_assert_cmpint (size, <, MAX_LINES_BUFF);
  75   g_assert_cmpstr ((char*)data, ==, lines);
  76
  77   g_object_unref (base_stream);
  78   g_object_unref (stream);
  79   g_free (data);
  80   g_free (lines);
  81 }
  82
  83 static void
  84 test_read_lines_LF (void)
  85 {
  86   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_LF);
  87 }
  88
  89 static void
  90 test_read_lines_CR (void)
  91 {
  92   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_CR);
  93 }
  94
  95 static void
  96 test_read_lines_CR_LF (void)
  97 {
  98   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
  99 }
 100
 101 enum TestDataType {
 102   TEST_DATA_BYTE = 0,
 103   TEST_DATA_INT16,
 104   TEST_DATA_UINT16,
 105   TEST_DATA_INT32,
 106   TEST_DATA_UINT32,
 107   TEST_DATA_INT64,
 108   TEST_DATA_UINT64
 109 };
 110
 111 #define TEST_DATA_RETYPE(a, v)  \
 112         (a == TEST_DATA_BYTE    ? (guchar)v : \
 113         (a == TEST_DATA_INT16   ? (gint16)v : \
 114         (a == TEST_DATA_UINT16  ? (guint16)v : \
 115         (a == TEST_DATA_INT32   ? (gint32)v : \
 116         (a == TEST_DATA_UINT32  ? (guint32)v : \
 117         (a == TEST_DATA_INT64   ? (gint64)v : \
 118          (guint64)v ))))))
 119
 120 #define TEST_DATA_RETYPE_BUFF(a, v)     \
 121         (a == TEST_DATA_BYTE    ? *(guchar*)v : \
 122         (a == TEST_DATA_INT16   ? *(gint16*)v : \
 123         (a == TEST_DATA_UINT16  ? *(guint16*)v : \
 124         (a == TEST_DATA_INT32   ? *(gint32*)v : \
 125         (a == TEST_DATA_UINT32  ? *(guint32*)v : \
 126         (a == TEST_DATA_INT64   ? *(gint64*)v : \
 127          *(guint64*)v ))))))
 128
 129
 130
 131
 132 static void
 133 test_data_array (gpointer buffer, int len,
 134                  enum TestDataType data_type, GDataStreamByteOrder byte_order)
 135 {
 136   GOutputStream *stream;
 137   GOutputStream *base_stream;
 138   gpointer stream_data;
 139
 140   GError *error = NULL;
 141   int pos;
 142   int data_size = 1;
 143   GDataStreamByteOrder native;
 144   gboolean swap;
 145   gboolean res;
 146   guint64 data;
 147
 148   /*  create objects */
 149   stream_data = g_malloc0 (len);
 150   base_stream = g_memory_output_stream_new (stream_data, len, NULL, NULL);
 151   stream = G_OUTPUT_STREAM (g_data_output_stream_new (base_stream));
 152   g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), byte_order);
 153
 154
 155   /*  Set correct data size */
 156   switch (data_type)
 157     {
 158     case TEST_DATA_BYTE:
 159       data_size = 1;
 160       break;
 161     case TEST_DATA_INT16:
 162     case TEST_DATA_UINT16:
 163       data_size = 2;
 164       break;
 165     case TEST_DATA_INT32:
 166     case TEST_DATA_UINT32:
 167       data_size = 4;
 168       break;
 169     case TEST_DATA_INT64:
 170     case TEST_DATA_UINT64:
 171       data_size = 8;
 172       break;
 173     }
 174
 175   /*  Set flag to swap bytes if needed */
 176   native = (G_BYTE_ORDER == G_BIG_ENDIAN) ? G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN : G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
 177   swap = (byte_order != G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN) && (byte_order != native);
 178
 179   /*  Write data to the file */
 180   pos = 0;
 181   while (pos < len)
 182     {
 183       switch (data_type)
 184         {
 185         case TEST_DATA_BYTE:
 186           res = g_data_output_stream_put_byte (G_DATA_OUTPUT_STREAM (stream), TEST_DATA_RETYPE_BUFF (data_type, (buffer + pos)), NULL, &error);
 187           break;
 188         case TEST_DATA_INT16:
 189           res = g_data_output_stream_put_int16 (G_DATA_OUTPUT_STREAM (stream), TEST_DATA_RETYPE_BUFF (data_type, (buffer + pos)), NULL, &error);
 190           break;
 191         case TEST_DATA_UINT16:
 192           res = g_data_output_stream_put_uint16 (G_DATA_OUTPUT_STREAM (stream), TEST_DATA_RETYPE_BUFF (data_type, (buffer + pos)), NULL, &error);
 193           break;
 194         case TEST_DATA_INT32:
 195           res = g_data_output_stream_put_int32 (G_DATA_OUTPUT_STREAM (stream), TEST_DATA_RETYPE_BUFF (data_type, (buffer + pos)), NULL, &error);
 196           break;
 197         case TEST_DATA_UINT32:
 198           res = g_data_output_stream_put_uint32 (G_DATA_OUTPUT_STREAM (stream), TEST_DATA_RETYPE_BUFF (data_type, (buffer + pos)), NULL, &error);
 199           break;
 200         case TEST_DATA_INT64:
 201           res = g_data_output_stream_put_int64 (G_DATA_OUTPUT_STREAM (stream), TEST_DATA_RETYPE_BUFF (data_type, (buffer + pos)), NULL, &error);
 202           break;
 203         case TEST_DATA_UINT64:
 204           res = g_data_output_stream_put_uint64 (G_DATA_OUTPUT_STREAM (stream), TEST_DATA_RETYPE_BUFF (data_type, (buffer + pos)), NULL, &error);
 205           break;
 206         }
 207       g_assert (error == NULL);
 208       g_assert_cmpint (res, ==, TRUE);
 209       pos += data_size;
 210     }
 211
 212
 213   /*  Compare data back */
 214   pos = 0;
 215   data = 0;
 216   while (pos < len)
 217     {
 218       data = TEST_DATA_RETYPE_BUFF(data_type, (stream_data + pos));
 219       if (swap)
 220         {
 221           switch (data_type)
 222             {
 223             case TEST_DATA_BYTE:
 224               break;
 225             case TEST_DATA_UINT16:
 226             case TEST_DATA_INT16:
 227               data = TEST_DATA_RETYPE(data_type, GUINT16_SWAP_LE_BE(TEST_DATA_RETYPE(data_type, data)));
 228               break;
 229             case TEST_DATA_UINT32:
 230             case TEST_DATA_INT32:
 231               data = TEST_DATA_RETYPE(data_type, GUINT32_SWAP_LE_BE(TEST_DATA_RETYPE(data_type, data)));
 232               break;
 233             case TEST_DATA_UINT64:
 234             case TEST_DATA_INT64:
 235               data = TEST_DATA_RETYPE(data_type, GUINT64_SWAP_LE_BE(TEST_DATA_RETYPE(data_type, data)));
 236               break;
 237             }
 238         }
 239       g_assert_cmpint (data, ==, TEST_DATA_RETYPE_BUFF(data_type, (buffer + pos)));
 240       break;
 241
 242       pos += data_size;
 243     }
 244
 245   g_object_unref (base_stream);
 246   g_object_unref (stream);
 247   g_free (stream_data);
 248 }
 249
 250 static void
 251 test_read_int (void)
 252 {
 253   GRand *rand;
 254   gpointer buffer;
 255
 256   rand = g_rand_new ();
 257   buffer = g_malloc0(MAX_BYTES_BINARY);
 258
 259   /*  Fill in some random data */
 260   int i;
 261   for (i = 0; i < MAX_BYTES_BINARY; i++)
 262     {
 263       guchar x = 0;
 264       while (! x)  x = (guchar)g_rand_int (rand);
 265       *(guchar*)(buffer + sizeof(guchar) * i) = x;
 266     }
 267
 268   for (i = 0; i < 3; i++)
 269     {
 270       int j;
 271       for (j = 0; j <= TEST_DATA_UINT64; j++)
 272         test_data_array (buffer, MAX_BYTES_BINARY, j, i);
 273     }
 274
 275   g_rand_free (rand);
 276   g_free (buffer);
 277 }
 278
 279 int
 280 main (int   argc,
 281       char *argv[])
 282 {
 283   g_type_init ();
 284   g_test_init (&argc, &argv, NULL);
 285
 286   g_test_add_func ("/data-input-stream/read-lines-LF", test_read_lines_LF);
 287   g_test_add_func ("/data-input-stream/read-lines-CR", test_read_lines_CR);
 288   g_test_add_func ("/data-input-stream/read-lines-CR-LF", test_read_lines_CR_LF);
 289   g_test_add_func ("/data-input-stream/read-int", test_read_int);
 290
 291   return g_test_run();
 292 }