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
  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_basic (void)
  34 {
  35   GOutputStream *stream;
  36   GOutputStream *base_stream;
  37   gpointer data;
  38   gint val;
  39
  40   data = g_malloc0 (MAX_LINES_BUFF);
  41
  42   /* initialize objects */
  43   base_stream = g_memory_output_stream_new (data, MAX_LINES_BUFF, NULL, NULL);
  44   stream = G_OUTPUT_STREAM (g_data_output_stream_new (base_stream));
  45
  46   g_object_get (stream, "byte-order", &val, NULL);
  47   g_assert_cmpint (val, ==, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
  48   g_object_set (stream, "byte-order", G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN, NULL);
  49   g_assert_cmpint (g_data_output_stream_get_byte_order (G_DATA_OUTPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
  50
  51   g_object_unref (stream);
  52   g_object_unref (base_stream);
  53 }
  54
  55 static void
  56 test_read_lines (GDataStreamNewlineType newline_type)
  57 {
  58   GOutputStream *stream;
  59   GOutputStream *base_stream;
  60   GError *error = NULL;
  61   gpointer data;
  62   char *lines;
  63   int size;
  64   int i;
  65
  66 #define TEST_STRING     "some_text"
  67
  68   const char* endl[4] = {"\n", "\r", "\r\n", "\n"};
  69
  70
  71   data = g_malloc0 (MAX_LINES_BUFF);
  72   lines = g_malloc0 ((strlen (TEST_STRING) + strlen (endl[newline_type])) * MAX_LINES + 1);
  73
  74   /* initialize objects */
  75   base_stream = g_memory_output_stream_new (data, MAX_LINES_BUFF, NULL, NULL);
  76   stream = G_OUTPUT_STREAM (g_data_output_stream_new (base_stream));
  77
  78
  79   /*  fill data */
  80   for (i = 0; i < MAX_LINES; i++)
  81     {
  82       gboolean res;
  83       char *s = g_strconcat (TEST_STRING, endl[newline_type], NULL);
  84       res = g_data_output_stream_put_string (G_DATA_OUTPUT_STREAM (stream), s, NULL, &error);
  85       g_stpcpy ((char*)(lines + i*strlen(s)), s);
  86       g_assert_no_error (error);
  87       g_assert (res == TRUE);
  88       g_free (s);
  89     }
  90
  91   /*  Byte order testing */
  92   g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
  93   g_assert_cmpint (g_data_output_stream_get_byte_order (G_DATA_OUTPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
  94   g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
  95   g_assert_cmpint (g_data_output_stream_get_byte_order (G_DATA_OUTPUT_STREAM (stream)), ==, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN);
  96
  97   /*  compare data */
  98   size = strlen (data);
  99   g_assert_cmpint (size, <, MAX_LINES_BUFF);
 100   g_assert_cmpstr ((char*)data, ==, lines);
 101
 102   g_object_unref (base_stream);
 103   g_object_unref (stream);
 104   g_free (data);
 105   g_free (lines);
 106 }
 107
 108 static void
 109 test_read_lines_LF (void)
 110 {
 111   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_LF);
 112 }
 113
 114 static void
 115 test_read_lines_CR (void)
 116 {
 117   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_CR);
 118 }
 119
 120 static void
 121 test_read_lines_CR_LF (void)
 122 {
 123   test_read_lines (G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
 124 }
 125
 126 enum TestDataType {
 127   TEST_DATA_BYTE = 0,
 128   TEST_DATA_INT16,
 129   TEST_DATA_UINT16,
 130   TEST_DATA_INT32,
 131   TEST_DATA_UINT32,
 132   TEST_DATA_INT64,
 133   TEST_DATA_UINT64
 134 };
 135
 136 static void
 137 test_data_array (guchar *buffer, gsize len,
 138                  enum TestDataType data_type, GDataStreamByteOrder byte_order)
 139 {
 140   GOutputStream *stream;
 141   GOutputStream *base_stream;
 142   guchar *stream_data;
 143
 144   GError *error = NULL;
 145   guint pos;
 146   GDataStreamByteOrder native;
 147   gboolean swap;
 148   gboolean res;
 149
 150   /*  create objects */
 151   stream_data = g_malloc0 (len);
 152   base_stream = g_memory_output_stream_new (stream_data, len, NULL, NULL);
 153   stream = G_OUTPUT_STREAM (g_data_output_stream_new (base_stream));
 154   g_data_output_stream_set_byte_order (G_DATA_OUTPUT_STREAM (stream), byte_order);
 155
 156   /*  Set flag to swap bytes if needed */
 157   native = (G_BYTE_ORDER == G_BIG_ENDIAN) ? G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN : G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN;
 158   swap = (byte_order != G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN) && (byte_order != native);
 159
 160   /* set len to length of buffer cast to actual type */
 161   switch (data_type)
 162     {
 163     case TEST_DATA_BYTE:
 164       break;
 165     case TEST_DATA_INT16:
 166     case TEST_DATA_UINT16:
 167       g_assert_cmpint (len % 2, ==, 0);
 168     case TEST_DATA_INT32:
 169     case TEST_DATA_UINT32:
 170       g_assert_cmpint (len % 4, ==, 0);
 171     case TEST_DATA_INT64:
 172     case TEST_DATA_UINT64:
 173       g_assert_cmpint (len % 8, ==, 0);
 174       len /= 8;
 175       break;
 176     default:
 177       g_assert_not_reached ();
 178       break;
 179     }
 180
 181   /*  Write data to the file */
 182   for (pos = 0; pos < len; pos++)
 183     {
 184       switch (data_type)
 185         {
 186         case TEST_DATA_BYTE:
 187           res = g_data_output_stream_put_byte (G_DATA_OUTPUT_STREAM (stream), buffer[pos], NULL, &error);
 188           break;
 189         case TEST_DATA_INT16:
 190           res = g_data_output_stream_put_int16 (G_DATA_OUTPUT_STREAM (stream), ((gint16 *) buffer)[pos], NULL, &error);
 191           break;
 192         case TEST_DATA_UINT16:
 193           res = g_data_output_stream_put_uint16 (G_DATA_OUTPUT_STREAM (stream), ((guint16 *) buffer)[pos], NULL, &error);
 194           break;
 195         case TEST_DATA_INT32:
 196           res = g_data_output_stream_put_int32 (G_DATA_OUTPUT_STREAM (stream), ((gint32 *) buffer)[pos], NULL, &error);
 197           break;
 198         case TEST_DATA_UINT32:
 199           res = g_data_output_stream_put_uint32 (G_DATA_OUTPUT_STREAM (stream), ((guint32 *) buffer)[pos], NULL, &error);
 200           break;
 201         case TEST_DATA_INT64:
 202           res = g_data_output_stream_put_int64 (G_DATA_OUTPUT_STREAM (stream), ((gint64 *) buffer)[pos], NULL, &error);
 203           break;
 204         case TEST_DATA_UINT64:
 205           res = g_data_output_stream_put_uint64 (G_DATA_OUTPUT_STREAM (stream), ((guint64 *) buffer)[pos], NULL, &error);
 206           break;
 207         default:
 208           g_assert_not_reached ();
 209           break;
 210         }
 211       g_assert_no_error (error);
 212       g_assert_cmpint (res, ==, TRUE);
 213     }
 214
 215   /*  Compare data back */
 216   for (pos = 0; pos < len; pos++)
 217     {
 218       switch (data_type)
 219         {
 220         case TEST_DATA_BYTE:
 221           /* swapping unnecessary */
 222           g_assert_cmpint (buffer[pos], ==, stream_data[pos]);
 223           break;
 224         case TEST_DATA_UINT16:
 225           if (swap)
 226             g_assert_cmpint (GUINT16_SWAP_LE_BE (((guint16 *) buffer)[pos]), ==, ((guint16 *) stream_data)[pos]);
 227           else
 228             g_assert_cmpint (((guint16 *) buffer)[pos], ==, ((guint16 *) stream_data)[pos]);
 229           break;
 230         case TEST_DATA_INT16:
 231           if (swap)
 232             g_assert_cmpint ((gint16) GUINT16_SWAP_LE_BE (((gint16 *) buffer)[pos]), ==, ((gint16 *) stream_data)[pos]);
 233           else
 234             g_assert_cmpint (((gint16 *) buffer)[pos], ==, ((gint16 *) stream_data)[pos]);
 235           break;
 236         case TEST_DATA_UINT32:
 237           if (swap)
 238             g_assert_cmpint (GUINT32_SWAP_LE_BE (((guint32 *) buffer)[pos]), ==, ((guint32 *) stream_data)[pos]);
 239           else
 240             g_assert_cmpint (((guint32 *) buffer)[pos], ==, ((guint32 *) stream_data)[pos]);
 241           break;
 242         case TEST_DATA_INT32:
 243           if (swap)
 244             g_assert_cmpint ((gint32) GUINT32_SWAP_LE_BE (((gint32 *) buffer)[pos]), ==, ((gint32 *) stream_data)[pos]);
 245           else
 246             g_assert_cmpint (((gint32 *) buffer)[pos], ==, ((gint32 *) stream_data)[pos]);
 247           break;
 248         case TEST_DATA_UINT64:
 249           if (swap)
 250             g_assert_cmpint (GUINT64_SWAP_LE_BE (((guint64 *) buffer)[pos]), ==, ((guint64 *) stream_data)[pos]);
 251           else
 252             g_assert_cmpint (((guint64 *) buffer)[pos], ==, ((guint64 *) stream_data)[pos]);
 253           break;
 254         case TEST_DATA_INT64:
 255           if (swap)
 256             g_assert_cmpint ((gint64) GUINT64_SWAP_LE_BE (((gint64 *) buffer)[pos]), ==, ((gint64 *) stream_data)[pos]);
 257           else
 258             g_assert_cmpint (((gint64 *) buffer)[pos], ==, ((gint64 *) stream_data)[pos]);
 259           break;
 260         default:
 261             g_assert_not_reached ();
 262           break;
 263         }
 264     }
 265
 266   g_object_unref (base_stream);
 267   g_object_unref (stream);
 268   g_free (stream_data);
 269 }
 270
 271 static void
 272 test_read_int (void)
 273 {
 274   GRand *randomizer;
 275   gpointer buffer;
 276   int i;
 277
 278   randomizer = g_rand_new ();
 279   buffer = g_malloc0(MAX_BYTES_BINARY);
 280
 281   /*  Fill in some random data */
 282   for (i = 0; i < MAX_BYTES_BINARY; i++)
 283     {
 284       guchar x = 0;
 285       while (! x)  x = (guchar)g_rand_int (randomizer);
 286       *(guchar*)((guchar*)buffer + sizeof (guchar) * i) = x;
 287     }
 288
 289   for (i = 0; i < 3; i++)
 290     {
 291       int j;
 292       for (j = 0; j <= TEST_DATA_UINT64; j++)
 293         test_data_array (buffer, MAX_BYTES_BINARY, j, i);
 294     }
 295
 296   g_rand_free (randomizer);
 297   g_free (buffer);
 298 }
 299
 300 int
 301 main (int   argc,
 302       char *argv[])
 303 {
 304   g_type_init ();
 305   g_test_init (&argc, &argv, NULL);
 306
 307   g_test_add_func ("/data-output-stream/basic", test_basic);
 308   g_test_add_func ("/data-output-stream/write-lines-LF", test_read_lines_LF);
 309   g_test_add_func ("/data-output-stream/write-lines-CR", test_read_lines_CR);
 310   g_test_add_func ("/data-output-stream/write-lines-CR-LF", test_read_lines_CR_LF);
 311   g_test_add_func ("/data-output-stream/write-int", test_read_int);
 312
 313   return g_test_run();
 314 }