test/test_buckets.c - serf - Git at Google

 /* Copyright 2002-2007 Justin Erenkrantz and Greg Stein
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <apr.h>
 #include <apr_pools.h>
 #include <apr_strings.h>

 #include "serf.h"
 #include "test_serf.h"

 #define CRLF "\r\n"

 static void test_simple_bucket_readline(CuTest *tc)
 {
     apr_status_t status;
     serf_bucket_t *bkt;
     const char *data;
     int found;
     apr_size_t len;

     apr_pool_t *test_pool = test_setup();
     serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
                                                               NULL);

     bkt = SERF_BUCKET_SIMPLE_STRING(
         "line1" CRLF
         "line2",
         alloc);

     /* Initialize parameters to check that they will be initialized. */
     len = 0x112233;
     data = 0;
     status = serf_bucket_readline(bkt, SERF_NEWLINE_CRLF, &found, &data, &len);

     CuAssertIntEquals(tc, APR_SUCCESS, status);
     CuAssertIntEquals(tc, SERF_NEWLINE_CRLF, found);
     CuAssertIntEquals(tc, 7, len);
     CuAssert(tc, data, strncmp("line1" CRLF, data, len) == 0);

     /* Initialize parameters to check that they will be initialized. */
     len = 0x112233;
     data = 0;
     status = serf_bucket_readline(bkt, SERF_NEWLINE_CRLF, &found, &data, &len);

     CuAssertIntEquals(tc, APR_EOF, status);
     CuAssertIntEquals(tc, SERF_NEWLINE_NONE, found);
     CuAssertIntEquals(tc, 5, len);
     CuAssert(tc, data, strncmp("line2", data, len) == 0);
     test_teardown(test_pool);
 }

 /* Reads bucket until EOF found and compares read data with zero terminated
    string expected. Report all failures using CuTest. */
 static void read_and_check_bucket(CuTest *tc, serf_bucket_t *bkt,
                                   const char *expected)
 {
     apr_status_t status;
     do
     {
         const char *data;
         apr_size_t len;

         status = serf_bucket_read(bkt, SERF_READ_ALL_AVAIL, &data, &len);
         CuAssert(tc, "Got error during bucket reading.",
                  !SERF_BUCKET_READ_ERROR(status));
         CuAssert(tc, "Read more data than expected.",
                  strlen(expected) >= len);
         CuAssert(tc, "Read data is not equal to expected.",
                  strncmp(expected, data, len) == 0);

         expected += len;
     } while(!APR_STATUS_IS_EOF(status));

     CuAssert(tc, "Read less data than expected.", strlen(expected) == 0);
 }

 static void test_response_bucket_read(CuTest *tc)
 {
     serf_bucket_t *bkt, *tmp;

     apr_pool_t *test_pool = test_setup();
     serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
                                                               NULL);

     tmp = SERF_BUCKET_SIMPLE_STRING(
         "HTTP/1.1 200 OK" CRLF
         "Content-Length: 7" CRLF
         CRLF
         "abc1234",
         alloc);

     bkt = serf_bucket_response_create(tmp, alloc);

     /* Read all bucket and check it content. */
     read_and_check_bucket(tc, bkt, "abc1234");
     test_teardown(test_pool);
 }

 static void test_response_bucket_headers(CuTest *tc)
 {
     serf_bucket_t *bkt, *tmp, *hdr;

     apr_pool_t *test_pool = test_setup();
     serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
                                                               NULL);

     tmp = SERF_BUCKET_SIMPLE_STRING(
         "HTTP/1.1 405 Method Not Allowed" CRLF
         "Date: Sat, 12 Jun 2010 14:17:10 GMT"  CRLF
         "Server: Apache"  CRLF
         "Allow: "  CRLF
         "Content-Length: 7"  CRLF
         "Content-Type: text/html; charset=iso-8859-1" CRLF
         "NoSpace:" CRLF
         CRLF
         "abc1234",
         alloc);

     bkt = serf_bucket_response_create(tmp, alloc);

     /* Read all bucket and check it content. */
     read_and_check_bucket(tc, bkt, "abc1234");

     hdr = serf_bucket_response_get_headers(bkt);
     CuAssertStrEquals(tc,
         "",
         serf_bucket_headers_get(hdr, "Allow"));
     CuAssertStrEquals(tc,
         "7",
         serf_bucket_headers_get(hdr, "Content-Length"));
     CuAssertStrEquals(tc,
         "",
         serf_bucket_headers_get(hdr, "NoSpace"));
     test_teardown(test_pool);
 }

 static void test_response_bucket_chunked_read(CuTest *tc)
 {
     serf_bucket_t *bkt, *tmp, *hdrs;

     apr_pool_t *test_pool = test_setup();
     serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
                                                               NULL);

     tmp = SERF_BUCKET_SIMPLE_STRING(
         "HTTP/1.1 200 OK" CRLF
         "Transfer-Encoding: chunked" CRLF
         CRLF
         "3" CRLF
         "abc" CRLF
         "4" CRLF
         "1234" CRLF
         "0" CRLF
         "Footer: value" CRLF
         CRLF,
         alloc);

     bkt = serf_bucket_response_create(tmp, alloc);

     /* Read all bucket and check it content. */
     read_and_check_bucket(tc, bkt, "abc1234");

     hdrs = serf_bucket_response_get_headers(bkt);
     CuAssertTrue(tc, hdrs != NULL);

     /* Check that trailing headers parsed correctly. */
     CuAssertStrEquals(tc, "value", serf_bucket_headers_get(hdrs, "Footer"));
     test_teardown(test_pool);
 }

 static void test_bucket_header_set(CuTest *tc)
 {
     apr_pool_t *test_pool = test_setup();
     serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
                                                               NULL);
     serf_bucket_t *hdrs = serf_bucket_headers_create(alloc);

     CuAssertTrue(tc, hdrs != NULL);

     serf_bucket_headers_set(hdrs, "Foo", "bar");

     CuAssertStrEquals(tc, "bar", serf_bucket_headers_get(hdrs, "Foo"));

     serf_bucket_headers_set(hdrs, "Foo", "baz");

     CuAssertStrEquals(tc, "bar,baz", serf_bucket_headers_get(hdrs, "Foo"));

     serf_bucket_headers_set(hdrs, "Foo", "test");

     CuAssertStrEquals(tc, "bar,baz,test", serf_bucket_headers_get(hdrs, "Foo"));

     // headers are case insensitive.
     CuAssertStrEquals(tc, "bar,baz,test", serf_bucket_headers_get(hdrs, "fOo"));
     test_teardown(test_pool);
 }

 static apr_status_t read_requested_bytes(serf_bucket_t *bkt,
                                          apr_size_t requested,
                                          const char **buf,
                                          apr_size_t *len,
                                          apr_pool_t *pool)
 {
     apr_size_t current = 0;
     const char *tmp;
     const char *data;
     apr_status_t status = APR_SUCCESS;

     tmp = apr_pcalloc(pool, requested);
     while (current < requested) {
         status = serf_bucket_read(bkt, requested, &data, len);
         memcpy((void*)(tmp + current), (void*)data, *len);
         current += *len;
         if (APR_STATUS_IS_EOF(status))
             break;
     }

     *buf = tmp;
     *len = current;
     return status;
 }


 static void test_iovec_buckets(CuTest *tc)
 {
     apr_status_t status;
     serf_bucket_t *bkt, *iobkt;
     const char *data;
     apr_size_t len;
     struct iovec vecs[32];
     struct iovec tgt_vecs[32];
     int i;
     int vecs_used;

     apr_pool_t *test_pool = test_setup();
     serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
                                                               NULL);

     /* Test 1: Read a single string in an iovec, store it in a iovec_bucket
        and then read it back. */
     bkt = SERF_BUCKET_SIMPLE_STRING(
         "line1" CRLF
         "line2",
         alloc);

     status = serf_bucket_read_iovec(bkt, SERF_READ_ALL_AVAIL, 32, vecs,
                                     &vecs_used);

     iobkt = serf_bucket_iovec_create(vecs, vecs_used, alloc);

     /* Check available data */
     status = serf_bucket_peek(iobkt, &data, &len);
     CuAssertIntEquals(tc, APR_EOF, status);
     CuAssertIntEquals(tc, strlen("line1" CRLF "line2"), len);

     /* Try to read only a few bytes (less than what's in the first buffer). */
     status = serf_bucket_read_iovec(iobkt, 3, 32, tgt_vecs, &vecs_used);
     CuAssertIntEquals(tc, APR_SUCCESS, status);
     CuAssertIntEquals(tc, 1, vecs_used);
     CuAssertIntEquals(tc, 3, tgt_vecs[0].iov_len);
     CuAssert(tc, tgt_vecs[0].iov_base,
              strncmp("lin", tgt_vecs[0].iov_base, tgt_vecs[0].iov_len) == 0);

     /* Read the rest of the data. */
     status = serf_bucket_read_iovec(iobkt, SERF_READ_ALL_AVAIL, 32, tgt_vecs,
                                     &vecs_used);
     CuAssertIntEquals(tc, APR_EOF, status);
     CuAssertIntEquals(tc, 1, vecs_used);
     CuAssertIntEquals(tc, strlen("e1" CRLF "line2"), tgt_vecs[0].iov_len);
     CuAssert(tc, tgt_vecs[0].iov_base,
              strncmp("e1" CRLF "line2", tgt_vecs[0].iov_base, tgt_vecs[0].iov_len - 3) == 0);

     /* Bucket should now be empty */
     status = serf_bucket_peek(iobkt, &data, &len);
     CuAssertIntEquals(tc, APR_EOF, status);
     CuAssertIntEquals(tc, 0, len);

     /* Test 2: Read multiple character bufs in an iovec, then read them back
        in bursts. */
     for (i = 0; i < 32 ; i++) {
         vecs[i].iov_base = apr_psprintf(test_pool, "data %02d 901234567890", i);
         vecs[i].iov_len = strlen(vecs[i].iov_base);
     }

     iobkt = serf_bucket_iovec_create(vecs, 32, alloc);

     /* Check that some data is in the buffer. Don't verify the actual data, the
        amount of data returned is not guaranteed to be the full buffer. */
     status = serf_bucket_peek(iobkt, &data, &len);
     CuAssertTrue(tc, len > 0);
     CuAssertIntEquals(tc, APR_SUCCESS, status); /* this assumes not all data is
                                                    returned at once,
                                                    not guaranteed! */

     /* Read 1 buf.   20 = sizeof("data %2d 901234567890") */
     status = serf_bucket_read_iovec(iobkt, 1 * 20, 32,
                                     tgt_vecs, &vecs_used);
     CuAssertIntEquals(tc, APR_SUCCESS, status);
     CuAssertIntEquals(tc, 1, vecs_used);
     CuAssert(tc, tgt_vecs[0].iov_base,
              strncmp("data 00 901234567890", tgt_vecs[0].iov_base, tgt_vecs[0].iov_len) == 0);

     /* Read 2 bufs. */
     status = serf_bucket_read_iovec(iobkt, 2 * 20, 32,
                                     tgt_vecs, &vecs_used);
     CuAssertIntEquals(tc, APR_SUCCESS, status);
     CuAssertIntEquals(tc, 2, vecs_used);

     /* Read the remaining 29 bufs. */
     vecs_used = 400;  /* test if iovec code correctly resets vecs_used */
     status = serf_bucket_read_iovec(iobkt, SERF_READ_ALL_AVAIL, 32,
                                     tgt_vecs, &vecs_used);
     CuAssertIntEquals(tc, APR_EOF, status);
     CuAssertIntEquals(tc, 29, vecs_used);

     /* Test 3: use serf_bucket_read */
     for (i = 0; i < 32 ; i++) {
         vecs[i].iov_base = apr_psprintf(test_pool, "DATA %02d 901234567890", i);
         vecs[i].iov_len = strlen(vecs[i].iov_base);
     }

     iobkt = serf_bucket_iovec_create(vecs, 32, alloc);

     status = serf_bucket_read(iobkt, 10, &data, &len);
     CuAssertIntEquals(tc, APR_SUCCESS, status);
     CuAssertIntEquals(tc, 10, len);
     CuAssert(tc, data,
              strncmp("DATA 00 90", data, len) == 0);

     status = serf_bucket_read(iobkt, 10, &data, &len);
     CuAssertIntEquals(tc, APR_SUCCESS, status);
     CuAssertIntEquals(tc, 10, len);
     CuAssert(tc, tgt_vecs[0].iov_base,
              strncmp("1234567890", data, len) == 0);

     for (i = 1; i < 31 ; i++) {
         const char *exp = apr_psprintf(test_pool, "DATA %02d 901234567890", i);
         status = serf_bucket_read(iobkt, SERF_READ_ALL_AVAIL, &data, &len);
         CuAssertIntEquals(tc, APR_SUCCESS, status);
         CuAssertIntEquals(tc, 20, len);
         CuAssert(tc, data,
                  strncmp(exp, data, len) == 0);

     }

     status = serf_bucket_read(iobkt, 20, &data, &len);
     CuAssertIntEquals(tc, APR_EOF, status);
     CuAssertIntEquals(tc, 20, len);
     CuAssert(tc, data,
              strncmp("DATA 31 901234567890", data, len) == 0);

     /* Test 3: read an empty iovec */
     iobkt = serf_bucket_iovec_create(vecs, 0, alloc);
     status = serf_bucket_read_iovec(iobkt, SERF_READ_ALL_AVAIL, 32,
                                     tgt_vecs, &vecs_used);
     CuAssertIntEquals(tc, APR_EOF, status);
     CuAssertIntEquals(tc, 0, vecs_used);

     status = serf_bucket_read(iobkt, SERF_READ_ALL_AVAIL, &data, &len);
     CuAssertIntEquals(tc, APR_EOF, status);
     CuAssertIntEquals(tc, 0, len);

     /* Test 4: read 0 bytes from an iovec */
     bkt = SERF_BUCKET_SIMPLE_STRING("line1" CRLF, alloc);
     status = serf_bucket_read_iovec(bkt, SERF_READ_ALL_AVAIL, 32, vecs,
                                     &vecs_used);
     iobkt = serf_bucket_iovec_create(vecs, vecs_used, alloc);
     status = serf_bucket_read_iovec(iobkt, 0, 32,
                                     tgt_vecs, &vecs_used);
     CuAssertIntEquals(tc, APR_SUCCESS, status);
     CuAssertIntEquals(tc, 0, vecs_used);

     test_teardown(test_pool);
 }

 static void test_aggregate_buckets(CuTest *tc)
 {
     apr_status_t status;
     serf_bucket_t *bkt, *aggbkt;
     struct iovec tgt_vecs[32];
     int vecs_used;

     apr_pool_t *test_pool = test_setup();
     serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
                                                               NULL);

     /* Test 1: read 0 bytes from an aggregate */
     aggbkt = serf_bucket_aggregate_create(alloc);

     bkt = SERF_BUCKET_SIMPLE_STRING("line1" CRLF, alloc);
     serf_bucket_aggregate_append(aggbkt, bkt);

     status = serf_bucket_read_iovec(aggbkt, 0, 32,
                                     tgt_vecs, &vecs_used);
     CuAssertIntEquals(tc, APR_SUCCESS, status);
     CuAssertIntEquals(tc, 0, vecs_used);

     test_teardown(test_pool);
 }

 CuSuite *test_buckets(void)
 {
     CuSuite *suite = CuSuiteNew();

     SUITE_ADD_TEST(suite, test_simple_bucket_readline);
     SUITE_ADD_TEST(suite, test_response_bucket_read);
     SUITE_ADD_TEST(suite, test_response_bucket_headers);
     SUITE_ADD_TEST(suite, test_response_bucket_chunked_read);
     SUITE_ADD_TEST(suite, test_bucket_header_set);
     SUITE_ADD_TEST(suite, test_iovec_buckets);
     SUITE_ADD_TEST(suite, test_aggregate_buckets);

     return suite;
 }
	/* Copyright 2002-2007 Justin Erenkrantz and Greg Stein
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <apr.h>
	#include <apr_pools.h>
	#include <apr_strings.h>

	#include "serf.h"
	#include "test_serf.h"

	#define CRLF "\r\n"

	static void test_simple_bucket_readline(CuTest *tc)
	{
	apr_status_t status;
	serf_bucket_t *bkt;
	const char *data;
	int found;
	apr_size_t len;

	apr_pool_t *test_pool = test_setup();
	serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
	NULL);

	bkt = SERF_BUCKET_SIMPLE_STRING(
	"line1" CRLF
	"line2",
	alloc);

	/* Initialize parameters to check that they will be initialized. */
	len = 0x112233;
	data = 0;
	status = serf_bucket_readline(bkt, SERF_NEWLINE_CRLF, &found, &data, &len);

	CuAssertIntEquals(tc, APR_SUCCESS, status);
	CuAssertIntEquals(tc, SERF_NEWLINE_CRLF, found);
	CuAssertIntEquals(tc, 7, len);
	CuAssert(tc, data, strncmp("line1" CRLF, data, len) == 0);

	/* Initialize parameters to check that they will be initialized. */
	len = 0x112233;
	data = 0;
	status = serf_bucket_readline(bkt, SERF_NEWLINE_CRLF, &found, &data, &len);

	CuAssertIntEquals(tc, APR_EOF, status);
	CuAssertIntEquals(tc, SERF_NEWLINE_NONE, found);
	CuAssertIntEquals(tc, 5, len);
	CuAssert(tc, data, strncmp("line2", data, len) == 0);
	test_teardown(test_pool);
	}

	/* Reads bucket until EOF found and compares read data with zero terminated
	string expected. Report all failures using CuTest. */
	static void read_and_check_bucket(CuTest tc, serf_bucket_t bkt,
	const char *expected)
	{
	apr_status_t status;
	do
	{
	const char *data;
	apr_size_t len;

	status = serf_bucket_read(bkt, SERF_READ_ALL_AVAIL, &data, &len);
	CuAssert(tc, "Got error during bucket reading.",
	!SERF_BUCKET_READ_ERROR(status));
	CuAssert(tc, "Read more data than expected.",
	strlen(expected) >= len);
	CuAssert(tc, "Read data is not equal to expected.",
	strncmp(expected, data, len) == 0);

	expected += len;
	} while(!APR_STATUS_IS_EOF(status));

	CuAssert(tc, "Read less data than expected.", strlen(expected) == 0);
	}

	static void test_response_bucket_read(CuTest *tc)
	{
	serf_bucket_t bkt, tmp;

	apr_pool_t *test_pool = test_setup();
	serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
	NULL);

	tmp = SERF_BUCKET_SIMPLE_STRING(
	"HTTP/1.1 200 OK" CRLF
	"Content-Length: 7" CRLF
	CRLF
	"abc1234",
	alloc);

	bkt = serf_bucket_response_create(tmp, alloc);

	/* Read all bucket and check it content. */
	read_and_check_bucket(tc, bkt, "abc1234");
	test_teardown(test_pool);
	}

	static void test_response_bucket_headers(CuTest *tc)
	{
	serf_bucket_t bkt, tmp, *hdr;

	apr_pool_t *test_pool = test_setup();
	serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
	NULL);

	tmp = SERF_BUCKET_SIMPLE_STRING(
	"HTTP/1.1 405 Method Not Allowed" CRLF
	"Date: Sat, 12 Jun 2010 14:17:10 GMT" CRLF
	"Server: Apache" CRLF
	"Allow: " CRLF
	"Content-Length: 7" CRLF
	"Content-Type: text/html; charset=iso-8859-1" CRLF
	"NoSpace:" CRLF
	CRLF
	"abc1234",
	alloc);

	bkt = serf_bucket_response_create(tmp, alloc);

	/* Read all bucket and check it content. */
	read_and_check_bucket(tc, bkt, "abc1234");

	hdr = serf_bucket_response_get_headers(bkt);
	CuAssertStrEquals(tc,
	"",
	serf_bucket_headers_get(hdr, "Allow"));
	CuAssertStrEquals(tc,
	"7",
	serf_bucket_headers_get(hdr, "Content-Length"));
	CuAssertStrEquals(tc,
	"",
	serf_bucket_headers_get(hdr, "NoSpace"));
	test_teardown(test_pool);
	}

	static void test_response_bucket_chunked_read(CuTest *tc)
	{
	serf_bucket_t bkt, tmp, *hdrs;

	apr_pool_t *test_pool = test_setup();
	serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
	NULL);

	tmp = SERF_BUCKET_SIMPLE_STRING(
	"HTTP/1.1 200 OK" CRLF
	"Transfer-Encoding: chunked" CRLF
	CRLF
	"3" CRLF
	"abc" CRLF
	"4" CRLF
	"1234" CRLF
	"0" CRLF
	"Footer: value" CRLF
	CRLF,
	alloc);

	bkt = serf_bucket_response_create(tmp, alloc);

	/* Read all bucket and check it content. */
	read_and_check_bucket(tc, bkt, "abc1234");

	hdrs = serf_bucket_response_get_headers(bkt);
	CuAssertTrue(tc, hdrs != NULL);

	/* Check that trailing headers parsed correctly. */
	CuAssertStrEquals(tc, "value", serf_bucket_headers_get(hdrs, "Footer"));
	test_teardown(test_pool);
	}

	static void test_bucket_header_set(CuTest *tc)
	{
	apr_pool_t *test_pool = test_setup();
	serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
	NULL);
	serf_bucket_t *hdrs = serf_bucket_headers_create(alloc);

	CuAssertTrue(tc, hdrs != NULL);

	serf_bucket_headers_set(hdrs, "Foo", "bar");

	CuAssertStrEquals(tc, "bar", serf_bucket_headers_get(hdrs, "Foo"));

	serf_bucket_headers_set(hdrs, "Foo", "baz");

	CuAssertStrEquals(tc, "bar,baz", serf_bucket_headers_get(hdrs, "Foo"));

	serf_bucket_headers_set(hdrs, "Foo", "test");

	CuAssertStrEquals(tc, "bar,baz,test", serf_bucket_headers_get(hdrs, "Foo"));

	// headers are case insensitive.
	CuAssertStrEquals(tc, "bar,baz,test", serf_bucket_headers_get(hdrs, "fOo"));
	test_teardown(test_pool);
	}

	static apr_status_t read_requested_bytes(serf_bucket_t *bkt,
	apr_size_t requested,
	const char **buf,
	apr_size_t *len,
	apr_pool_t *pool)
	{
	apr_size_t current = 0;
	const char *tmp;
	const char *data;
	apr_status_t status = APR_SUCCESS;

	tmp = apr_pcalloc(pool, requested);
	while (current < requested) {
	status = serf_bucket_read(bkt, requested, &data, len);
	memcpy((void)(tmp + current), (void)data, *len);
	current += *len;
	if (APR_STATUS_IS_EOF(status))
	break;
	}

	*buf = tmp;
	*len = current;
	return status;
	}


	static void test_iovec_buckets(CuTest *tc)
	{
	apr_status_t status;
	serf_bucket_t bkt, iobkt;
	const char *data;
	apr_size_t len;
	struct iovec vecs[32];
	struct iovec tgt_vecs[32];
	int i;
	int vecs_used;

	apr_pool_t *test_pool = test_setup();
	serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
	NULL);

	/* Test 1: Read a single string in an iovec, store it in a iovec_bucket
	and then read it back. */
	bkt = SERF_BUCKET_SIMPLE_STRING(
	"line1" CRLF
	"line2",
	alloc);

	status = serf_bucket_read_iovec(bkt, SERF_READ_ALL_AVAIL, 32, vecs,
	&vecs_used);

	iobkt = serf_bucket_iovec_create(vecs, vecs_used, alloc);

	/* Check available data */
	status = serf_bucket_peek(iobkt, &data, &len);
	CuAssertIntEquals(tc, APR_EOF, status);
	CuAssertIntEquals(tc, strlen("line1" CRLF "line2"), len);

	/* Try to read only a few bytes (less than what's in the first buffer). */
	status = serf_bucket_read_iovec(iobkt, 3, 32, tgt_vecs, &vecs_used);
	CuAssertIntEquals(tc, APR_SUCCESS, status);
	CuAssertIntEquals(tc, 1, vecs_used);
	CuAssertIntEquals(tc, 3, tgt_vecs[0].iov_len);
	CuAssert(tc, tgt_vecs[0].iov_base,
	strncmp("lin", tgt_vecs[0].iov_base, tgt_vecs[0].iov_len) == 0);

	/* Read the rest of the data. */
	status = serf_bucket_read_iovec(iobkt, SERF_READ_ALL_AVAIL, 32, tgt_vecs,
	&vecs_used);
	CuAssertIntEquals(tc, APR_EOF, status);
	CuAssertIntEquals(tc, 1, vecs_used);
	CuAssertIntEquals(tc, strlen("e1" CRLF "line2"), tgt_vecs[0].iov_len);
	CuAssert(tc, tgt_vecs[0].iov_base,
	strncmp("e1" CRLF "line2", tgt_vecs[0].iov_base, tgt_vecs[0].iov_len - 3) == 0);

	/* Bucket should now be empty */
	status = serf_bucket_peek(iobkt, &data, &len);
	CuAssertIntEquals(tc, APR_EOF, status);
	CuAssertIntEquals(tc, 0, len);

	/* Test 2: Read multiple character bufs in an iovec, then read them back
	in bursts. */
	for (i = 0; i < 32 ; i++) {
	vecs[i].iov_base = apr_psprintf(test_pool, "data %02d 901234567890", i);
	vecs[i].iov_len = strlen(vecs[i].iov_base);
	}

	iobkt = serf_bucket_iovec_create(vecs, 32, alloc);

	/* Check that some data is in the buffer. Don't verify the actual data, the
	amount of data returned is not guaranteed to be the full buffer. */
	status = serf_bucket_peek(iobkt, &data, &len);
	CuAssertTrue(tc, len > 0);
	CuAssertIntEquals(tc, APR_SUCCESS, status); /* this assumes not all data is
	returned at once,
	not guaranteed! */

	/* Read 1 buf. 20 = sizeof("data %2d 901234567890") */
	status = serf_bucket_read_iovec(iobkt, 1 * 20, 32,
	tgt_vecs, &vecs_used);
	CuAssertIntEquals(tc, APR_SUCCESS, status);
	CuAssertIntEquals(tc, 1, vecs_used);
	CuAssert(tc, tgt_vecs[0].iov_base,
	strncmp("data 00 901234567890", tgt_vecs[0].iov_base, tgt_vecs[0].iov_len) == 0);

	/* Read 2 bufs. */
	status = serf_bucket_read_iovec(iobkt, 2 * 20, 32,
	tgt_vecs, &vecs_used);
	CuAssertIntEquals(tc, APR_SUCCESS, status);
	CuAssertIntEquals(tc, 2, vecs_used);

	/* Read the remaining 29 bufs. */
	vecs_used = 400; /* test if iovec code correctly resets vecs_used */
	status = serf_bucket_read_iovec(iobkt, SERF_READ_ALL_AVAIL, 32,
	tgt_vecs, &vecs_used);
	CuAssertIntEquals(tc, APR_EOF, status);
	CuAssertIntEquals(tc, 29, vecs_used);

	/* Test 3: use serf_bucket_read */
	for (i = 0; i < 32 ; i++) {
	vecs[i].iov_base = apr_psprintf(test_pool, "DATA %02d 901234567890", i);
	vecs[i].iov_len = strlen(vecs[i].iov_base);
	}

	iobkt = serf_bucket_iovec_create(vecs, 32, alloc);

	status = serf_bucket_read(iobkt, 10, &data, &len);
	CuAssertIntEquals(tc, APR_SUCCESS, status);
	CuAssertIntEquals(tc, 10, len);
	CuAssert(tc, data,
	strncmp("DATA 00 90", data, len) == 0);

	status = serf_bucket_read(iobkt, 10, &data, &len);
	CuAssertIntEquals(tc, APR_SUCCESS, status);
	CuAssertIntEquals(tc, 10, len);
	CuAssert(tc, tgt_vecs[0].iov_base,
	strncmp("1234567890", data, len) == 0);

	for (i = 1; i < 31 ; i++) {
	const char *exp = apr_psprintf(test_pool, "DATA %02d 901234567890", i);
	status = serf_bucket_read(iobkt, SERF_READ_ALL_AVAIL, &data, &len);
	CuAssertIntEquals(tc, APR_SUCCESS, status);
	CuAssertIntEquals(tc, 20, len);
	CuAssert(tc, data,
	strncmp(exp, data, len) == 0);

	}

	status = serf_bucket_read(iobkt, 20, &data, &len);
	CuAssertIntEquals(tc, APR_EOF, status);
	CuAssertIntEquals(tc, 20, len);
	CuAssert(tc, data,
	strncmp("DATA 31 901234567890", data, len) == 0);

	/* Test 3: read an empty iovec */
	iobkt = serf_bucket_iovec_create(vecs, 0, alloc);
	status = serf_bucket_read_iovec(iobkt, SERF_READ_ALL_AVAIL, 32,
	tgt_vecs, &vecs_used);
	CuAssertIntEquals(tc, APR_EOF, status);
	CuAssertIntEquals(tc, 0, vecs_used);

	status = serf_bucket_read(iobkt, SERF_READ_ALL_AVAIL, &data, &len);
	CuAssertIntEquals(tc, APR_EOF, status);
	CuAssertIntEquals(tc, 0, len);

	/* Test 4: read 0 bytes from an iovec */
	bkt = SERF_BUCKET_SIMPLE_STRING("line1" CRLF, alloc);
	status = serf_bucket_read_iovec(bkt, SERF_READ_ALL_AVAIL, 32, vecs,
	&vecs_used);
	iobkt = serf_bucket_iovec_create(vecs, vecs_used, alloc);
	status = serf_bucket_read_iovec(iobkt, 0, 32,
	tgt_vecs, &vecs_used);
	CuAssertIntEquals(tc, APR_SUCCESS, status);
	CuAssertIntEquals(tc, 0, vecs_used);

	test_teardown(test_pool);
	}

	static void test_aggregate_buckets(CuTest *tc)
	{
	apr_status_t status;
	serf_bucket_t bkt, aggbkt;
	struct iovec tgt_vecs[32];
	int vecs_used;

	apr_pool_t *test_pool = test_setup();
	serf_bucket_alloc_t *alloc = serf_bucket_allocator_create(test_pool, NULL,
	NULL);

	/* Test 1: read 0 bytes from an aggregate */
	aggbkt = serf_bucket_aggregate_create(alloc);

	bkt = SERF_BUCKET_SIMPLE_STRING("line1" CRLF, alloc);
	serf_bucket_aggregate_append(aggbkt, bkt);

	status = serf_bucket_read_iovec(aggbkt, 0, 32,
	tgt_vecs, &vecs_used);
	CuAssertIntEquals(tc, APR_SUCCESS, status);
	CuAssertIntEquals(tc, 0, vecs_used);

	test_teardown(test_pool);
	}

	CuSuite *test_buckets(void)
	{
	CuSuite *suite = CuSuiteNew();

	SUITE_ADD_TEST(suite, test_simple_bucket_readline);
	SUITE_ADD_TEST(suite, test_response_bucket_read);
	SUITE_ADD_TEST(suite, test_response_bucket_headers);
	SUITE_ADD_TEST(suite, test_response_bucket_chunked_read);
	SUITE_ADD_TEST(suite, test_bucket_header_set);
	SUITE_ADD_TEST(suite, test_iovec_buckets);
	SUITE_ADD_TEST(suite, test_aggregate_buckets);

	return suite;
	}