static void
test_bson_iter_overwrite_decimal128 (void)
{
bson_iter_t iter;
bson_t b;
bson_decimal128_t value;
bson_decimal128_t new_value;
bson_decimal128_t iter_value;
value.high = 0;
value.low = 1;
new_value.high = 0;
new_value.low = 2;
bson_init(&b);
assert(bson_append_decimal128(&b, "key", -1, &value));
assert(bson_iter_init_find(&iter, &b, "key"));
assert(BSON_ITER_HOLDS_DECIMAL128(&iter));
bson_iter_overwrite_decimal128(&iter, &new_value);
assert(bson_iter_init_find(&iter, &b, "key"));
assert(BSON_ITER_HOLDS_DECIMAL128(&iter));
assert(bson_iter_decimal128(&iter, &iter_value));
assert(memcmp(&iter_value, &new_value, sizeof(new_value)) == 0);
bson_destroy(&b);
}
static void
test_bson_as_json (void)
{
bson_oid_t oid;
bson_decimal128_t decimal128;
bson_t *b;
bson_t *b2;
char *str;
size_t len;
int i;
decimal128.high = 0x3040000000000000ULL;
decimal128.low = 0x000000000000000B;
bson_oid_init_from_string(&oid, "123412341234abcdabcdabcd");
b = bson_new();
assert(bson_append_utf8(b, "utf8", -1, "bar", -1));
assert(bson_append_int32(b, "int32", -1, 1234));
assert(bson_append_int64(b, "int64", -1, 4321));
assert(bson_append_double(b, "double", -1, 123.4));
assert(bson_append_undefined(b, "undefined", -1));
assert(bson_append_null(b, "null", -1));
assert(bson_append_oid(b, "oid", -1, &oid));
assert(bson_append_bool(b, "true", -1, true));
assert(bson_append_bool(b, "false", -1, false));
assert(bson_append_time_t(b, "date", -1, time(NULL)));
assert(bson_append_timestamp(b, "timestamp", -1, (uint32_t)time(NULL), 1234));
assert(bson_append_regex(b, "regex", -1, "^abcd", "xi"));
assert(bson_append_dbpointer(b, "dbpointer", -1, "mycollection", &oid));
assert(bson_append_minkey(b, "minkey", -1));
assert(bson_append_maxkey(b, "maxkey", -1));
assert(bson_append_symbol(b, "symbol", -1, "var a = {};", -1));
assert(bson_append_decimal128(b, "decimal128", -1, &decimal128));
b2 = bson_new();
assert(bson_append_int32(b2, "0", -1, 60));
assert(bson_append_document(b, "document", -1, b2));
assert(bson_append_array(b, "array", -1, b2));
{
const uint8_t binary[] = { 0, 1, 2, 3, 4 };
assert(bson_append_binary(b, "binary", -1, BSON_SUBTYPE_BINARY,
binary, sizeof binary));
}
for (i = 0; i < 1000; i++) {
str = bson_as_json(b, &len);
bson_free(str);
}
bson_destroy(b);
bson_destroy(b2);
}
static void
test_bson_iter_mixed (void)
{
bson_iter_t iter;
bson_decimal128_t iter_value;
bson_decimal128_t value;
bson_t *b;
bson_t *b2;
b = bson_new();
b2 = bson_new();
value.high = 0;
value.low = 1;
assert(bson_append_utf8(b2, "foo", -1, "bar", -1));
assert(bson_append_code(b, "0", -1, "var a = {};"));
assert(bson_append_code_with_scope(b, "1", -1, "var b = {};", b2));
assert(bson_append_int32(b, "2", -1, 1234));
assert(bson_append_int64(b, "3", -1, 4567));
assert(bson_append_time_t(b, "4", -1, 123456));
assert(bson_append_decimal128(b, "5", -1, &value));
assert(bson_iter_init(&iter, b));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_CODE(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_CODEWSCOPE(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_INT32(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_INT64(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_DATE_TIME(&iter));
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_DECIMAL128(&iter));
assert(!bson_iter_next(&iter));
assert(bson_iter_init_find(&iter, b, "3"));
assert(!strcmp(bson_iter_key(&iter), "3"));
assert(bson_iter_int64(&iter) == 4567);
assert(bson_iter_next(&iter));
assert(BSON_ITER_HOLDS_DATE_TIME(&iter));
assert(bson_iter_time_t(&iter) == 123456);
assert(bson_iter_date_time(&iter) == 123456000);
assert(bson_iter_next(&iter));
/* This test uses memcmp because libbson lacks decimal128 comparison. */
bson_iter_decimal128(&iter, &iter_value);
assert(memcmp(&iter_value, &value, sizeof(value)) == 0);
assert(!bson_iter_next(&iter));
bson_destroy(b);
bson_destroy(b2);
}
static void
test_decimal128 (void)
{
bson_t bcon, expected;
bson_decimal128_t dec;
bson_decimal128_from_string("120E20", &dec);
bson_init (&bcon);
bson_init (&expected);
bson_append_decimal128 (&expected, "foo", -1, &dec);
BCON_APPEND(&bcon, "foo", BCON_DECIMAL128(&dec));
bson_eq_bson (&bcon, &expected);
bson_destroy (&bcon);
bson_destroy (&expected);
}
static void
test_bson_as_json_decimal128 (void)
{
size_t len;
bson_t *b;
char *str;
bson_decimal128_t decimal128;
decimal128.high = 0x3040000000000000ULL;
decimal128.low = 0x000000000000000B;
b = bson_new ();
assert (bson_append_decimal128 (b, "decimal128", -1, &decimal128));
str = bson_as_json (b, &len);
ASSERT_CMPSTR (str,
"{ "
"\"decimal128\" : { \"$numberDecimal\" : \"11\" }"
" }");
bson_free(str);
bson_destroy(b);
}
/* {{{ MongoDriver\BSON\Decimal128 */
void VariantToBsonConverter::_convertDecimal128(bson_t *bson, const char *key, Object v)
{
MongoDBBsonDecimal128Data* data = Native::data<MongoDBBsonDecimal128Data>(v.get());
bson_append_decimal128(bson, key, -1, &data->m_decimal);
}
