/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* Copyright 2012 Red Hat, Inc.
*/
#include "test-utils.h"
static void
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer data)
{
const char *last_modified, *etag;
const char *header;
guint status = SOUP_STATUS_OK;
if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_POST) {
soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
header = soup_message_headers_get_one (msg->request_headers,
"Test-Set-Expires");
if (header) {
soup_message_headers_append (msg->response_headers,
"Expires",
header);
}
header = soup_message_headers_get_one (msg->request_headers,
"Test-Set-Cache-Control");
if (header) {
soup_message_headers_append (msg->response_headers,
"Cache-Control",
header);
}
last_modified = soup_message_headers_get_one (msg->request_headers,
"Test-Set-Last-Modified");
if (last_modified) {
soup_message_headers_append (msg->response_headers,
"Last-Modified",
last_modified);
}
etag = soup_message_headers_get_one (msg->request_headers,
"Test-Set-ETag");
if (etag) {
soup_message_headers_append (msg->response_headers,
"ETag",
etag);
}
header = soup_message_headers_get_one (msg->request_headers,
"If-Modified-Since");
if (header && last_modified) {
SoupDate *date;
time_t lastmod, check;
date = soup_date_new_from_string (last_modified);
lastmod = soup_date_to_time_t (date);
soup_date_free (date);
date = soup_date_new_from_string (header);
check = soup_date_to_time_t (date);
soup_date_free (date);
if (lastmod <= check)
status = SOUP_STATUS_NOT_MODIFIED;
}
header = soup_message_headers_get_one (msg->request_headers,
"If-None-Match");
if (header && etag) {
if (!strcmp (header, etag))
status = SOUP_STATUS_NOT_MODIFIED;
}
header = soup_message_headers_get_one (msg->request_headers,
"Test-Set-My-Header");
if (header) {
soup_message_headers_append (msg->response_headers,
"My-Header",
header);
}
if (status == SOUP_STATUS_OK) {
GChecksum *sum;
const char *body;
sum = g_checksum_new (G_CHECKSUM_SHA256);
g_checksum_update (sum, (guchar *)path, strlen (path));
if (last_modified)
g_checksum_update (sum, (guchar *)last_modified, strlen (last_modified));
if (etag)
g_checksum_update (sum, (guchar *)etag, strlen (etag));
body = g_checksum_get_string (sum);
soup_message_set_response (msg, "text/plain",
SOUP_MEMORY_COPY,
body, strlen (body) + 1);
g_checksum_free (sum);
}
soup_message_set_status (msg, status);
}
static gboolean
is_network_stream (GInputStream *stream)
{
while (G_IS_FILTER_INPUT_STREAM (stream))
stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
return !G_IS_FILE_INPUT_STREAM (stream);
}
static char *do_request (SoupSession *session,
SoupURI *base_uri,
const char *method,
const char *path,
SoupMessageHeaders *response_headers,
...) G_GNUC_NULL_TERMINATED;
static gboolean last_request_hit_network;
static gboolean last_request_validated;
static gboolean last_request_unqueued;
static guint cancelled_requests;
static void
copy_headers (const char *name,
const char *value,
gpointer user_data)
{
SoupMessageHeaders *headers = (SoupMessageHeaders *) user_data;
soup_message_headers_append (headers, name, value);
}
static char *
do_request (SoupSession *session,
SoupURI *base_uri,
const char *method,
const char *path,
SoupMessageHeaders *response_headers,
...)
{
SoupRequestHTTP *req;
SoupMessage *msg;
GInputStream *stream;
SoupURI *uri;
va_list ap;
const char *header, *value;
char buf[256];
gsize nread;
GError *error = NULL;
last_request_validated = last_request_hit_network = FALSE;
last_request_unqueued = FALSE;
uri = soup_uri_new_with_base (base_uri, path);
req = soup_session_request_http_uri (session, method, uri, NULL);
soup_uri_free (uri);
msg = soup_request_http_get_message (req);
va_start (ap, response_headers);
while ((header = va_arg (ap, const char *))) {
value = va_arg (ap, const char *);
soup_message_headers_append (msg->request_headers,
header, value);
}
va_end (ap);
stream = soup_test_request_send (SOUP_REQUEST (req), NULL, 0, &error);
if (!stream) {
debug_printf (1, " could not send request: %s\n",
error->message);
g_error_free (error);
g_object_unref (req);
g_object_unref (msg);
return NULL;
}
if (response_headers)
soup_message_headers_foreach (msg->response_headers, copy_headers, response_headers);
g_object_unref (msg);
if (last_request_validated)
last_request_unqueued = FALSE;
else
soup_test_assert (!last_request_unqueued,
"Request unqueued before finishing");
last_request_hit_network = is_network_stream (stream);
g_input_stream_read_all (stream, buf, sizeof (buf), &nread,
NULL, &error);
if (error) {
debug_printf (1, " could not read response: %s\n",
error->message);
g_clear_error (&error);
}
soup_test_request_close_stream (SOUP_REQUEST (req), stream,
NULL, &error);
if (error) {
debug_printf (1, " could not close stream: %s\n",
error->message);
g_clear_error (&error);
}
g_object_unref (stream);
g_object_unref (req);
/* Cache writes are G_PRIORITY_LOW, so they won't have happened yet... */
soup_cache_flush ((SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE));
return nread ? g_memdup (buf, nread) : g_strdup ("");
}
static void
do_request_with_cancel (SoupSession *session,
SoupURI *base_uri,
const char *method,
const char *path,
SoupTestRequestFlags flags)
{
SoupRequestHTTP *req;
GInputStream *stream;
SoupURI *uri;
GError *error = NULL;
GCancellable *cancellable;
last_request_validated = last_request_hit_network = last_request_unqueued = FALSE;
cancelled_requests = 0;
uri = soup_uri_new_with_base (base_uri, path);
req = soup_session_request_http_uri (session, method, uri, NULL);
soup_uri_free (uri);
cancellable = flags & SOUP_TEST_REQUEST_CANCEL_CANCELLABLE ? g_cancellable_new () : NULL;
stream = soup_test_request_send (SOUP_REQUEST (req), cancellable, flags, &error);
if (stream) {
debug_printf (1, " could not cancel the request\n");
g_object_unref (stream);
g_object_unref (req);
return;
} else
g_clear_error (&error);
g_clear_object (&cancellable);
g_clear_object (&stream);
g_clear_object (&req);
soup_cache_flush ((SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE));
}
static void
message_starting (SoupMessage *msg, gpointer data)
{
if (soup_message_headers_get_one (msg->request_headers,
"If-Modified-Since") ||
soup_message_headers_get_one (msg->request_headers,
"If-None-Match")) {
debug_printf (2, " Conditional request for %s\n",
soup_message_get_uri (msg)->path);
last_request_validated = TRUE;
}
}
static void
request_queued (SoupSession *session, SoupMessage *msg,
gpointer data)
{
g_signal_connect (msg, "starting",
G_CALLBACK (message_starting),
data);
}
static void
request_unqueued (SoupSession *session, SoupMessage *msg,
gpointer data)
{
if (msg->status_code == SOUP_STATUS_CANCELLED)
cancelled_requests++;
last_request_unqueued = TRUE;
}
static void
do_basics_test (gconstpointer data)
{
SoupURI *base_uri = (SoupURI *)data;
SoupSession *session;
SoupCache *cache;
char *cache_dir;
char *body1, *body2, *body3, *body4, *body5, *cmp;
cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
debug_printf (2, " Caching to %s\n", cache_dir);
cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE, cache,
NULL);
g_signal_connect (session, "request-queued",
G_CALLBACK (request_queued), NULL);
g_signal_connect (session, "request-unqueued",
G_CALLBACK (request_unqueued), NULL);
debug_printf (2, " Initial requests\n");
body1 = do_request (session, base_uri, "GET", "/1", NULL,
"Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
NULL);
body2 = do_request (session, base_uri, "GET", "/2", NULL,
"Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
"Test-Set-Cache-Control", "must-revalidate",
NULL);
body3 = do_request (session, base_uri, "GET", "/3", NULL,
"Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
"Test-Set-Expires", "Sat, 02 Jan 2011 00:00:00 GMT",
"Test-Set-Cache-Control", "must-revalidate",
NULL);
body4 = do_request (session, base_uri, "GET", "/4", NULL,
"Test-Set-ETag", "\"abcdefg\"",
"Test-Set-Cache-Control", "must-revalidate",
NULL);
body5 = do_request (session, base_uri, "GET", "/5", NULL,
"Test-Set-Cache-Control", "no-cache",
NULL);
/* Resource with future Expires should have been cached */
debug_printf (1, " Fresh cached resource\n");
cmp = do_request (session, base_uri, "GET", "/1", NULL,
NULL);
soup_test_assert (!last_request_hit_network,
"Request for /1 not filled from cache");
soup_test_assert (last_request_unqueued,
"Cached resource /1 not unqueued");
g_assert_cmpstr (body1, ==, cmp);
g_free (cmp);
/* Resource with long-ago Last-Modified should have been cached */
debug_printf (1, " Heuristically-fresh cached resource\n");
cmp = do_request (session, base_uri, "GET", "/2", NULL,
NULL);
/* Not validated even if it has must-revalidate, because it hasn't expired */
soup_test_assert (!last_request_validated,
"Request for /2 was validated");
soup_test_assert (!last_request_hit_network,
"Request for /2 not filled from cache");
soup_test_assert (last_request_unqueued,
"Cached resource /2 not unqueued");
g_assert_cmpstr (body2, ==, cmp);
g_free (cmp);
/* Adding a query string should bypass the cache but not invalidate it */
debug_printf (1, " Fresh cached resource with a query\n");
cmp = do_request (session, base_uri, "GET", "/1?attr=value", NULL,
NULL);
soup_test_assert (last_request_hit_network,
"Request for /1?attr=value filled from cache");
soup_test_assert (last_request_unqueued,
"Cached resource /1?attr=value not unqueued");
g_free (cmp);
debug_printf (2, " Second request\n");
cmp = do_request (session, base_uri, "GET", "/1", NULL,
NULL);
soup_test_assert (!last_request_hit_network,
"Second request for /1 not filled from cache");
soup_test_assert (last_request_unqueued,
"Request for /1 not unqueued");
g_assert_cmpstr (body1, ==, cmp);
g_free (cmp);
/* Expired + must-revalidate causes a conditional request */
debug_printf (1, " Unchanged must-revalidate resource w/ Last-Modified\n");
cmp = do_request (session, base_uri, "GET", "/3", NULL,
"Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
"Test-Set-Expires", "Sat, 02 Jan 2011 00:00:00 GMT",
"Test-Set-Cache-Control", "must-revalidate",
NULL);
soup_test_assert (last_request_validated,
"Request for /3 not validated");
soup_test_assert (!last_request_hit_network,
"Request for /3 not filled from cache");
soup_test_assert (last_request_unqueued,
"Cached resource /3 not unqueued");
g_assert_cmpstr (body3, ==, cmp);
g_free (cmp);
/* Validation failure should update cache */
debug_printf (1, " Changed must-revalidate resource w/ Last-Modified\n");
cmp = do_request (session, base_uri, "GET", "/3", NULL,
"Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
"Test-Set-Expires", "Sat, 02 Jan 2011 00:00:00 GMT",
"Test-Set-Cache-Control", "must-revalidate",
NULL);
soup_test_assert (last_request_validated,
"Request for /3 not validated");
soup_test_assert (last_request_hit_network,
"Request for /3 filled from cache");
soup_test_assert (last_request_unqueued,
"Request for /3 not unqueued");
g_assert_cmpstr (body3, !=, cmp);
g_free (cmp);
debug_printf (2, " Second request\n");
cmp = do_request (session, base_uri, "GET", "/3", NULL,
"Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
"Test-Set-Cache-Control", "must-revalidate",
NULL);
soup_test_assert (last_request_validated,
"Second request for /3 not validated");
soup_test_assert (!last_request_hit_network,
"Second request for /3 not filled from cache");
soup_test_assert (last_request_unqueued,
"Cached resource /3 not unqueued");
g_assert_cmpstr (body3, !=, cmp);
g_free (cmp);
/* ETag + must-revalidate causes a conditional request */
debug_printf (1, " Unchanged must-revalidate resource w/ ETag\n");
cmp = do_request (session, base_uri, "GET", "/4", NULL,
"Test-Set-ETag", "\"abcdefg\"",
NULL);
soup_test_assert (last_request_validated,
"Request for /4 not validated");
soup_test_assert (!last_request_hit_network,
"Request for /4 not filled from cache");
soup_test_assert (last_request_unqueued,
"Cached resource /4 not unqueued");
g_assert_cmpstr (body4, ==, cmp);
g_free (cmp);
/* Cache-Control: no-cache prevents caching */
debug_printf (1, " Uncacheable resource\n");
cmp = do_request (session, base_uri, "GET", "/5", NULL,
"Test-Set-Cache-Control", "no-cache",
NULL);
soup_test_assert (last_request_hit_network,
"Request for /5 filled from cache");
soup_test_assert (last_request_unqueued,
"Request for /5 not unqueued");
g_assert_cmpstr (body5, ==, cmp);
g_free (cmp);
/* PUT to a URI invalidates the cache entry */
debug_printf (1, " Invalidating and re-requesting a cached resource\n");
cmp = do_request (session, base_uri, "PUT", "/1", NULL,
NULL);
soup_test_assert (last_request_hit_network,
"PUT filled from cache");
g_free (cmp);
cmp = do_request (session, base_uri, "GET", "/1", NULL,
NULL);
soup_test_assert (last_request_hit_network,
"PUT failed to invalidate cache entry");
g_assert_true (last_request_hit_network);
g_free (cmp);
soup_test_session_abort_unref (session);
g_object_unref (cache);
g_free (cache_dir);
g_free (body1);
g_free (body2);
g_free (body3);
g_free (body4);
g_free (body5);
}
static void
do_cancel_test (gconstpointer data)
{
SoupURI *base_uri = (SoupURI *)data;
SoupSession *session;
SoupCache *cache;
char *cache_dir;
char *body1, *body2;
guint flags;
g_test_bug ("692310");
cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
debug_printf (2, " Caching to %s\n", cache_dir);
cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE, cache,
NULL);
g_signal_connect (session, "request-unqueued",
G_CALLBACK (request_unqueued), NULL);
debug_printf (2, " Initial requests\n");
body1 = do_request (session, base_uri, "GET", "/1", NULL,
"Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
NULL);
body2 = do_request (session, base_uri, "GET", "/2", NULL,
"Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
"Test-Set-Expires", "Fri, 01 Jan 2011 00:00:00 GMT",
"Test-Set-Cache-Control", "must-revalidate",
NULL);
/* Check that messages are correctly processed on cancellations. */
debug_printf (1, " Cancel fresh resource with soup_session_message_cancel()\n");
flags = SOUP_TEST_REQUEST_CANCEL_MESSAGE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
do_request_with_cancel (session, base_uri, "GET", "/1", flags);
g_assert_cmpint (cancelled_requests, ==, 1);
soup_test_assert (last_request_unqueued,
"Cancelled request /1 not unqueued");
debug_printf (1, " Cancel fresh resource with g_cancellable_cancel()\n");
flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
do_request_with_cancel (session, base_uri, "GET", "/1", flags);
g_assert_cmpint (cancelled_requests, ==, 1);
soup_test_assert (last_request_unqueued,
"Cancelled request /1 not unqueued");
soup_test_session_abort_unref (session);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE, cache,
NULL);
g_signal_connect (session, "request-unqueued",
G_CALLBACK (request_unqueued), NULL);
/* Check that messages are correctly processed on cancellations. */
debug_printf (1, " Cancel a revalidating resource with soup_session_message_cancel()\n");
flags = SOUP_TEST_REQUEST_CANCEL_MESSAGE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
do_request_with_cancel (session, base_uri, "GET", "/2", flags);
g_assert_cmpint (cancelled_requests, ==, 2);
soup_test_assert (last_request_unqueued,
"Cancelled request /2 not unqueued");
debug_printf (1, " Cancel a revalidating resource with g_cancellable_cancel()\n");
flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
do_request_with_cancel (session, base_uri, "GET", "/2", flags);
g_assert_cmpint (cancelled_requests, ==, 2);
soup_test_assert (last_request_unqueued,
"Cancelled request /2 not unqueued");
soup_test_session_abort_unref (session);
g_object_unref (cache);
g_free (cache_dir);
g_free (body1);
g_free (body2);
}
static gboolean
unref_stream (gpointer stream)
{
g_object_unref (stream);
return FALSE;
}
static void
base_stream_unreffed (gpointer loop, GObject *ex_base_stream)
{
g_main_loop_quit (loop);
}
static void
do_refcounting_test (gconstpointer data)
{
SoupURI *base_uri = (SoupURI *)data;
SoupSession *session;
SoupCache *cache;
char *cache_dir;
SoupRequestHTTP *req;
GInputStream *stream, *base_stream;
SoupURI *uri;
GError *error = NULL;
guint flags;
GMainLoop *loop;
g_test_bug ("682527");
cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
debug_printf (2, " Caching to %s\n", cache_dir);
cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE, cache,
NULL);
last_request_validated = last_request_hit_network = FALSE;
cancelled_requests = 0;
uri = soup_uri_new_with_base (base_uri, "/1");
req = soup_session_request_http_uri (session, "GET", uri, NULL);
soup_uri_free (uri);
flags = SOUP_TEST_REQUEST_CANCEL_AFTER_SEND_FINISH | SOUP_TEST_REQUEST_CANCEL_MESSAGE;
stream = soup_test_request_send (SOUP_REQUEST (req), NULL, flags, &error);
if (!stream) {
debug_printf (1, " could not send request: %s\n",
error->message);
g_error_free (error);
g_object_unref (req);
return;
}
g_object_unref (req);
base_stream = g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (stream));
debug_printf (1, " Checking that the base stream is properly unref'ed\n");
loop = g_main_loop_new (NULL, FALSE);
g_object_weak_ref (G_OBJECT (base_stream), base_stream_unreffed, loop);
g_idle_add (unref_stream, stream);
g_main_loop_run (loop);
g_main_loop_unref (loop);
soup_cache_flush ((SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE));
soup_test_session_abort_unref (session);
g_object_unref (cache);
g_free (cache_dir);
}
static void
do_headers_test (gconstpointer data)
{
SoupURI *base_uri = (SoupURI *)data;
SoupSession *session;
SoupMessageHeaders *headers;
SoupCache *cache;
char *cache_dir;
char *body1, *cmp;
const char *header_value;
cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
debug_printf (2, " Caching to %s\n", cache_dir);
cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE, cache,
NULL);
g_signal_connect (session, "request-queued",
G_CALLBACK (request_queued), NULL);
debug_printf (2, " Initial requests\n");
body1 = do_request (session, base_uri, "GET", "/1", NULL,
"Test-Set-Last-Modified", "Fri, 01 Jan 2100 00:00:00 GMT",
"Test-Set-My-Header", "My header value",
NULL);
/* My-Header new value should be updated in cache */
debug_printf (2, " Fresh cached resource which updates My-Header\n");
cmp = do_request (session, base_uri, "GET", "/1", NULL,
"Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
"Test-Set-My-Header", "My header NEW value",
NULL);
soup_test_assert (last_request_validated,
"Request for /1 not validated");
soup_test_assert (!last_request_hit_network,
"Request for /1 not filled from cache");
g_free (cmp);
/* Check that cache returns the updated header */
debug_printf (2, " Fresh cached resource with new value for My-Header\n");
headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_RESPONSE);
cmp = do_request (session, base_uri, "GET", "/1", headers,
"Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
NULL);
soup_test_assert (!last_request_hit_network,
"Request for /1 not filled from cache");
g_free (cmp);
header_value = soup_message_headers_get_list (headers, "My-Header");
g_assert_cmpstr (header_value, ==, "My header NEW value");
soup_message_headers_free (headers);
soup_test_session_abort_unref (session);
g_object_unref (cache);
g_free (cache_dir);
g_free (body1);
}
static guint
count_cached_resources_in_dir (const char *cache_dir)
{
GDir *dir;
const char *name;
guint retval = 0;
dir = g_dir_open (cache_dir, 0, NULL);
while ((name = g_dir_read_name (dir))) {
if (g_str_has_prefix (name, "soup."))
continue;
retval++;
}
g_dir_close (dir);
return retval;
}
static void
do_leaks_test (gconstpointer data)
{
SoupURI *base_uri = (SoupURI *)data;
SoupSession *session;
SoupCache *cache;
char *cache_dir;
char *body;
cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
debug_printf (2, " Caching to %s\n", cache_dir);
cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE, cache,
NULL);
debug_printf (2, " Initial requests\n");
body = do_request (session, base_uri, "GET", "/1", NULL,
"Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
NULL);
g_free (body);
body = do_request (session, base_uri, "GET", "/2", NULL,
"Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
NULL);
g_free (body);
body = do_request (session, base_uri, "GET", "/3", NULL,
"Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
NULL);
g_free (body);
debug_printf (2, " Dumping the cache\n");
soup_cache_dump (cache);
g_assert_cmpuint (count_cached_resources_in_dir (cache_dir), ==, 3);
body = do_request (session, base_uri, "GET", "/4", NULL,
"Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
NULL);
g_free (body);
body = do_request (session, base_uri, "GET", "/5", NULL,
"Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
NULL);
g_free (body);
/* Destroy the cache without dumping the last two resources */
soup_test_session_abort_unref (session);
g_object_unref (cache);
cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
debug_printf (2, " Loading the cache\n");
g_assert_cmpuint (count_cached_resources_in_dir (cache_dir), ==, 5);
soup_cache_load (cache);
g_assert_cmpuint (count_cached_resources_in_dir (cache_dir), ==, 3);
g_object_unref (cache);
g_free (cache_dir);
}
int
main (int argc, char **argv)
{
SoupServer *server;
SoupURI *base_uri;
int ret;
test_init (argc, argv, NULL);
server = soup_test_server_new (TRUE);
soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
base_uri = soup_test_server_get_uri (server, "http", NULL);
g_test_add_data_func ("/cache/basics", base_uri, do_basics_test);
g_test_add_data_func ("/cache/cancellation", base_uri, do_cancel_test);
g_test_add_data_func ("/cache/refcounting", base_uri, do_refcounting_test);
g_test_add_data_func ("/cache/headers", base_uri, do_headers_test);
g_test_add_data_func ("/cache/leaks", base_uri, do_leaks_test);
ret = g_test_run ();
soup_uri_free (base_uri);
soup_test_server_quit_unref (server);
test_cleanup ();
return ret;
}