static void
test_bson_iter_overflow (void)
{
bson_iter_t iter;
bson_t *b;
b = get_bson(BINARY_DIR"/overflow1.bson");
assert(!b);
b = get_bson(BINARY_DIR"/overflow2.bson");
assert(b);
assert(bson_iter_init(&iter, b));
assert(!bson_iter_next(&iter));
bson_destroy(b);
}
static void
test_bson_iter_find_descendant (void)
{
bson_iter_t iter;
bson_iter_t desc;
bson_t *b;
b = get_bson(BINARY_DIR"/dotkey.bson");
assert(bson_iter_init(&iter, b));
assert(bson_iter_find_descendant(&iter, "a.b.c.0", &desc));
assert(BSON_ITER_HOLDS_INT32(&desc));
assert(bson_iter_int32(&desc) == 1);
bson_destroy(b);
b = BCON_NEW ("foo", "{", "bar", "[", "{", "baz", BCON_INT32 (1), "}", "]", "}");
assert (bson_iter_init (&iter, b));
assert (bson_iter_find_descendant (&iter, "foo.bar.0.baz", &desc));
assert (BSON_ITER_HOLDS_INT32 (&desc));
assert (bson_iter_int32 (&desc) == 1);
bson_destroy (b);
b = BCON_NEW ("nModified", BCON_INT32 (1), "n", BCON_INT32 (2));
assert (bson_iter_init (&iter, b));
assert (bson_iter_find_descendant (&iter, "n", &desc));
assert (!strcmp (bson_iter_key (&desc), "n"));
bson_destroy (b);
b = BCON_NEW ("", BCON_INT32 (1), "n", BCON_INT32 (2));
assert (bson_iter_init (&iter, b));
assert (bson_iter_find_descendant (&iter, "n", &desc));
assert (!strcmp (bson_iter_key (&desc), "n"));
bson_destroy (b);
}
static void
assert_bson_equal_file (const bson_t *b,
const char *filename)
{
bson_t *b2 = get_bson(filename);
assert_bson_equal(b, b2);
bson_destroy(b2);
}
static void
test_bson_append_code_with_scope (void)
{
const bson_uint8_t *scope_buf = NULL;
bson_uint32_t scopelen = 0;
bson_uint32_t len = 0;
bson_iter_t iter;
bson_bool_t r;
const char *code = NULL;
bson_t *b;
bson_t *b2;
bson_t *scope;
/* Test with empty bson, which converts to just CODE type. */
b = bson_new();
scope = bson_new();
assert(bson_append_code_with_scope(b, "code", -1, "var a = {};", scope));
b2 = get_bson("test30.bson");
assert_bson_equal(b, b2);
r = bson_iter_init_find(&iter, b, "code");
assert(r);
assert(BSON_ITER_HOLDS_CODE(&iter)); /* Not codewscope */
bson_destroy(b);
bson_destroy(b2);
bson_destroy(scope);
/* Test with non-empty scope */
b = bson_new();
scope = bson_new();
assert(bson_append_utf8(scope, "foo", -1, "bar", -1));
assert(bson_append_code_with_scope(b, "code", -1, "var a = {};", scope));
b2 = get_bson("test31.bson");
assert_bson_equal(b, b2);
r = bson_iter_init_find(&iter, b, "code");
assert(r);
assert(BSON_ITER_HOLDS_CODEWSCOPE(&iter));
code = bson_iter_codewscope(&iter, &len, &scopelen, &scope_buf);
assert(len == 11);
assert(scopelen == scope->len);
assert(!strcmp(code, "var a = {};"));
bson_destroy(b);
bson_destroy(b2);
bson_destroy(scope);
}
static void
test_bson_iter_trailing_null (void)
{
bson_iter_t iter;
bson_t *b;
b = get_bson(BINARY_DIR"/trailingnull.bson");
assert(b);
assert(bson_iter_init(&iter, b));
assert(!bson_iter_next(&iter));
bson_destroy(b);
}
static void
test_bson_append_code (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_code(b, "code", -1, "var a = {};"));
b2 = get_bson("test29.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_timestamp (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_timestamp(b, "timestamp", -1, 1234, 9876));
b2 = get_bson("test35.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_double (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_double(b, "double", -1, 123.4567));
b2 = get_bson("test20.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_regex (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_regex(b, "regex", -1, "^abcd", "ilx"));
b2 = get_bson("test27.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_symbol (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
b2 = get_bson("test32.bson");
assert(bson_append_symbol(b, "hello", -1, "world", -1));
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_minkey (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_minkey(b, "minkey", -1));
b2 = get_bson("test36.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_undefined (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_undefined(b, "undefined", -1));
b2 = get_bson("test25.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_null (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_null(b, "hello", -1));
b2 = get_bson("test18.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_int64 (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_int64(b, "a", -1, 100000000000000ULL));
b2 = get_bson("test34.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_bool (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_bool(b, "bool", -1, TRUE));
b2 = get_bson("test19.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_binary_deprecated (void)
{
const static bson_uint8_t binary[] = { '1', '2', '3', '4' };
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_binary(b, "binary", -1, BSON_SUBTYPE_BINARY_DEPRECATED, binary, 4));
b2 = get_bson("binary_deprecated.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_binary (void)
{
const static bson_uint8_t binary[] = { '1', '2', '3', '4' };
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_binary(b, "binary", -1, BSON_SUBTYPE_USER, binary, 4));
b2 = get_bson("test24.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_dbpointer (void)
{
bson_oid_t oid;
bson_t *b;
bson_t *b2;
b = bson_new();
bson_oid_init_from_string(&oid, "0123abcd0123abcd0123abcd");
assert(bson_append_dbpointer(b, "dbpointer", -1, "foo", &oid));
b2 = get_bson("test28.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_int32 (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_int32(b, "a", -1, -123));
assert(bson_append_int32(b, "c", -1, 0));
assert(bson_append_int32(b, "b", -1, 123));
b2 = get_bson("test33.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_document (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
b2 = bson_new();
assert(bson_append_document(b, "document", -1, b2));
bson_destroy(b2);
b2 = get_bson("test21.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_oid (void)
{
bson_oid_t oid;
bson_t *b;
bson_t *b2;
bson_oid_init_from_string(&oid, "1234567890abcdef1234abcd");
b = bson_new();
assert(bson_append_oid(b, "oid", -1, &oid));
b2 = get_bson("test22.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_time_t (void)
{
bson_t *b;
bson_t *b2;
time_t t;
t = 1234567890;
b = bson_new();
assert(bson_append_time_t(b, "time_t", -1, t));
b2 = get_bson("test26.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_timeval (void)
{
struct timeval tv = { 0 };
bson_t *b;
bson_t *b2;
tv.tv_sec = 1234567890;
tv.tv_usec = 0;
b = bson_new();
assert(bson_append_timeval(b, "time_t", -1, &tv));
b2 = get_bson("test26.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_append_array (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
b2 = bson_new();
assert(bson_append_utf8(b2, "0", -1, "hello", -1));
assert(bson_append_utf8(b2, "1", -1, "world", -1));
assert(bson_append_array(b, "array", -1, b2));
bson_destroy(b2);
b2 = get_bson("test23.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_iter_timeval (void)
{
bson_iter_t iter;
bson_t * b;
struct timeval tv;
b = get_bson(BINARY_DIR"/test26.bson");
assert(b);
assert(bson_iter_init(&iter, b));
assert(bson_iter_next(&iter));
bson_iter_timeval(&iter, &tv);
assert(tv.tv_sec == 1234567890);
assert(tv.tv_usec == 0);
bson_destroy(b);
}
static void
test_bson_utf8_key (void)
{
bson_uint32_t length;
bson_iter_t iter;
const char *str;
bson_t *b;
size_t offset;
b = get_bson("eurokey.bson");
assert(bson_validate(b, BSON_VALIDATE_NONE, &offset));
assert(bson_iter_init(&iter, b));
assert(bson_iter_next(&iter));
assert(!strcmp(bson_iter_key(&iter), "€€€€€"));
assert((str = bson_iter_utf8(&iter, &length)));
assert(length == 15); /* 5 3-byte sequences. */
assert(!strcmp(str, "€€€€€"));
bson_destroy(b);
}
static void
test_bson_iter_binary_deprecated (void)
{
bson_subtype_t subtype;
uint32_t binary_len;
const uint8_t * binary;
bson_iter_t iter;
bson_t * b;
b = get_bson(BINARY_DIR"/binary_deprecated.bson");
assert(b);
assert(bson_iter_init(&iter, b));
assert(bson_iter_next(&iter));
bson_iter_binary(&iter, &subtype, &binary_len, &binary);
assert(binary_len == 4);
assert(memcmp(binary, "1234", 4) == 0);
bson_destroy(b);
}
static void
test_bson_validate (void)
{
char filename[64];
size_t offset;
bson_t *b;
int i;
for (i = 1; i <= 38; i++) {
snprintf(filename, sizeof filename, "test%u.bson", i);
b = get_bson(filename);
assert(bson_validate(b, BSON_VALIDATE_NONE, &offset));
bson_destroy(b);
}
b = get_bson("overflow2.bson");
assert(!bson_validate(b, BSON_VALIDATE_NONE, &offset));
assert(offset == 9);
bson_destroy(b);
b = get_bson("trailingnull.bson");
assert(!bson_validate(b, BSON_VALIDATE_NONE, &offset));
assert(offset == 14);
bson_destroy(b);
b = get_bson("dollarquery.bson");
assert(!bson_validate(b, BSON_VALIDATE_DOLLAR_KEYS, &offset));
bson_destroy(b);
b = get_bson("dotquery.bson");
assert(!bson_validate(b, BSON_VALIDATE_DOT_KEYS, &offset));
bson_destroy(b);
b = get_bson("overflow3.bson");
assert(!bson_validate(b, BSON_VALIDATE_NONE, &offset));
assert(offset == 9);
bson_destroy(b);
b = get_bson("overflow4.bson");
assert(!bson_validate(b, BSON_VALIDATE_NONE, &offset));
bson_destroy(b);
b = get_bson("codewscope.bson");
assert(bson_validate (b, BSON_VALIDATE_NONE, &offset));
bson_destroy(b);
#define ENSURE_FAILURE(file) \
b = get_bson(file); \
assert(!bson_validate(b, BSON_VALIDATE_NONE, &offset)); \
bson_destroy(b);
ENSURE_FAILURE("test40.bson");
ENSURE_FAILURE("test41.bson");
ENSURE_FAILURE("test42.bson");
ENSURE_FAILURE("test43.bson");
ENSURE_FAILURE("test44.bson");
ENSURE_FAILURE("test45.bson");
ENSURE_FAILURE("test46.bson");
ENSURE_FAILURE("test47.bson");
ENSURE_FAILURE("test48.bson");
ENSURE_FAILURE("test49.bson");
ENSURE_FAILURE("test50.bson");
ENSURE_FAILURE("test51.bson");
ENSURE_FAILURE("test52.bson");
ENSURE_FAILURE("test53.bson");
ENSURE_FAILURE("test54.bson");
#undef ENSURE_FAILURE
}
