static void
test_remove_data(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
int err;
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("ABCDEFGHI");
err = sol_buffer_append_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("ABCDEFGHI"));
ASSERT_STR_EQ(buf.data, "ABCDEFGHI");
err = sol_buffer_remove_data(&buf, strlen("ABC"), 0);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("DEFGHI"));
err = sol_buffer_remove_data(&buf, strlen("GHI"), 3);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("DEF"));
err = sol_buffer_remove_data(&buf, strlen("DEF"), 0);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, 0);
err = sol_buffer_remove_data(&buf, 100, 0);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, 0);
err = sol_buffer_remove_data(&buf, 0, 100);
ASSERT_INT_EQ(err, -EINVAL);
sol_buffer_fini(&buf);
}
static void
test_append_from_base64(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char to_decode[] = "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz";
int err;
#define B64_DECODED "This is a message that is multiple of 3 chars"
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("XYZ");
err = sol_buffer_append_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("XYZ"));
ASSERT_STR_EQ(buf.data, "XYZ");
slice = sol_str_slice_from_str(to_decode);
err = sol_buffer_append_from_base64(&buf, slice, SOL_BASE64_MAP);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("XYZ" B64_DECODED));
ASSERT_STR_EQ(buf.data, "XYZ" B64_DECODED);
sol_buffer_fini(&buf);
#undef B64_DECODED
}
static void
test_append_from_base16(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char to_decode[] = "546573742001090a0f2048656c6c6f";
int err;
#define B16_DECODED "Test \x01\x09\x0a\x0f Hello"
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("XYZ");
err = sol_buffer_append_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("XYZ"));
ASSERT_STR_EQ(buf.data, "XYZ");
slice = sol_str_slice_from_str(to_decode);
err = sol_buffer_append_from_base16(&buf, slice, SOL_DECODE_LOWERCASE);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("XYZ" B16_DECODED));
ASSERT_STR_EQ(buf.data, "XYZ" B16_DECODED);
sol_buffer_fini(&buf);
#undef B16_DECODED
}
static void
test_insert_as_base16(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char to_encode[] = "Test \x01\x09\x0a\x0f Hello";
int err;
#define B16_ENCODED "546573742001090a0f2048656c6c6f"
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("World");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("World"));
ASSERT_STR_EQ(buf.data, "World");
slice = sol_str_slice_from_str("Hello");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("HelloWorld"));
ASSERT_STR_EQ(buf.data, "HelloWorld");
slice = sol_str_slice_from_str(to_encode);
err = sol_buffer_insert_as_base16(&buf, strlen("Hello"), slice, false);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("Hello" B16_ENCODED "World"));
ASSERT_STR_EQ(buf.data, "Hello" B16_ENCODED "World");
sol_buffer_fini(&buf);
#undef B16_ENCODED
}
static void
test_insert_slice(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
int err;
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("World");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("World"));
ASSERT_STR_EQ(buf.data, "World");
slice = sol_str_slice_from_str("Hello");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("HelloWorld"));
ASSERT_STR_EQ(buf.data, "HelloWorld");
slice = sol_str_slice_from_str(" -*- ");
err = sol_buffer_insert_slice(&buf, strlen("Hello"), slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("Hello -*- World"));
ASSERT_STR_EQ(buf.data, "Hello -*- World");
sol_buffer_fini(&buf);
}
static void
test_insert_as_base64(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char to_encode[] = "This is a message that is multiple of 3 chars";
int err;
#define B64_ENCODED "VGhpcyBpcyBhIG1lc3NhZ2UgdGhhdCBpcyBtdWx0aXBsZSBvZiAzIGNoYXJz"
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("World");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("World"));
ASSERT_STR_EQ(buf.data, "World");
slice = sol_str_slice_from_str("Hello");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("HelloWorld"));
ASSERT_STR_EQ(buf.data, "HelloWorld");
slice = sol_str_slice_from_str(to_encode);
err = sol_buffer_insert_as_base64(&buf, strlen("Hello"), slice, SOL_BASE64_MAP);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("Hello" B64_ENCODED "World"));
ASSERT_STR_EQ(buf.data, "Hello" B64_ENCODED "World");
sol_buffer_fini(&buf);
#undef B64_ENCODED
}
static void
test_set_slice(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char *str = "Hello";
char *backend;
int err;
backend = strdup(str);
slice = sol_str_slice_from_str(backend);
sol_buffer_init(&buf);
err = sol_buffer_set_slice(&buf, slice);
ASSERT(err >= 0);
ASSERT_INT_EQ(buf.used, strlen(backend));
ASSERT_STR_EQ(buf.data, backend);
backend[1] = 'a';
ASSERT_STR_NE(buf.data, backend);
ASSERT_STR_EQ(buf.data, str);
sol_buffer_fini(&buf);
free(backend);
}
static void
test_copy_slice(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char *str = "Hello";
char *backend;
int err;
backend = strdup(str);
slice = sol_str_slice_from_str(backend);
sol_buffer_init(&buf);
err = sol_buffer_copy_slice(&buf, slice);
ASSERT(err >= 0);
ASSERT(buf.size >= strlen(backend) + 1);
ASSERT(streq(buf.data, backend));
backend[1] = 'a';
ASSERT(!streq(buf.data, backend));
ASSERT(streq(buf.data, str));
sol_buffer_fini(&buf);
free(backend);
}
static void
fini_null_is_fine(void)
{
struct sol_buffer buf;
sol_buffer_init(&buf);
sol_buffer_fini(&buf);
/* Finish an already finished buffer. */
sol_buffer_fini(&buf);
sol_buffer_fini(NULL);
}
static void
test_insert_from_base16(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char to_decode[] = "546573742001090a0f2048656c6c6f";
int err;
#define B16_DECODED "Test \x01\x09\x0a\x0f Hello"
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("World");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("World"));
ASSERT_STR_EQ(buf.data, "World");
slice = sol_str_slice_from_str("Hello");
err = sol_buffer_insert_slice(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("HelloWorld"));
ASSERT_STR_EQ(buf.data, "HelloWorld");
slice = sol_str_slice_from_str(to_decode);
err = sol_buffer_insert_from_base16(&buf, strlen("Hello"), slice,
SOL_DECODE_LOWERCASE);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("Hello" B16_DECODED "World"));
ASSERT_STR_EQ(buf.data, "Hello" B16_DECODED "World");
slice = sol_str_slice_from_str("12x"); /* broken base16 */
err = sol_buffer_insert_from_base16(&buf, strlen("Hello"), slice,
SOL_DECODE_LOWERCASE);
ASSERT_INT_NE(err, 0);
ASSERT_INT_EQ(buf.used, strlen("Hello" B16_DECODED "World"));
ASSERT_STR_EQ(buf.data, "Hello" B16_DECODED "World");
sol_buffer_fini(&buf);
#undef B16_DECODED
}
static void
test_insert_printf(void)
{
struct sol_buffer buf;
int err;
sol_buffer_init(&buf);
err = sol_buffer_insert_printf(&buf, 0, "'%s'", "This is a longer string, bla bla bla, bla bla bla");
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "'This is a longer string, bla bla bla, bla bla bla'");
err = sol_buffer_insert_printf(&buf, 0, "[%03d]", 1);
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "[001]'This is a longer string, bla bla bla, bla bla bla'");
err = sol_buffer_insert_printf(&buf, strlen("[001]"), " ### ");
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "[001] ### 'This is a longer string, bla bla bla, bla bla bla'");
sol_buffer_fini(&buf);
}
static void
test_append_printf(void)
{
struct sol_buffer buf;
int err;
sol_buffer_init(&buf);
err = sol_buffer_append_printf(&buf, "[%03d]", 1);
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "[001]");
err = sol_buffer_append_printf(&buf, "'%s'", "This is a longer string, bla bla bla, bla bla bla");
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "[001]'This is a longer string, bla bla bla, bla bla bla'");
err = sol_buffer_append_printf(&buf, ".");
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "[001]'This is a longer string, bla bla bla, bla bla bla'.");
sol_buffer_fini(&buf);
}
static void
test_append_slice(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
const char *str = "Hello";
const char *expected_str = "HelloHello";
char *backend;
int err;
backend = strdup(str);
slice = sol_str_slice_from_str(backend);
sol_buffer_init(&buf);
err = sol_buffer_set_slice(&buf, slice);
ASSERT(err >= 0);
ASSERT_INT_EQ(buf.used, strlen(backend));
ASSERT_STR_EQ(buf.data, backend);
err = sol_buffer_append_slice(&buf, slice);
ASSERT(err >= 0);
ASSERT_INT_EQ(buf.used, strlen(expected_str));
backend[1] = 'a';
ASSERT_STR_NE(buf.data, backend);
ASSERT_STR_EQ(buf.data, expected_str);
slice = sol_buffer_get_slice(&buf);
ASSERT_INT_EQ(slice.len, buf.used);
ASSERT_STR_EQ(slice.data, buf.data);
slice = sol_buffer_get_slice_at(&buf, 2);
ASSERT_INT_EQ(slice.len, buf.used - 2);
ASSERT_STR_EQ(slice.data, (char *)buf.data + 2);
sol_buffer_fini(&buf);
free(backend);
}
static void
test_set_char_at(void)
{
struct sol_buffer buf;
int err;
sol_buffer_init(&buf);
err = sol_buffer_set_char_at(&buf, 0, 'a');
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, 1);
ASSERT_STR_EQ(buf.data, "a");
err = sol_buffer_set_char_at(&buf, 0, 'b');
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, 1);
ASSERT_STR_EQ(buf.data, "b");
err = sol_buffer_set_char_at(&buf, 1, 'c');
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("bc"));
ASSERT_STR_EQ(buf.data, "bc");
err = sol_buffer_set_char_at(&buf, 0, 'a');
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("ac"));
ASSERT_STR_EQ(buf.data, "ac");
//growing
err = sol_buffer_set_char_at(&buf, 2, 'd');
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("acd"));
ASSERT_STR_EQ(buf.data, "acd");
err = sol_buffer_set_char_at(&buf, 222, 'e');
ASSERT_INT_EQ(err, -EINVAL);
sol_buffer_fini(&buf);
}
static void
on_digest_ready(void *data, struct sol_message_digest *handle, struct sol_blob *digest)
{
struct feed_ctx *ctx = data;
struct sol_buffer buf;
int r;
sol_buffer_init(&buf);
r = sol_buffer_append_as_base16(&buf, sol_str_slice_from_blob(digest), false);
if (r == 0) {
printf("%s\t%s\n", (char *)buf.data, ctx->file);
}
sol_buffer_fini(&buf);
print_time(ctx, ctx->done, "final");
sol_message_digest_del(handle);
free(ctx);
pending--;
if (pending == 0)
sol_quit();
}
static void
test_set_slice_at(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
int err;
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("World");
err = sol_buffer_set_slice_at(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("World"));
ASSERT_STR_EQ(buf.data, "World");
slice = sol_str_slice_from_str("Hello");
err = sol_buffer_set_slice_at(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("Hello"));
ASSERT_STR_EQ(buf.data, "Hello");
slice = sol_str_slice_from_str("World");
err = sol_buffer_set_slice_at(&buf, strlen("Hello"), slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("HelloWorld"));
ASSERT_STR_EQ(buf.data, "HelloWorld");
slice = sol_str_slice_from_str(" -*- ");
err = sol_buffer_set_slice_at(&buf, 2, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("He -*- rld"));
ASSERT_STR_EQ(buf.data, "He -*- rld");
//overlapping
slice = SOL_STR_SLICE_STR((char *)buf.data + 3, 3);
err = sol_buffer_set_slice_at(&buf, 7, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("He -*- -*-"));
ASSERT_STR_EQ(buf.data, "He -*- -*-");
slice = sol_str_slice_from_str("whatever");
err = sol_buffer_set_slice_at(&buf, 222, slice);
ASSERT_INT_EQ(err, -EINVAL);
sol_buffer_fini(&buf);
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("abcd");
err = sol_buffer_set_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("abcd"));
ASSERT_STR_EQ(buf.data, "abcd");
slice = sol_str_slice_from_str("XY");
err = sol_buffer_set_slice_at(&buf, 4, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("abcdXY"));
ASSERT_STR_EQ(buf.data, "abcdXY");
sol_buffer_fini(&buf);
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("abcd");
err = sol_buffer_set_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("abcd"));
ASSERT_STR_EQ(buf.data, "abcd");
slice = sol_str_slice_from_str("XY");
err = sol_buffer_set_slice_at(&buf, 3, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("abcXY"));
ASSERT_STR_EQ(buf.data, "abcXY");
sol_buffer_fini(&buf);
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("abcd");
err = sol_buffer_set_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("abcd"));
ASSERT_STR_EQ(buf.data, "abcd");
slice = sol_str_slice_from_str("XY");
err = sol_buffer_set_slice_at(&buf, 2, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("abXY"));
ASSERT_STR_EQ(buf.data, "abXY");
sol_buffer_fini(&buf);
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("abcd");
err = sol_buffer_set_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("abcd"));
ASSERT_STR_EQ(buf.data, "abcd");
slice = sol_str_slice_from_str("XY");
err = sol_buffer_set_slice_at(&buf, 1, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("aXYd"));
ASSERT_STR_EQ(buf.data, "aXYd");
sol_buffer_fini(&buf);
sol_buffer_init(&buf);
slice = sol_str_slice_from_str("abcd");
err = sol_buffer_set_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("abcd"));
ASSERT_STR_EQ(buf.data, "abcd");
slice = sol_str_slice_from_str("XY");
err = sol_buffer_set_slice_at(&buf, 0, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_INT_EQ(buf.used, strlen("XYcd"));
ASSERT_STR_EQ(buf.data, "XYcd");
sol_buffer_fini(&buf);
}
