From 59dcff0ac9fd99dd2625a3e8863fa0ee45a99937 Mon Sep 17 00:00:00 2001 From: Dan Winship Date: Tue, 9 Nov 2010 12:58:31 -0500 Subject: [PATCH] timeout-test: add SOUP_SESSION_IDLE_TIMEOUT tests as well --- tests/timeout-test.c | 126 +++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 101 insertions(+), 25 deletions(-) diff --git a/tests/timeout-test.c b/tests/timeout-test.c index 3bca7ba..53d54d9 100644 --- a/tests/timeout-test.c +++ b/tests/timeout-test.c @@ -13,52 +13,128 @@ #include "test-utils.h" static void -do_tests_for_session (SoupSession *session, - char *fast_uri, char *slow_uri) +do_message_to_session (SoupSession *session, const char *uri, + const char *comment, guint expected_status) { SoupMessage *msg; - debug_printf (1, " fast\n"); - msg = soup_message_new ("GET", fast_uri); + debug_printf (1, " %s\n", comment); + msg = soup_message_new ("GET", uri); soup_session_send_message (session, msg); - if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { - debug_printf (1, " FAILED: %d %s (expected 200 OK)\n", - msg->status_code, msg->reason_phrase); - errors++; - } - g_object_unref (msg); - debug_printf (1, " slow\n"); - msg = soup_message_new ("GET", slow_uri); - soup_session_send_message (session, msg); - if (msg->status_code != SOUP_STATUS_IO_ERROR) { + if (msg->status_code != expected_status) { debug_printf (1, " FAILED: %d %s (expected %d %s)\n", msg->status_code, msg->reason_phrase, - SOUP_STATUS_IO_ERROR, - soup_status_get_phrase (SOUP_STATUS_IO_ERROR)); + expected_status, + soup_status_get_phrase (expected_status)); + errors++; + } + + if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code) && + !soup_message_is_keepalive (msg)) { + debug_printf (1, " ERROR: message is not keepalive!"); errors++; } + g_object_unref (msg); } static void +request_started_cb (SoupSession *session, SoupMessage *msg, + SoupSocket *socket, gpointer user_data) +{ + SoupSocket **ret = user_data; + + *ret = socket; +} + +static void +do_tests_for_session (SoupSession *timeout_session, + SoupSession *idle_session, + SoupSession *plain_session, + char *fast_uri, char *slow_uri) +{ + SoupSocket *ret, *idle_first, *idle_second; + SoupSocket *plain_first, *plain_second; + + if (idle_session) { + g_signal_connect (idle_session, "request-started", + G_CALLBACK (request_started_cb), &ret); + do_message_to_session (idle_session, fast_uri, "fast to idle", SOUP_STATUS_OK); + idle_first = ret; + } + + if (plain_session) { + g_signal_connect (plain_session, "request-started", + G_CALLBACK (request_started_cb), &ret); + do_message_to_session (plain_session, fast_uri, "fast to plain", SOUP_STATUS_OK); + plain_first = ret; + } + + do_message_to_session (timeout_session, fast_uri, "fast to timeout", SOUP_STATUS_OK); + do_message_to_session (timeout_session, slow_uri, "slow to timeout", SOUP_STATUS_IO_ERROR); + + if (idle_session) { + do_message_to_session (idle_session, fast_uri, "fast to idle", SOUP_STATUS_OK); + idle_second = ret; + g_signal_handlers_disconnect_by_func (idle_session, + (gpointer)request_started_cb, + &ret); + + if (idle_first == idle_second) { + debug_printf (1, " ERROR: idle_session did not close first connection\n"); + errors++; + } + } + + if (plain_session) { + do_message_to_session (plain_session, fast_uri, "fast to plain", SOUP_STATUS_OK); + plain_second = ret; + g_signal_handlers_disconnect_by_func (plain_session, + (gpointer)request_started_cb, + &ret); + + if (plain_first != plain_second) { + debug_printf (1, " ERROR: plain_session closed connection\n"); + errors++; + } + } +} + +static void do_timeout_tests (char *fast_uri, char *slow_uri) { - SoupSession *session; + SoupSession *timeout_session, *idle_session, *plain_session; debug_printf (1, " async\n"); - session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, + timeout_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_TIMEOUT, 1, NULL); - do_tests_for_session (session, fast_uri, slow_uri); - soup_test_session_abort_unref (session); + idle_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, + SOUP_SESSION_IDLE_TIMEOUT, 1, + NULL); + /* The "plain" session also has an idle timeout, but it's longer + * than the test takes, so for our purposes it should behave like + * it has no timeout. + */ + plain_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, + SOUP_SESSION_IDLE_TIMEOUT, 2, + NULL); + do_tests_for_session (timeout_session, idle_session, plain_session, + fast_uri, slow_uri); + soup_test_session_abort_unref (timeout_session); + soup_test_session_abort_unref (idle_session); + soup_test_session_abort_unref (plain_session); debug_printf (1, " sync\n"); - session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, - SOUP_SESSION_TIMEOUT, 1, - NULL); - do_tests_for_session (session, fast_uri, slow_uri); - soup_test_session_abort_unref (session); + timeout_session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, + SOUP_SESSION_TIMEOUT, 1, + NULL); + /* SOUP_SESSION_TIMEOUT doesn't work with sync sessions */ + plain_session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, + NULL); + do_tests_for_session (timeout_session, NULL, plain_session, fast_uri, slow_uri); + soup_test_session_abort_unref (timeout_session); } static void -- 2.7.4