tests/resource-test.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2012 Igalia S.L.
   4  */
   5
   6 #include "test-utils.h"
   7
   8 SoupBuffer *index_buffer;
   9
  10 static void
  11 get_index (void)
  12 {
  13         char *contents;
  14         gsize length;
  15         GError *error = NULL;
  16
  17         if (!g_file_get_contents (SRCDIR "/index.txt", &contents, &length, &error)) {
  18                 g_printerr ("Could not read index.txt: %s\n",
  19                             error->message);
  20                 exit (1);
  21         }
  22
  23         index_buffer = soup_buffer_new (SOUP_MEMORY_TAKE, contents, length);
  24 }
  25
  26 static void
  27 register_gresource (void)
  28 {
  29         GResource *resource;
  30         GError *error = NULL;
  31
  32         resource = g_resource_load ("soup-tests.gresource", &error);
  33         if (!resource) {
  34                 g_printerr ("Could not load resource soup-tests.gresource: %s\n",
  35                             error->message);
  36                 exit (1);
  37         }
  38         g_resources_register (resource);
  39         g_resource_unref (resource);
  40 }
  41
  42 static void
  43 check_results (GString *body)
  44 {
  45         if (body->len != index_buffer->length) {
  46                 debug_printf (1, "    body length mismatch: expected %d, got %d\n",
  47                               (int)index_buffer->length, (int)body->len);
  48                 errors++;
  49         } else if (memcmp (body->str, index_buffer->data, body->len) != 0) {
  50                 debug_printf (1, "    body data mismatch\n");
  51                 errors++;
  52         }
  53 }
  54
  55 typedef struct {
  56         GString *body;
  57         char buffer[1024];
  58         GMainLoop *loop;
  59 } AsyncRequestData;
  60
  61 static void
  62 stream_closed (GObject *source, GAsyncResult *result, gpointer user_data)
  63 {
  64         GInputStream *in = G_INPUT_STREAM (source);
  65         AsyncRequestData *data = user_data;
  66         GError *error = NULL;
  67
  68         if (!g_input_stream_close_finish (in, result, &error)) {
  69                 debug_printf (1, "    close failed: %s\n", error->message);
  70                 g_error_free (error);
  71                 errors++;
  72         }
  73         g_main_loop_quit (data->loop);
  74         g_object_unref (in);
  75 }
  76
  77 static void
  78 test_read_ready (GObject *source, GAsyncResult *result, gpointer user_data)
  79 {
  80         GInputStream *in = G_INPUT_STREAM (source);
  81         AsyncRequestData *data = user_data;
  82         gssize nread;
  83         GError *error = NULL;
  84
  85         nread = g_input_stream_read_finish (in, result, &error);
  86         if (nread == -1) {
  87                 debug_printf (1, "    g_input_stream_read failed: %s\n",
  88                               error->message);
  89                 g_clear_error (&error);
  90                 g_input_stream_close (in, NULL, NULL);
  91                 g_object_unref (in);
  92                 errors++;
  93                 return;
  94         } else if (nread == 0) {
  95                 g_input_stream_close_async (in, G_PRIORITY_DEFAULT, NULL,
  96                                             stream_closed, data);
  97                 return;
  98         }
  99
 100         g_string_append_len (data->body, data->buffer, nread);
 101         g_input_stream_read_async (in, data->buffer, sizeof (data->buffer),
 102                                    G_PRIORITY_DEFAULT, NULL,
 103                                    test_read_ready, data);
 104 }
 105
 106 static void
 107 async_request_sent (GObject *source, GAsyncResult *result, gpointer user_data)
 108 {
 109         GInputStream *in;
 110         AsyncRequestData *data = user_data;
 111         GError *error = NULL;
 112
 113         in = soup_request_send_finish (SOUP_REQUEST (source), result, &error);
 114         if (!in) {
 115                 debug_printf (1, "    soup_request_send_async failed: %s\n",
 116                               error->message);
 117                 g_clear_error (&error);
 118                 errors++;
 119                 return;
 120         }
 121
 122         g_input_stream_read_async (in, data->buffer, sizeof (data->buffer),
 123                                    G_PRIORITY_DEFAULT, NULL,
 124                                    test_read_ready, data);
 125 }
 126
 127 static void
 128 do_async_request (SoupRequest *request)
 129 {
 130         AsyncRequestData data;
 131
 132         data.body = g_string_new (NULL);
 133         soup_request_send_async (request, NULL, async_request_sent, &data);
 134
 135         data.loop = g_main_loop_new (soup_session_get_async_context (soup_request_get_session (request)), TRUE);
 136         g_main_loop_run (data.loop);
 137         g_main_loop_unref (data.loop);
 138
 139         check_results (data.body);
 140         g_string_free (data.body, TRUE);
 141 }
 142
 143 static void
 144 do_sync_request (SoupRequest *request)
 145 {
 146         GInputStream *in;
 147         GString *body;
 148         char buffer[1024];
 149         gssize nread;
 150         GError *error = NULL;
 151
 152         in = soup_request_send (request, NULL, &error);
 153         if (!in) {
 154                 debug_printf (1, "    soup_request_send failed: %s\n",
 155                               error->message);
 156                 g_clear_error (&error);
 157                 errors++;
 158                 return;
 159         }
 160
 161         body = g_string_new (NULL);
 162         do {
 163                 nread = g_input_stream_read (in, buffer, sizeof (buffer),
 164                                              NULL, &error);
 165                 if (nread == -1) {
 166                         debug_printf (1, "    g_input_stream_read failed: %s\n",
 167                                       error->message);
 168                         g_clear_error (&error);
 169                         errors++;
 170                         break;
 171                 }
 172                 g_string_append_len (body, buffer, nread);
 173         } while (nread > 0);
 174
 175         if (!g_input_stream_close (in, NULL, &error)) {
 176                 debug_printf (1, "    g_input_stream_close failed: %s\n",
 177                               error->message);
 178                 g_clear_error (&error);
 179                 errors++;
 180         }
 181         g_object_unref (in);
 182
 183         check_results (body);
 184         g_string_free (body, TRUE);
 185 }
 186
 187 static void
 188 do_request_file_test (SoupRequester *requester,
 189                       gboolean       async)
 190 {
 191         SoupRequest *request;
 192         GFile *index;
 193         char *uri_string;
 194         SoupURI *uri;
 195
 196         index = g_file_new_for_path (SRCDIR "/index.txt");
 197         uri_string = g_file_get_uri (index);
 198         g_object_unref (index);
 199
 200         uri = soup_uri_new (uri_string);
 201         g_free (uri_string);
 202
 203         request = soup_requester_request_uri (requester, uri, NULL);
 204         if (async)
 205                 do_async_request (request);
 206         else
 207                 do_sync_request (request);
 208         g_object_unref (request);
 209
 210         soup_uri_free (uri);
 211 }
 212
 213 static void
 214 do_request_data_test (SoupRequester *requester,
 215                       gboolean       async)
 216 {
 217         SoupRequest *request;
 218         gchar *base64;
 219         char *uri_string;
 220         SoupURI *uri;
 221
 222         base64 = g_base64_encode ((const guchar *)index_buffer->data, index_buffer->length);
 223         uri_string = g_strdup_printf ("data:text/plain;charset=utf8;base64,%s", base64);
 224         g_free (base64);
 225
 226         uri = soup_uri_new (uri_string);
 227         g_free (uri_string);
 228
 229         request = soup_requester_request_uri (requester, uri, NULL);
 230         if (async)
 231                 do_async_request (request);
 232         else
 233                 do_sync_request (request);
 234         g_object_unref (request);
 235
 236         soup_uri_free (uri);
 237 }
 238
 239 static void
 240 do_request_gresource_test (SoupRequester *requester,
 241                            gboolean       async)
 242 {
 243         SoupRequest *request;
 244         SoupURI *uri;
 245
 246         uri = soup_uri_new ("resource:///org/gnome/libsoup/tests/index.txt");
 247         request = soup_requester_request_uri (requester, uri, NULL);
 248         if (async)
 249                 do_async_request (request);
 250         else
 251                 do_sync_request (request);
 252         g_object_unref (request);
 253
 254         soup_uri_free (uri);
 255 }
 256
 257 int
 258 main (int argc, char **argv)
 259 {
 260         SoupSession *session;
 261         SoupRequester *requester;
 262
 263         test_init (argc, argv, NULL);
 264
 265         get_index ();
 266         register_gresource ();
 267
 268         /* Sync tests */
 269         session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
 270         requester = soup_requester_new ();
 271         soup_session_add_feature (session, SOUP_SESSION_FEATURE (requester));
 272         g_object_unref (requester);
 273
 274         do_request_file_test (requester, FALSE);
 275         do_request_data_test (requester, FALSE);
 276         do_request_gresource_test (requester, FALSE);
 277
 278         soup_test_session_abort_unref (session);
 279
 280         /* Async tests */
 281         session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
 282                                          SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
 283                                          NULL);
 284         requester = soup_requester_new ();
 285         soup_session_add_feature (session, SOUP_SESSION_FEATURE (requester));
 286         g_object_unref (requester);
 287
 288         do_request_file_test (requester, TRUE);
 289         do_request_data_test (requester, TRUE);
 290         do_request_gresource_test (requester, TRUE);
 291
 292         soup_test_session_abort_unref (session);
 293
 294         test_cleanup ();
 295         return errors != 0;
 296 }