1 files changed, 118 insertions, 149 deletions

diff --git a/tests/redirect-test.c b/tests/redirect-test.c
index 2b4fb5ea..b20a3187 100644
--- a/tests/redirect-test.c
+++ b/tests/redirect-test.c
@@ -5,7 +5,9 @@
 
 #include "test-utils.h"
 
+SoupURI *base_uri;
 char *server2_uri;
+SoupSession *async_session, *sync_session;
 
 typedef struct {
 	const char *method;
@@ -14,11 +16,13 @@ typedef struct {
 	gboolean repeat;
 } TestRequest;
 
-static struct {
+typedef struct {
 	TestRequest requests[3];
 	guint final_status;
 	guint request_api_final_status;
-} tests[] = {
+} TestCase;
+
+static TestCase tests[] = {
 	/* A redirecty response to a GET or HEAD should cause a redirect */
 
 	{ { { "GET", "/301", 301 },
@@ -131,11 +135,7 @@ got_headers (SoupMessage *msg, gpointer user_data)
 	if (!(*treq)->method)
 		return;
 
-	if (msg->status_code != (*treq)->status_code) {
-		debug_printf (1, "    - Expected %d !\n",
-			      (*treq)->status_code);
-		errors++;
-	}
+	soup_test_assert_message_status (msg, (*treq)->status_code);
 }
 
 static void
@@ -149,35 +149,26 @@ restarted (SoupMessage *msg, gpointer user_data)
 	if ((*treq)->method && !(*treq)->repeat)
 		(*treq)++;
 
-	if (!(*treq)->method) {
-		debug_printf (1, "    - Expected to be done!\n");
-		errors++;
-		return;
-	}
+	soup_test_assert ((*treq)->method,
+			  "Expected to be done");
 
-	if (strcmp (msg->method, (*treq)->method) != 0) {
-		debug_printf (1, "    - Expected %s !\n", (*treq)->method);
-		errors++;
-	}
-	if (strcmp (uri->path, (*treq)->path) != 0) {
-		debug_printf (1, "    - Expected %s !\n", (*treq)->path);
-		errors++;
-	}
+	g_assert_cmpstr (msg->method, ==, (*treq)->method);
+	g_assert_cmpstr (uri->path, ==, (*treq)->path);
 }
 
 static void
-do_message_api_test (SoupSession *session, SoupURI *base_uri, int n)
+do_message_api_test (SoupSession *session, TestCase *test)
 {
 	SoupURI *uri;
 	SoupMessage *msg;
 	TestRequest *treq;
 
-	debug_printf (1, "%2d. %s %s\n", n + 1,
-		      tests[n].requests[0].method,
-		      tests[n].requests[0].path);
+	debug_printf (1, "%s %s\n",
+		      test->requests[0].method,
+		      test->requests[0].path);
 
-	uri = soup_uri_new_with_base (base_uri, tests[n].requests[0].path);
-	msg = soup_message_new_from_uri (tests[n].requests[0].method, uri);
+	uri = soup_uri_new_with_base (base_uri, test->requests[0].path);
+	msg = soup_message_new_from_uri (test->requests[0].method, uri);
 	soup_uri_free (uri);
 
 	if (msg->method == SOUP_METHOD_POST) {
@@ -187,7 +178,7 @@ do_message_api_test (SoupSession *session, SoupURI *base_uri, int n)
 					  strlen ("post body"));
 	}
 
-	treq = &tests[n].requests[0];
+	treq = &test->requests[0];
 	g_signal_connect (msg, "got_headers",
 			  G_CALLBACK (got_headers), &treq);
 	g_signal_connect (msg, "restarted",
@@ -195,18 +186,14 @@ do_message_api_test (SoupSession *session, SoupURI *base_uri, int n)
 
 	soup_session_send_message (session, msg);
 
-	if (msg->status_code != tests[n].final_status) {
-		debug_printf (1, "    - Expected final status of %d, got %d !\n",
-			      tests[n].final_status, msg->status_code);
-		errors++;
-	}
+	soup_test_assert_message_status (msg, test->final_status);
 
 	g_object_unref (msg);
 	debug_printf (2, "\n");
 }
 
 static void
-do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
+do_request_api_test (SoupSession *session, TestCase *test)
 {
 	SoupURI *uri;
 	SoupRequestHTTP *reqh;
@@ -216,24 +203,22 @@ do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
 	GError *error = NULL;
 	guint final_status;
 
-	debug_printf (1, "%2d. %s %s\n", n + 1,
-		      tests[n].requests[0].method,
-		      tests[n].requests[0].path);
+	debug_printf (1, "%s %s\n",
+		      test->requests[0].method,
+		      test->requests[0].path);
 
-	final_status = tests[n].request_api_final_status;
+	final_status = test->request_api_final_status;
 	if (!final_status)
-		final_status = tests[n].final_status;
+		final_status = test->final_status;
 
-	uri = soup_uri_new_with_base (base_uri, tests[n].requests[0].path);
+	uri = soup_uri_new_with_base (base_uri, test->requests[0].path);
 	reqh = soup_session_request_http_uri (session,
-					      tests[n].requests[0].method,
+					      test->requests[0].method,
 					      uri, &error);
 	soup_uri_free (uri);
-	if (!reqh) {
-		debug_printf (1, "    could not create request: %s\n",
-			      error->message);
+	g_assert_no_error (error);
+	if (error) {
 		g_error_free (error);
-		errors++;
 		debug_printf (2, "\n");
 		return;
 	}
@@ -246,7 +231,7 @@ do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
 					  strlen ("post body"));
 	}
 
-	treq = &tests[n].requests[0];
+	treq = &test->requests[0];
 	g_signal_connect (msg, "got_headers",
 			  G_CALLBACK (got_headers), &treq);
 	g_signal_connect (msg, "restarted",
@@ -255,58 +240,37 @@ do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
 	stream = soup_test_request_send (SOUP_REQUEST (reqh), NULL, 0, &error);
 
 	if (SOUP_STATUS_IS_TRANSPORT_ERROR (final_status)) {
-		if (stream) {
-			debug_printf (1, "    expected failure (%s) but succeeded",
-				      soup_status_get_phrase (final_status));
-			errors++;
-			g_object_unref (stream);
-		}
-		if (error->domain != SOUP_HTTP_ERROR ||
-		    error->code != final_status) {
-			debug_printf (1, "    expected '%s' but got '%s'",
-				      soup_status_get_phrase (final_status),
-				      error->message);
-			errors++;
-		}
+		g_assert_error (error, SOUP_HTTP_ERROR, final_status);
+		g_clear_error (&error);
+
+		g_assert_null (stream);
+		g_clear_object (&stream);
 
-		g_error_free (error);
 		g_object_unref (msg);
 		g_object_unref (reqh);
 		debug_printf (2, "\n");
 		return;
-	} else if (!stream) {
-		debug_printf (1, "    could not send request: %s\n",
-			      error->message);
+	}
+
+	g_assert_no_error (error);
+	if (error) {
 		g_error_free (error);
 		g_object_unref (msg);
 		g_object_unref (reqh);
-		errors++;
 		debug_printf (2, "\n");
 		return;
 	}
 
 	soup_test_request_read_all (SOUP_REQUEST (reqh), stream, NULL, &error);
-	if (error) {
-		debug_printf (1, "    could not read from stream: %s\n",
-			      error->message);
-		g_error_free (error);
-		errors++;
-	}
+	g_assert_no_error (error);
+	g_clear_error (&error);
 
 	soup_test_request_close_stream (SOUP_REQUEST (reqh), stream, NULL, &error);
-	if (error) {
-		debug_printf (1, "    could not close stream: %s\n",
-			      error->message);
-		g_error_free (error);
-		errors++;
-	}
+	g_assert_no_error (error);
+	g_clear_error (&error);
 	g_object_unref (stream);
 
-	if (msg->status_code != final_status) {
-		debug_printf (1, "    - Expected final status of %d, got %d !\n",
-			      final_status, msg->status_code);
-		errors++;
-	}
+	g_assert_cmpint (msg->status_code, ==, final_status);
 
 	g_object_unref (msg);
 	g_object_unref (reqh);
@@ -314,30 +278,27 @@ do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
 }
 
 static void
-do_redirect_tests (SoupURI *base_uri)
+do_async_msg_api_test (gconstpointer test)
 {
-	SoupSession *session;
-	int n;
-
-	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
-					 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
-					 NULL);
-	debug_printf (1, "Async session, SoupMessage\n");
-	for (n = 0; n < n_tests; n++)
-		do_message_api_test (session, base_uri, n);
-	debug_printf (1, "\nAsync session, SoupRequest\n");
-	for (n = 0; n < n_tests; n++)
-		do_request_api_test (session, base_uri, n);
-	soup_test_session_abort_unref (session);
-
-	session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
-	debug_printf (1, "\nSync session, SoupMessage\n");
-	for (n = 0; n < n_tests; n++)
-		do_message_api_test (session, base_uri, n);
-	debug_printf (1, "\nSync session, SoupRequest\n");
-	for (n = 0; n < n_tests; n++)
-		do_request_api_test (session, base_uri, n);
-	soup_test_session_abort_unref (session);
+	do_message_api_test (async_session, (TestCase *)test);
+}
+
+static void
+do_async_req_api_test (gconstpointer test)
+{
+	do_request_api_test (async_session, (TestCase *)test);
+}
+
+static void
+do_sync_msg_api_test (gconstpointer test)
+{
+	do_message_api_test (sync_session, (TestCase *)test);
+}
+
+static void
+do_sync_req_api_test (gconstpointer test)
+{
+	do_request_api_test (sync_session, (TestCase *)test);
 }
 
 typedef struct {
@@ -350,11 +311,7 @@ typedef struct {
 static void
 msg2_finished (SoupSession *session, SoupMessage *msg2, gpointer user_data)
 {
-	if (!SOUP_STATUS_IS_SUCCESSFUL (msg2->status_code)) {
-		debug_printf (1, "  msg2 failed: %d %s\n",
-			      msg2->status_code, msg2->reason_phrase);
-		errors++;
-	}
+	soup_test_assert_message_status (msg2, SOUP_STATUS_OK);
 }
 
 static void
@@ -362,16 +319,12 @@ unpause_msg1 (SoupMessage *msg2, gpointer user_data)
 {
        ConnectionTestData *data = user_data;
 
-       if (!data->sock1) {
-	       debug_printf (1, "  msg1 has no connection?\n");
-	       errors++;
-       } else if (!data->sock2) {
-	       debug_printf (1, "  msg2 has no connection?\n");
-	       errors++;
-       } else if (data->sock1 == data->sock2) {
-	       debug_printf (1, "  Both messages sharing the same connection\n");
-	       errors++;
-       }
+       soup_test_assert (data->sock1 != NULL,
+			 "msg1 has no connection");
+       soup_test_assert (data->sock2 != NULL,
+			 "msg2 has no connection");
+       soup_test_assert (data->sock1 != data->sock2,
+			 "Both messages sharing the same connection");
 
        soup_session_unpause_message (data->session, data->msg1);
 }
@@ -422,11 +375,10 @@ request_started (SoupSession *session, SoupMessage *msg,
 }
 
 static void
-do_connection_test (SoupURI *base_uri)
+do_connection_test (void)
 {
 	ConnectionTestData data;
 
-	debug_printf (1, "\nConnection reuse\n");
 	memset (&data, 0, sizeof (data));
 
 	data.session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
@@ -441,11 +393,8 @@ do_connection_test (SoupURI *base_uri)
 			  G_CALLBACK (msg1_about_to_restart), &data);
 	soup_session_send_message (data.session, data.msg1);
 
-	if (!SOUP_STATUS_IS_SUCCESSFUL (data.msg1->status_code)) {
-		debug_printf (1, "  msg1 failed: %d %s\n",
-			      data.msg1->status_code, data.msg1->reason_phrase);
-		errors++;
-	}
+	soup_test_assert_message_status (data.msg1, SOUP_STATUS_OK);
+
 	g_object_unref (data.msg1);
 	soup_uri_free (data.uri1);
 	soup_uri_free (data.uri2);
@@ -550,29 +499,23 @@ server2_callback (SoupServer *server, SoupMessage *msg,
 	soup_message_set_status (msg, SOUP_STATUS_OK);
 }
 
-static gboolean run_tests = TRUE;
-
-static GOptionEntry no_test_entry[] = {
-        { "no-tests", 'n', G_OPTION_FLAG_REVERSE,
-          G_OPTION_ARG_NONE, &run_tests,
-          "Don't run tests, just run the test server", NULL },
-        { NULL }
-};
-
 int
 main (int argc, char **argv)
 {
 	GMainLoop *loop;
 	SoupServer *server, *server2;
 	guint port;
-	SoupURI *base_uri;
+	char *path;
+	int n, ret;
 
-	test_init (argc, argv, no_test_entry);
+	test_init (argc, argv, NULL);
 
 	server = soup_test_server_new (TRUE);
 	soup_server_add_handler (server, NULL,
 				 server_callback, NULL, NULL);
 	port = soup_server_get_port (server);
+	base_uri = soup_uri_new ("http://127.0.0.1");
+	soup_uri_set_port (base_uri, port);
 
 	server2 = soup_test_server_new (TRUE);
 	soup_server_add_handler (server2, NULL,
@@ -582,23 +525,49 @@ main (int argc, char **argv)
 
 	loop = g_main_loop_new (NULL, TRUE);
 
-	if (run_tests) {
-		base_uri = soup_uri_new ("http://127.0.0.1");
-		soup_uri_set_port (base_uri, port);
-		do_redirect_tests (base_uri);
-		do_connection_test (base_uri);
-		soup_uri_free (base_uri);
-	} else {
-		g_print ("Listening on port %d\n", port);
-		g_main_loop_run (loop);
+	async_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
+					       SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
+					       NULL);
+	sync_session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);
+
+	for (n = 0; n < n_tests; n++) {
+		path = g_strdup_printf ("/redirect/async/msg/%d-%s-%d", n
+					, tests[n].requests[0].method,
+					tests[n].requests[0].status_code);
+		g_test_add_data_func (path, &tests[n], do_async_msg_api_test);
+		g_free (path);
+
+		path = g_strdup_printf ("/redirect/async/req/%d-%s-%d", n,
+					tests[n].requests[0].method,
+					tests[n].requests[0].status_code);
+		g_test_add_data_func (path, &tests[n], do_async_req_api_test);
+		g_free (path);
+
+		path = g_strdup_printf ("/redirect/sync/msg/%d-%s-%d", n,
+					tests[n].requests[0].method,
+					tests[n].requests[0].status_code);
+		g_test_add_data_func (path, &tests[n], do_sync_msg_api_test);
+		g_free (path);
+
+		path = g_strdup_printf ("/redirect/sync/req/%d-%s-%d", n,
+					tests[n].requests[0].method,
+					tests[n].requests[0].status_code);
+		g_test_add_data_func (path, &tests[n], do_sync_req_api_test);
+		g_free (path);
 	}
 
+	g_test_add_func ("/redirect/reuse", do_connection_test);
+
+	ret = g_test_run ();
+
 	g_main_loop_unref (loop);
-	g_free (server2_uri);
+	soup_uri_free (base_uri);
 	soup_test_server_quit_unref (server);
+	g_free (server2_uri);
 	soup_test_server_quit_unref (server2);
 
-	if (run_tests)
-		test_cleanup ();
-	return errors != 0;
+	soup_test_session_abort_unref (async_session);
+	soup_test_session_abort_unref (sync_session);
+
+	return ret;
 }