static void log_query (const bson_t *doc, const bson_t *query) { char *str1; char *str2; str1 = bson_as_json (doc, NULL); str2 = bson_as_json (query, NULL); printf ("Matching %s against %s\n", str2, str1); bson_free (str1); bson_free (str2); }
int mongo_get_documents(mongoc_client_t *client, char *database, char *collection_name, bson_t *query, query_result **result) { mongoc_collection_t *collection; mongoc_cursor_t *cursor; const bson_t *doc; char *str; int index = 0; collection = mongoc_client_get_collection(client, database, collection_name); cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL); query_result *current = *result; while (mongoc_cursor_next(cursor, &doc)) { str = bson_as_json(doc, NULL); if (index == 0) { (*result)->document = malloc(strlen(str) + 1); strcpy((*result)->document, str); (*result)->next = NULL; } else { current->next = malloc(sizeof(query_result)); current->next->document = malloc(strlen(str) + 1); strcpy(current->next->document, str); current->next->next = NULL; current = current->next; } index++; bson_free(str); } mongoc_cursor_destroy(cursor); mongoc_collection_destroy(collection); return 0; }
int main(void) { const uint8_t *json = (uint8_t*)"{ \"message\" : \"Hello World!\" }"; bson_error_t error; bson_t *doc; char *str; size_t len; if (!(doc = bson_new_from_json(json, -1, &error))) { fprintf(stderr, "Cannot initialize BSON structure from JSON example.\n"); fprintf(stderr, "BSON error message: %s\n", error.message); return 1; } printf("Has key \"message\" (expect \"yes\") : %s\n", yesno(bson_has_field(doc, "message"))); printf("Has key \"triceratops\" (expect\"no\") : %s\n", yesno(bson_has_field(doc, "triceratops"))); str = bson_as_json(doc, &len); printf("Original JSON document : %s\n", json); printf("BSON-to-JSON conversion : %s\n", str); bson_free(str); bson_destroy(doc); return 0; }
int main (int argc, char *argv[]) { size_t index; aggregation_state_t *state = aggregate_start(NULL, NULL); aggregate_match(state, "{}"); printf("Match:\n"); for(index = 0; index < (*state).docs_len; index++) { char *str; str = bson_as_json (&(*state).docs[index], NULL); printf("%s\n", str); } printf("Group:\n"); printf("{\"_id\" : \"$state\", \"data\" : {\"views\" : 0, \"total_population\" : {\"$sum\" : \"$population\"} } }\n"); aggregate_group(state, "{\"_id\" : \"$state\", \"data\" : {\"views\" : 0, \"total_population\" : {\"$sum\" : \"$population\"} } }"); aggregation_result_t *result = aggregate_end(state); printf("Result:\n"); for(index = 0; index < (*result).docs_len; index++) { printf("%s\n", (*result).docs[index]); } }
static void test_bson_corrupt_binary (void) { uint8_t *buf; bson_t b; size_t buflen = 1024; char *str; int fd; ssize_t r; buf = bson_malloc0(buflen); fd = bson_open(BINARY_DIR"/test57.bson", O_RDONLY); BSON_ASSERT(-1 != fd); r = bson_read(fd, buf, buflen); BSON_ASSERT(r == 26); r = bson_init_static(&b, buf, (uint32_t)r); BSON_ASSERT(r); str = bson_as_json(&b, NULL); BSON_ASSERT(!str); bson_destroy(&b); bson_free(buf); }
static void run_command (void) { mongoc_client_t *client; mongoc_collection_t *collection; bson_error_t error; bson_t *command; bson_t reply; char *str; client = mongoc_client_new ("mongodb://*****:*****@192.168.0.112:27017/"); collection = mongoc_client_get_collection (client, "test", "test"); command = BCON_NEW ("collStats", BCON_UTF8 ("test")); if (mongoc_collection_command_simple (collection, command, NULL, &reply, &error)) { str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); } else { fprintf (stderr, "Failed to run command: %s\n", error.message); } bson_destroy (command); bson_destroy (&reply); mongoc_collection_destroy (collection); mongoc_client_destroy (client); }
static PyObject * cbson_as_json (PyObject *self, PyObject *args) { const bson_uint8_t *buffer; bson_uint32_t buffer_length; bson_reader_t reader; const bson_t *b; PyObject *ret = NULL; size_t len = 0; char *str; if (!PyArg_ParseTuple(args, "s#", &buffer, &buffer_length)) { return NULL; } bson_reader_init_from_data(&reader, buffer, buffer_length); b = bson_reader_read(&reader, NULL); bson_reader_destroy(&reader); if (b) { str = bson_as_json(b, &len); ret = PyUnicode_DecodeUTF8(str, len, "strict"); bson_free(str); } else { PyErr_SetString(PyExc_ValueError, "Failed to parse BSON document."); } return ret; }
int main (int argc, char *argv[]) { mongoc_client_t *client; mongoc_collection_t *collection; mongoc_cursor_t *cursor; const bson_t *doc; bson_t *query; char *str; mongoc_init (); client = mongoc_client_new ("mongodb://localhost:3001/"); collection = mongoc_client_get_collection (client, "meteor", "sensors"); query = bson_new (); cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL); while (mongoc_cursor_next (cursor, &doc)) { str = bson_as_json (doc, NULL); printf ("%s\n", str); bson_free (str); } bson_destroy (query); mongoc_cursor_destroy (cursor); mongoc_collection_destroy (collection); mongoc_client_destroy (client); return 0; }
SEXP R_mongo_cursor_next_json (SEXP ptr, SEXP n){ mongoc_cursor_t *c = r2cursor(ptr); int len = asInteger(n); SEXP out = PROTECT(allocVector(STRSXP, len)); const bson_t *b = NULL; int total = 0; bson_error_t err; while(total < len){ if(!mongoc_cursor_next(c, &b)){ if(mongoc_cursor_error (c, &err)) stop(err.message); else //cursor exchausted: done break; } else { size_t jsonlength; const char *str = bson_as_json ((bson_t*) b, &jsonlength); SET_STRING_ELT(out, total, mkCharLenCE(str, jsonlength, CE_UTF8)); if(str) bson_free(str); total++; } } if(total < len){ SEXP out2 = PROTECT(allocVector(STRSXP, total)); for(int i = 0; i < total; i++){ SET_STRING_ELT(out2, i, STRING_ELT(out, i)); } UNPROTECT(2); return out2; } UNPROTECT(1); return out; }
int main (int argc,char* argv[]) { mongoc_client_t *client; mongoc_collection_t *collection; mongoc_cursor_t *cursor; const bson_t *doc; bson_t *query; char *str; mongoc_init (); client = mongoc_client_new ("mongodb://*****:*****@192.168.0.112:27017/"); collection = mongoc_client_get_collection (client, "clown", "testCollection"); query = bson_new (); cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL); while (mongoc_cursor_next (cursor, &doc)) { str = bson_as_json (doc, NULL); printf ("%s\n", str); bson_free (str); } bson_destroy (query); mongoc_cursor_destroy (cursor); mongoc_collection_destroy (collection); mongoc_client_destroy (client); return 0; }
static void bulk1 (mongoc_collection_t *collection) { mongoc_bulk_operation_t *bulk; bson_error_t error; bson_t *doc; bson_t reply; char *str; bool ret; int i; bulk = mongoc_collection_create_bulk_operation (collection, true, NULL); for (i = 0; i < 10000; i++) { doc = BCON_NEW ("i", BCON_INT32 (i)); mongoc_bulk_operation_insert (bulk, doc); bson_destroy (doc); } ret = mongoc_bulk_operation_execute (bulk, &reply, &error); str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); if (!ret) { fprintf (stderr, "Error: %s\n", error.message); } bson_destroy (&reply); mongoc_bulk_operation_destroy (bulk); }
static void test_bson_as_json_stack_overflow (void) { uint8_t *buf; bson_t b; size_t buflen = 1024 * 1024 * 17; char *str; int fd; ssize_t r; buf = bson_malloc0(buflen); fd = bson_open(BINARY_DIR"/stackoverflow.bson", O_RDONLY); BSON_ASSERT(-1 != fd); r = bson_read(fd, buf, buflen); BSON_ASSERT(r == 16777220); r = bson_init_static(&b, buf, 16777220); BSON_ASSERT(r); str = bson_as_json(&b, NULL); BSON_ASSERT(str); r = !!strstr(str, "..."); BSON_ASSERT(str); bson_free(str); bson_destroy(&b); bson_free(buf); }
static void print_pipeline (mongoc_collection_t *collection) { mongoc_cursor_t *cursor; bson_error_t error; const bson_t *doc; bson_t *pipeline; char *str; pipeline = BCON_NEW ("pipeline", "[", "{", "$group", "{", "_id", "$state", "total_pop", "{", "$sum", "$pop", "}", "}", "}", "{", "$match", "{", "total_pop", "{", "$gte", BCON_INT32 (10000000), "}", "}", "}", "]"); cursor = mongoc_collection_aggregate (collection, MONGOC_QUERY_NONE, pipeline, NULL, NULL); while (mongoc_cursor_next (cursor, &doc)) { str = bson_as_json (doc, NULL); printf ("%s\n", str); bson_free (str); } if (mongoc_cursor_error (cursor, &error)) { fprintf (stderr, "Cursor Failure: %s\n", error.message); } mongoc_cursor_destroy (cursor); bson_destroy (pipeline); }
int main (int argc, char *argv[]) { mongoc_matcher_t *matcher; bson_reader_t *reader; const bson_t *bson; bson_t *spec; char *str; reader = bson_reader_new_from_handle ((void *)&MONGOC_STDIN_FILENO, &_read_cb, &_destroy_cb); spec = BCON_NEW ("hello", "world"); matcher = mongoc_matcher_new (spec, NULL); while ((bson = bson_reader_read (reader, NULL))) { if (mongoc_matcher_match (matcher, bson)) { str = bson_as_json (bson, NULL); printf ("%s\n", str); bson_free (str); } } bson_reader_destroy (reader); bson_destroy (spec); return 0; }
static void print_doc (const bson_t *b) { char *str; str = bson_as_json(b, NULL); MONGOC_DEBUG("%s", str); bson_free(str); }
int main(int argc, char *argv[]) { mongoc_client_t *client; mongoc_collection_t *collection; mongoc_cursor_t *cursor; const bson_t *doc; bson_t *query; char *str; mongoc_init(); client = mongoc_client_new("mongodb://localhost:27017/"); collection = mongoc_client_get_collection(client, "stockopedia", "instruments"); query = bson_new(); bson_t *fields = bson_new(); BSON_APPEND_INT32(fields, "RIC", 1); cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, query, fields, NULL); bson_iter_t iter; const bson_value_t *value; while (mongoc_cursor_next(cursor, &doc)) { str = bson_as_json(doc, NULL); printf("%s\n", str); if (bson_iter_init(&iter, doc)) { while (bson_iter_next(&iter)) { printf("Found a field named: %s\n", bson_iter_key(&iter)); value = bson_iter_value(&iter); if (value->value_type == BSON_TYPE_UTF8) { printf("It's a UTF8 : '%s'\n", value->value.v_utf8.str); } } } //printf("Found element key : '%s'\n", bson_iter_key(&iter)); // if (bson_iter_init(&iter, doc)) { // // } bson_free(str); } //Now fetch quotes for each RIC bson_destroy(query); mongoc_cursor_destroy(cursor); mongoc_collection_destroy(collection); mongoc_client_destroy(client); return 0; }
static void print_bson (const bson_t *b) { char *str; str = bson_as_json(b, NULL); fprintf(stdout, "%s\n", str); bson_free(str); }
void bson_printf (const char *format, const bson_t *bson) { const char *str; str = bson_as_json (bson, NULL); printf (format, str); bson_free ((void*)str); }
int main (int argc, char *argv[]) { mongoc_collection_t *collection; mongoc_client_t *client; bson_error_t error; bson_t *query; bson_t *update; bson_t reply; char *str; mongoc_init (); client = mongoc_client_new ("mongodb://127.0.0.1:27017/"); collection = mongoc_client_get_collection (client, "test", "test"); /* * Build our query, {"cmpxchg": 1} */ query = BCON_NEW ("cmpxchg", BCON_INT32 (1)); /* * Build our update. {"$set": {"cmpxchg": 2}} */ update = BCON_NEW ("$set", "{", "cmpxchg", BCON_INT32 (2), "}"); /* * Submit the findAndModify. */ if (!mongoc_collection_find_and_modify (collection, query, NULL, update, NULL, false, false, true, &reply, &error)) { fprintf (stderr, "find_and_modify() failure: %s\n", error.message); return 1; } /* * Print the result as JSON. */ str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); /* * Cleanup. */ bson_destroy (query); bson_destroy (update); bson_destroy (&reply); mongoc_collection_destroy (collection); mongoc_client_destroy (client); mongoc_cleanup (); return 0; }
void ha_replica_set_wait_for_healthy (ha_replica_set_t *replica_set) { bson_iter_t iter; bson_iter_t ar; bson_iter_t member; const char *stateStr; bson_t status; again: sleep(1); if (!ha_replica_set_get_status(replica_set, &status)) { MONGOC_INFO("Failed to get replicaSet status. " "Sleeping 1 second."); goto again; } #if 0 { char *str; str = bson_as_json(&status, NULL); printf("%s\n", str); bson_free(str); } #endif if (!bson_iter_init_find(&iter, &status, "members") || !BSON_ITER_HOLDS_ARRAY(&iter) || !bson_iter_recurse(&iter, &ar)) { bson_destroy(&status); MONGOC_INFO("ReplicaSet has not yet come online. " "Sleeping 1 second."); goto again; } while (bson_iter_next(&ar)) { if (BSON_ITER_HOLDS_DOCUMENT(&ar) && bson_iter_recurse(&ar, &member) && bson_iter_find(&member, "stateStr") && (stateStr = bson_iter_utf8(&member, NULL))) { if (!!strcmp(stateStr, "PRIMARY") && !!strcmp(stateStr, "SECONDARY") && !!strcmp(stateStr, "ARBITER")) { bson_destroy(&status); MONGOC_INFO("Found unhealthy node. Sleeping 1 second."); goto again; } } } bson_destroy(&status); }
int main (int argc, char *argv[]) { bson_t * query; /* time_t oid_thinks_time; //what time does the OID think it is bson_oid_t oid; bson_oid_t *oid_pointer = &oid; bson_oid_init (&oid, NULL); // get a standard ObjectId oid_thinks_time = bson_oid_get_time_t (&oid); //It was just made printf ("The OID was generated at %u\n", (unsigned) oid_thinks_time); //prove it time_t ts = time(NULL); //make a new time struct tm * timeinfo = localtime(&ts); timeinfo->tm_year = 2014-1900; //-1900 because time.h timeinfo->tm_mon = 12 - 1; // time.h off by one (starts at 0) timeinfo->tm_mday = 25; ts = mktime(timeinfo); // create the time u_int32_t ts_uint = (uint32_t)ts; ts_uint = BSON_UINT32_TO_BE (ts_uint); //BSON wants big endian time memcpy (&oid_pointer->bytes[0], &ts_uint, sizeof (ts_uint)); //overwrite the first 4 bytes with user selected time oid_thinks_time = bson_oid_get_time_t (&oid); printf ("The OID was fixed to time %u\n", (unsigned) oid_thinks_time);//prove it */ query = BCON_NEW ("ping", BCON_INT32 (1)); query = BCON_NEW("$and","[", "{", "a", BCON_INT32(1), "}", "{", "yyyyyyy", "{", "$ne", BCON_UTF8("xxxxxxxxxx"), "}", "}","]"); bson_t *doc; query = BCON_NEW ( "$and", "[", "{", "_id", BCON_INT32(1), "}", "{", "yyyyyy", "{", "$ne", BCON_UTF8 ("xxxxxxx"), "}", "}","]" ); query = BCON_NEW("$and","[", "{", "timestamp", "{", "$eq", BCON_INT64(1111111111112), "}", "}", "{", "timestamp", "{", "$gte", BCON_INT64(1111111111111), "}", "}", "{", "timestamp", "{", "$lt", BCON_INT64(1111111111110), "}", "}","]"); //prove it looks right size_t s; char * as_json; as_json = bson_as_json(query, &s); printf("%s\n", as_json); return 0; }
char *be_mongo_getuser(void *handle, const char *username) { struct mongo_backend *conf = (struct mongo_backend *)handle; mongoc_collection_t *collection; mongoc_cursor_t *cursor; bson_error_t error; const bson_t *doc; const char *collection_name = "passport"; bson_t query; char *str = NULL; char *result = malloc(33); memset(result, 0, 33); bson_init (&query); bson_append_utf8 (&query, "username", -1, username, -1); collection = mongoc_client_get_collection (conf->client, "cas", collection_name); cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 0, &query, NULL, /* Fields, NULL for all. */ NULL); /* Read Prefs, NULL for default */ bson_iter_t iter; while (!mongoc_cursor_error (cursor, &error) && mongoc_cursor_more (cursor)) { if (mongoc_cursor_next (cursor, &doc)) { bson_iter_init(&iter, doc); bson_iter_find(&iter, "pwd"); //fprintf (stdout, "%s\n", bson_iter_utf8(&iter, NULL)); str = bson_as_json (doc, NULL); //fprintf (stdout, "%s\n", str); bson_free (str); char *src = (char *)bson_iter_utf8(&iter, NULL); memcpy(result, src, strlen(src)); } } if (mongoc_cursor_error (cursor, &error)) { fprintf (stderr, "Cursor Failure: %s\n", error.message); return result; } bson_destroy (&query); mongoc_cursor_destroy (cursor); mongoc_collection_destroy (collection); return result; }
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 ha_config_add_shard (ha_node_t *node, ha_replica_set_t *replica_set) { mongoc_collection_t *collection; mongoc_client_t *client; bson_string_t *shardstr; bson_error_t error; bson_bool_t r; bson_t reply; bson_t cmd = BSON_INITIALIZER; char *uristr; uristr = bson_strdup_printf ("mongodb://127.0.0.1:%hu/", node->port); client = mongoc_client_new (uristr); collection = mongoc_client_get_collection (client, "admin", "fake"); shardstr = bson_string_new (NULL); bson_string_append_printf (shardstr, "%s/127.0.0.1:%hu", replica_set->name, replica_set->nodes->port); bson_append_utf8 (&cmd, "addShard", -1, shardstr->str, shardstr->len); bson_string_free (shardstr, TRUE); again: sleep (1); r = mongoc_collection_command_simple (collection, &cmd, NULL, &reply, &error); if (!r) { fprintf (stderr, "%s\n", error.message); goto again; } #if 1 { char *str; str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); } #endif bson_destroy (&reply); bson_destroy (&cmd); mongoc_collection_destroy (collection); mongoc_client_destroy (client); bson_free (uristr); }
int main (int argc, char *argv[]) { const bson_t *b; extent_t extent; record_t record; char *str; db_t db; ns_t ns; if (argc != 3) { fprintf(stderr, "usage: mdbdump DBPATH DBNAME\n"); return ARGC_FAILURE; } errno = 0; if (!!db_init(&db, argv[1], argv[2])) { perror("Failed to load database"); return DB_FAILURE; } errno = 0; if (!!db_namespaces(&db, &ns)) { perror("Failed to load namespaces"); return NS_FAILURE; } do { //fprintf(stdout, "\nNamespace \"%s\"\n\n", ns_name(&ns)); if (!!ns_extents(&ns, &extent)) { perror("Failed to load extent"); return EXTENT_FAILURE; } do { if (!extent_records(&extent, &record)) { do { b = record_bson(&record); if ((str = bson_as_json(b, NULL))) { puts(str); } bson_free(str); } while (!record_next(&record)); } } while (!extent_next(&extent)); } while (ns_next(&ns)); db_destroy(&db); return 0; }
void command_succeeded (const mongoc_apm_command_succeeded_t *event) { char *s; s = bson_as_json (mongoc_apm_command_succeeded_get_reply (event), NULL); printf ("Command %s succeeded:\n%s\n\n", mongoc_apm_command_succeeded_get_command_name (event), s); ((stats_t *) mongoc_apm_command_succeeded_get_context (event))->succeeded++; bson_free (s); }
static void test_bson_as_json_utf8 (void) { size_t len; bson_t *b; char *str; b = bson_new(); assert(bson_append_utf8(b, "€€€€€", -1, "€€€€€", -1)); str = bson_as_json(b, &len); assert(!strcmp(str, "{ \"€€€€€\" : \"€€€€€\" }")); bson_free(str); bson_destroy(b); }
static void bulk3 (mongoc_collection_t *collection) { mongoc_bulk_operation_t *bulk; bson_error_t error; bson_t *query; bson_t *doc; bson_t reply; char *str; bool ret; /* false indicates unordered */ bulk = mongoc_collection_create_bulk_operation (collection, false, NULL); /* Add a document */ doc = BCON_NEW ("_id", BCON_INT32 (1)); mongoc_bulk_operation_insert (bulk, doc); bson_destroy (doc); /* remove {_id: 2} */ query = BCON_NEW ("_id", BCON_INT32 (2)); mongoc_bulk_operation_remove_one (bulk, query); bson_destroy (query); /* insert {_id: 3} */ doc = BCON_NEW ("_id", BCON_INT32 (3)); mongoc_bulk_operation_insert (bulk, doc); bson_destroy (doc); /* replace {_id:4} {'i': 1} */ query = BCON_NEW ("_id", BCON_INT32 (4)); doc = BCON_NEW ("i", BCON_INT32 (1)); mongoc_bulk_operation_replace_one (bulk, query, doc, false); bson_destroy (query); bson_destroy (doc); ret = mongoc_bulk_operation_execute (bulk, &reply, &error); str = bson_as_json (&reply, NULL); printf ("%s\n", str); bson_free (str); if (!ret) { printf ("Error: %s\n", error.message); } bson_destroy (&reply); mongoc_bulk_operation_destroy (bulk); }
static void test_bson_as_json_int64 (void) { size_t len; bson_t *b; char *str; b = bson_new(); assert(bson_append_int64(b, "foo", -1, 341234123412341234ULL)); str = bson_as_json(b, &len); assert(len == 30); assert(!strcmp("{ \"foo\" : 341234123412341234 }", str)); bson_free(str); bson_destroy(b); }
static void test_bson_as_json_string (void) { size_t len; bson_t *b; char *str; b = bson_new(); assert(bson_append_utf8(b, "foo", -1, "bar", -1)); str = bson_as_json(b, &len); assert(len == 17); assert(!strcmp("{ \"foo\" : \"bar\" }", str)); bson_free(str); bson_destroy(b); }