diff options
Diffstat (limited to 'tests/misc-test.c')
| -rw-r--r-- | tests/misc-test.c | 588 |
1 files changed, 158 insertions, 430 deletions
diff --git a/tests/misc-test.c b/tests/misc-test.c index 605fa216..00559a03 100644 --- a/tests/misc-test.c +++ b/tests/misc-test.c @@ -32,16 +32,6 @@ server_callback (SoupServer *server, SoupMessage *msg, SoupURI *uri = soup_message_get_uri (msg); const char *server_protocol = data; - soup_message_headers_append (msg->response_headers, - "X-Handled-By", "server_callback"); - - if (!strcmp (path, "*")) { - debug_printf (1, " default server_callback got request for '*'!\n"); - errors++; - soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); - return; - } - if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_POST) { soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED); return; @@ -99,32 +89,8 @@ server_callback (SoupServer *server, SoupMessage *msg, } } -static void -server_star_callback (SoupServer *server, SoupMessage *msg, - const char *path, GHashTable *query, - SoupClientContext *context, gpointer data) -{ - soup_message_headers_append (msg->response_headers, - "X-Handled-By", "star_callback"); - - if (strcmp (path, "*") != 0) { - debug_printf (1, " server_star_callback got request for '%s'!\n", path); - errors++; - soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); - return; - } - - if (msg->method != SOUP_METHOD_OPTIONS) { - soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED); - return; - } - - soup_message_set_status (msg, SOUP_STATUS_OK); -} - /* Host header handling: client must be able to override the default * value, server must be able to recognize different Host values. - * #539803. */ static void do_host_test (void) @@ -132,7 +98,7 @@ do_host_test (void) SoupSession *session; SoupMessage *one, *two; - debug_printf (1, "Host handling\n"); + g_test_bug ("539803"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); @@ -145,42 +111,24 @@ do_host_test (void) soup_test_session_abort_unref (session); - if (!SOUP_STATUS_IS_SUCCESSFUL (one->status_code)) { - debug_printf (1, " Message 1 failed: %d %s\n", - one->status_code, one->reason_phrase); - errors++; - } else if (strcmp (one->response_body->data, "index") != 0) { - debug_printf (1, " Unexpected response to message 1: '%s'\n", - one->response_body->data); - errors++; - } + soup_test_assert_message_status (one, SOUP_STATUS_OK); + g_assert_cmpstr (one->response_body->data, ==, "index"); g_object_unref (one); - if (!SOUP_STATUS_IS_SUCCESSFUL (two->status_code)) { - debug_printf (1, " Message 2 failed: %d %s\n", - two->status_code, two->reason_phrase); - errors++; - } else if (strcmp (two->response_body->data, "foo-index") != 0) { - debug_printf (1, " Unexpected response to message 2: '%s'\n", - two->response_body->data); - errors++; - } + soup_test_assert_message_status (two, SOUP_STATUS_OK); + g_assert_cmpstr (two->response_body->data, ==, "foo-index"); g_object_unref (two); } /* Dropping the application's ref on the session from a callback * should not cause the session to be freed at an incorrect time. - * (This test will crash if it fails.) #533473 + * (This test will crash if it fails.) */ static void cu_one_completed (SoupSession *session, SoupMessage *msg, gpointer loop) { debug_printf (2, " Message 1 completed\n"); - if (msg->status_code != SOUP_STATUS_CANT_CONNECT) { - debug_printf (1, " Unexpected status on Message 1: %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } + soup_test_assert_message_status (msg, SOUP_STATUS_CANT_CONNECT); g_object_unref (session); } @@ -195,11 +143,7 @@ static void cu_two_completed (SoupSession *session, SoupMessage *msg, gpointer loop) { debug_printf (2, " Message 2 completed\n"); - if (msg->status_code != SOUP_STATUS_CANT_CONNECT) { - debug_printf (1, " Unexpected status on Message 2: %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } + soup_test_assert_message_status (msg, SOUP_STATUS_CANT_CONNECT); g_idle_add (cu_idle_quit, loop); } @@ -213,7 +157,7 @@ do_callback_unref_test (void) GMainLoop *loop; char *bad_uri; - debug_printf (1, "\nCallback unref handling (msg api)\n"); + g_test_bug ("533473"); /* Get a guaranteed-bad URI */ addr = soup_address_new ("127.0.0.1", SOUP_ADDRESS_ANY_PORT); @@ -243,22 +187,19 @@ do_callback_unref_test (void) g_main_loop_run (loop); g_main_loop_unref (loop); + g_assert_null (session); if (session) { g_object_remove_weak_pointer (G_OBJECT (session), (gpointer *)&session); - debug_printf (1, " Session not destroyed?\n"); - errors++; g_object_unref (session); } + g_assert_null (one); if (one) { g_object_remove_weak_pointer (G_OBJECT (one), (gpointer *)&one); - debug_printf (1, " Message 1 not destroyed?\n"); - errors++; g_object_unref (one); } + g_assert_null (two); if (two) { g_object_remove_weak_pointer (G_OBJECT (two), (gpointer *)&two); - debug_printf (1, " Message 2 not destroyed?\n"); - errors++; g_object_unref (two); } @@ -272,14 +213,8 @@ cur_one_completed (GObject *source, GAsyncResult *result, gpointer session) GError *error = NULL; debug_printf (2, " Request 1 completed\n"); - if (soup_request_send_finish (one, result, &error)) { - debug_printf (1, " Request 1 succeeded?\n"); - errors++; - } else if (!g_error_matches (error, SOUP_HTTP_ERROR, SOUP_STATUS_CANT_CONNECT)) { - debug_printf (1, " Unexpected error on Request 1: %s\n", - error->message); - errors++; - } + soup_request_send_finish (one, result, &error); + g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_REFUSED); g_clear_error (&error); g_object_unref (session); @@ -299,14 +234,8 @@ cur_two_completed (GObject *source, GAsyncResult *result, gpointer loop) GError *error = NULL; debug_printf (2, " Request 2 completed\n"); - if (soup_request_send_finish (two, result, &error)) { - debug_printf (1, " Request 2 succeeded?\n"); - errors++; - } else if (!g_error_matches (error, SOUP_HTTP_ERROR, SOUP_STATUS_CANT_CONNECT)) { - debug_printf (1, " Unexpected error on Request 2: %s\n", - error->message); - errors++; - } + soup_request_send_finish (two, result, &error); + g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_REFUSED); g_clear_error (&error); g_idle_add (cur_idle_quit, loop); @@ -318,13 +247,10 @@ do_callback_unref_req_test (void) SoupServer *bad_server; SoupAddress *addr; SoupSession *session; - SoupRequester *requester; SoupRequest *one, *two; GMainLoop *loop; char *bad_uri; - debug_printf (1, "\nCallback unref handling (request api)\n"); - /* Get a guaranteed-bad URI */ addr = soup_address_new ("127.0.0.1", SOUP_ADDRESS_ANY_PORT); soup_address_resolve_sync (addr, NULL); @@ -337,18 +263,15 @@ do_callback_unref_req_test (void) g_object_unref (bad_server); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, - SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER, SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, NULL); g_object_add_weak_pointer (G_OBJECT (session), (gpointer *)&session); - requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER); - loop = g_main_loop_new (NULL, TRUE); - one = soup_requester_request (requester, bad_uri, NULL); + one = soup_session_request (session, bad_uri, NULL); g_object_add_weak_pointer (G_OBJECT (one), (gpointer *)&one); - two = soup_requester_request (requester, bad_uri, NULL); + two = soup_session_request (session, bad_uri, NULL); g_object_add_weak_pointer (G_OBJECT (two), (gpointer *)&two); g_free (bad_uri); @@ -360,22 +283,19 @@ do_callback_unref_req_test (void) g_main_loop_run (loop); g_main_loop_unref (loop); + g_assert_null (session); if (session) { g_object_remove_weak_pointer (G_OBJECT (session), (gpointer *)&session); - debug_printf (1, " Session not destroyed?\n"); - errors++; g_object_unref (session); } + g_assert_null (one); if (one) { g_object_remove_weak_pointer (G_OBJECT (one), (gpointer *)&one); - debug_printf (1, " Request 1 not destroyed?\n"); - errors++; g_object_unref (one); } + g_assert_null (two); if (two) { g_object_remove_weak_pointer (G_OBJECT (two), (gpointer *)&two); - debug_printf (1, " Request 2 not destroyed?\n"); - errors++; g_object_unref (two); } @@ -384,20 +304,19 @@ do_callback_unref_req_test (void) /* SoupSession should clean up all signal handlers on a message after * it is finished, allowing the message to be reused if desired. - * #559054 */ static void ensure_no_signal_handlers (SoupMessage *msg, guint *signal_ids, guint n_signal_ids) { int i; + guint id; for (i = 0; i < n_signal_ids; i++) { - if (g_signal_handler_find (msg, G_SIGNAL_MATCH_ID, signal_ids[i], - 0, NULL, NULL, NULL)) { - debug_printf (1, " Message has handler for '%s'\n", - g_signal_name (signal_ids[i])); - errors++; - } + id = g_signal_handler_find (msg, G_SIGNAL_MATCH_ID, signal_ids[i], + 0, NULL, NULL, NULL); + soup_test_assert (id == 0, + "message has handler for '%s'", + g_signal_name (signal_ids[i])); } } @@ -420,7 +339,7 @@ do_msg_reuse_test (void) SoupURI *uri; guint *signal_ids, n_signal_ids; - debug_printf (1, "\nSoupMessage reuse\n"); + g_test_bug ("559054"); signal_ids = g_signal_list_ids (SOUP_TYPE_MESSAGE, &n_signal_ids); @@ -438,10 +357,7 @@ do_msg_reuse_test (void) soup_message_set_uri (msg, uri); soup_uri_free (uri); soup_session_send_message (session, msg); - if (!soup_uri_equal (soup_message_get_uri (msg), base_uri)) { - debug_printf (1, " Message did not get redirected!\n"); - errors++; - } + g_assert_true (soup_uri_equal (soup_message_get_uri (msg), base_uri)); ensure_no_signal_handlers (msg, signal_ids, n_signal_ids); debug_printf (1, " Auth message\n"); @@ -449,10 +365,7 @@ do_msg_reuse_test (void) soup_message_set_uri (msg, uri); soup_uri_free (uri); soup_session_send_message (session, msg); - if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { - debug_printf (1, " Message did not get authenticated!\n"); - errors++; - } + soup_test_assert_message_status (msg, SOUP_STATUS_OK); ensure_no_signal_handlers (msg, signal_ids, n_signal_ids); /* One last try to make sure the auth stuff got cleaned up */ @@ -466,79 +379,12 @@ do_msg_reuse_test (void) g_free (signal_ids); } -/* Server handlers for "*" work but are separate from handlers for - * all other URIs. #590751 - */ -static void -do_star_test (void) -{ - SoupSession *session; - SoupMessage *msg; - SoupURI *star_uri; - const char *handled_by; - - debug_printf (1, "\nOPTIONS *\n"); - - session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); - star_uri = soup_uri_copy (base_uri); - soup_uri_set_path (star_uri, "*"); - - debug_printf (1, " Testing with no handler\n"); - msg = soup_message_new_from_uri ("OPTIONS", star_uri); - soup_session_send_message (session, msg); - - if (msg->status_code != SOUP_STATUS_NOT_FOUND) { - debug_printf (1, " Unexpected response: %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } - handled_by = soup_message_headers_get_one (msg->response_headers, - "X-Handled-By"); - if (handled_by) { - /* Should have been rejected by SoupServer directly */ - debug_printf (1, " Message reached handler '%s'\n", - handled_by); - errors++; - } - g_object_unref (msg); - - soup_server_add_handler (server, "*", server_star_callback, NULL, NULL); - - debug_printf (1, " Testing with handler\n"); - msg = soup_message_new_from_uri ("OPTIONS", star_uri); - soup_session_send_message (session, msg); - - if (msg->status_code != SOUP_STATUS_OK) { - debug_printf (1, " Unexpected response: %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } - handled_by = soup_message_headers_get_one (msg->response_headers, - "X-Handled-By"); - if (!handled_by) { - debug_printf (1, " Message did not reach handler!\n"); - errors++; - } else if (strcmp (handled_by, "star_callback") != 0) { - debug_printf (1, " Message reached incorrect handler '%s'\n", - handled_by); - errors++; - } - g_object_unref (msg); - - soup_test_session_abort_unref (session); - soup_uri_free (star_uri); -} - -/* Handle unexpectedly-early aborts. #596074, #618641 */ +/* Handle unexpectedly-early aborts. */ static void ea_msg_completed_one (SoupSession *session, SoupMessage *msg, gpointer loop) { debug_printf (2, " Message 1 completed\n"); - if (msg->status_code != SOUP_STATUS_CANCELLED) { - debug_printf (1, " Unexpected status on Message 1: %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } + soup_test_assert_message_status (msg, SOUP_STATUS_CANCELLED); g_main_loop_quit (loop); } @@ -585,7 +431,8 @@ do_early_abort_test (void) GMainContext *context; GMainLoop *loop; - debug_printf (1, "\nAbort with pending connection (msg api)\n"); + g_test_bug ("596074"); + g_test_bug ("618641"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); msg = soup_message_new_from_uri ("GET", base_uri); @@ -609,11 +456,7 @@ do_early_abort_test (void) soup_session_send_message (session, msg); debug_printf (2, " Message 2 completed\n"); - if (msg->status_code != SOUP_STATUS_CANCELLED) { - debug_printf (1, " Unexpected response: %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } + soup_test_assert_message_status (msg, SOUP_STATUS_CANCELLED); g_object_unref (msg); while (g_main_context_pending (context)) @@ -621,6 +464,8 @@ do_early_abort_test (void) soup_test_session_abort_unref (session); + g_test_bug ("668098"); + session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); msg = soup_message_new_from_uri ("GET", base_uri); @@ -629,11 +474,7 @@ do_early_abort_test (void) soup_session_send_message (session, msg); debug_printf (2, " Message 3 completed\n"); - if (msg->status_code != SOUP_STATUS_CANCELLED) { - debug_printf (1, " Unexpected response: %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } + soup_test_assert_message_status (msg, SOUP_STATUS_CANCELLED); g_object_unref (msg); while (g_main_context_pending (context)) @@ -648,14 +489,8 @@ ear_one_completed (GObject *source, GAsyncResult *result, gpointer user_data) GError *error = NULL; debug_printf (2, " Request 1 completed\n"); - if (soup_request_send_finish (SOUP_REQUEST (source), result, &error)) { - debug_printf (1, " Request 1 succeeded?\n"); - errors++; - } else if (!g_error_matches (error, SOUP_HTTP_ERROR, SOUP_STATUS_CANCELLED)) { - debug_printf (1, " Unexpected error on Request 1: %s\n", - error->message); - errors++; - } + soup_request_send_finish (SOUP_REQUEST (source), result, &error); + g_assert_error (error, SOUP_HTTP_ERROR, SOUP_STATUS_CANCELLED); g_clear_error (&error); } @@ -665,14 +500,8 @@ ear_two_completed (GObject *source, GAsyncResult *result, gpointer loop) GError *error = NULL; debug_printf (2, " Request 2 completed\n"); - if (soup_request_send_finish (SOUP_REQUEST (source), result, &error)) { - debug_printf (1, " Request 2 succeeded?\n"); - errors++; - } else if (!g_error_matches (error, SOUP_HTTP_ERROR, SOUP_STATUS_CANCELLED)) { - debug_printf (1, " Unexpected error on Request 2: %s\n", - error->message); - errors++; - } + soup_request_send_finish (SOUP_REQUEST (source), result, &error); + g_assert_error (error, SOUP_HTTP_ERROR, SOUP_STATUS_CANCELLED); g_clear_error (&error); g_main_loop_quit (loop); @@ -684,14 +513,8 @@ ear_three_completed (GObject *source, GAsyncResult *result, gpointer loop) GError *error = NULL; debug_printf (2, " Request 3 completed\n"); - if (soup_request_send_finish (SOUP_REQUEST (source), result, &error)) { - debug_printf (1, " Request 3 succeeded?\n"); - errors++; - } else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { - debug_printf (1, " Unexpected error on Request 3: %s\n", - error->message); - errors++; - } + soup_request_send_finish (SOUP_REQUEST (source), result, &error); + g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED); g_clear_error (&error); g_main_loop_quit (loop); @@ -708,20 +531,15 @@ static void do_early_abort_req_test (void) { SoupSession *session; - SoupRequester *requester; SoupRequest *req; GMainContext *context; GMainLoop *loop; GCancellable *cancellable; - debug_printf (1, "\nAbort with pending connection (request api)\n"); - session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, - SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER, SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, NULL); - requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER); - req = soup_requester_request_uri (requester, base_uri, NULL); + req = soup_session_request_uri (session, base_uri, NULL); context = g_main_context_default (); loop = g_main_loop_new (context, TRUE); @@ -735,11 +553,9 @@ do_early_abort_req_test (void) soup_test_session_abort_unref (session); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, - SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER, SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, NULL); - requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER); - req = soup_requester_request_uri (requester, base_uri, NULL); + req = soup_session_request_uri (session, base_uri, NULL); g_signal_connect (session, "connection-created", G_CALLBACK (ea_connection_created), NULL); @@ -753,11 +569,9 @@ do_early_abort_req_test (void) soup_test_session_abort_unref (session); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, - SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER, SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, NULL); - requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER); - req = soup_requester_request_uri (requester, base_uri, NULL); + req = soup_session_request_uri (session, base_uri, NULL); cancellable = g_cancellable_new (); g_signal_connect (session, "request-started", @@ -790,21 +604,10 @@ do_one_accept_language_test (const char *language, const char *expected_header) soup_session_send_message (session, msg); soup_test_session_abort_unref (session); - if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { - debug_printf (1, " Message failed? %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } + soup_test_assert_message_status (msg, SOUP_STATUS_OK); val = soup_message_headers_get_list (msg->request_headers, "Accept-Language"); - if (!val) { - debug_printf (1, " No Accept-Language set!\n"); - errors++; - } else if (strcmp (val, expected_header) != 0) { - debug_printf (1, " Wrong Accept-Language: expected '%s', got '%s'\n", - expected_header, val); - errors++; - } + g_assert_cmpstr (val, ==, expected_header); g_object_unref (msg); } @@ -814,7 +617,7 @@ do_accept_language_test (void) { const char *orig_language; - debug_printf (1, "\nAutomatic Accept-Language processing\n"); + g_test_bug ("602547"); orig_language = g_getenv ("LANGUAGE"); do_one_accept_language_test ("C", "en"); @@ -887,11 +690,7 @@ do_cancel_while_reading_test_for_session (SoupSession *session) while (!done) g_main_context_iteration (NULL, TRUE); - if (msg->status_code != SOUP_STATUS_CANCELLED) { - debug_printf (1, " FAILED: %d %s (expected Cancelled)\n", - msg->status_code, msg->reason_phrase); - errors++; - } + soup_test_assert_message_status (msg, SOUP_STATUS_CANCELLED); g_object_unref (msg); if (thread) @@ -903,7 +702,8 @@ do_cancel_while_reading_test (void) { SoupSession *session; - debug_printf (1, "\nCancelling message while reading response (msg api)\n"); + g_test_bug ("637741"); + g_test_bug ("676038"); debug_printf (1, " Async session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); @@ -916,23 +716,9 @@ do_cancel_while_reading_test (void) soup_test_session_abort_unref (session); } -static gboolean -cancel_request_timeout (gpointer cancellable) -{ - g_cancellable_cancel (cancellable); - return FALSE; -} - -static gpointer -cancel_request_thread (gpointer cancellable) -{ - g_usleep (100000); /* .1s */ - g_cancellable_cancel (cancellable); - return NULL; -} - static void -do_cancel_while_reading_req_test_for_session (SoupRequester *requester) +do_cancel_while_reading_req_test_for_session (SoupSession *session, + guint flags) { SoupRequest *req; SoupURI *uri; @@ -940,30 +726,12 @@ do_cancel_while_reading_req_test_for_session (SoupRequester *requester) GError *error = NULL; uri = soup_uri_new_with_base (base_uri, "/slow"); - req = soup_requester_request_uri (requester, uri, NULL); + req = soup_session_request_uri (session, uri, NULL); soup_uri_free (uri); cancellable = g_cancellable_new (); - - if (SOUP_IS_SESSION_ASYNC (soup_request_get_session (req))) { - g_timeout_add (100, cancel_request_timeout, cancellable); - soup_test_request_send_async_as_sync (req, cancellable, &error); - } else { - GThread *thread; - - thread = g_thread_new ("cancel_request_thread", cancel_request_thread, cancellable); - soup_request_send (req, cancellable, &error); - g_thread_unref (thread); - } - - if (!error) { - debug_printf (1, " Request succeeded?\n"); - errors++; - } else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { - debug_printf (1, " Unexpected error: %s\n", - error->message); - errors++; - } + soup_test_request_send (req, cancellable, flags, &error); + g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED); g_clear_error (&error); g_object_unref (req); @@ -971,169 +739,128 @@ do_cancel_while_reading_req_test_for_session (SoupRequester *requester) } static void -do_cancel_while_reading_req_test (void) +do_cancel_while_reading_immediate_req_test (void) { SoupSession *session; - SoupRequester *requester; + guint flags; - debug_printf (1, "\nCancelling message while reading response (request api)\n"); + g_test_bug ("692310"); + + flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE; debug_printf (1, " Async session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, - SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER, SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, NULL); - requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER); - do_cancel_while_reading_req_test_for_session (requester); + do_cancel_while_reading_req_test_for_session (session, flags); soup_test_session_abort_unref (session); debug_printf (1, " Sync session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, - SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER, NULL); - requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER); - do_cancel_while_reading_req_test_for_session (requester); + do_cancel_while_reading_req_test_for_session (session, flags); soup_test_session_abort_unref (session); } static void -do_aliases_test_for_session (SoupSession *session, - const char *redirect_protocol) +do_cancel_while_reading_delayed_req_test (void) { - SoupMessage *msg; - SoupURI *uri; - const char *redirected_protocol; - - uri = soup_uri_new_with_base (base_uri, "/alias-redirect"); - msg = soup_message_new_from_uri ("GET", uri); - if (redirect_protocol) - soup_message_headers_append (msg->request_headers, "X-Redirect-Protocol", redirect_protocol); - soup_uri_free (uri); - soup_session_send_message (session, msg); + SoupSession *session; + guint flags; - redirected_protocol = soup_message_headers_get_one (msg->response_headers, "X-Redirected-Protocol"); + flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_SOON; - if (g_strcmp0 (redirect_protocol, redirected_protocol)) { - debug_printf (1, " redirect went to %s, should have gone to %s!\n", - redirected_protocol ? redirected_protocol : "(none)", - redirect_protocol ? redirect_protocol : "(none)"); - errors++; - } else if (redirect_protocol && !SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { - debug_printf (1, " msg failed? (%d %s)\n", - msg->status_code, msg->reason_phrase); - errors++; - } else if (!redirect_protocol && SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { - debug_printf (1, " msg succeeded? (%d %s)\n", - msg->status_code, msg->reason_phrase); - errors++; - } + debug_printf (1, " Async session\n"); + session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, + SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, + NULL); + do_cancel_while_reading_req_test_for_session (session, flags); + soup_test_session_abort_unref (session); - g_object_unref (msg); + debug_printf (1, " Sync session\n"); + session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, + NULL); + do_cancel_while_reading_req_test_for_session (session, flags); + soup_test_session_abort_unref (session); } static void -do_aliases_test (void) +do_cancel_while_reading_preemptive_req_test (void) { SoupSession *session; - char *aliases[] = { "foo", NULL }; + guint flags; - debug_printf (1, "\nhttp-aliases / https-aliases\n"); + g_test_bug ("637039"); - debug_printf (1, " Default behavior\n"); - session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); - do_aliases_test_for_session (session, "http"); - soup_test_session_abort_unref (session); + flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_PREEMPTIVE; - debug_printf (1, " foo-means-https\n"); + debug_printf (1, " Async session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, - SOUP_SESSION_HTTPS_ALIASES, aliases, + SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, NULL); - do_aliases_test_for_session (session, "https"); + do_cancel_while_reading_req_test_for_session (session, flags); soup_test_session_abort_unref (session); - debug_printf (1, " foo-means-nothing\n"); - session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, - SOUP_SESSION_HTTP_ALIASES, NULL, + debug_printf (1, " Sync session\n"); + session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); - do_aliases_test_for_session (session, NULL); + do_cancel_while_reading_req_test_for_session (session, flags); soup_test_session_abort_unref (session); } static void -do_dot_dot_test (void) +do_aliases_test_for_session (SoupSession *session, + const char *redirect_protocol) { - SoupSession *session; SoupMessage *msg; SoupURI *uri; + const char *redirected_protocol; - debug_printf (1, "\n'..' smuggling test\n"); - - session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); - - uri = soup_uri_new_with_base (base_uri, "/..%2ftest"); + uri = soup_uri_new_with_base (base_uri, "/alias-redirect"); msg = soup_message_new_from_uri ("GET", uri); + if (redirect_protocol) + soup_message_headers_append (msg->request_headers, "X-Redirect-Protocol", redirect_protocol); soup_uri_free (uri); - soup_session_send_message (session, msg); - if (msg->status_code != SOUP_STATUS_BAD_REQUEST) { - debug_printf (1, " FAILED: %d %s (expected Bad Request)\n", - msg->status_code, msg->reason_phrase); - errors++; - } - g_object_unref (msg); + redirected_protocol = soup_message_headers_get_one (msg->response_headers, "X-Redirected-Protocol"); - soup_test_session_abort_unref (session); + g_assert_cmpstr (redirect_protocol, ==, redirected_protocol); + if (redirect_protocol) + soup_test_assert_message_status (msg, SOUP_STATUS_OK); + else + soup_test_assert_message_status (msg, SOUP_STATUS_FOUND); + + g_object_unref (msg); } static void -do_ipv6_test (void) +do_aliases_test (void) { - SoupServer *ipv6_server; - SoupURI *ipv6_uri; - SoupAddress *ipv6_addr; SoupSession *session; - SoupMessage *msg; - - debug_printf (1, "\nIPv6 server test\n"); - - ipv6_addr = soup_address_new ("::1", SOUP_ADDRESS_ANY_PORT); - soup_address_resolve_sync (ipv6_addr, NULL); - ipv6_server = soup_server_new (SOUP_SERVER_INTERFACE, ipv6_addr, - NULL); - g_object_unref (ipv6_addr); - soup_server_add_handler (ipv6_server, NULL, server_callback, NULL, NULL); - soup_server_run_async (ipv6_server); - - ipv6_uri = soup_uri_new ("http://[::1]/"); - soup_uri_set_port (ipv6_uri, soup_server_get_port (ipv6_server)); + char *aliases[] = { "foo", NULL }; + debug_printf (1, " Default behavior\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); + do_aliases_test_for_session (session, "http"); + soup_test_session_abort_unref (session); - debug_printf (1, " HTTP/1.1\n"); - msg = soup_message_new_from_uri ("GET", ipv6_uri); - soup_session_send_message (session, msg); - if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { - debug_printf (1, " request failed: %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } - g_object_unref (msg); - - debug_printf (1, " HTTP/1.0\n"); - msg = soup_message_new_from_uri ("GET", ipv6_uri); - soup_message_set_http_version (msg, SOUP_HTTP_1_0); - soup_session_send_message (session, msg); - if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { - debug_printf (1, " request failed: %d %s\n", - msg->status_code, msg->reason_phrase); - errors++; - } - g_object_unref (msg); + if (tls_available) { + debug_printf (1, " foo-means-https\n"); + session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, + SOUP_SESSION_HTTPS_ALIASES, aliases, + NULL); + do_aliases_test_for_session (session, "https"); + soup_test_session_abort_unref (session); + } else + debug_printf (1, " foo-means-https -- SKIPPING\n"); - soup_uri_free (ipv6_uri); + debug_printf (1, " foo-means-nothing\n"); + session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, + SOUP_SESSION_HTTP_ALIASES, NULL, + NULL); + do_aliases_test_for_session (session, NULL); soup_test_session_abort_unref (session); - soup_test_server_quit_unref (ipv6_server); } static void @@ -1143,7 +870,7 @@ do_idle_on_dispose_test (void) SoupMessage *msg; GMainContext *async_context; - debug_printf (1, "\nTesting SoupSessionAsync dispose behavior\n"); + g_test_bug ("667364"); async_context = g_main_context_new (); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, @@ -1159,10 +886,8 @@ do_idle_on_dispose_test (void) g_object_run_dispose (G_OBJECT (session)); - if (g_main_context_iteration (async_context, FALSE)) { - debug_printf (1, " idle was queued!\n"); - errors++; - } + if (g_main_context_iteration (async_context, FALSE)) + soup_test_assert (FALSE, "idle was queued"); g_object_unref (session); g_main_context_unref (async_context); @@ -1175,7 +900,7 @@ do_pause_abort_test (void) SoupMessage *msg; gpointer ptr; - debug_printf (1, "\nTesting paused messages don't get leaked on abort\n"); + g_test_bug ("673905"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); @@ -1186,16 +911,14 @@ do_pause_abort_test (void) g_object_add_weak_pointer (G_OBJECT (msg), &ptr); soup_test_session_abort_unref (session); - if (ptr) { - debug_printf (1, " msg was leaked\n"); - errors++; - } + g_assert_null (ptr); } int main (int argc, char **argv) { SoupAuthDomain *auth_domain; + int ret; test_init (argc, argv, NULL); @@ -1212,32 +935,37 @@ main (int argc, char **argv) soup_server_add_auth_domain (server, auth_domain); g_object_unref (auth_domain); - ssl_server = soup_test_server_new_ssl (TRUE); - soup_server_add_handler (ssl_server, NULL, server_callback, "https", NULL); - ssl_base_uri = soup_uri_new ("https://127.0.0.1/"); - soup_uri_set_port (ssl_base_uri, soup_server_get_port (ssl_server)); - - do_host_test (); - do_callback_unref_test (); - do_callback_unref_req_test (); - do_msg_reuse_test (); - do_star_test (); - do_early_abort_test (); - do_early_abort_req_test (); - do_accept_language_test (); - do_cancel_while_reading_test (); - do_cancel_while_reading_req_test (); - do_aliases_test (); - do_dot_dot_test (); - do_ipv6_test (); - do_idle_on_dispose_test (); - do_pause_abort_test (); + if (tls_available) { + ssl_server = soup_test_server_new_ssl (TRUE); + soup_server_add_handler (ssl_server, NULL, server_callback, "https", NULL); + ssl_base_uri = soup_uri_new ("https://127.0.0.1/"); + soup_uri_set_port (ssl_base_uri, soup_server_get_port (ssl_server)); + } + + g_test_add_func ("/misc/host", do_host_test); + g_test_add_func ("/misc/callback-unref/msg", do_callback_unref_test); + g_test_add_func ("/misc/callback-unref/req", do_callback_unref_req_test); + g_test_add_func ("/misc/msg-reuse", do_msg_reuse_test); + g_test_add_func ("/misc/early-abort/msg", do_early_abort_test); + g_test_add_func ("/misc/early-abort/req", do_early_abort_req_test); + g_test_add_func ("/misc/accept-language", do_accept_language_test); + g_test_add_func ("/misc/cancel-while-reading/msg", do_cancel_while_reading_test); + g_test_add_func ("/misc/cancel-while-reading/req/immediate", do_cancel_while_reading_immediate_req_test); + g_test_add_func ("/misc/cancel-while-reading/req/delayed", do_cancel_while_reading_delayed_req_test); + g_test_add_func ("/misc/cancel-while-reading/req/preemptive", do_cancel_while_reading_preemptive_req_test); + g_test_add_func ("/misc/aliases", do_aliases_test); + g_test_add_func ("/misc/idle-on-dispose", do_idle_on_dispose_test); + g_test_add_func ("/misc/pause-abort", do_pause_abort_test); + + ret = g_test_run (); soup_uri_free (base_uri); - soup_uri_free (ssl_base_uri); soup_test_server_quit_unref (server); - soup_test_server_quit_unref (ssl_server); - test_cleanup (); - return errors != 0; + if (tls_available) { + soup_uri_free (ssl_base_uri); + soup_test_server_quit_unref (ssl_server); + } + + return ret; } |