Ejemplo n.º 1
0
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
}
Ejemplo n.º 2
0
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
}
Ejemplo n.º 3
0
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);
}
Ejemplo n.º 4
0
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
}
Ejemplo n.º 5
0
// 37 = 2 * 16 (chars) + 4 (hyphens) + 1 (\0)
SOL_API int
sol_util_uuid_gen(bool upcase,
    bool with_hyphens,
    char id[SOL_STATIC_ARRAY_SIZE(37)])
{
    static struct sol_str_slice hyphen = SOL_STR_SLICE_LITERAL("-");
    /* hyphens on positions 8, 13, 18, 23 (from 0) */
    static const int hyphens_pos[] = { 8, 13, 18, 23 };
    struct sol_uuid uuid = { { 0 } };
    unsigned i;
    int r;

    struct sol_buffer buf = { 0 };

    sol_buffer_init_flags(&buf, id, 37,
        SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED);

    r = uuid_gen(&uuid);
    SOL_INT_CHECK(r, < 0, r);

    for (i = 0; i < SOL_UTIL_ARRAY_SIZE(uuid.bytes); i++) {
        r = sol_buffer_append_printf(&buf, upcase ? "%02hhX" : "%02hhx",
            uuid.bytes[i]);
        SOL_INT_CHECK_GOTO(r, < 0, err);
    }

    if (with_hyphens) {
        for (i = 0; i < SOL_UTIL_ARRAY_SIZE(hyphens_pos); i++) {
            r = sol_buffer_insert_slice(&buf, hyphens_pos[i], hyphen);
            SOL_INT_CHECK_GOTO(r, < 0, err);
        }
    }

err:
    sol_buffer_fini(&buf);
    return r;
}
Ejemplo n.º 6
0
SOL_API int
sol_buffer_insert_vprintf(struct sol_buffer *buf, size_t pos, const char *fmt, va_list args)
{
    char *s;
    ssize_t len;
    struct sol_str_slice slice;
    int r;

    SOL_NULL_CHECK(buf, -EINVAL);
    SOL_NULL_CHECK(fmt, -EINVAL);
    SOL_INT_CHECK(pos, > buf->used, -EINVAL);

    if (pos == buf->used)
        return sol_buffer_append_vprintf(buf, fmt, args);

    len = vasprintf(&s, fmt, args);
    if (len < 0)
        return -errno;

    slice = SOL_STR_SLICE_STR(s, len);
    r = sol_buffer_insert_slice(buf, pos, slice);
    free(s);
    return r;
}