[libsoup] timeout-test: add SOUP_SESSION_IDLE_TIMEOUT tests as well

[Dan Winship <danw src gnome org>]

commit 59dcff0ac9fd99dd2625a3e8863fa0ee45a99937
Author: Dan Winship <danw gnome org>
Date:   Tue Nov 9 12:58:31 2010 -0500

    timeout-test: add SOUP_SESSION_IDLE_TIMEOUT tests as well

 tests/timeout-test.c |  126 ++++++++++++++++++++++++++++++++++++++++----------
 1 files 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