static void
test_no_nul_byte(void)
{
struct sol_buffer buf;
int32_t backend;
int32_t value = 0xdeadbeef;
int err;
sol_buffer_init_flags(&buf, &backend, sizeof(backend),
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED | SOL_BUFFER_FLAGS_NO_NUL_BYTE);
err = sol_buffer_ensure(&buf, sizeof(int32_t));
ASSERT_INT_EQ(err, 0);
err = sol_buffer_append_slice(&buf, SOL_STR_SLICE_STR((const char *)&value, sizeof(value)));
ASSERT_INT_EQ(err, 0);
err = sol_buffer_append_slice(&buf, SOL_STR_SLICE_STR((const char *)&value, sizeof(value)));
ASSERT_INT_NE(err, 0);
sol_buffer_fini(&buf);
sol_buffer_init_flags(&buf, NULL, 0, SOL_BUFFER_FLAGS_NO_NUL_BYTE);
err = sol_buffer_append_printf(&buf, "123");
ASSERT_INT_EQ(err, 0);
err = sol_buffer_append_printf(&buf, "4");
ASSERT_INT_EQ(err, 0);
ASSERT(sol_str_slice_eq(sol_buffer_get_slice(&buf),
SOL_STR_SLICE_STR("1234", 4)));
sol_buffer_fini(&buf);
}
/*
* If index is between [' and '] we need to unescape the ' char and to remove
* the [' and '] separator.
*/
static int
json_path_parse_object_key(const struct sol_str_slice slice, struct sol_buffer *buffer)
{
const char *end, *p, *p2;
struct sol_str_slice key;
int r;
if (slice.data[0] != '[') {
sol_buffer_init_flags(buffer, (char *)slice.data, slice.len,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED | SOL_BUFFER_FLAGS_NO_NUL_BYTE);
buffer->used = buffer->capacity;
return 0;
}
//remove [' and ']
key = SOL_STR_SLICE_STR(slice.data + 2, slice.len - 4);
//unescape '\'' if necessary
sol_buffer_init_flags(buffer, NULL, 0, SOL_BUFFER_FLAGS_NO_NUL_BYTE);
end = key.data + key.len;
for (p = key.data; p < end; p = p2 + 1) {
p2 = memchr(p, '\'', end - p);
if (!p2)
break;
//Append string preceding '
r = sol_buffer_append_slice(buffer, SOL_STR_SLICE_STR(p, p2 - p - 1));
SOL_INT_CHECK(r, < 0, r);
r = sol_buffer_append_char(buffer, '\'');
SOL_INT_CHECK(r, < 0, r);
}
if (!buffer->data) {
sol_buffer_init_flags(buffer, (char *)key.data, key.len,
SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED | SOL_BUFFER_FLAGS_NO_NUL_BYTE);
buffer->used = buffer->capacity;
return 0;
}
//Append the string leftover
r = sol_buffer_append_slice(buffer, SOL_STR_SLICE_STR(p, end - p));
SOL_INT_CHECK(r, < 0, r);
return 0;
}
static void
test_memory_not_owned(void)
{
struct sol_buffer buf;
struct sol_str_slice slice;
char backend[10];
int err;
sol_buffer_init_flags(&buf, backend, sizeof(backend), SOL_BUFFER_FLAGS_MEMORY_NOT_OWNED);
err = sol_buffer_ensure(&buf, 0);
ASSERT_INT_EQ(err, 0);
/* ensure considers null-byte, so we use sizeof - 1 */
err = sol_buffer_ensure(&buf, sizeof(backend) - 1);
ASSERT_INT_EQ(err, 0);
err = sol_buffer_ensure(&buf, sizeof(backend) * 2);
ASSERT_INT_EQ(err, -ENOMEM);
err = sol_buffer_resize(&buf, 0);
ASSERT_INT_EQ(err, -EPERM);
slice = sol_str_slice_from_str("test");
err = sol_buffer_append_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "test");
slice = sol_str_slice_from_str("other");
err = sol_buffer_append_slice(&buf, slice);
ASSERT_INT_EQ(err, 0);
ASSERT_STR_EQ(buf.data, "testother");
slice = sol_str_slice_from_str("OVERFLOW");
err = sol_buffer_append_slice(&buf, slice);
ASSERT_INT_EQ(err, -ENOMEM);
sol_buffer_fini(&buf);
}
// 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;
}
