/*
* 实现抽象接口：
*/
int LikeDecorator::custom_result_set_query(bson* query)
{
int size = this->fitler_conditions.size();
LOGD("[GWJ] %s: filter_size[%d]", __FUNCTION__, size);
if(size > 0)
{
for(int i = 0; i < size; i++)
{
if(this->fitler_conditions[i].table_column != NULL &&
this->fitler_conditions[i].value != NULL)
{
bson_append_regex(query,
this->fitler_conditions[i].table_column,
this->fitler_conditions[i].value,
"x");
LOGD("[GWJ] %s: %s is [%s]",
__FUNCTION__, this->fitler_conditions[i].table_column, this->fitler_conditions[i].value);
}
}
}
else if(size == 0)
{
LOGD("[GWJ] %s: IsDecorator no filter Error!", __FUNCTION__);
return -1;
}
LOGD("[GWJ] %s: IsDecorator end", __FUNCTION__);
return 0;
}
static void
test_regex (void)
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error = { 0 };
int64_t count;
bson_t q = BSON_INITIALIZER;
client = mongoc_client_new (gTestUri);
ASSERT (client);
collection = mongoc_client_get_collection (client, "test", "test");
ASSERT (collection);
bson_append_regex (&q, "hello", -1, "^/wo", NULL);
count = mongoc_collection_count (collection,
MONGOC_QUERY_NONE,
&q,
0,
0,
NULL,
&error);
ASSERT (count > 0);
ASSERT (!error.domain);
bson_destroy (&q);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
}
void VariantToBsonConverter::_convertRegex(bson_t *bson, const char *key, Object v)
{
String regex = v.o_get(s_MongoBsonRegex_pattern, false, s_MongoBsonRegex_className).toString();
String flags = v.o_get(s_MongoBsonRegex_flags, false, s_MongoBsonRegex_className).toString();
bson_append_regex(bson, key, -1, regex.c_str(), flags.c_str());
}
static void
test_bson_iter_regex (void)
{
bson_iter_t iter;
bson_t *b;
b = bson_new();
assert(bson_append_regex(b, "foo", -1, "^abcd", ""));
assert(bson_append_regex(b, "foo", -1, "^abcd", NULL));
assert(bson_append_regex(b, "foo", -1, "^abcd", "ix"));
assert(bson_iter_init(&iter, b));
assert(bson_iter_next(&iter));
assert(bson_iter_next(&iter));
assert(bson_iter_next(&iter));
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_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_regex (void)
{
bson_t bcon, expected;
bson_init (&bcon);
bson_init (&expected);
/* option flags are sorted */
bson_append_regex (&expected, "foo", -1, "^foo|bar$", "mis");
BCON_APPEND (&bcon, "foo", BCON_REGEX ("^foo|bar$", "msi"));
bson_eq_bson (&bcon, &expected);
bson_destroy (&bcon);
bson_destroy (&expected);
}
bson *
test_bson_generate_full (void)
{
bson *b, *d, *a, *scope;
guint8 oid[] = "1234567890ab";
a = bson_new ();
bson_append_int32 (a, "0", 32);
bson_append_int64 (a, "1", (gint64)-42);
bson_finish (a);
d = bson_new ();
bson_append_string (d, "name", "sub-document", -1);
bson_append_int32 (d, "answer", 42);
bson_finish (d);
scope = bson_new ();
bson_append_string (scope, "v", "hello world", -1);
bson_finish (scope);
b = bson_new ();
bson_append_double (b, "double", 3.14);
bson_append_string (b, "str", "hello world", -1);
bson_append_document (b, "doc", d);
bson_append_array (b, "array", a);
bson_append_binary (b, "binary0", BSON_BINARY_SUBTYPE_GENERIC,
(guint8 *)"foo\0bar", 7);
bson_append_oid (b, "_id", oid);
bson_append_boolean (b, "TRUE", FALSE);
bson_append_utc_datetime (b, "date", 1294860709000);
bson_append_timestamp (b, "ts", 1294860709000);
bson_append_null (b, "null");
bson_append_regex (b, "foobar", "s/foo.*bar/", "i");
bson_append_javascript (b, "alert", "alert (\"hello world!\");", -1);
bson_append_symbol (b, "sex", "Marilyn Monroe", -1);
bson_append_javascript_w_scope (b, "print", "alert (v);", -1, scope);
bson_append_int32 (b, "int32", 32);
bson_append_int64 (b, "int64", (gint64)-42);
bson_finish (b);
bson_free (d);
bson_free (a);
bson_free (scope);
return b;
}
static void
test_regex (void)
{
bson_t bcon, expected;
bson_init (&bcon);
bson_init (&expected);
bson_append_regex (&expected, "foo", -1, "^foo|bar$", "i");
BCON_APPEND (&bcon, "foo", BCON_REGEX ("^foo|bar$", "i"));
bson_eq_bson (&bcon, &expected);
bson_destroy (&bcon);
bson_destroy (&expected);
}
int main() {
mongo_connection conn[1];
bson_buffer bb;
bson b;
unsigned char not_utf8[3];
int result;
not_utf8[0] = 0xC0;
not_utf8[1] = 0xC0;
not_utf8[3] = '\0';
INIT_SOCKETS_FOR_WINDOWS;
if (mongo_connect( conn , TEST_SERVER, 27017 )){
printf("failed to connect\n");
exit(1);
}
/* Test valid keys. */
bson_buffer_init( & bb );
result = bson_append_string( &bb , "a.b" , "17" );
ASSERT( result == BSON_OK );
ASSERT( bb.err & BSON_FIELD_HAS_DOT );
result = bson_append_string( &bb , "$ab" , "17" );
ASSERT( result == BSON_OK );
ASSERT( bb.err & BSON_FIELD_INIT_DOLLAR );
result = bson_append_string( &bb , "ab" , "this is valid utf8" );
ASSERT( result == BSON_OK );
ASSERT( ! (bb.err & BSON_NOT_UTF8 ) );
result = bson_append_string( &bb , (const char*)not_utf8, "valid" );
ASSERT( result == BSON_ERROR );
ASSERT( bb.err & BSON_NOT_UTF8 );
bson_from_buffer(&b, &bb);
ASSERT( b.err & BSON_FIELD_HAS_DOT );
ASSERT( b.err & BSON_FIELD_INIT_DOLLAR );
ASSERT( b.err & BSON_NOT_UTF8 );
bson_destroy(&b);
/* Test valid strings. */
bson_buffer_init( & bb );
result = bson_append_string( &bb , "foo" , "bar" );
ASSERT( result == BSON_OK );
ASSERT( bb.err == 0 );
result = bson_append_string( &bb , "foo" , (const char*)not_utf8 );
ASSERT( result == BSON_ERROR );
ASSERT( bb.err & BSON_NOT_UTF8 );
bb.err = 0;
ASSERT( bb.err == 0 );
result = bson_append_regex( &bb , "foo" , (const char*)not_utf8, "s" );
ASSERT( result == BSON_ERROR );
ASSERT( bb.err & BSON_NOT_UTF8 );
mongo_cmd_drop_db(conn, "test");
mongo_disconnect( conn );
mongo_destroy( conn );
return 0;
}
void mongoRegexToBSON(const Object& value, const char* key, bson_t* bson) {
bson_append_regex(bson, key, -1,
value->o_get("regex").toString().c_str(),
value->o_get("flags").toString().c_str()
);
}
int test_bson_generic( void ) {
bson_iterator it, it2, it3;
bson_oid_t oid;
bson_timestamp_t ts;
bson_timestamp_t ts_result;
bson b[1];
bson copy[1];
bson scope[1];
ts.i = 1;
ts.t = 2;
bson_init( b );
bson_append_double( b, "d", 3.14 );
bson_append_string( b, "s", "hello" );
bson_append_string_n( b, "s_n", "goodbye cruel world", 7 );
{
bson_append_start_object( b, "o" );
bson_append_start_array( b, "a" );
bson_append_binary( b, "0", 8, "w\0rld", 5 );
bson_append_finish_object( b );
bson_append_finish_object( b );
}
bson_append_undefined( b, "u" );
bson_oid_from_string( &oid, "010203040506070809101112" );
ASSERT( !memcmp( oid.bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12 ) );
bson_append_oid( b, "oid", &oid );
bson_append_bool( b, "b", 1 );
bson_append_date( b, "date", 0x0102030405060708 );
bson_append_null( b, "n" );
bson_append_regex( b, "r", "^asdf", "imx" );
/* no dbref test (deprecated) */
bson_append_code( b, "c", "function(){}" );
bson_append_code_n( b, "c_n", "function(){}garbage", 12 );
bson_append_symbol( b, "symbol", "symbol" );
bson_append_symbol_n( b, "symbol_n", "symbol and garbage", 6 );
{
bson_init( scope );
bson_append_int( scope, "i", 123 );
bson_finish( scope );
bson_append_code_w_scope( b, "cws", "function(){return i}", scope );
bson_destroy( scope );
}
bson_append_timestamp( b, "timestamp", &ts );
bson_append_long( b, "l", 0x1122334455667788 );
/* Ensure that we can't copy a non-finished object. */
ASSERT( bson_copy( copy, b ) == BSON_ERROR );
bson_finish( b );
ASSERT( b->err == BSON_VALID );
/* Test append after finish. */
ASSERT( bson_append_string( b, "foo", "bar" ) == BSON_ERROR );
ASSERT( b->err & BSON_ALREADY_FINISHED );
ASSERT( bson_copy( copy, b ) == BSON_OK );
ASSERT( 1 == copy->finished );
ASSERT( 0 == copy->err );
bson_destroy( copy );
bson_print( b );
bson_iterator_init( &it, b );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( bson_iterator_type( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "d" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_STRING );
ASSERT( bson_iterator_type( &it ) == BSON_STRING );
ASSERT( !strcmp( bson_iterator_key( &it ), "s" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "hello" ) );
ASSERT( strcmp( bson_iterator_string( &it ), "" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_STRING );
ASSERT( bson_iterator_type( &it ) == BSON_STRING );
ASSERT( !strcmp( bson_iterator_key( &it ), "s_n" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "goodbye" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_OBJECT );
ASSERT( bson_iterator_type( &it ) == BSON_OBJECT );
ASSERT( !strcmp( bson_iterator_key( &it ), "o" ) );
bson_iterator_subiterator( &it, &it2 );
ASSERT( bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_next( &it2 ) == BSON_ARRAY );
ASSERT( bson_iterator_type( &it2 ) == BSON_ARRAY );
ASSERT( !strcmp( bson_iterator_key( &it2 ), "a" ) );
bson_iterator_subiterator( &it2, &it3 );
ASSERT( bson_iterator_more( &it3 ) );
ASSERT( bson_iterator_next( &it3 ) == BSON_BINDATA );
ASSERT( bson_iterator_type( &it3 ) == BSON_BINDATA );
ASSERT( !strcmp( bson_iterator_key( &it3 ), "0" ) );
ASSERT( bson_iterator_bin_type( &it3 ) == 8 );
ASSERT( bson_iterator_bin_len( &it3 ) == 5 );
ASSERT( !memcmp( bson_iterator_bin_data( &it3 ), "w\0rld", 5 ) );
ASSERT( bson_iterator_more( &it3 ) );
ASSERT( bson_iterator_next( &it3 ) == BSON_EOO );
ASSERT( bson_iterator_type( &it3 ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it3 ) );
ASSERT( bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_next( &it2 ) == BSON_EOO );
ASSERT( bson_iterator_type( &it2 ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_UNDEFINED );
ASSERT( bson_iterator_type( &it ) == BSON_UNDEFINED );
ASSERT( !strcmp( bson_iterator_key( &it ), "u" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_OID );
ASSERT( bson_iterator_type( &it ) == BSON_OID );
ASSERT( !strcmp( bson_iterator_key( &it ), "oid" ) );
ASSERT( !memcmp( bson_iterator_oid( &it )->bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12 ) );
ASSERT( bson_iterator_oid( &it )->ints[0] == oid.ints[0] );
ASSERT( bson_iterator_oid( &it )->ints[1] == oid.ints[1] );
ASSERT( bson_iterator_oid( &it )->ints[2] == oid.ints[2] );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_BOOL );
ASSERT( bson_iterator_type( &it ) == BSON_BOOL );
ASSERT( !strcmp( bson_iterator_key( &it ), "b" ) );
ASSERT( bson_iterator_bool( &it ) == 1 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DATE );
ASSERT( bson_iterator_type( &it ) == BSON_DATE );
ASSERT( !strcmp( bson_iterator_key( &it ), "date" ) );
ASSERT( bson_iterator_date( &it ) == 0x0102030405060708 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_NULL );
ASSERT( bson_iterator_type( &it ) == BSON_NULL );
ASSERT( !strcmp( bson_iterator_key( &it ), "n" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_REGEX );
ASSERT( bson_iterator_type( &it ) == BSON_REGEX );
ASSERT( !strcmp( bson_iterator_key( &it ), "r" ) );
ASSERT( !strcmp( bson_iterator_regex( &it ), "^asdf" ) );
ASSERT( !strcmp( bson_iterator_regex_opts( &it ), "imx" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_CODE );
ASSERT( bson_iterator_type( &it ) == BSON_CODE );
ASSERT( !strcmp( bson_iterator_code(&it), "function(){}") );
ASSERT( !strcmp( bson_iterator_key( &it ), "c" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_CODE );
ASSERT( bson_iterator_type( &it ) == BSON_CODE );
ASSERT( !strcmp( bson_iterator_key( &it ), "c_n" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "" ) );
ASSERT( !strcmp( bson_iterator_code( &it ), "function(){}" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_SYMBOL );
ASSERT( bson_iterator_type( &it ) == BSON_SYMBOL );
ASSERT( !strcmp( bson_iterator_key( &it ), "symbol" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "symbol" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_SYMBOL );
ASSERT( bson_iterator_type( &it ) == BSON_SYMBOL );
ASSERT( !strcmp( bson_iterator_key( &it ), "symbol_n" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "symbol" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_CODEWSCOPE );
ASSERT( bson_iterator_type( &it ) == BSON_CODEWSCOPE );
ASSERT( !strcmp( bson_iterator_key( &it ), "cws" ) );
ASSERT( !strcmp( bson_iterator_code( &it ), "function(){return i}" ) );
{
bson scope;
bson_iterator_code_scope( &it, &scope );
bson_iterator_init( &it2, &scope );
ASSERT( bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_next( &it2 ) == BSON_INT );
ASSERT( bson_iterator_type( &it2 ) == BSON_INT );
ASSERT( !strcmp( bson_iterator_key( &it2 ), "i" ) );
ASSERT( bson_iterator_int( &it2 ) == 123 );
ASSERT( bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_next( &it2 ) == BSON_EOO );
ASSERT( bson_iterator_type( &it2 ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it2 ) );
}
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_TIMESTAMP );
ASSERT( bson_iterator_type( &it ) == BSON_TIMESTAMP );
ASSERT( !strcmp( bson_iterator_key( &it ), "timestamp" ) );
ts_result = bson_iterator_timestamp( &it );
ASSERT( ts_result.i == 1 );
ASSERT( ts_result.t == 2 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_LONG );
ASSERT( bson_iterator_type( &it ) == BSON_LONG );
ASSERT( !strcmp( bson_iterator_key( &it ), "l" ) );
ASSERT( bson_iterator_long( &it ) == 0x1122334455667788 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_EOO );
ASSERT( bson_iterator_type( &it ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it ) );
bson_destroy( b );
{
bson bsrc[1];
bson_init( bsrc );
bson_append_double( bsrc, "d", 3.14 );
bson_finish( bsrc );
ASSERT( bsrc->err == BSON_VALID );
bson_init( b );
bson_append_double( b, "", 3.14 ); /* test empty name (in general) */
bson_iterator_init( &it, bsrc );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( bson_iterator_type( &it ) == BSON_DOUBLE );
bson_append_element( b, "d", &it );
bson_append_element( b, 0, &it ); /* test null */
bson_append_element( b, "", &it ); /* test empty name */
bson_finish( b );
ASSERT( b->err == BSON_VALID );
/* bson_print( b ); */
bson_iterator_init( &it, b );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "d" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "d" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it ) );
bson_destroy( bsrc );
bson_destroy( b );
}
return 0;
}
int main(int argc, char *argv[])
{
bson_buffer bb;
bson b;
bson_iterator it, it2, it3;
bson_oid_t oid;
bson_buffer_init(&bb);
bson_append_double(&bb, "d", 3.14);
bson_append_string(&bb, "s", "hello");
{
bson_buffer *obj = bson_append_start_object(&bb, "o");
bson_buffer *arr = bson_append_start_array(obj, "a");
bson_append_binary(arr, "0", 8, "w\0rld", 5);
bson_append_finish_object(arr);
bson_append_finish_object(obj);
}
bson_append_undefined(&bb, "u");
bson_oid_from_string(&oid, "010203040506070809101112");
ASSERT(!memcmp(oid.bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12));
bson_append_oid(&bb, "oid", &oid);
bson_append_bool(&bb, "b", 1);
bson_append_date(&bb, "date", 0x0102030405060708ULL);
bson_append_null(&bb, "n");
bson_append_regex(&bb, "r", "^asdf", "imx");
/* no dbref test (deprecated) */
bson_append_code(&bb, "c", "function(){}");
bson_append_symbol(&bb, "symbol", "SYMBOL");
{
bson_buffer scope_buf;
bson scope;
bson_buffer_init(&scope_buf);
bson_append_int(&scope_buf, "i", 123);
bson_from_buffer(&scope, &scope_buf);
bson_append_code_w_scope(&bb, "cws", "function(){return i}", &scope);
bson_destroy(&scope);
}
/* no timestamp test (internal) */
bson_append_long(&bb, "l", 0x1122334455667788ULL);
bson_from_buffer(&b, &bb);
bson_iterator_init(&it, b.data);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_double);
ASSERT(bson_iterator_type(&it) == bson_double);
ASSERT(!strcmp(bson_iterator_key(&it), "d"));
ASSERT(bson_iterator_double(&it) == 3.14);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_string);
ASSERT(bson_iterator_type(&it) == bson_string);
ASSERT(!strcmp(bson_iterator_key(&it), "s"));
ASSERT(!strcmp(bson_iterator_string(&it), "hello"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_object);
ASSERT(bson_iterator_type(&it) == bson_object);
ASSERT(!strcmp(bson_iterator_key(&it), "o"));
bson_iterator_subiterator(&it, &it2);
ASSERT(bson_iterator_more(&it2));
ASSERT(bson_iterator_next(&it2) == bson_array);
ASSERT(bson_iterator_type(&it2) == bson_array);
ASSERT(!strcmp(bson_iterator_key(&it2), "a"));
bson_iterator_subiterator(&it2, &it3);
ASSERT(bson_iterator_more(&it3));
ASSERT(bson_iterator_next(&it3) == bson_bindata);
ASSERT(bson_iterator_type(&it3) == bson_bindata);
ASSERT(!strcmp(bson_iterator_key(&it3), "0"));
ASSERT(bson_iterator_bin_type(&it3) == 8);
ASSERT(bson_iterator_bin_len(&it3) == 5);
ASSERT(!memcmp(bson_iterator_bin_data(&it3), "w\0rld", 5));
ASSERT(bson_iterator_more(&it3));
ASSERT(bson_iterator_next(&it3) == bson_eoo);
ASSERT(bson_iterator_type(&it3) == bson_eoo);
ASSERT(!bson_iterator_more(&it3));
ASSERT(bson_iterator_more(&it2));
ASSERT(bson_iterator_next(&it2) == bson_eoo);
ASSERT(bson_iterator_type(&it2) == bson_eoo);
ASSERT(!bson_iterator_more(&it2));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_undefined);
ASSERT(bson_iterator_type(&it) == bson_undefined);
ASSERT(!strcmp(bson_iterator_key(&it), "u"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_oid);
ASSERT(bson_iterator_type(&it) == bson_oid);
ASSERT(!strcmp(bson_iterator_key(&it), "oid"));
ASSERT(!memcmp(bson_iterator_oid(&it)->bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12));
ASSERT(bson_iterator_oid(&it)->ints[0] == oid.ints[0]);
ASSERT(bson_iterator_oid(&it)->ints[1] == oid.ints[1]);
ASSERT(bson_iterator_oid(&it)->ints[2] == oid.ints[2]);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_bool);
ASSERT(bson_iterator_type(&it) == bson_bool);
ASSERT(!strcmp(bson_iterator_key(&it), "b"));
ASSERT(bson_iterator_bool(&it) == 1);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_date);
ASSERT(bson_iterator_type(&it) == bson_date);
ASSERT(!strcmp(bson_iterator_key(&it), "date"));
ASSERT(bson_iterator_date(&it) == 0x0102030405060708ULL);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_null);
ASSERT(bson_iterator_type(&it) == bson_null);
ASSERT(!strcmp(bson_iterator_key(&it), "n"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_regex);
ASSERT(bson_iterator_type(&it) == bson_regex);
ASSERT(!strcmp(bson_iterator_key(&it), "r"));
ASSERT(!strcmp(bson_iterator_regex(&it), "^asdf"));
ASSERT(!strcmp(bson_iterator_regex_opts(&it), "imx"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_code);
ASSERT(bson_iterator_type(&it) == bson_code);
ASSERT(!strcmp(bson_iterator_key(&it), "c"));
ASSERT(!strcmp(bson_iterator_string(&it), "function(){}"));
ASSERT(!strcmp(bson_iterator_code(&it), "function(){}"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_symbol);
ASSERT(bson_iterator_type(&it) == bson_symbol);
ASSERT(!strcmp(bson_iterator_key(&it), "symbol"));
ASSERT(!strcmp(bson_iterator_string(&it), "SYMBOL"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_codewscope);
ASSERT(bson_iterator_type(&it) == bson_codewscope);
ASSERT(!strcmp(bson_iterator_key(&it), "cws"));
ASSERT(!strcmp(bson_iterator_code(&it), "function(){return i}"));
{
bson scope;
bson_iterator_code_scope(&it, &scope);
bson_iterator_init(&it2, scope.data);
ASSERT(bson_iterator_more(&it2));
ASSERT(bson_iterator_next(&it2) == bson_int);
ASSERT(bson_iterator_type(&it2) == bson_int);
ASSERT(!strcmp(bson_iterator_key(&it2), "i"));
ASSERT(bson_iterator_int(&it2) == 123);
ASSERT(bson_iterator_more(&it2));
ASSERT(bson_iterator_next(&it2) == bson_eoo);
ASSERT(bson_iterator_type(&it2) == bson_eoo);
ASSERT(!bson_iterator_more(&it2));
}
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_long);
ASSERT(bson_iterator_type(&it) == bson_long);
ASSERT(!strcmp(bson_iterator_key(&it), "l"));
ASSERT(bson_iterator_long(&it) == 0x1122334455667788ULL);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_eoo);
ASSERT(bson_iterator_type(&it) == bson_eoo);
ASSERT(!bson_iterator_more(&it));
return 0;
}
static void lua_val_to_bson(lua_State *L, const char *key, int vpos, bson *bs, int tref) {
int vtype = lua_type(L, vpos);
char nbuf[TCNUMBUFSIZ];
if (key == NULL && vtype != LUA_TTABLE) {
luaL_error(L, "lua_val_to_bson: Table must be on top of lua stack");
return;
}
switch (vtype) {
case LUA_TTABLE:
{
if (vpos < 0) {
vpos = lua_gettop(L) + vpos + 1;
}
lua_checkstack(L, 3);
int bsontype_found = luaL_getmetafield(L, vpos, "__bsontype");
if (!bsontype_found) {
lua_rawgeti(L, LUA_REGISTRYINDEX, tref); //+ reg table
lua_pushvalue(L, vpos); //+ val
lua_rawget(L, -2); //-val +reg table val
if (lua_toboolean(L, -1)) { //already traversed
lua_pop(L, 2);
break;
}
lua_pop(L, 1); //-reg table val
lua_pushvalue(L, vpos);
lua_pushboolean(L, 1);
lua_rawset(L, -3);
lua_pop(L, 1); //-reg table
int len = 0;
bool query = false;
bool array = true;
if (luaL_getmetafield(L, vpos, "__query")) {
lua_pop(L, 1);
query = true;
array = false;
}
if (array) {
for (lua_pushnil(L); lua_next(L, vpos); lua_pop(L, 1)) {
++len;
if ((lua_type(L, -2) != LUA_TNUMBER) || (lua_tointeger(L, -2) != len)) {
lua_pop(L, 2);
array = false;
break;
}
}
}
if (array) {
if (key) bson_append_start_array(bs, key);
int i;
for (i = 1; i <= len; ++i, lua_pop(L, 1)) {
lua_rawgeti(L, vpos, i);
bson_numstrn(nbuf, TCNUMBUFSIZ, (int64_t) i);
lua_val_to_bson(L, nbuf, -1, bs, tref);
}
if (key) bson_append_finish_array(bs);
} else if (query) { //special query builder case
//oarr format:
//{ {fname1, v1, v2...}, {fname2, v21, v22,..}, ... }
//where: vN: {op, val} OR {val} with '__bval' metafield
//Eg: {fname : {$inc : {...}, $dec : {...}}} -> {fname, {$inc, {}}, {$dec, {}}}
lua_getfield(L, vpos, "_oarr"); //+oarr
if (!lua_istable(L, -1)) { //it is not array
lua_pop(L, 1);
break;
}
if (key) bson_append_start_object(bs, key);
//iterate over _oarr
int ipos = lua_gettop(L);
size_t ilen = lua_objlen(L, ipos);
lua_checkstack(L, 2);
size_t i;
for (i = 1; i <= ilen; ++i, lua_pop(L, 1)) {
lua_rawgeti(L, ipos, i);
//gettop == 3
if (!lua_istable(L, -1)) continue;
char *fname = NULL;
int jpos = lua_gettop(L);
size_t jlen = lua_objlen(L, jpos);
lua_checkstack(L, 3);
bool wrapped = false;
size_t j;
for (j = 1; j <= jlen; ++j, lua_pop(L, 1)) {
lua_rawgeti(L, jpos, j);
if (j == 1) {
fname = strdup(lua_tostring(L, -1));
continue;
}
if (!fname || !lua_istable(L, -1)) { //invalid state
lua_pop(L, 1); //pop val
break;
}
int vblkpos = lua_gettop(L);
if (j == 2 && luaL_getmetafield(L, -1, "__bval")) { //{val} single value +metafield
lua_pop(L, 1); //-metafield
lua_rawgeti(L, vblkpos, 1); //+val
lua_val_to_bson(L, fname, lua_gettop(L), bs, tref);
lua_pop(L, 2); //-val -lua_rawgeti
break; //Terminate due single val
} else { //{op, val} value
if (!wrapped) {
bson_append_start_object(bs, fname);
wrapped = true;
}
lua_rawgeti(L, vblkpos, 1); //+op
const char *op = lua_tostring(L, -1);
if (op) {
lua_rawgeti(L, vblkpos, 2); //+val
lua_val_to_bson(L, op, lua_gettop(L), bs, tref);
lua_pop(L, 1); //-val
}
lua_pop(L, 1); //-op
}
}
if (wrapped) {
bson_append_finish_object(bs);
}
if (fname) {
free(fname);
fname = NULL;
}
}
if (key) bson_append_finish_object(bs);
lua_pop(L, 1); //-oarr
} else {
if (key) bson_append_start_object(bs, key);
TCLIST *keys = tclistnew();
//we need to sort keys due to unordered nature of lua tables
for (lua_pushnil(L); lua_next(L, vpos);) {
lua_pop(L, 1); //-val
size_t ksize = 0;
int ktype = lua_type(L, -1);
if (ktype == LUA_TSTRING) { //accept only string keys
const char* key = lua_tolstring(L, -1, &ksize);
tclistpush(keys, key, ksize);
}
}
tclistsort(keys);
int i;
for (i = 0; i < TCLISTNUM(keys); ++i) {
int vkeysz = TCLISTVALSIZ(keys, i);
const char *vkey = TCLISTVALPTR(keys, i);
lua_pushlstring(L, vkey, vkeysz);
lua_rawget(L, vpos); //+val
if (key == NULL && lua_type(L, -1) == LUA_TSTRING &&
vkeysz == JDBIDKEYNAMEL && !strcmp(JDBIDKEYNAME, vkey)) { //root level OID as string
//pack OID as type table
lua_push_bsontype_table(L, BSON_OID); //+type table
lua_pushvalue(L, -2); //dup oid(val) on stack
lua_rawseti(L, -2, 1); //pop oid val
if (ejdbisvalidoidstr(lua_tostring(L, -2))) {
lua_val_to_bson(L, vkey, lua_gettop(L), bs, tref);
} else {
luaL_error(L, "OID _id='%s' is not valid", lua_tostring(L, -2));
}
lua_pop(L, 1); //-type table
} else {
lua_val_to_bson(L, vkey, lua_gettop(L), bs, tref);
}
lua_pop(L, 1); //-val
}
tclistdel(keys);
if (key) bson_append_finish_object(bs);
}
} else { //metafield __bsontype on top
int bson_type = lua_tointeger(L, -1);
if (!key && bson_type != BSON_OBJECT && bson_type != BSON_ARRAY) {
lua_pop(L, 1);
luaL_error(L, "Invalid object structure");
}
lua_pop(L, 1); //-metafield __bsontype
lua_rawgeti(L, -1, 1); //get first value
switch (bson_type) {
case BSON_OID:
{
const char* boid = lua_tostring(L, -1);
if (boid && strlen(boid) == 24) {
bson_oid_t oid;
bson_oid_from_string(&oid, boid);
bson_append_oid(bs, key, &oid);
}
break;
}
case BSON_DATE:
bson_append_date(bs, key, (bson_date_t) lua_tonumber(L, -1));
break;
case BSON_REGEX:
{
const char* regex = lua_tostring(L, -1);
lua_rawgeti(L, -2, 2); // re opts
const char* options = lua_tostring(L, -1);
if (regex && options) {
bson_append_regex(bs, key, regex, options);
}
lua_pop(L, 1);
break;
}
case BSON_BINDATA:
{
size_t len;
const char* cbuf = lua_tolstring(L, -1, &len);
bson_append_binary(bs, key, BSON_BIN_BINARY, cbuf, len);
break;
}
case BSON_NULL:
bson_append_null(bs, key);
break;
case BSON_UNDEFINED:
bson_append_undefined(bs, key);
break;
case BSON_OBJECT:
if (key) bson_append_start_object(bs, key);
lua_val_to_bson(L, NULL, vpos, bs, tref);
if (key) bson_append_finish_object(bs);
break;
case BSON_ARRAY:
if (key) bson_append_start_array(bs, key);
lua_val_to_bson(L, NULL, vpos, bs, tref);
if (key) bson_append_finish_array(bs);
break;
case BSON_DOUBLE:
bson_append_double(bs, key, (double) lua_tonumber(L, -1));
break;
case BSON_INT:
bson_append_int(bs, key, (int32_t) lua_tonumber(L, -1));
break;
case BSON_LONG:
bson_append_long(bs, key, (int64_t) lua_tonumber(L, -1));
break;
case BSON_BOOL:
bson_append_bool(bs, key, lua_toboolean(L, -1));
break;
default:
break;
}
lua_pop(L, 1); //-1 first value
}
break;
}
case LUA_TNIL:
bson_append_null(bs, key);
break;
case LUA_TNUMBER:
{
lua_Number numval = lua_tonumber(L, vpos);
if (numval == floor(numval)) {
int64_t iv = (int64_t) numval;
if (-(1LL << 31) <= iv && iv <= (1LL << 31)) {
bson_append_int(bs, key, iv);
} else {
bson_append_long(bs, key, iv);
}
} else {
bson_append_double(bs, key, numval);
}
break;
}
case LUA_TBOOLEAN:
bson_append_bool(bs, key, lua_toboolean(L, vpos));
break;
case LUA_TSTRING:
bson_append_string(bs, key, lua_tostring(L, vpos));
break;
}
}
EXPORT int mongo_bson_buffer_append_regex(struct bson_buffer* b, char *name, char* pattern, char* options) {
return (bson_append_regex((bson*) b, name, pattern, options) == BSON_OK);
}
static void
test_bson_append_general (void)
{
bson_uint8_t bytes[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01, 0x23, 0x45 };
bson_oid_t oid;
bson_t *bson;
bson_t *array;
bson_t *subdoc;
bson = bson_new();
assert(bson_append_int32(bson, "int", -1, 1));
assert_bson_equal_file(bson, "test1.bson");
bson_destroy(bson);
bson = bson_new();
assert(bson_append_int64(bson, "int64", -1, 1));
assert_bson_equal_file(bson, "test2.bson");
bson_destroy(bson);
bson = bson_new();
assert(bson_append_double(bson, "double", -1, 1.123));
assert_bson_equal_file(bson, "test3.bson");
bson_destroy(bson);
bson = bson_new();
assert(bson_append_utf8(bson, "string", -1, "some string", -1));
assert_bson_equal_file(bson, "test5.bson");
bson_destroy(bson);
bson = bson_new();
array = bson_new();
assert(bson_append_int32(array, "0", -1, 1));
assert(bson_append_int32(array, "1", -1, 2));
assert(bson_append_int32(array, "2", -1, 3));
assert(bson_append_int32(array, "3", -1, 4));
assert(bson_append_int32(array, "4", -1, 5));
assert(bson_append_int32(array, "5", -1, 6));
assert(bson_append_array(bson, "array[int]", -1, array));
assert_bson_equal_file(bson, "test6.bson");
bson_destroy(array);
bson_destroy(bson);
bson = bson_new();
array = bson_new();
assert(bson_append_double(array, "0", -1, 1.123));
assert(bson_append_double(array, "1", -1, 2.123));
assert(bson_append_array(bson, "array[double]", -1, array));
assert_bson_equal_file(bson, "test7.bson");
bson_destroy(array);
bson_destroy(bson);
bson = bson_new();
subdoc = bson_new();
assert(bson_append_int32(subdoc, "int", -1, 1));
assert(bson_append_document(bson, "document", -1, subdoc));
assert_bson_equal_file(bson, "test8.bson");
bson_destroy(subdoc);
bson_destroy(bson);
bson = bson_new();
assert(bson_append_null(bson, "null", -1));
assert_bson_equal_file(bson, "test9.bson");
bson_destroy(bson);
bson = bson_new();
assert(bson_append_regex(bson, "regex", -1, "1234", "i"));
assert_bson_equal_file(bson, "test10.bson");
bson_destroy(bson);
bson = bson_new();
assert(bson_append_utf8(bson, "hello", -1, "world", -1));
assert_bson_equal_file(bson, "test11.bson");
bson_destroy(bson);
bson = bson_new();
array = bson_new();
assert(bson_append_utf8(array, "0", -1, "awesome", -1));
assert(bson_append_double(array, "1", -1, 5.05));
assert(bson_append_int32(array, "2", -1, 1986));
assert(bson_append_array(bson, "BSON", -1, array));
assert_bson_equal_file(bson, "test12.bson");
bson_destroy(bson);
bson_destroy(array);
bson = bson_new();
memcpy(&oid, bytes, sizeof oid);
assert(bson_append_oid(bson, "_id", -1, &oid));
subdoc = bson_new();
assert(bson_append_oid(subdoc, "_id", -1, &oid));
array = bson_new();
assert(bson_append_utf8(array, "0", -1, "1", -1));
assert(bson_append_utf8(array, "1", -1, "2", -1));
assert(bson_append_utf8(array, "2", -1, "3", -1));
assert(bson_append_utf8(array, "3", -1, "4", -1));
assert(bson_append_array(subdoc, "tags", -1, array));
bson_destroy(array);
assert(bson_append_utf8(subdoc, "text", -1, "asdfanother", -1));
array = bson_new();
assert(bson_append_utf8(array, "name", -1, "blah", -1));
assert(bson_append_document(subdoc, "source", -1, array));
bson_destroy(array);
assert(bson_append_document(bson, "document", -1, subdoc));
bson_destroy(subdoc);
array = bson_new();
assert(bson_append_utf8(array, "0", -1, "source", -1));
assert(bson_append_array(bson, "type", -1, array));
bson_destroy(array);
array = bson_new();
assert(bson_append_utf8(array, "0", -1, "server_created_at", -1));
assert(bson_append_array(bson, "missing", -1, array));
bson_destroy(array);
assert_bson_equal_file(bson, "test17.bson");
bson_destroy(bson);
}
void encodeValue(bson *bb, const char *name, v8::Local<v8::Value> element,
bool doJson)
{
if (element.IsEmpty() || element->IsUndefined() || element->IsFunction())
;
else if (element->IsNull())
bson_append_null(bb, name);
else if (element->IsDate())
bson_append_date(bb, name, (bson_date_t) element->NumberValue());
else if (element->IsBoolean())
bson_append_bool(bb, name, element->IsTrue());
else if (element->IsNumber() || element->IsNumberObject())
{
double value = element->NumberValue();
int64_t num = (int64_t) value;
if (value == (double) num)
{
if (num >= -2147483648ll && num <= 2147483647ll)
bson_append_int(bb, name, (int) num);
else
bson_append_long(bb, name, num);
}
else
bson_append_double(bb, name, value);
}
else if (element->IsArray())
encodeArray(bb, name, element);
else if (element->IsRegExp())
{
v8::Local<v8::RegExp> re = v8::Local<v8::RegExp>::Cast(element);
v8::Local<v8::String> src = re->GetSource();
v8::RegExp::Flags flgs = re->GetFlags();
char flgStr[4];
char *p = flgStr;
if (flgs & v8::RegExp::kIgnoreCase)
*p++ = 'i';
if (flgs & v8::RegExp::kGlobal)
*p++ = 'g';
if (flgs & v8::RegExp::kMultiline)
*p++ = 'm';
*p = 0;
bson_append_regex(bb, name, *v8::String::Utf8Value(src), flgStr);
}
else if (element->IsObject())
{
{
obj_ptr<Int64> num = (Int64 *)Int64_base::getInstance(element);
if (num)
{
if (num->m_num >= -2147483648ll && num->m_num <= 2147483647ll)
bson_append_int(bb, name, (int) num->m_num);
else
bson_append_long(bb, name, num->m_num);
return;
}
}
{
obj_ptr<Buffer_base> buf = Buffer_base::getInstance(element);
if (buf)
{
std::string strBuf;
buf->toString(strBuf);
bson_append_binary(bb, name, BSON_BIN_BINARY, strBuf.c_str(),
(int) strBuf.length());
return;
}
}
{
obj_ptr<MongoID> oid = (MongoID *) MongoID_base::getInstance(
element);
if (oid)
{
bson_append_oid(bb, name, &oid->m_id);
return;
}
}
encodeObject(bb, name, element, doJson);
}
else
{
v8::String::Utf8Value v(element);
bson_append_string(bb, name, ToCString(v));
}
}
int main() {
mongo conn[1];
bson b, empty;
mongo_cursor cursor[1];
unsigned char not_utf8[3];
int result = 0;
const char *ns = "test.c.validate";
int i=0, j=0;
bson bs[BATCH_SIZE];
bson *bp[BATCH_SIZE];
not_utf8[0] = 0xC0;
not_utf8[1] = 0xC0;
not_utf8[2] = '\0';
INIT_SOCKETS_FOR_WINDOWS;
if ( mongo_connect( conn, TEST_SERVER, 27017 ) ) {
printf( "failed to connect\n" );
exit( 1 );
}
/* Test checking for finished bson. */
bson_init( &b );
bson_append_int( &b, "foo", 1 );
ASSERT( mongo_insert( conn, "test.foo", &b, NULL ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_BSON_NOT_FINISHED );
bson_destroy( &b );
/* Test valid keys. */
bson_init( &b );
result = bson_append_string( &b , "a.b" , "17" );
ASSERT( result == BSON_OK );
ASSERT( b.err & BSON_FIELD_HAS_DOT );
/* Don't set INIT dollar if deb ref fields are being used. */
result = bson_append_string( &b , "$id" , "17" );
ASSERT( result == BSON_OK );
ASSERT( !(b.err & BSON_FIELD_INIT_DOLLAR) );
result = bson_append_string( &b , "$ref" , "17" );
ASSERT( result == BSON_OK );
ASSERT( !(b.err & BSON_FIELD_INIT_DOLLAR) );
result = bson_append_string( &b , "$db" , "17" );
ASSERT( result == BSON_OK );
ASSERT( !(b.err & BSON_FIELD_INIT_DOLLAR) );
result = bson_append_string( &b , "$ab" , "17" );
ASSERT( result == BSON_OK );
ASSERT( b.err & BSON_FIELD_INIT_DOLLAR );
result = bson_append_string( &b , "ab" , "this is valid utf8" );
ASSERT( result == BSON_OK );
ASSERT( ! ( b.err & BSON_NOT_UTF8 ) );
result = bson_append_string( &b , ( const char * )not_utf8, "valid" );
ASSERT( result == BSON_ERROR );
ASSERT( b.err & BSON_NOT_UTF8 );
ASSERT( bson_finish( &b ) == BSON_ERROR );
ASSERT( b.err & BSON_FIELD_HAS_DOT );
ASSERT( b.err & BSON_FIELD_INIT_DOLLAR );
ASSERT( b.err & BSON_NOT_UTF8 );
result = mongo_insert( conn, ns, &b, NULL );
ASSERT( result == MONGO_ERROR );
ASSERT( conn->err & MONGO_BSON_NOT_FINISHED );
result = mongo_update( conn, ns, bson_empty( &empty ), &b, 0, NULL );
ASSERT( result == MONGO_ERROR );
ASSERT( conn->err & MONGO_BSON_NOT_FINISHED );
mongo_cursor_init( cursor, conn, "test.cursors" );
mongo_cursor_set_query( cursor, &b );
result = mongo_cursor_next( cursor );
ASSERT( result == MONGO_ERROR );
ASSERT( cursor->err & MONGO_CURSOR_BSON_ERROR );
ASSERT( cursor->conn->err & MONGO_BSON_NOT_FINISHED );
bson_destroy( &b );
mongo_cursor_destroy( cursor );
/* Test valid strings. */
bson_init( &b );
result = bson_append_string( &b , "foo" , "bar" );
ASSERT( result == BSON_OK );
ASSERT( b.err == 0 );
result = bson_append_string( &b , "foo" , ( const char * )not_utf8 );
ASSERT( result == BSON_ERROR );
ASSERT( b.err & BSON_NOT_UTF8 );
b.err = 0;
ASSERT( b.err == 0 );
result = bson_append_regex( &b , "foo" , ( const char * )not_utf8, "s" );
ASSERT( result == BSON_ERROR );
ASSERT( b.err & BSON_NOT_UTF8 );
for ( j=0; j < BATCH_SIZE; j++ )
bp[j] = &bs[j];
for ( j=0; j < BATCH_SIZE; j++ )
make_small_invalid( &bs[j], i );
result = mongo_insert_batch( conn, ns, (const bson **)bp, BATCH_SIZE, NULL, 0 );
ASSERT( result == MONGO_ERROR );
ASSERT( conn->err == MONGO_BSON_INVALID );
for ( j=0; j < BATCH_SIZE; j++ )
bson_destroy( &bs[j] );
bson_destroy( &b );
mongo_cmd_drop_db( conn, "test" );
mongo_disconnect( conn );
mongo_destroy( conn );
return 0;
}
void core::append(const types::b_regex& value) {
stdx::string_view key = _impl->next_key();
bson_append_regex(_impl->back(), key.data(), key.length(), value.regex.to_string().data(),
value.options.to_string().data());
}
