自学教程：C++ soup_test_session_new函数代码示例

static voiddo_persistent_connection_timeout_test (void){	SoupSession *session;	debug_printf (1, "/nUnexpected timing out of persistent connections/n");	debug_printf (1, "  Async session, message API/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	do_timeout_test_for_session (session);	soup_test_session_abort_unref (session);	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,					 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,					 NULL);	do_timeout_req_test_for_session (session);	soup_test_session_abort_unref (session);	debug_printf (1, "  Sync session, message API/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);	do_timeout_test_for_session (session);	soup_test_session_abort_unref (session);	session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);	do_timeout_req_test_for_session (session);	soup_test_session_abort_unref (session);}

static voiddo_aliases_test (void){	SoupSession *session;	char *aliases[] = { "foo", NULL };	debug_printf (1, "/nhttp-aliases / https-aliases/n");	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, "  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);	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);}

static voiddo_timeout_tests (char *fast_uri, char *slow_uri){	SoupSession *timeout_session, *idle_session, *plain_session;	debug_printf (1, "  async/n");	timeout_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,					 SOUP_SESSION_TIMEOUT, 1,					 NULL);	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");	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);}

intmain (int argc, char **argv){	SoupSession *session;	const char *base_uri;	test_init (argc, argv, NULL);	apache_init ();	base_uri = "http://127.0.0.1:47524/";	get_correct_response (base_uri);	debug_printf (1, "/nFully async, fast requests/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	g_signal_connect (session, "authenticate",			  G_CALLBACK (authenticate), NULL);	do_fully_async_test (session, base_uri, "/",			     TRUE, SOUP_STATUS_OK);	do_fully_async_test (session, base_uri, "/Basic/realm1/",			     TRUE, SOUP_STATUS_UNAUTHORIZED);	do_fully_async_test (session, base_uri, "/Basic/realm2/",			     TRUE, SOUP_STATUS_OK);	soup_test_session_abort_unref (session);	debug_printf (1, "/nFully async, slow requests/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	g_signal_connect (session, "authenticate",			  G_CALLBACK (authenticate), NULL);	do_fully_async_test (session, base_uri, "/",			     FALSE, SOUP_STATUS_OK);	do_fully_async_test (session, base_uri, "/Basic/realm1/",			     FALSE, SOUP_STATUS_UNAUTHORIZED);	do_fully_async_test (session, base_uri, "/Basic/realm2/",			     FALSE, SOUP_STATUS_OK);	soup_test_session_abort_unref (session);	debug_printf (1, "/nSynchronously async/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	g_signal_connect (session, "authenticate",			  G_CALLBACK (authenticate), NULL);	do_synchronously_async_test (session, base_uri, "/",				     SOUP_STATUS_OK);	do_synchronously_async_test (session, base_uri, "/Basic/realm1/",				     SOUP_STATUS_UNAUTHORIZED);	do_synchronously_async_test (session, base_uri, "/Basic/realm2/",				     SOUP_STATUS_OK);	soup_test_session_abort_unref (session);	soup_buffer_free (correct_response);	test_cleanup ();	return errors != 0;}

static voiddo_infinite_auth_test (void){	SoupSession *session;	SoupMessage *msg;	char *uri;	int timeout;	SOUP_TEST_SKIP_IF_NO_APACHE;	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	g_signal_connect (session, "authenticate",			  G_CALLBACK (infinite_authenticate), NULL);	uri = g_strconcat (base_uri, "Basic/realm1/", NULL);	msg = soup_message_new ("GET", uri);	g_free (uri);	timeout = g_timeout_add (500, infinite_cancel, session);	g_test_expect_message ("libsoup", G_LOG_LEVEL_WARNING,			       "*stuck in infinite loop*");	soup_session_send_message (session, msg);	g_test_assert_expected_messages ();	soup_test_assert (msg->status_code != SOUP_STATUS_CANCELLED,			  "Got stuck in loop");	soup_test_assert_message_status (msg, SOUP_STATUS_UNAUTHORIZED);	g_source_remove (timeout);	soup_test_session_abort_unref (session);	g_object_unref (msg);}

static voiddo_infinite_auth_test (const char *base_uri){	SoupSession *session;	SoupMessage *msg;	char *uri;	int timeout;	debug_printf (1, "/nTesting broken infinite-loop auth:/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	g_signal_connect (session, "authenticate",			  G_CALLBACK (infinite_authenticate), NULL);	uri = g_strconcat (base_uri, "Basic/realm1/", NULL);	msg = soup_message_new ("GET", uri);	g_free (uri);	timeout = g_timeout_add (500, infinite_cancel, session);	expect_warning = TRUE;	soup_session_send_message (session, msg);	if (msg->status_code == SOUP_STATUS_CANCELLED) {		debug_printf (1, "    FAILED: Got stuck in loop");		errors++;	} else if (msg->status_code != SOUP_STATUS_UNAUTHORIZED) {		debug_printf (1, "    Final status wrong: expected 401, got %u/n",			      msg->status_code);		errors++;	}	g_source_remove (timeout);	soup_test_session_abort_unref (session);	g_object_unref (msg);}

static voidforce_io_streams_init (void){	SoupServer *server;	SoupSession *session;	guint port;	SoupURI *base_uri;	SoupMessage *msg;	/* Poke libsoup enough to cause SoupBodyInputStream and	 * SoupBodyOutputStream to get defined, so we can find them	 * via g_type_from_name() later.	 */	server = soup_test_server_new (TRUE);	port = 	soup_server_get_port (server);	base_uri = soup_uri_new ("http://127.0.0.1");	soup_uri_set_port (base_uri, port);	session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);	msg = soup_message_new_from_uri ("POST", base_uri);	soup_session_send_message (session, msg);	g_object_unref (msg);	soup_test_session_abort_unref (session);	soup_uri_free (base_uri);	soup_test_server_quit_unref (server);}

static voiddo_idle_on_dispose_test (void){	SoupSession *session;	SoupMessage *msg;	GMainContext *async_context;	debug_printf (1, "/nTesting SoupSessionAsync dispose behavior/n");	async_context = g_main_context_new ();	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,					 SOUP_SESSION_ASYNC_CONTEXT, async_context,					 NULL);	msg = soup_message_new_from_uri ("GET", base_uri);	soup_session_send_message (session, msg);	g_object_unref (msg);	while (g_main_context_iteration (async_context, FALSE))		;	g_object_run_dispose (G_OBJECT (session));	if (g_main_context_iteration (async_context, FALSE)) {		debug_printf (1, "  idle was queued!/n");		errors++;	}	g_object_unref (session);	g_main_context_unref (async_context);}

static voiddo_dot_dot_test (void){	SoupSession *session;	SoupMessage *msg;	SoupURI *uri;	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");	msg = soup_message_new_from_uri ("GET", uri);	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);	soup_test_session_abort_unref (session);}

static voiddo_pipelined_auth_test (const char *base_uri){	SoupSession *session;	SoupMessage *msg;	gboolean authenticated;	char *uri;	int i;	debug_printf (1, "Testing pipelined auth (bug 271540):/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	authenticated = FALSE;	g_signal_connect (session, "authenticate",			  G_CALLBACK (bug271540_authenticate), &authenticated);	uri = g_strconcat (base_uri, "Basic/realm1/", NULL);	for (i = 0; i < 10; i++) {		msg = soup_message_new (SOUP_METHOD_GET, uri);		g_object_set_data (G_OBJECT (msg), "#", GINT_TO_POINTER (i + 1));		g_signal_connect (msg, "wrote_headers",				  G_CALLBACK (bug271540_sent), &authenticated);		soup_session_queue_message (session, msg,					    bug271540_finished, &i);	}	g_free (uri);	loop = g_main_loop_new (NULL, TRUE);	g_main_loop_run (loop);	g_main_loop_unref (loop);	soup_test_session_abort_unref (session);}

static voiddo_proxy_fragment_test (SoupURI *base_uri){	SoupSession *session;	SoupURI *proxy_uri, *req_uri;	SoupMessage *msg;	debug_printf (1, "/nTesting request with fragment via proxy/n");	proxy_uri = soup_uri_new (proxies[SIMPLE_PROXY]);	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,					 SOUP_SESSION_PROXY_URI, proxy_uri,					 NULL);	soup_uri_free (proxy_uri);	req_uri = soup_uri_new_with_base (base_uri, "/#foo");	msg = soup_message_new_from_uri (SOUP_METHOD_GET, req_uri);	soup_uri_free (req_uri);	soup_session_send_message (session, msg);	if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {		debug_printf (1, "  unexpected status %d %s!/n",			      msg->status_code, msg->reason_phrase);		errors++;	}	g_object_unref (msg);	soup_test_session_abort_unref (session);}

static voiddo_ntlm_round (SoupURI *base_uri, gboolean use_ntlm, const char *user){	SoupSession *session;	gboolean alice = use_ntlm && !strcmp (user, "alice");	gboolean bob = use_ntlm && !strcmp (user, "bob");	g_return_if_fail (use_ntlm || !alice);	session = soup_test_session_new (		SOUP_TYPE_SESSION_ASYNC,		SOUP_SESSION_USE_NTLM, use_ntlm,		NULL);	if (user) {		g_signal_connect (session, "authenticate",				  G_CALLBACK (authenticate), (char *)user);	}	do_message (session, base_uri, "/noauth",		    FALSE, use_ntlm,		    FALSE, FALSE,		    SOUP_STATUS_OK);	do_message (session, base_uri, "/alice",		    !use_ntlm || bob, FALSE,		    FALSE, FALSE,		    alice ? SOUP_STATUS_OK :		    SOUP_STATUS_UNAUTHORIZED);	do_message (session, base_uri, "/alice/404",		    !use_ntlm, bob,		    FALSE, FALSE,		    alice ? SOUP_STATUS_NOT_FOUND :		    SOUP_STATUS_UNAUTHORIZED);	do_message (session, base_uri, "/alice",		    !use_ntlm, bob,		    FALSE, FALSE,		    alice ? SOUP_STATUS_OK :		    SOUP_STATUS_UNAUTHORIZED);	do_message (session, base_uri, "/bob",		    !use_ntlm || alice, bob,		    FALSE, FALSE,		    bob ? SOUP_STATUS_OK :		    SOUP_STATUS_UNAUTHORIZED);	do_message (session, base_uri, "/alice",		    !use_ntlm || bob, alice,		    FALSE, FALSE,		    alice ? SOUP_STATUS_OK :		    SOUP_STATUS_UNAUTHORIZED);	do_message (session, base_uri, "/basic",		    FALSE, bob,		    TRUE, user != NULL,		    user != NULL ? SOUP_STATUS_OK :		    SOUP_STATUS_UNAUTHORIZED);	do_message (session, base_uri, "/either",		    !use_ntlm, FALSE,		    !use_ntlm, !use_ntlm && user != NULL,		    user != NULL ? SOUP_STATUS_OK :		    SOUP_STATUS_UNAUTHORIZED);	soup_test_session_abort_unref (session);}

static voiddo_async_auth_no_password_test (void){	SoupSession *session;	SoupMessage *msg;	guint auth_id;	char *uri;	int remaining;	gboolean been_there;	/* Test that giving no password doesn't cause multiple	 * authenticate signals the second time.	 */	g_test_bug ("583462");	SOUP_TEST_SKIP_IF_NO_APACHE;	loop = g_main_loop_new (NULL, TRUE);	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	uri = g_strconcat (base_uri, "Basic/realm1/", NULL);	remaining = 0;	/* Send a message that doesn't actually authenticate	 */	msg = soup_message_new ("GET", uri);	g_object_set_data (G_OBJECT (msg), "id", GINT_TO_POINTER (1));	auth_id = g_signal_connect (session, "authenticate",				    G_CALLBACK (async_authenticate), NULL);	g_object_ref (msg);	remaining++;	soup_session_queue_message (session, msg, async_finished, &remaining);	g_main_loop_run (loop);	g_signal_handler_disconnect (session, auth_id);	soup_session_unpause_message (session, msg);	g_main_loop_run (loop);	g_object_unref(msg);	/* Now send a second message */	msg = soup_message_new ("GET", uri);	g_object_set_data (G_OBJECT (msg), "id", GINT_TO_POINTER (2));	g_object_ref (msg);	been_there = FALSE;	auth_id = g_signal_connect (session, "authenticate",				    G_CALLBACK (async_authenticate_assert_once_and_stop),				    &been_there);	remaining++;	soup_session_queue_message (session, msg, async_finished, &remaining);	g_main_loop_run (loop);	soup_session_unpause_message (session, msg);	g_main_loop_run (loop);	g_signal_handler_disconnect (session, auth_id);	soup_test_session_abort_unref (session);	g_object_unref (msg);	g_free (uri);	g_main_loop_unref (loop);}

static voiddo_cancel_while_reading_test (void){	SoupSession *session;	debug_printf (1, "/nCancelling message while reading response (msg api)/n");	debug_printf (1, "  Async session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	do_cancel_while_reading_test_for_session (session);	soup_test_session_abort_unref (session);	debug_printf (1, "  Sync session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);	do_cancel_while_reading_test_for_session (session);	soup_test_session_abort_unref (session);}

static voiddo_connection_event_test (void){	SoupSession *session;	debug_printf (1, "/nConnection events/n");	debug_printf (1, "  Async session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	do_connection_event_test_for_session (session);	soup_test_session_abort_unref (session);	debug_printf (1, "  Sync session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);	do_connection_event_test_for_session (session);	soup_test_session_abort_unref (session);}

static voiddo_non_persistent_connection_test (void){	SoupSession *session;	debug_printf (1, "/nNon-persistent connections are closed immediately/n");	debug_printf (1, "  Async session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	do_non_persistent_test_for_session (session);	soup_test_session_abort_unref (session);	debug_printf (1, "  Sync session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);	do_non_persistent_test_for_session (session);	soup_test_session_abort_unref (session);}

static voiddo_non_idempotent_connection_test (void){	SoupSession *session;	debug_printf (1, "/nNon-idempotent methods are always sent on new connections/n");	debug_printf (1, "  Async session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	do_non_idempotent_test_for_session (session);	soup_test_session_abort_unref (session);	debug_printf (1, "  Sync session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);	do_non_idempotent_test_for_session (session);	soup_test_session_abort_unref (session);}

static voiddo_content_length_framing_test (void){	SoupSession *session;	SoupMessage *msg;	SoupURI *request_uri;	goffset declared_length;	debug_printf (1, "/nInvalid Content-Length framing tests/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	debug_printf (1, "  Content-Length larger than message body length/n");	request_uri = soup_uri_new_with_base (base_uri, "/content-length/long");	msg = soup_message_new_from_uri ("GET", request_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++;	} else {		declared_length = soup_message_headers_get_content_length (msg->response_headers);		debug_printf (2, "    Content-Length: %lu, body: %s/n",			      (gulong)declared_length, msg->response_body->data);		if (msg->response_body->length >= declared_length) {			debug_printf (1, "    Body length %lu >= declared length %lu/n",				      (gulong)msg->response_body->length,				      (gulong)declared_length);			errors++;		}	}	soup_uri_free (request_uri);	g_object_unref (msg);	debug_printf (1, "  Server claims 'Connection: close' but doesn't/n");	request_uri = soup_uri_new_with_base (base_uri, "/content-length/noclose");	msg = soup_message_new_from_uri ("GET", request_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++;	} else {		declared_length = soup_message_headers_get_content_length (msg->response_headers);		debug_printf (2, "    Content-Length: %lu, body: %s/n",			      (gulong)declared_length, msg->response_body->data);		if (msg->response_body->length != declared_length) {			debug_printf (1, "    Body length %lu != declared length %lu/n",				      (gulong)msg->response_body->length,				      (gulong)declared_length);			errors++;		}	}	soup_uri_free (request_uri);	g_object_unref (msg);	soup_test_session_abort_unref (session);}

static voiddo_redirect_tests (SoupURI *base_uri){    SoupSession *session;    int n;    session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);    debug_printf (1, "Async session/n");    for (n = 0; n < n_tests; n++)        do_test (session, base_uri, n);    soup_test_session_abort_unref (session);    session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL);    debug_printf (1, "Sync session/n");    for (n = 0; n < n_tests; n++)        do_test (session, base_uri, n);    soup_test_session_abort_unref (session);}

static voiddo_cookies_accept_policy_test (void){	SoupSession *session;	SoupMessage *msg;	SoupURI *uri;	SoupCookieJar *jar;	GSList *l, *p;	int i;	debug_printf (1, "SoupCookieJarAcceptPolicy test/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	soup_session_add_feature_by_type (session, SOUP_TYPE_COOKIE_JAR);	jar = SOUP_COOKIE_JAR (soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR));	for (i = 0; i < G_N_ELEMENTS (validResults); i++) {		soup_cookie_jar_set_accept_policy (jar, validResults[i].policy);		uri = soup_uri_new_with_base (first_party_uri, "/index.html");		msg = soup_message_new_from_uri ("GET", uri);		soup_message_set_first_party (msg, first_party_uri);		soup_session_send_message (session, msg);		soup_uri_free (uri);		g_object_unref (msg);		/* We can't use two servers due to limitations in		 * test_server, so let's swap first and third party here		 * to simulate a cookie coming from a third party.		 */		uri = soup_uri_new_with_base (first_party_uri, "/foo.jpg");		msg = soup_message_new_from_uri ("GET", uri);		soup_message_set_first_party (msg, third_party_uri);		soup_session_send_message (session, msg);		soup_uri_free (uri);		g_object_unref (msg);		l = soup_cookie_jar_all_cookies (jar);		if (g_slist_length (l) < validResults[i].n_cookies) {			debug_printf (1, " accepted less cookies than it should have/n");			errors++;		} else if (g_slist_length (l) > validResults[i].n_cookies) {			debug_printf (1, " accepted more cookies than it should have/n");			errors++;		}		for (p = l; p; p = p->next) {			soup_cookie_jar_delete_cookie (jar, p->data);			soup_cookie_free (p->data);		}		g_slist_free (l);	}	soup_test_session_abort_unref (session);}

static voiddo_timeout_tests (char *fast_uri, char *slow_uri){	SoupSession *session;	debug_printf (1, "  async/n");	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);	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);}

static voiddo_message_has_authorization_header_test (void){	SoupSession *session;	SoupMessage *msg;	SoupAuthManager *manager;	SoupAuth *auth = NULL;	char *token;	guint auth_id;	char *uri;	g_test_bug ("775882");	SOUP_TEST_SKIP_IF_NO_APACHE;	session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);	uri = g_strconcat (base_uri, "Digest/realm1/", NULL);	msg = soup_message_new ("GET", uri);	auth_id = g_signal_connect (session, "authenticate",			  G_CALLBACK (has_authorization_header_authenticate), &auth);	soup_session_send_message (session, msg);	soup_test_assert_message_status (msg, SOUP_STATUS_OK);	soup_test_assert (SOUP_IS_AUTH (auth), "Expected a SoupAuth");	token = soup_auth_get_authorization (auth, msg);	g_object_unref (auth);	g_object_unref (msg);	g_signal_handler_disconnect (session, auth_id);	manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER));	soup_auth_manager_clear_cached_credentials (manager);	msg = soup_message_new ("GET", uri);	soup_message_headers_replace (msg->request_headers, "Authorization", token);	auth_id = g_signal_connect (session, "authenticate",				    G_CALLBACK (has_authorization_header_authenticate_assert),				    NULL);	soup_session_send_message (session, msg);	soup_test_assert_message_status (msg, SOUP_STATUS_OK);	g_object_unref (msg);	/* Check that we can also provide our own Authorization header when not using credentials cache. */	soup_auth_manager_clear_cached_credentials (manager);	msg = soup_message_new ("GET", uri);	soup_message_headers_replace (msg->request_headers, "Authorization", token);	soup_message_set_flags (msg, soup_message_get_flags (msg) | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE);	soup_session_send_message (session, msg);	soup_test_assert_message_status (msg, SOUP_STATUS_OK);	g_object_unref (msg);	g_free (token);	g_signal_handler_disconnect (session, auth_id);	g_free (uri);	soup_test_session_abort_unref (session);}

static voiddo_max_conns_test (void){	SoupSession *session;	debug_printf (1, "/nExceeding max-conns/n");	debug_printf (1, "  Async session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,					 SOUP_SESSION_MAX_CONNS, MAX_CONNS,					 NULL);	do_max_conns_test_for_session (session);	soup_test_session_abort_unref (session);	debug_printf (1, "  Sync session/n");	session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC,					 SOUP_SESSION_MAX_CONNS, MAX_CONNS,					 NULL);	do_max_conns_test_for_session (session);	soup_test_session_abort_unref (session);}

static voiddo_async_auth_bad_password_test (void){	SoupSession *session;	SoupMessage *msg;	guint auth_id;	char *uri;	SoupAuth *auth = NULL;	int remaining;	gboolean been_there;	/* Test that giving the wrong password doesn't cause multiple	 * authenticate signals the second time.	 */	g_test_bug ("522601");	SOUP_TEST_SKIP_IF_NO_APACHE;	loop = g_main_loop_new (NULL, TRUE);	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);	uri = g_strconcat (base_uri, "Basic/realm1/", NULL);	remaining = 0;	auth = NULL;	msg = soup_message_new ("GET", uri);	g_object_set_data (G_OBJECT (msg), "id", GINT_TO_POINTER (1));	auth_id = g_signal_connect (session, "authenticate",				    G_CALLBACK (async_authenticate), &auth);	g_object_ref (msg);	remaining++;	soup_session_queue_message (session, msg, async_finished, &remaining);	g_main_loop_run (loop);	g_signal_handler_disconnect (session, auth_id);	soup_auth_authenticate (auth, "user1", "wrong");	g_object_unref (auth);	soup_session_unpause_message (session, msg);	been_there = FALSE;	auth_id = g_signal_connect (session, "authenticate",				    G_CALLBACK (async_authenticate_assert_once),				    &been_there);	g_main_loop_run (loop);	g_signal_handler_disconnect (session, auth_id);	soup_test_assert (been_there,			  "authenticate not emitted");	soup_test_session_abort_unref (session);	g_object_unref (msg);	g_free (uri);	g_main_loop_unref (loop);}