static void
test_evbuffer_reserve_many(void *ptr)
{
/* This is a glass-box test to handle expanding a buffer with more
* chunks and reallocating chunks as needed */
struct evbuffer *buf = evbuffer_new();
struct evbuffer_iovec v[8];
int n;
size_t sz;
int add_data = ptr && !strcmp(ptr, "add");
int fill_first = ptr && !strcmp(ptr, "fill");
char *cp1, *cp2;
/* When reserving the the first chunk, we just allocate it */
n = evbuffer_reserve_space(buf, 128, v, 2);
evbuffer_validate(buf);
tt_int_op(n, ==, 1);
tt_assert(v[0].iov_len >= 128);
sz = v[0].iov_len;
cp1 = v[0].iov_base;
if (add_data) {
*(char*)v[0].iov_base = 'X';
v[0].iov_len = 1;
n = evbuffer_commit_space(buf, v, 1);
tt_int_op(n, ==, 0);
} else if (fill_first) {
static void
test_evbuffer_remove_buffer_with_empty(void *ptr)
{
struct evbuffer *src = evbuffer_new();
struct evbuffer *dst = evbuffer_new();
char buf[2];
evbuffer_validate(src);
evbuffer_validate(dst);
/* setup the buffers */
/* we need more data in src than we will move later */
evbuffer_add_reference(src, buf, sizeof(buf), no_cleanup, NULL);
evbuffer_add_reference(src, buf, sizeof(buf), no_cleanup, NULL);
/* we need one buffer in dst and one empty buffer at the end */
evbuffer_add(dst, buf, sizeof(buf));
evbuffer_add_reference(dst, buf, 0, no_cleanup, NULL);
evbuffer_validate(src);
evbuffer_validate(dst);
/* move three bytes over */
evbuffer_remove_buffer(src, dst, 3);
evbuffer_validate(src);
evbuffer_validate(dst);
end:
evbuffer_free(src);
evbuffer_free(dst);
}
static void
test_evbuffer(void *ptr)
{
static char buffer[512], *tmp;
struct evbuffer *evb = evbuffer_new();
struct evbuffer *evb_two = evbuffer_new();
size_t sz_tmp;
int i;
evbuffer_validate(evb);
evbuffer_add_printf(evb, "%s/%d", "hello", 1);
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb) == 7);
tt_assert(!memcmp((char*)EVBUFFER_DATA(evb), "hello/1", 1));
evbuffer_add_buffer(evb, evb_two);
evbuffer_validate(evb);
evbuffer_drain(evb, strlen("hello/"));
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb) == 1);
tt_assert(!memcmp((char*)EVBUFFER_DATA(evb), "1", 1));
evbuffer_add_printf(evb_two, "%s", "/hello");
evbuffer_validate(evb);
evbuffer_add_buffer(evb, evb_two);
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb_two) == 0);
tt_assert(evbuffer_get_length(evb) == 7);
tt_assert(!memcmp((char*)EVBUFFER_DATA(evb), "1/hello", 7) != 0);
memset(buffer, 0, sizeof(buffer));
evbuffer_add(evb, buffer, sizeof(buffer));
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb) == 7 + 512);
tmp = (char *)evbuffer_pullup(evb, 7 + 512);
tt_assert(tmp);
tt_assert(!strncmp(tmp, "1/hello", 7));
tt_assert(!memcmp(tmp + 7, buffer, sizeof(buffer)));
evbuffer_validate(evb);
evbuffer_prepend(evb, "something", 9);
evbuffer_validate(evb);
evbuffer_prepend(evb, "else", 4);
evbuffer_validate(evb);
tmp = (char *)evbuffer_pullup(evb, 4 + 9 + 7);
tt_assert(!strncmp(tmp, "elsesomething1/hello", 4 + 9 + 7));
evbuffer_validate(evb);
evbuffer_drain(evb, -1);
evbuffer_validate(evb);
evbuffer_drain(evb_two, -1);
evbuffer_validate(evb);
for (i = 0; i < 3; ++i) {
evbuffer_add(evb_two, buffer, sizeof(buffer));
evbuffer_validate(evb_two);
evbuffer_add_buffer(evb, evb_two);
evbuffer_validate(evb);
evbuffer_validate(evb_two);
}
tt_assert(evbuffer_get_length(evb_two) == 0);
tt_assert(evbuffer_get_length(evb) == i * sizeof(buffer));
/* test remove buffer */
sz_tmp = (size_t)(sizeof(buffer)*2.5);
evbuffer_remove_buffer(evb, evb_two, sz_tmp);
tt_assert(evbuffer_get_length(evb_two) == sz_tmp);
tt_assert(evbuffer_get_length(evb) == sizeof(buffer) / 2);
evbuffer_validate(evb);
if (memcmp(evbuffer_pullup(
evb, -1), buffer, sizeof(buffer) / 2) != 0 ||
memcmp(evbuffer_pullup(
evb_two, -1), buffer, sizeof(buffer) != 0))
tt_abort_msg("Pullup did not preserve content");
evbuffer_validate(evb);
/* testing one-vector reserve and commit */
{
struct evbuffer_iovec v[1];
char *buf;
int i, j, r;
for (i = 0; i < 3; ++i) {
r = evbuffer_reserve_space(evb, 10000, v, 1);
tt_int_op(r, ==, 1);
tt_assert(v[0].iov_len >= 10000);
tt_assert(v[0].iov_base != NULL);
evbuffer_validate(evb);
buf = v[0].iov_base;
for (j = 0; j < 10000; ++j) {
buf[j] = j;
}
evbuffer_validate(evb);
tt_int_op(evbuffer_commit_space(evb, v, 1), ==, 0);
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb) >= 10000);
evbuffer_drain(evb, j * 5000);
evbuffer_validate(evb);
}
}
end:
evbuffer_free(evb);
evbuffer_free(evb_two);
}
static void
test_evbuffer_reserve2(void *ptr)
{
/* Test the two-vector cases of reserve/commit. */
struct evbuffer *buf = evbuffer_new();
int n, i;
struct evbuffer_iovec v[2];
size_t remaining;
char *cp, *cp2;
/* First chunk will necessarily be one chunk. Use 512 bytes of it.*/
n = evbuffer_reserve_space(buf, 1024, v, 2);
tt_int_op(n, ==, 1);
tt_int_op(evbuffer_get_length(buf), ==, 0);
tt_assert(v[0].iov_base != NULL);
tt_int_op(v[0].iov_len, >=, 1024);
memset(v[0].iov_base, 'X', 512);
cp = v[0].iov_base;
remaining = v[0].iov_len - 512;
v[0].iov_len = 512;
evbuffer_validate(buf);
tt_int_op(0, ==, evbuffer_commit_space(buf, v, 1));
tt_int_op(evbuffer_get_length(buf), ==, 512);
evbuffer_validate(buf);
/* Ask for another same-chunk request, in an existing chunk. Use 8
* bytes of it. */
n = evbuffer_reserve_space(buf, 32, v, 2);
tt_int_op(n, ==, 1);
tt_assert(cp + 512 == v[0].iov_base);
tt_int_op(remaining, ==, v[0].iov_len);
memset(v[0].iov_base, 'Y', 8);
v[0].iov_len = 8;
tt_int_op(0, ==, evbuffer_commit_space(buf, v, 1));
tt_int_op(evbuffer_get_length(buf), ==, 520);
remaining -= 8;
evbuffer_validate(buf);
/* Now ask for a request that will be split. Use only one byte of it,
though. */
n = evbuffer_reserve_space(buf, remaining+64, v, 2);
tt_int_op(n, ==, 2);
tt_assert(cp + 520 == v[0].iov_base);
tt_int_op(remaining, ==, v[0].iov_len);
tt_assert(v[1].iov_base);
tt_assert(v[1].iov_len >= 64);
cp2 = v[1].iov_base;
memset(v[0].iov_base, 'Z', 1);
v[0].iov_len = 1;
tt_int_op(0, ==, evbuffer_commit_space(buf, v, 1));
tt_int_op(evbuffer_get_length(buf), ==, 521);
remaining -= 1;
evbuffer_validate(buf);
/* Now ask for a request that will be split. Use some of the first
* part and some of the second. */
n = evbuffer_reserve_space(buf, remaining+64, v, 2);
evbuffer_validate(buf);
tt_int_op(n, ==, 2);
tt_assert(cp + 521 == v[0].iov_base);
tt_int_op(remaining, ==, v[0].iov_len);
tt_assert(v[1].iov_base == cp2);
tt_assert(v[1].iov_len >= 64);
memset(v[0].iov_base, 'W', 400);
v[0].iov_len = 400;
memset(v[1].iov_base, 'x', 60);
v[1].iov_len = 60;
tt_int_op(0, ==, evbuffer_commit_space(buf, v, 2));
tt_int_op(evbuffer_get_length(buf), ==, 981);
evbuffer_validate(buf);
/* Now peek to make sure stuff got made how we like. */
memset(v,0,sizeof(v));
n = evbuffer_peek(buf, -1, NULL, v, 2);
tt_int_op(n, ==, 2);
tt_int_op(v[0].iov_len, ==, 921);
tt_int_op(v[1].iov_len, ==, 60);
cp = v[0].iov_base;
for (i=0; i<512; ++i)
tt_int_op(cp[i], ==, 'X');
for (i=512; i<520; ++i)
tt_int_op(cp[i], ==, 'Y');
for (i=520; i<521; ++i)
tt_int_op(cp[i], ==, 'Z');
for (i=521; i<921; ++i)
tt_int_op(cp[i], ==, 'W');
cp = v[1].iov_base;
for (i=0; i<60; ++i)
tt_int_op(cp[i], ==, 'x');
end:
evbuffer_free(buf);
}
