static void test_istream_tee_blocks(const char *str)
{
struct istream *test_input, *child_input[CHILD_COUNT];
struct tee_istream *tee;
unsigned int i, j;
test_input = test_istream_create(str);
test_istream_set_max_buffer_size(test_input, TEST_BUF_SIZE);
test_begin("istream tee blocks");
tee = tee_i_stream_create(test_input);
for (i = 0; i < CHILD_COUNT; i++)
child_input[i] = tee_i_stream_create_child(tee);
test_istream_set_allow_eof(test_input, FALSE);
for (j = 1; j <= 3; j++) {
test_istream_set_size(test_input, TEST_BUF_SIZE*j);
for (i = 0; i < CHILD_COUNT; i++) {
test_assert(i_stream_read(child_input[i]) == TEST_BUF_SIZE);
i_stream_skip(child_input[i], TEST_BUF_SIZE);
}
}
test_istream_set_allow_eof(test_input, TRUE);
for (i = 0; i < CHILD_COUNT; i++) {
test_assert(i_stream_read(child_input[i]) == -1);
i_stream_unref(&child_input[i]);
}
i_stream_unref(&test_input);
test_end();
}
static void test_istream_children(void)
{
struct istream *parent, *child1, *child2;
const unsigned char *data;
size_t size;
test_begin("istream children");
parent = test_istream_create_data("123456789", 9);
test_istream_set_max_buffer_size(parent, 3);
child1 = i_stream_create_limit(parent, (uoff_t)-1);
child2 = i_stream_create_limit(parent, (uoff_t)-1);
/* child1 read beginning */
test_assert(i_stream_read(child1) == 3);
data = i_stream_get_data(child1, &size);
test_assert(size == 3 && memcmp(data, "123", 3) == 0);
i_stream_skip(child1, 3);
/* child1 read middle.. */
test_assert(i_stream_read(child1) == 3);
data = i_stream_get_data(child1, &size);
test_assert(size == 3 && memcmp(data, "456", 3) == 0);
/* child2 read beginning.. */
test_assert(i_stream_read(child2) == 3);
data = i_stream_get_data(child2, &size);
test_assert(size == 3 && memcmp(data, "123", 3) == 0);
/* child1 check middle again.. the parent has been modified,
so it can't return the original data (without some code changes). */
data = i_stream_get_data(child1, &size);
test_assert(size == 0);
i_stream_skip(child1, 3);
/* child1 read end */
test_assert(i_stream_read(child1) == 3);
data = i_stream_get_data(child1, &size);
test_assert(size == 3 && memcmp(data, "789", 3) == 0);
i_stream_skip(child1, 3);
test_assert(i_stream_read(child1) == -1);
/* child2 check beginning again.. */
data = i_stream_get_data(child2, &size);
test_assert(size == 0);
i_stream_skip(child2, 3);
/* child2 read middle */
test_assert(i_stream_read(child2) == 3);
data = i_stream_get_data(child2, &size);
test_assert(size == 3 && memcmp(data, "456", 3) == 0);
i_stream_skip(child2, 3);
i_stream_destroy(&child1);
i_stream_destroy(&child2);
i_stream_destroy(&parent);
test_end();
}
static void
decode_test(const char *qp_input, const char *output, bool broken_input,
unsigned int buffer_size)
{
unsigned int qp_input_len = strlen(qp_input);
struct istream *input_data, *input;
const unsigned char *data;
size_t i, size;
string_t *str = t_str_new(32);
int ret = 0;
input_data = test_istream_create_data(qp_input, qp_input_len);
test_istream_set_max_buffer_size(input_data, buffer_size);
test_istream_set_allow_eof(input_data, FALSE);
input = i_stream_create_qp_decoder(input_data);
for (i = 1; i <= qp_input_len; i++) {
test_istream_set_size(input_data, i);
while ((ret = i_stream_read_more(input, &data, &size)) > 0) {
str_append_n(str, data, size);
i_stream_skip(input, size);
}
if (ret == -1 && broken_input)
break;
test_assert(ret == 0);
}
if (ret == 0) {
test_istream_set_allow_eof(input_data, TRUE);
while ((ret = i_stream_read_more(input, &data, &size)) > 0) {
str_append_n(str, data, size);
i_stream_skip(input, size);
}
}
test_assert(ret == -1);
test_assert((input->stream_errno == 0 && !broken_input) ||
(input->stream_errno == EINVAL && broken_input));
test_assert(strcmp(str_c(str), output) == 0);
i_stream_unref(&input);
i_stream_unref(&input_data);
}
static void
test_message_header_parser_long_lines_str(const char *str,
unsigned int buffer_size,
struct message_size *size_r)
{
struct message_header_parser_ctx *parser;
struct message_header_line *hdr;
struct istream *input;
unsigned int i, len = strlen(str);
input = test_istream_create(str);
test_istream_set_max_buffer_size(input, buffer_size);
parser = message_parse_header_init(input, size_r, 0);
for (i = 1; i <= len; i++) {
test_istream_set_size(input, i);
while (message_parse_header_next(parser, &hdr) > 0) ;
}
message_parse_header_deinit(&parser);
i_stream_unref(&input);
}
static void test_fs_metawrap_stat(void)
{
struct fs *fs;
struct fs_file *file;
struct test_fs_file *test_file;
struct istream *input;
struct stat st;
const char *error;
unsigned int i;
test_begin("fs metawrap stat");
if (fs_init("metawrap", "test", &fs_set, &fs, &error) < 0)
i_fatal("fs_init() failed: %s", error);
for (i = 0; i < 2; i++) {
file = fs_file_init(fs, "foo", FS_OPEN_MODE_READONLY);
test_file = test_fs_file_get(fs, "foo");
str_append(test_file->contents, "key:value\n\n12345678901234567890");
if (i == 0) {
input = fs_read_stream(file, 2);
test_istream_set_max_buffer_size(test_file->input, 2);
} else {
input = NULL;
}
test_assert_idx(fs_stat(file, &st) == 0 && st.st_size == 20, i);
if (input != NULL)
i_stream_unref(&input);
fs_file_deinit(&file);
}
fs_deinit(&fs);
test_end();
}
static void test_istream_tee_tailing(const char *str)
{
struct istream *test_input, *child_input[CHILD_COUNT];
struct tee_istream *tee;
unsigned int i, len;
test_input = test_istream_create(str);
test_istream_set_max_buffer_size(test_input, TEST_BUF_SIZE);
test_begin("istream tee tailing");
tee = tee_i_stream_create(test_input);
for (i = 0; i < CHILD_COUNT; i++)
child_input[i] = tee_i_stream_create_child(tee);
test_istream_set_allow_eof(test_input, FALSE);
for (len = 1; len < TEST_BUF_SIZE; len++) {
test_istream_set_size(test_input, len);
for (i = 0; i < CHILD_COUNT; i++) {
test_assert(i_stream_read(child_input[i]) == 1);
test_assert(!tee_i_stream_child_is_waiting(child_input[i]));
test_assert(i_stream_read(child_input[i]) == 0);
test_assert(!tee_i_stream_child_is_waiting(child_input[i]));
}
}
test_istream_set_size(test_input, len);
for (i = 0; i < CHILD_COUNT; i++) {
test_assert(i_stream_read(child_input[i]) == 1);
test_assert(i_stream_read(child_input[i]) == -2);
test_assert(!tee_i_stream_child_is_waiting(child_input[i]));
}
for (len++; len <= TEST_STR_LEN; len++) {
test_istream_set_size(test_input, len);
for (i = 0; i < CHILD_COUNT; i++) {
test_assert(i_stream_read(child_input[i]) == -2);
test_assert(!tee_i_stream_child_is_waiting(child_input[i]));
}
for (i = 0; i < CHILD_COUNT-1; i++) {
i_stream_skip(child_input[i], 1);
test_assert(i_stream_read(child_input[i]) == 0);
test_assert(tee_i_stream_child_is_waiting(child_input[i]));
}
i_stream_skip(child_input[i], 1);
for (i = 0; i < CHILD_COUNT; i++) {
test_assert(i_stream_read(child_input[i]) == 1);
test_assert(i_stream_read(child_input[i]) == -2);
test_assert(!tee_i_stream_child_is_waiting(child_input[i]));
}
}
for (i = 0; i < CHILD_COUNT-1; i++) {
i_stream_skip(child_input[i], 1);
test_assert(i_stream_read(child_input[i]) == 0);
test_assert(tee_i_stream_child_is_waiting(child_input[i]));
}
i_stream_skip(child_input[i], 1);
test_assert(i_stream_read(child_input[i]) == 0);
test_assert(!tee_i_stream_child_is_waiting(child_input[i]));
test_istream_set_allow_eof(test_input, TRUE);
for (i = 0; i < CHILD_COUNT; i++) {
test_assert(i_stream_read(child_input[i]) == -1);
i_stream_unref(&child_input[i]);
}
i_stream_unref(&test_input);
test_end();
}
