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