1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
3 * Copyright 2007-2012 Red Hat, Inc.
6 #include "test-utils.h"
8 SoupServer *server, *ssl_server;
9 SoupURI *base_uri, *ssl_base_uri;
12 auth_callback (SoupAuthDomain *auth_domain, SoupMessage *msg,
13 const char *username, const char *password, gpointer data)
15 return !strcmp (username, "user") && !strcmp (password, "password");
19 timeout_finish_message (gpointer msg)
21 SoupServer *server = g_object_get_data (G_OBJECT (msg), "server");
23 soup_server_unpause_message (server, msg);
28 server_callback (SoupServer *server, SoupMessage *msg,
29 const char *path, GHashTable *query,
30 SoupClientContext *context, gpointer data)
32 SoupURI *uri = soup_message_get_uri (msg);
33 const char *server_protocol = data;
35 if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_POST) {
36 soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
40 if (!strcmp (path, "/redirect")) {
41 soup_message_set_redirect (msg, SOUP_STATUS_FOUND, "/");
45 if (!strcmp (path, "/alias-redirect")) {
46 SoupURI *redirect_uri;
47 char *redirect_string;
48 const char *redirect_protocol;
50 redirect_protocol = soup_message_headers_get_one (msg->request_headers, "X-Redirect-Protocol");
52 redirect_uri = soup_uri_copy (uri);
53 soup_uri_set_scheme (redirect_uri, "foo");
54 if (!g_strcmp0 (redirect_protocol, "https"))
55 soup_uri_set_port (redirect_uri, ssl_base_uri->port);
57 soup_uri_set_port (redirect_uri, base_uri->port);
58 soup_uri_set_path (redirect_uri, "/alias-redirected");
59 redirect_string = soup_uri_to_string (redirect_uri, FALSE);
61 soup_message_set_redirect (msg, SOUP_STATUS_FOUND, redirect_string);
62 g_free (redirect_string);
63 soup_uri_free (redirect_uri);
65 } else if (!strcmp (path, "/alias-redirected")) {
66 soup_message_set_status (msg, SOUP_STATUS_OK);
67 soup_message_headers_append (msg->response_headers,
68 "X-Redirected-Protocol",
73 if (!strcmp (path, "/slow")) {
74 soup_server_pause_message (server, msg);
75 g_object_set_data (G_OBJECT (msg), "server", server);
76 soup_add_timeout (soup_server_get_async_context (server),
77 1000, timeout_finish_message, msg);
80 soup_message_set_status (msg, SOUP_STATUS_OK);
81 if (!strcmp (uri->host, "foo")) {
82 soup_message_set_response (msg, "text/plain",
83 SOUP_MEMORY_STATIC, "foo-index", 9);
86 soup_message_set_response (msg, "text/plain",
87 SOUP_MEMORY_STATIC, "index", 5);
92 /* Host header handling: client must be able to override the default
93 * value, server must be able to recognize different Host values.
99 SoupMessage *one, *two;
101 g_test_bug ("539803");
103 session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
105 one = soup_message_new_from_uri ("GET", base_uri);
106 two = soup_message_new_from_uri ("GET", base_uri);
107 soup_message_headers_replace (two->request_headers, "Host", "foo");
109 soup_session_send_message (session, one);
110 soup_session_send_message (session, two);
112 soup_test_session_abort_unref (session);
114 soup_test_assert_message_status (one, SOUP_STATUS_OK);
115 g_assert_cmpstr (one->response_body->data, ==, "index");
116 g_object_unref (one);
118 soup_test_assert_message_status (two, SOUP_STATUS_OK);
119 g_assert_cmpstr (two->response_body->data, ==, "foo-index");
120 g_object_unref (two);
123 /* Dropping the application's ref on the session from a callback
124 * should not cause the session to be freed at an incorrect time.
125 * (This test will crash if it fails.)
128 cu_one_completed (SoupSession *session, SoupMessage *msg, gpointer loop)
130 debug_printf (2, " Message 1 completed\n");
131 soup_test_assert_message_status (msg, SOUP_STATUS_CANT_CONNECT);
132 g_object_unref (session);
136 cu_idle_quit (gpointer loop)
138 g_main_loop_quit (loop);
143 cu_two_completed (SoupSession *session, SoupMessage *msg, gpointer loop)
145 debug_printf (2, " Message 2 completed\n");
146 soup_test_assert_message_status (msg, SOUP_STATUS_CANT_CONNECT);
147 g_idle_add (cu_idle_quit, loop);
151 do_callback_unref_test (void)
153 SoupServer *bad_server;
155 SoupSession *session;
156 SoupMessage *one, *two;
160 g_test_bug ("533473");
162 /* Get a guaranteed-bad URI */
163 addr = soup_address_new ("127.0.0.1", SOUP_ADDRESS_ANY_PORT);
164 soup_address_resolve_sync (addr, NULL);
165 bad_server = soup_server_new (SOUP_SERVER_INTERFACE, addr,
167 g_object_unref (addr);
169 bad_uri = g_strdup_printf ("http://127.0.0.1:%u/",
170 soup_server_get_port (bad_server));
171 g_object_unref (bad_server);
173 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
174 g_object_add_weak_pointer (G_OBJECT (session), (gpointer *)&session);
176 loop = g_main_loop_new (NULL, TRUE);
178 one = soup_message_new ("GET", bad_uri);
179 g_object_add_weak_pointer (G_OBJECT (one), (gpointer *)&one);
180 two = soup_message_new ("GET", bad_uri);
181 g_object_add_weak_pointer (G_OBJECT (two), (gpointer *)&two);
184 soup_session_queue_message (session, one, cu_one_completed, loop);
185 soup_session_queue_message (session, two, cu_two_completed, loop);
187 g_main_loop_run (loop);
188 g_main_loop_unref (loop);
190 g_assert_null (session);
192 g_object_remove_weak_pointer (G_OBJECT (session), (gpointer *)&session);
193 g_object_unref (session);
197 g_object_remove_weak_pointer (G_OBJECT (one), (gpointer *)&one);
198 g_object_unref (one);
202 g_object_remove_weak_pointer (G_OBJECT (two), (gpointer *)&two);
203 g_object_unref (two);
206 /* Otherwise, if we haven't crashed, we're ok. */
210 cur_one_completed (GObject *source, GAsyncResult *result, gpointer session)
212 SoupRequest *one = SOUP_REQUEST (source);
213 GError *error = NULL;
215 debug_printf (2, " Request 1 completed\n");
216 soup_request_send_finish (one, result, &error);
217 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_REFUSED);
218 g_clear_error (&error);
220 g_object_unref (session);
224 cur_idle_quit (gpointer loop)
226 g_main_loop_quit (loop);
231 cur_two_completed (GObject *source, GAsyncResult *result, gpointer loop)
233 SoupRequest *two = SOUP_REQUEST (source);
234 GError *error = NULL;
236 debug_printf (2, " Request 2 completed\n");
237 soup_request_send_finish (two, result, &error);
238 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_REFUSED);
239 g_clear_error (&error);
241 g_idle_add (cur_idle_quit, loop);
245 do_callback_unref_req_test (void)
247 SoupServer *bad_server;
249 SoupSession *session;
250 SoupRequest *one, *two;
254 /* Get a guaranteed-bad URI */
255 addr = soup_address_new ("127.0.0.1", SOUP_ADDRESS_ANY_PORT);
256 soup_address_resolve_sync (addr, NULL);
257 bad_server = soup_server_new (SOUP_SERVER_INTERFACE, addr,
259 g_object_unref (addr);
261 bad_uri = g_strdup_printf ("http://127.0.0.1:%u/",
262 soup_server_get_port (bad_server));
263 g_object_unref (bad_server);
265 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
266 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
268 g_object_add_weak_pointer (G_OBJECT (session), (gpointer *)&session);
270 loop = g_main_loop_new (NULL, TRUE);
272 one = soup_session_request (session, bad_uri, NULL);
273 g_object_add_weak_pointer (G_OBJECT (one), (gpointer *)&one);
274 two = soup_session_request (session, bad_uri, NULL);
275 g_object_add_weak_pointer (G_OBJECT (two), (gpointer *)&two);
278 soup_request_send_async (one, NULL, cur_one_completed, session);
279 g_object_unref (one);
280 soup_request_send_async (two, NULL, cur_two_completed, loop);
281 g_object_unref (two);
283 g_main_loop_run (loop);
284 g_main_loop_unref (loop);
286 g_assert_null (session);
288 g_object_remove_weak_pointer (G_OBJECT (session), (gpointer *)&session);
289 g_object_unref (session);
293 g_object_remove_weak_pointer (G_OBJECT (one), (gpointer *)&one);
294 g_object_unref (one);
298 g_object_remove_weak_pointer (G_OBJECT (two), (gpointer *)&two);
299 g_object_unref (two);
302 /* Otherwise, if we haven't crashed, we're ok. */
305 /* SoupSession should clean up all signal handlers on a message after
306 * it is finished, allowing the message to be reused if desired.
309 ensure_no_signal_handlers (SoupMessage *msg, guint *signal_ids, guint n_signal_ids)
314 for (i = 0; i < n_signal_ids; i++) {
315 id = g_signal_handler_find (msg, G_SIGNAL_MATCH_ID, signal_ids[i],
316 0, NULL, NULL, NULL);
317 soup_test_assert (id == 0,
318 "message has handler for '%s'",
319 g_signal_name (signal_ids[i]));
324 reuse_test_authenticate (SoupSession *session, SoupMessage *msg,
325 SoupAuth *auth, gboolean retrying)
327 /* Get it wrong the first time, then succeed */
329 soup_auth_authenticate (auth, "user", "wrong password");
331 soup_auth_authenticate (auth, "user", "password");
335 do_msg_reuse_test (void)
337 SoupSession *session;
340 guint *signal_ids, n_signal_ids;
342 g_test_bug ("559054");
344 signal_ids = g_signal_list_ids (SOUP_TYPE_MESSAGE, &n_signal_ids);
346 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
347 g_signal_connect (session, "authenticate",
348 G_CALLBACK (reuse_test_authenticate), NULL);
350 debug_printf (1, " First message\n");
351 msg = soup_message_new_from_uri ("GET", base_uri);
352 soup_session_send_message (session, msg);
353 ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
355 debug_printf (1, " Redirect message\n");
356 uri = soup_uri_new_with_base (base_uri, "/redirect");
357 soup_message_set_uri (msg, uri);
359 soup_session_send_message (session, msg);
360 g_assert_true (soup_uri_equal (soup_message_get_uri (msg), base_uri));
361 ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
363 debug_printf (1, " Auth message\n");
364 uri = soup_uri_new_with_base (base_uri, "/auth");
365 soup_message_set_uri (msg, uri);
367 soup_session_send_message (session, msg);
368 soup_test_assert_message_status (msg, SOUP_STATUS_OK);
369 ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
371 /* One last try to make sure the auth stuff got cleaned up */
372 debug_printf (1, " Last message\n");
373 soup_message_set_uri (msg, base_uri);
374 soup_session_send_message (session, msg);
375 ensure_no_signal_handlers (msg, signal_ids, n_signal_ids);
377 soup_test_session_abort_unref (session);
378 g_object_unref (msg);
382 /* Handle unexpectedly-early aborts. */
384 ea_msg_completed_one (SoupSession *session, SoupMessage *msg, gpointer loop)
386 debug_printf (2, " Message 1 completed\n");
387 soup_test_assert_message_status (msg, SOUP_STATUS_CANCELLED);
388 g_main_loop_quit (loop);
392 ea_abort_session (gpointer session)
394 soup_session_abort (session);
399 ea_connection_state_changed (GObject *conn, GParamSpec *pspec, gpointer session)
401 SoupConnectionState state;
403 g_object_get (conn, "state", &state, NULL);
404 if (state == SOUP_CONNECTION_CONNECTING) {
405 g_idle_add_full (G_PRIORITY_HIGH,
408 g_signal_handlers_disconnect_by_func (conn, ea_connection_state_changed, session);
413 ea_connection_created (SoupSession *session, GObject *conn, gpointer user_data)
415 g_signal_connect (conn, "notify::state",
416 G_CALLBACK (ea_connection_state_changed), session);
417 g_signal_handlers_disconnect_by_func (session, ea_connection_created, user_data);
421 ea_request_started (SoupSession *session, SoupMessage *msg, SoupSocket *socket, gpointer user_data)
423 soup_session_cancel_message (session, msg, SOUP_STATUS_CANCELLED);
427 do_early_abort_test (void)
429 SoupSession *session;
431 GMainContext *context;
434 g_test_bug ("596074");
435 g_test_bug ("618641");
437 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
438 msg = soup_message_new_from_uri ("GET", base_uri);
440 context = g_main_context_default ();
441 loop = g_main_loop_new (context, TRUE);
442 soup_session_queue_message (session, msg, ea_msg_completed_one, loop);
443 g_main_context_iteration (context, FALSE);
445 soup_session_abort (session);
446 while (g_main_context_pending (context))
447 g_main_context_iteration (context, FALSE);
448 g_main_loop_unref (loop);
449 soup_test_session_abort_unref (session);
451 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
452 msg = soup_message_new_from_uri ("GET", base_uri);
454 g_signal_connect (session, "connection-created",
455 G_CALLBACK (ea_connection_created), NULL);
456 soup_session_send_message (session, msg);
457 debug_printf (2, " Message 2 completed\n");
459 soup_test_assert_message_status (msg, SOUP_STATUS_CANCELLED);
460 g_object_unref (msg);
462 while (g_main_context_pending (context))
463 g_main_context_iteration (context, FALSE);
465 soup_test_session_abort_unref (session);
467 g_test_bug ("668098");
469 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
470 msg = soup_message_new_from_uri ("GET", base_uri);
472 g_signal_connect (session, "request-started",
473 G_CALLBACK (ea_request_started), NULL);
474 soup_session_send_message (session, msg);
475 debug_printf (2, " Message 3 completed\n");
477 soup_test_assert_message_status (msg, SOUP_STATUS_CANCELLED);
478 g_object_unref (msg);
480 while (g_main_context_pending (context))
481 g_main_context_iteration (context, FALSE);
483 soup_test_session_abort_unref (session);
487 ear_one_completed (GObject *source, GAsyncResult *result, gpointer user_data)
489 GError *error = NULL;
491 debug_printf (2, " Request 1 completed\n");
492 soup_request_send_finish (SOUP_REQUEST (source), result, &error);
493 g_assert_error (error, SOUP_HTTP_ERROR, SOUP_STATUS_CANCELLED);
494 g_clear_error (&error);
498 ear_two_completed (GObject *source, GAsyncResult *result, gpointer loop)
500 GError *error = NULL;
502 debug_printf (2, " Request 2 completed\n");
503 soup_request_send_finish (SOUP_REQUEST (source), result, &error);
504 g_assert_error (error, SOUP_HTTP_ERROR, SOUP_STATUS_CANCELLED);
505 g_clear_error (&error);
507 g_main_loop_quit (loop);
511 ear_three_completed (GObject *source, GAsyncResult *result, gpointer loop)
513 GError *error = NULL;
515 debug_printf (2, " Request 3 completed\n");
516 soup_request_send_finish (SOUP_REQUEST (source), result, &error);
517 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
518 g_clear_error (&error);
520 g_main_loop_quit (loop);
524 ear_request_started (SoupSession *session, SoupMessage *msg,
525 SoupSocket *socket, gpointer cancellable)
527 g_cancellable_cancel (cancellable);
531 do_early_abort_req_test (void)
533 SoupSession *session;
535 GMainContext *context;
537 GCancellable *cancellable;
539 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
540 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
542 req = soup_session_request_uri (session, base_uri, NULL);
544 context = g_main_context_default ();
545 loop = g_main_loop_new (context, TRUE);
546 soup_request_send_async (req, NULL, ear_one_completed, NULL);
547 g_object_unref (req);
548 g_main_context_iteration (context, FALSE);
550 soup_session_abort (session);
551 while (g_main_context_pending (context))
552 g_main_context_iteration (context, FALSE);
553 soup_test_session_abort_unref (session);
555 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
556 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
558 req = soup_session_request_uri (session, base_uri, NULL);
560 g_signal_connect (session, "connection-created",
561 G_CALLBACK (ea_connection_created), NULL);
562 soup_request_send_async (req, NULL, ear_two_completed, loop);
563 g_main_loop_run (loop);
564 g_object_unref (req);
566 while (g_main_context_pending (context))
567 g_main_context_iteration (context, FALSE);
569 soup_test_session_abort_unref (session);
571 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
572 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
574 req = soup_session_request_uri (session, base_uri, NULL);
576 cancellable = g_cancellable_new ();
577 g_signal_connect (session, "request-started",
578 G_CALLBACK (ear_request_started), cancellable);
579 soup_request_send_async (req, cancellable, ear_three_completed, loop);
580 g_main_loop_run (loop);
581 g_object_unref (req);
582 g_object_unref (cancellable);
584 while (g_main_context_pending (context))
585 g_main_context_iteration (context, FALSE);
587 soup_test_session_abort_unref (session);
588 g_main_loop_unref (loop);
592 do_one_accept_language_test (const char *language, const char *expected_header)
594 SoupSession *session;
598 debug_printf (1, " LANGUAGE=%s\n", language);
599 g_setenv ("LANGUAGE", language, TRUE);
600 session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,
601 SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE,
603 msg = soup_message_new_from_uri ("GET", base_uri);
604 soup_session_send_message (session, msg);
605 soup_test_session_abort_unref (session);
607 soup_test_assert_message_status (msg, SOUP_STATUS_OK);
608 val = soup_message_headers_get_list (msg->request_headers,
610 g_assert_cmpstr (val, ==, expected_header);
612 g_object_unref (msg);
616 do_accept_language_test (void)
618 const char *orig_language;
620 g_test_bug ("602547");
622 orig_language = g_getenv ("LANGUAGE");
623 do_one_accept_language_test ("C", "en");
624 do_one_accept_language_test ("fr_FR", "fr-fr, fr;q=0.9");
625 do_one_accept_language_test ("fr_FR:de:en_US", "fr-fr, fr;q=0.9, de;q=0.8, en-us;q=0.7, en;q=0.6");
628 g_setenv ("LANGUAGE", orig_language, TRUE);
630 g_unsetenv ("LANGUAGE");
634 cancel_message_timeout (gpointer msg)
636 SoupSession *session = g_object_get_data (G_OBJECT (msg), "session");
638 soup_session_cancel_message (session, msg, SOUP_STATUS_CANCELLED);
639 g_object_unref (msg);
640 g_object_unref (session);
645 cancel_message_thread (gpointer msg)
647 SoupSession *session = g_object_get_data (G_OBJECT (msg), "session");
649 g_usleep (100000); /* .1s */
650 soup_session_cancel_message (session, msg, SOUP_STATUS_CANCELLED);
651 g_object_unref (msg);
652 g_object_unref (session);
657 set_done (SoupSession *session, SoupMessage *msg, gpointer user_data)
659 gboolean *done = user_data;
665 do_cancel_while_reading_test_for_session (SoupSession *session)
668 GThread *thread = NULL;
670 gboolean done = FALSE;
672 uri = soup_uri_new_with_base (base_uri, "/slow");
673 msg = soup_message_new_from_uri ("GET", uri);
676 g_object_set_data (G_OBJECT (msg), "session", session);
678 g_object_ref (session);
679 if (SOUP_IS_SESSION_ASYNC (session))
680 g_timeout_add (100, cancel_message_timeout, msg);
682 thread = g_thread_new ("cancel_message_thread", cancel_message_thread, msg);
684 /* We intentionally don't use soup_session_send_message() here,
685 * because it holds an extra ref on the SoupMessageQueueItem
686 * relative to soup_session_queue_message().
689 soup_session_queue_message (session, msg, set_done, &done);
691 g_main_context_iteration (NULL, TRUE);
693 soup_test_assert_message_status (msg, SOUP_STATUS_CANCELLED);
694 g_object_unref (msg);
697 g_thread_join (thread);
701 do_cancel_while_reading_test (void)
703 SoupSession *session;
705 g_test_bug ("637741");
706 g_test_bug ("676038");
708 debug_printf (1, " Async session\n");
709 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
710 do_cancel_while_reading_test_for_session (session);
711 soup_test_session_abort_unref (session);
713 debug_printf (1, " Sync session\n");
714 session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
715 do_cancel_while_reading_test_for_session (session);
716 soup_test_session_abort_unref (session);
720 do_cancel_while_reading_req_test_for_session (SoupSession *session,
725 GCancellable *cancellable;
726 GError *error = NULL;
728 uri = soup_uri_new_with_base (base_uri, "/slow");
729 req = soup_session_request_uri (session, uri, NULL);
732 cancellable = g_cancellable_new ();
733 soup_test_request_send (req, cancellable, flags, &error);
734 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
735 g_clear_error (&error);
737 g_object_unref (req);
738 g_object_unref (cancellable);
742 do_cancel_while_reading_immediate_req_test (void)
744 SoupSession *session;
747 g_test_bug ("692310");
749 flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
751 debug_printf (1, " Async session\n");
752 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
753 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
755 do_cancel_while_reading_req_test_for_session (session, flags);
756 soup_test_session_abort_unref (session);
758 debug_printf (1, " Sync session\n");
759 session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,
761 do_cancel_while_reading_req_test_for_session (session, flags);
762 soup_test_session_abort_unref (session);
766 do_cancel_while_reading_delayed_req_test (void)
768 SoupSession *session;
771 flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_SOON;
773 debug_printf (1, " Async session\n");
774 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
775 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
777 do_cancel_while_reading_req_test_for_session (session, flags);
778 soup_test_session_abort_unref (session);
780 debug_printf (1, " Sync session\n");
781 session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,
783 do_cancel_while_reading_req_test_for_session (session, flags);
784 soup_test_session_abort_unref (session);
788 do_cancel_while_reading_preemptive_req_test (void)
790 SoupSession *session;
793 g_test_bug ("637039");
795 flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_PREEMPTIVE;
797 debug_printf (1, " Async session\n");
798 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
799 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
801 do_cancel_while_reading_req_test_for_session (session, flags);
802 soup_test_session_abort_unref (session);
804 debug_printf (1, " Sync session\n");
805 session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,
807 do_cancel_while_reading_req_test_for_session (session, flags);
808 soup_test_session_abort_unref (session);
812 do_aliases_test_for_session (SoupSession *session,
813 const char *redirect_protocol)
817 const char *redirected_protocol;
819 uri = soup_uri_new_with_base (base_uri, "/alias-redirect");
820 msg = soup_message_new_from_uri ("GET", uri);
821 if (redirect_protocol)
822 soup_message_headers_append (msg->request_headers, "X-Redirect-Protocol", redirect_protocol);
824 soup_session_send_message (session, msg);
826 redirected_protocol = soup_message_headers_get_one (msg->response_headers, "X-Redirected-Protocol");
828 g_assert_cmpstr (redirect_protocol, ==, redirected_protocol);
829 if (redirect_protocol)
830 soup_test_assert_message_status (msg, SOUP_STATUS_OK);
832 soup_test_assert_message_status (msg, SOUP_STATUS_FOUND);
834 g_object_unref (msg);
838 do_aliases_test (void)
840 SoupSession *session;
841 char *aliases[] = { "foo", NULL };
843 debug_printf (1, " Default behavior\n");
844 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
845 do_aliases_test_for_session (session, "http");
846 soup_test_session_abort_unref (session);
849 debug_printf (1, " foo-means-https\n");
850 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
851 SOUP_SESSION_HTTPS_ALIASES, aliases,
853 do_aliases_test_for_session (session, "https");
854 soup_test_session_abort_unref (session);
856 debug_printf (1, " foo-means-https -- SKIPPING\n");
858 debug_printf (1, " foo-means-nothing\n");
859 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
860 SOUP_SESSION_HTTP_ALIASES, NULL,
862 do_aliases_test_for_session (session, NULL);
863 soup_test_session_abort_unref (session);
867 do_idle_on_dispose_test (void)
869 SoupSession *session;
871 GMainContext *async_context;
873 g_test_bug ("667364");
875 async_context = g_main_context_new ();
876 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
877 SOUP_SESSION_ASYNC_CONTEXT, async_context,
880 msg = soup_message_new_from_uri ("GET", base_uri);
881 soup_session_send_message (session, msg);
882 g_object_unref (msg);
884 while (g_main_context_iteration (async_context, FALSE))
887 g_object_run_dispose (G_OBJECT (session));
889 if (g_main_context_iteration (async_context, FALSE))
890 soup_test_assert (FALSE, "idle was queued");
892 g_object_unref (session);
893 g_main_context_unref (async_context);
897 do_pause_abort_test (void)
899 SoupSession *session;
903 g_test_bug ("673905");
905 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
907 msg = soup_message_new_from_uri ("GET", base_uri);
908 soup_session_queue_message (session, msg, NULL, NULL);
909 soup_session_pause_message (session, msg);
911 g_object_add_weak_pointer (G_OBJECT (msg), &ptr);
912 soup_test_session_abort_unref (session);
918 main (int argc, char **argv)
920 SoupAuthDomain *auth_domain;
923 test_init (argc, argv, NULL);
925 server = soup_test_server_new (TRUE);
926 soup_server_add_handler (server, NULL, server_callback, "http", NULL);
927 base_uri = soup_uri_new ("http://127.0.0.1/");
928 soup_uri_set_port (base_uri, soup_server_get_port (server));
930 auth_domain = soup_auth_domain_basic_new (
931 SOUP_AUTH_DOMAIN_REALM, "misc-test",
932 SOUP_AUTH_DOMAIN_ADD_PATH, "/auth",
933 SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK, auth_callback,
935 soup_server_add_auth_domain (server, auth_domain);
936 g_object_unref (auth_domain);
939 ssl_server = soup_test_server_new_ssl (TRUE);
940 soup_server_add_handler (ssl_server, NULL, server_callback, "https", NULL);
941 ssl_base_uri = soup_uri_new ("https://127.0.0.1/");
942 soup_uri_set_port (ssl_base_uri, soup_server_get_port (ssl_server));
945 g_test_add_func ("/misc/host", do_host_test);
946 g_test_add_func ("/misc/callback-unref/msg", do_callback_unref_test);
947 g_test_add_func ("/misc/callback-unref/req", do_callback_unref_req_test);
948 g_test_add_func ("/misc/msg-reuse", do_msg_reuse_test);
949 g_test_add_func ("/misc/early-abort/msg", do_early_abort_test);
950 g_test_add_func ("/misc/early-abort/req", do_early_abort_req_test);
951 g_test_add_func ("/misc/accept-language", do_accept_language_test);
952 g_test_add_func ("/misc/cancel-while-reading/msg", do_cancel_while_reading_test);
953 g_test_add_func ("/misc/cancel-while-reading/req/immediate", do_cancel_while_reading_immediate_req_test);
954 g_test_add_func ("/misc/cancel-while-reading/req/delayed", do_cancel_while_reading_delayed_req_test);
955 g_test_add_func ("/misc/cancel-while-reading/req/preemptive", do_cancel_while_reading_preemptive_req_test);
956 g_test_add_func ("/misc/aliases", do_aliases_test);
957 g_test_add_func ("/misc/idle-on-dispose", do_idle_on_dispose_test);
958 g_test_add_func ("/misc/pause-abort", do_pause_abort_test);
962 soup_uri_free (base_uri);
963 soup_test_server_quit_unref (server);
966 soup_uri_free (ssl_base_uri);
967 soup_test_server_quit_unref (ssl_server);