gio/tests/async-close-output-stream.c

   1 /* GLib testing framework examples and tests
   2  * Authors: Jesse van den Kieboom <jessevdk@gnome.org>
   3  *
   4  * This work is provided "as is"; redistribution and modification
   5  * in whole or in part, in any medium, physical or electronic is
   6  * permitted without restriction.
   7  *
   8  * This work is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * In no event shall the authors or contributors be liable for any
  13  * direct, indirect, incidental, special, exemplary, or consequential
  14  * damages (including, but not limited to, procurement of substitute
  15  * goods or services; loss of use, data, or profits; or business
  16  * interruption) however caused and on any theory of liability, whether
  17  * in contract, strict liability, or tort (including negligence or
  18  * otherwise) arising in any way out of the use of this software, even
  19  * if advised of the possibility of such damage.
  20  */
  21
  22 #include <glib/glib.h>
  23 #include <gio/gio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #define DATA_TO_WRITE "Hello world\n"
  28
  29 typedef struct
  30 {
  31   GOutputStream *conv_stream;
  32   GOutputStream *data_stream;
  33   gchar *expected_output;
  34   gsize expected_size;
  35   GMainLoop *main_loop;
  36 } SetupData;
  37
  38 static void
  39 create_streams (SetupData *data)
  40 {
  41   GConverter *converter;
  42
  43   converter = G_CONVERTER (g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP, -1));
  44
  45   data->data_stream = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
  46   data->conv_stream = g_converter_output_stream_new (data->data_stream,
  47                                                      converter);
  48
  49   g_object_unref (converter);
  50 }
  51
  52 static void
  53 destroy_streams (SetupData *data)
  54 {
  55   g_object_unref (data->data_stream);
  56   g_object_unref (data->conv_stream);
  57 }
  58
  59 static void
  60 write_data_to_stream (SetupData *data)
  61 {
  62   gsize bytes_written;
  63   GError *error = NULL;
  64
  65   /* just write the data synchronously */
  66   g_output_stream_write_all (data->conv_stream,
  67                              DATA_TO_WRITE,
  68                              sizeof (DATA_TO_WRITE),
  69                              &bytes_written,
  70                              NULL,
  71                              &error);
  72
  73   g_assert_no_error (error);
  74   g_assert_cmpint (sizeof (DATA_TO_WRITE), ==, bytes_written);
  75 }
  76
  77 static void
  78 setup_data (SetupData     *data,
  79             gconstpointer  user_data)
  80 {
  81   data->main_loop = g_main_loop_new (NULL, FALSE);
  82   create_streams (data);
  83 }
  84
  85 static void
  86 teardown_data (SetupData     *data,
  87                gconstpointer  user_data)
  88 {
  89   /* cleanup */
  90   g_main_loop_unref (data->main_loop);
  91
  92   destroy_streams (data);
  93
  94   g_free (data->expected_output);
  95 }
  96
  97 static void
  98 compare_output (SetupData *data)
  99 {
 100   gsize size;
 101   gpointer written;
 102
 103   size = g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (data->data_stream));
 104
 105   /* compare the size of the data */
 106   g_assert_cmpint (size, ==, data->expected_size);
 107
 108   written = g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (data->data_stream));
 109
 110   /* compare the data itself */
 111   g_assert (memcmp (written, data->expected_output, size) == 0);
 112 }
 113
 114 static void
 115 async_close_ready (GOutputStream *stream,
 116                    GAsyncResult  *result,
 117                    SetupData     *data)
 118 {
 119   GError *error = NULL;
 120
 121   /* finish the close */
 122   g_output_stream_close_finish (stream, result, &error);
 123
 124   g_assert_no_error (error);
 125
 126   /* compare the output with the desired output */
 127   compare_output (data);
 128
 129   g_main_loop_quit (data->main_loop);
 130 }
 131
 132 static void
 133 prepare_data (SetupData *data,
 134               gboolean   manual_flush)
 135 {
 136   GError *error = NULL;
 137   gpointer written;
 138
 139   write_data_to_stream (data);
 140
 141   if (manual_flush)
 142     {
 143       g_output_stream_flush (data->conv_stream, NULL, &error);
 144       g_assert_no_error (error);
 145     }
 146
 147   g_output_stream_close (data->conv_stream, NULL, &error);
 148
 149   g_assert_no_error (error);
 150
 151   written = g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (data->data_stream));
 152
 153   data->expected_size = g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (data->data_stream));
 154
 155   g_assert_cmpint (data->expected_size, >, 0);
 156
 157   data->expected_output = g_memdup (written, (guint)data->expected_size);
 158
 159   /* then recreate the streams and prepare them for the asynchronous close */
 160   destroy_streams (data);
 161   create_streams (data);
 162
 163   write_data_to_stream (data);
 164 }
 165
 166 static void
 167 test_without_flush (SetupData     *data,
 168                     gconstpointer  user_data)
 169 {
 170   prepare_data (data, FALSE);
 171
 172   /* just close asynchronously */
 173   g_output_stream_close_async (data->conv_stream,
 174                                G_PRIORITY_DEFAULT,
 175                                NULL,
 176                                (GAsyncReadyCallback)async_close_ready,
 177                                data);
 178
 179   g_main_loop_run (data->main_loop);
 180 }
 181
 182 static void
 183 test_with_flush (SetupData *data, gconstpointer user_data)
 184 {
 185   GError *error = NULL;
 186
 187   prepare_data (data, TRUE);
 188
 189   g_output_stream_flush (data->conv_stream, NULL, &error);
 190
 191   g_assert_no_error (error);
 192
 193   /* then close asynchronously */
 194   g_output_stream_close_async (data->conv_stream,
 195                                G_PRIORITY_DEFAULT,
 196                                NULL,
 197                                (GAsyncReadyCallback)async_close_ready,
 198                                data);
 199
 200   g_main_loop_run (data->main_loop);
 201 }
 202
 203 static void
 204 async_flush_ready (GOutputStream *stream,
 205                    GAsyncResult  *result,
 206                    SetupData     *data)
 207 {
 208   GError *error = NULL;
 209
 210   g_output_stream_flush_finish (stream, result, &error);
 211
 212   g_assert_no_error (error);
 213
 214   /* then close async after the flush */
 215   g_output_stream_close_async (data->conv_stream,
 216                                G_PRIORITY_DEFAULT,
 217                                NULL,
 218                                (GAsyncReadyCallback)async_close_ready,
 219                                data);
 220 }
 221
 222 static void
 223 test_with_async_flush (SetupData     *data,
 224                        gconstpointer  user_data)
 225 {
 226   prepare_data (data, TRUE);
 227
 228   /* first flush async */
 229   g_output_stream_flush_async (data->conv_stream,
 230                                G_PRIORITY_DEFAULT,
 231                                NULL,
 232                                (GAsyncReadyCallback)async_flush_ready,
 233                                data);
 234
 235   g_main_loop_run (data->main_loop);
 236 }
 237
 238 int
 239 main (int   argc,
 240       char *argv[])
 241 {
 242   SetupData *data;
 243
 244   g_type_init ();
 245   g_thread_init (NULL);
 246
 247   g_test_init (&argc, &argv, NULL);
 248
 249   data = g_slice_new (SetupData);
 250
 251   /* test closing asynchronously without flushing manually */
 252   g_test_add ("/close-async/without-flush",
 253               SetupData,
 254               data,
 255               setup_data,
 256               test_without_flush,
 257               teardown_data);
 258
 259   /* test closing asynchronously with a synchronous manually flush */
 260   g_test_add ("/close-async/with-flush",
 261               SetupData,
 262               data,
 263               setup_data,
 264               test_with_flush,
 265               teardown_data);
 266
 267   /* test closing asynchronously with an asynchronous manually flush */
 268   g_test_add ("/close-async/with-async-flush",
 269               SetupData,
 270               data,
 271               setup_data,
 272               test_with_async_flush,
 273               teardown_data);
 274
 275   g_slice_free (SetupData, data);
 276
 277   return g_test_run();
 278 }