/* Test that bucket E has content EDATA of length ELEN. */
static void test_bucket_content(abts_case *tc,
apr_bucket *e,
const char *edata,
apr_size_t elen)
{
const char *adata;
apr_size_t alen;
apr_assert_success(tc, "read from bucket",
apr_bucket_read(e, &adata, &alen,
APR_BLOCK_READ));
ABTS_ASSERT(tc, "read expected length", alen == elen);
ABTS_STR_NEQUAL(tc, edata, adata, elen);
}
static void snprintf_noNULL(abts_case *tc, void *data)
{
char buff[100];
char *testing = apr_palloc(p, 10);
testing[0] = 't';
testing[1] = 'e';
testing[2] = 's';
testing[3] = 't';
testing[4] = 'i';
testing[5] = 'n';
testing[6] = 'g';
/* If this test fails, we are going to seg fault. */
apr_snprintf(buff, sizeof(buff), "%.*s", 7, testing);
ABTS_STR_NEQUAL(tc, buff, testing, 7);
}
/* tests that 'bb' flattens to string 'expect'. */
static void flatten_match(abts_case *tc, const char *ctx,
apr_bucket_brigade *bb,
const char *expect)
{
apr_size_t elen = strlen(expect);
char *buf = malloc(elen);
apr_size_t len = elen;
char msg[200];
sprintf(msg, "%s: flatten brigade", ctx);
apr_assert_success(tc, msg, apr_brigade_flatten(bb, buf, &len));
sprintf(msg, "%s: length match (%ld not %ld)", ctx,
(long)len, (long)elen);
ABTS_ASSERT(tc, msg, len == elen);
sprintf(msg, "%s: result match", msg);
ABTS_STR_NEQUAL(tc, expect, buf, len);
free(buf);
}
static void test_splits(abts_case *tc, void *ctx)
{
apr_bucket_alloc_t *ba = apr_bucket_alloc_create(p);
apr_bucket_brigade *bb;
apr_bucket *e;
char *str = "alphabeta";
int n;
bb = apr_brigade_create(p, ba);
APR_BRIGADE_INSERT_TAIL(bb,
apr_bucket_immortal_create(str, 9, ba));
APR_BRIGADE_INSERT_TAIL(bb,
apr_bucket_transient_create(str, 9, ba));
APR_BRIGADE_INSERT_TAIL(bb,
apr_bucket_heap_create(strdup(str), 9, free, ba));
APR_BRIGADE_INSERT_TAIL(bb,
apr_bucket_pool_create(apr_pstrdup(p, str), 9, p,
ba));
ABTS_ASSERT(tc, "four buckets inserted", count_buckets(bb) == 4);
/* now split each of the buckets after byte 5 */
for (n = 0, e = APR_BRIGADE_FIRST(bb); n < 4; n++) {
ABTS_ASSERT(tc, "reached end of brigade",
e != APR_BRIGADE_SENTINEL(bb));
ABTS_ASSERT(tc, "split bucket OK",
apr_bucket_split(e, 5) == APR_SUCCESS);
e = APR_BUCKET_NEXT(e);
ABTS_ASSERT(tc, "split OK", e != APR_BRIGADE_SENTINEL(bb));
e = APR_BUCKET_NEXT(e);
}
ABTS_ASSERT(tc, "four buckets split into eight",
count_buckets(bb) == 8);
for (n = 0, e = APR_BRIGADE_FIRST(bb); n < 4; n++) {
const char *data;
apr_size_t len;
apr_assert_success(tc, "read alpha from bucket",
apr_bucket_read(e, &data, &len, APR_BLOCK_READ));
ABTS_ASSERT(tc, "read 5 bytes", len == 5);
ABTS_STR_NEQUAL(tc, "alpha", data, 5);
e = APR_BUCKET_NEXT(e);
apr_assert_success(tc, "read beta from bucket",
apr_bucket_read(e, &data, &len, APR_BLOCK_READ));
ABTS_ASSERT(tc, "read 4 bytes", len == 4);
ABTS_STR_NEQUAL(tc, "beta", data, 5);
e = APR_BUCKET_NEXT(e);
}
/* now delete the "alpha" buckets */
for (n = 0, e = APR_BRIGADE_FIRST(bb); n < 4; n++) {
apr_bucket *f;
ABTS_ASSERT(tc, "reached end of brigade",
e != APR_BRIGADE_SENTINEL(bb));
f = APR_BUCKET_NEXT(e);
apr_bucket_delete(e);
e = APR_BUCKET_NEXT(f);
}
ABTS_ASSERT(tc, "eight buckets reduced to four",
count_buckets(bb) == 4);
flatten_match(tc, "flatten beta brigade", bb,
"beta" "beta" "beta" "beta");
apr_brigade_destroy(bb);
apr_bucket_alloc_destroy(ba);
}
