自学教程：C++ BCON_INT32函数代码示例

static voidexample (void){   bson_t *query;   bson_t *doc;   doc = BCON_NEW ("hello", "[", "{", "foo", BCON_UTF8 ("bar"), "}", "]");   query = BCON_NEW ("hello.0.foo", BCON_UTF8 ("bar"));   log_query (doc, query);   check_match (doc, query);   bson_destroy (doc);   bson_destroy (query);   /* i is > 1 or i < -1. */   query = BCON_NEW ("$or", "[",                     "{", "i", "{", "$gt", BCON_INT32 (1), "}", "}",                     "{", "i", "{", "$lt", BCON_INT32 (-1), "}", "}", "]");   doc = BCON_NEW ("i", BCON_INT32 (2));   log_query (doc, query);   check_match (doc, query);   bson_destroy (doc);   doc = BCON_NEW ("i", BCON_INT32 (0));   log_query (doc, query);   check_match (doc, query);   bson_destroy (doc);   bson_destroy (query);}

static voidtest_mongoc_matcher_compare (void){   mongoc_matcher_t *matcher;   compare_check checks[] = {      { "$gt", 2, 2, false },      { "$gte", 2, 2, true},      { "$lt", 2, 2, false},      { "$lte", 2, 2, true},      { "$ne", 2, 2, false},      { NULL }   };   bson_t *doc;   bson_t *q;   int i;   for (i = 0; checks [i].op; i++) {      doc = BCON_NEW ("a", BCON_INT32 (checks[i].doc));      q = BCON_NEW ("a", "{", checks[i].op, BCON_INT32 (checks[i].query), "}");      matcher = mongoc_matcher_new (q, NULL);      assert (matcher);      assert (mongoc_matcher_match (matcher, doc) == checks[i].expected);      bson_destroy (q);      bson_destroy (doc);      mongoc_matcher_destroy (matcher);   }}

static voidtest_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 voidtest_extract_ctx (void){   int32_t a, b, c;   bson_t *bson =      BCON_NEW ("a", BCON_INT32 (1), "b", BCON_INT32 (2), "c", BCON_INT32 (3));   test_extract_ctx_helper (bson,                            3,                            "a",                            BCONE_INT32 (a),                            NULL,                            "b",                            BCONE_INT32 (b),                            NULL,                            "c",                            BCONE_INT32 (c),                            NULL);   assert (a == 1);   assert (b == 2);   assert (c == 3);   bson_destroy (bson);}

static voidtest_mongoc_matcher_eq_doc (void){   bson_t *spec;   bson_t *doc;   bson_error_t error;   mongoc_matcher_t *matcher;   /* {doc: {a: 1}} matches itself */   spec = BCON_NEW ("doc", "{", "a", BCON_INT32 (1), "}");   matcher = mongoc_matcher_new (spec, &error);   BSON_ASSERT (matcher);   BSON_ASSERT (mongoc_matcher_match (matcher, spec));   /* {doc: {a: 1}} matches {doc: {a: 1}, foo: "whatever"} */   doc = BCON_NEW ("doc", "{", "a", BCON_INT32 (1), "}",                   "foo", BCON_UTF8 ("whatever"));   BSON_ASSERT (mongoc_matcher_match (matcher, doc));   bson_destroy (doc);   /* {doc: {a: 1}} doesn't match {doc: 1} */   doc = BCON_NEW ("doc", BCON_INT32 (1));   BSON_ASSERT (!mongoc_matcher_match (matcher, doc));   bson_destroy (doc);   /* {doc: {a: 1}} doesn't match {doc: {}} */   doc = BCON_NEW ("doc", "{", "}");   BSON_ASSERT (!mongoc_matcher_match (matcher, doc));   bson_destroy (doc);   /* {doc: {a: 1}} doesn't match {doc: {a: 2}} */   doc = BCON_NEW ("doc", "{", "a", BCON_INT32 (2), "}");   BSON_ASSERT (!mongoc_matcher_match (matcher, doc));   bson_destroy (doc);   /* {doc: {a: 1}} doesn't match {doc: {b: 1}} */   doc = BCON_NEW ("doc", "{", "b", BCON_INT32 (1), "}");   BSON_ASSERT (!mongoc_matcher_match (matcher, doc));   bson_destroy (doc);   /* {doc: {a: 1}} doesn't match {doc: {a: 1, b: 1}} */   doc = BCON_NEW ("doc", "{", "a", BCON_INT32 (1), "b", BCON_INT32 (1), "}");   BSON_ASSERT (!mongoc_matcher_match (matcher, doc));   bson_destroy (doc);   /* {doc: {a: 1, b:1}} matches itself */   bson_destroy (spec);   mongoc_matcher_destroy (matcher);   spec = BCON_NEW ("doc", "{", "a", BCON_INT32 (1), "b", BCON_INT32 (1), "}");   matcher = mongoc_matcher_new (spec, &error);   BSON_ASSERT (matcher);   BSON_ASSERT (mongoc_matcher_match (matcher, spec));   /* {doc: {a: 1, b:1}} doesn't match {doc: {a: 1}} */   doc = BCON_NEW ("doc", "{", "a", BCON_INT32 (1), "}");   BSON_ASSERT (!mongoc_matcher_match (matcher, doc));   bson_destroy (spec);   bson_destroy (doc);   mongoc_matcher_destroy (matcher);}

intmain (int argc, char *argv[]){   int i;   int n;   int bcon;   bson_t bson, foo, bar, baz;   bson_init (&bson);   if (argc != 3) {      fprintf (stderr,               "usage: bcon-speed NUM_ITERATIONS [y|n]/n"               "/n"               "  y = perform speed tests with bcon/n"               "  n = perform speed tests with bson_append/n"               "/n");      return EXIT_FAILURE;   }   assert (argc == 3);   n = atoi (argv[1]);   bcon = (argv[2][0] == 'y') ? 1 : 0;   for (i = 0; i < n; i++) {      if (bcon) {         BCON_APPEND (&bson,                      "foo",                      "{",                      "bar",                      "{",                      "baz",                      "[",                      BCON_INT32 (1),                      BCON_INT32 (2),                      BCON_INT32 (3),                      "]",                      "}",                      "}");      } else {         bson_append_document_begin (&bson, "foo", -1, &foo);         bson_append_document_begin (&foo, "bar", -1, &bar);         bson_append_array_begin (&bar, "baz", -1, &baz);         bson_append_int32 (&baz, "0", -1, 1);         bson_append_int32 (&baz, "1", -1, 2);         bson_append_int32 (&baz, "2", -1, 3);         bson_append_array_end (&bar, &baz);         bson_append_document_end (&foo, &bar);         bson_append_document_end (&bson, &foo);      }      bson_reinit (&bson);   }   bson_destroy (&bson);   return 0;}

intmain (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;}

intmain (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;}

static voidbulk3 (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 voidtest_inline_array (void){   int32_t a, b;   bson_t *bcon = BCON_NEW ("foo", "[", BCON_INT32 (1), BCON_INT32 (2), "]");   assert (      BCON_EXTRACT (bcon, "foo", "[", BCONE_INT32 (a), BCONE_INT32 (b), "]"));   assert (a == 1);   assert (b == 2);   bson_destroy (bcon);}

int main(void){   mongoc_collection_t *collection;   mongoc_database_t *database;   mongoc_client_t *client;   bson_error_t error;   bson_t *options;   client = mongoc_client_new ("mongodb://localhost:27017/admin");   database = mongoc_client_get_database (client, "databaseName");   options = BCON_NEW ( "validator", "{", "age", "{", "$lte", BCON_INT32 (34), "}", "}", "validationAction", BCON_UTF8 ("error"), "validationLevel", BCON_UTF8 ("moderate"));   collection = mongoc_database_create_collection (database, "collectionName", options, &error);   if (!collection) {      fprintf(stderr, "Got error: /"%s/" on line %d/n", error.message, __LINE__);      return 1;   }   fam_flags (collection);   fam_bypass (collection);   fam_update (collection);   fam_fields (collection);   fam_sort (collection);   mongoc_collection_drop (collection, NULL);   bson_destroy (options);   mongoc_database_destroy (database);   mongoc_collection_destroy (collection);   mongoc_client_destroy (client);   return 0;}

void test_suite (mongoc_database_t   *db,                 mongoc_collection_t *collection){   bson_error_t error;   bson_t query = BSON_INITIALIZER;   int64_t count;   bson_t *options, *pipeline;   double start_time, end_time, delta_time;   mongoc_cursor_t *cursor;   count = mongoc_collection_count (collection, MONGOC_QUERY_NONE, &query, 0, 0, NULL, &error);   printf ("mongoc_collection_count count: %"PRId64"/n", count);   options = BCON_NEW ("cursor", "{", "}", "allowDiskUse", BCON_BOOL (1));   pipeline = BCON_NEW (      "pipeline", "[",          "{",             "$match", "{",             "}",          "}",          "{",             "$project", "{",                "text", BCON_INT32 (1),             "}",          "}",       "]"   );   start_time = dtimeofday ();   cursor = mongoc_collection_aggregate (collection, MONGOC_QUERY_NONE, pipeline, options, NULL);   count = mongoc_cursor_dump (cursor);   end_time = dtimeofday ();   delta_time = end_time - start_time + 0.0000001;   printf ("mongoc_cursor_dump: secs: %.2f, count: %"PRId64", %.2f docs/sec/n", delta_time, count, count/delta_time);}

static voidbulk1 (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);}

intmain (int argc,      char *argv[]){   bson_t *options;   bson_error_t error;   mongoc_client_t *client;   mongoc_collection_t *collection;   mongoc_database_t *database;   mongoc_init ();   client = mongoc_client_new ("mongodb://localhost/");   database = mongoc_client_get_database (client, "testasdf");   /* Create schema validator */   options = BCON_NEW ("validator", "{", "number", "{", "$gte", BCON_INT32 (5), "}", "}");   collection = mongoc_database_create_collection (database, "collname", options, &error);   if (collection) {      bulk5_fail (collection);      bulk5_success (collection);      mongoc_collection_destroy (collection);   } else {      fprintf(stderr, "Couldn't create collection: '%s'/n", error.message);   }   bson_free (options);   mongoc_database_destroy (database);   mongoc_client_destroy (client);   mongoc_cleanup ();   return 0;}

static voidprint_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);}

static voidtest_skip (void){   bson_t *bcon = BCON_NEW (      "hello", "world",      "foo", "{",      "bar", BCON_INT32 (10),      "}"      );   assert (BCON_EXTRACT (bcon,                         "hello", BCONE_SKIP (BSON_TYPE_UTF8),                         "foo", "{",                         "bar", BCONE_SKIP (BSON_TYPE_INT32),                         "}"                         ));   assert (!BCON_EXTRACT (bcon,                          "hello", BCONE_SKIP (BSON_TYPE_UTF8),                          "foo", "{",                          "bar", BCONE_SKIP (BSON_TYPE_INT64),                          "}"                          ));   bson_destroy (bcon);}

static voidtest_inline_doc (void){   int32_t a, b;   bson_t *bcon =      BCON_NEW ("foo", "{", "b", BCON_INT32 (2), "a", BCON_INT32 (1), "}");   BSON_ASSERT (BCON_EXTRACT (      bcon, "foo", "{", "a", BCONE_INT32 (a), "b", BCONE_INT32 (b), "}"));   BSON_ASSERT (a == 1);   BSON_ASSERT (b == 2);   bson_destroy (bcon);}

static voidtest_nested (void){   const char *utf8;   int i32;   bson_t *bcon = BCON_NEW (      "hello", "world",      "foo", "{",      "bar", BCON_INT32 (10),      "}"      );   assert (BCON_EXTRACT (bcon,                         "hello", BCONE_UTF8 (utf8),                         "foo", "{",                         "bar", BCONE_INT32 (i32),                         "}"                         ));   assert (strcmp ("world", utf8) == 0);   assert (i32 == 10);   bson_destroy (bcon);}

static voidtest_mongoc_matcher_in_basic (void){   mongoc_matcher_t *matcher;   bson_error_t error;   bool r;   bson_t *spec;   bson_t doc = BSON_INITIALIZER;   spec = BCON_NEW ("key", "{",                       "$in", "[",                          BCON_INT32 (1),                          BCON_INT32 (2),                          BCON_INT32 (3),                       "]",                    "}");   matcher = mongoc_matcher_new (spec, &error);   r = mongoc_matcher_match (matcher, &doc);   ASSERT (!r);   bson_reinit (&doc);   bson_append_int32 (&doc, "key", 3, 1);   r = mongoc_matcher_match (matcher, &doc);   ASSERT (r);   bson_reinit (&doc);   bson_append_int32 (&doc, "key", 3, 2);   r = mongoc_matcher_match (matcher, &doc);   ASSERT (r);   bson_reinit (&doc);   bson_append_int32 (&doc, "key", 3, 3);   r = mongoc_matcher_match (matcher, &doc);   ASSERT (r);   bson_reinit (&doc);   bson_append_int32 (&doc, "key", 3, 4);   r = mongoc_matcher_match (matcher, &doc);   ASSERT (!r);   bson_destroy (&doc);   bson_destroy (spec);   mongoc_matcher_destroy (matcher);}

static voidtest_invalid_write_concern (void){   mongoc_bulk_write_flags_t write_flags = MONGOC_BULK_WRITE_FLAGS_INIT;   mongoc_write_command_t command;   mongoc_write_result_t result;   mongoc_collection_t *collection;   mongoc_client_t *client;   mongoc_write_concern_t *write_concern;   mongoc_server_stream_t *server_stream;   bson_t *doc;   bson_t reply = BSON_INITIALIZER;   bson_error_t error;   bool r;   client = test_framework_client_new ();   assert(client);   collection = get_test_collection(client, "test_invalid_write_concern");   assert(collection);   write_concern = mongoc_write_concern_new();   assert(write_concern);   mongoc_write_concern_set_w(write_concern, 0);   mongoc_write_concern_set_journal(write_concern, true);   assert(!mongoc_write_concern_is_valid (write_concern));   doc = BCON_NEW("_id", BCON_INT32(0));   _mongoc_write_command_init_insert(&command, doc, write_flags,                                     ++client->cluster.operation_id, true);   _mongoc_write_result_init (&result);   server_stream = mongoc_cluster_stream_for_writes (&client->cluster, &error);   ASSERT_OR_PRINT (server_stream, error);   _mongoc_write_command_execute (&command, client, server_stream,                                  collection->db, collection->collection,                                  write_concern, 0, &result);   r = _mongoc_write_result_complete (&result, 2, collection->write_concern,                                      &reply, &error);   assert(!r);   ASSERT_CMPINT(error.domain, ==, MONGOC_ERROR_COMMAND);   ASSERT_CMPINT(error.code, ==, MONGOC_ERROR_COMMAND_INVALID_ARG);   _mongoc_write_command_destroy (&command);   _mongoc_write_result_destroy (&result);   bson_destroy(doc);   mongoc_server_stream_cleanup (server_stream);   mongoc_collection_destroy(collection);   mongoc_client_destroy(client);   mongoc_write_concern_destroy(write_concern);}

static voidtest_inline_nested (void){   bson_t bcon, expected, foo, bar, third;   bson_init (&bcon);   bson_init (&expected);   bson_init (&foo);   bson_init (&bar);   bson_init (&third);   bson_append_utf8 (&third, "hello", -1, "world", -1);   bson_append_int32 (&bar, "0", -1, 1);   bson_append_int32 (&bar, "1", -1, 2);   bson_append_document (&bar, "2", -1, &third);   bson_append_array (&foo, "bar", -1, &bar);   bson_append_document (&expected, "foo", -1, &foo);   BCON_APPEND (&bcon,                "foo",                "{",                "bar",                "[",                BCON_INT32 (1),                BCON_INT32 (2),                "{",                "hello",                "world",                "}",                "]",                "}");   bson_eq_bson (&bcon, &expected);   bson_destroy (&bcon);   bson_destroy (&expected);   bson_destroy (&foo);   bson_destroy (&bar);   bson_destroy (&third);}

static voidbulk4 (mongoc_collection_t *collection){   mongoc_write_concern_t *wc;   mongoc_bulk_operation_t *bulk;   bson_error_t error;   bson_t *doc;   bson_t reply;   char *str;   bool ret;   wc = mongoc_write_concern_new ();   mongoc_write_concern_set_w (wc, 4);   mongoc_write_concern_set_wtimeout (wc, 100);  /* milliseconds */   bulk = mongoc_collection_create_bulk_operation (collection, true, wc);   /* Two inserts */   doc = BCON_NEW ("_id", BCON_INT32 (10));   mongoc_bulk_operation_insert (bulk, doc);   bson_destroy (doc);   doc = BCON_NEW ("_id", BCON_INT32 (11));   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) {      printf ("Error: %s/n", error.message);   }   bson_destroy (&reply);   mongoc_bulk_operation_destroy (bulk);   mongoc_write_concern_destroy (wc);}

static voidtest_int32 (void){   int32_t i32;   bson_t *bcon = BCON_NEW ("foo", BCON_INT32 (10));   assert (BCON_EXTRACT (bcon, "foo", BCONE_INT32 (i32)));   assert (i32 == 10);   bson_destroy (bcon);}

static voidbulk5_success (mongoc_collection_t *collection){   mongoc_bulk_operation_t *bulk;   bson_error_t error;   bson_t *doc;   bson_t reply;   char *str;   bool ret;   bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);   /* Allow this document to bypass document validation.    * NOTE: When authentication is enabled, the authenticated user must have    * either the "dbadmin" or "restore" roles to bypass document validation */   mongoc_bulk_operation_set_bypass_document_validation (bulk, true);   /* Two inserts */   doc = BCON_NEW ("_id", BCON_INT32 (31));   mongoc_bulk_operation_insert (bulk, doc);   bson_destroy (doc);   doc = BCON_NEW ("_id", BCON_INT32 (32));   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) {      printf ("Error: %s/n", error.message);   }   bson_destroy (&reply);   mongoc_bulk_operation_destroy (bulk);}

static voidtest_invalid_write_concern (void){   mongoc_write_command_t command;   mongoc_write_result_t result;   mongoc_collection_t *collection;   mongoc_client_t *client;   mongoc_write_concern_t *write_concern;   bson_t **docs;   bson_t reply = BSON_INITIALIZER;   bson_error_t error;   bool r;   client = test_framework_client_new (NULL);   assert(client);   collection = get_test_collection(client, "test_invalid_write_concern");   assert(collection);   write_concern = mongoc_write_concern_new();   assert(write_concern);   mongoc_write_concern_set_w(write_concern, 0);   mongoc_write_concern_set_journal(write_concern, true);   assert(!_mongoc_write_concern_is_valid(write_concern));   docs = bson_malloc(sizeof(bson_t*));   docs[0] = BCON_NEW("_id", BCON_INT32(0));   _mongoc_write_command_init_insert(&command, (const bson_t * const *)docs, 1, true, true);   _mongoc_write_result_init (&result);   _mongoc_write_command_execute (&command, client, 0, collection->db,                                  collection->collection, write_concern, 0,                                  &result);   r = _mongoc_write_result_complete (&result, &reply, &error);   assert(!r);   assert(error.domain = MONGOC_ERROR_COMMAND);   assert(error.code = MONGOC_ERROR_COMMAND_INVALID_ARG);   _mongoc_write_command_destroy (&command);   _mongoc_write_result_destroy (&result);   bson_destroy(docs[0]);   bson_free(docs);   mongoc_collection_destroy(collection);   mongoc_client_destroy(client);   mongoc_write_concern_destroy(write_concern);}

static voidtest_mongoc_matcher_eq_int32 (void){   bson_t *spec;   bson_t *doc;   bson_error_t error;   mongoc_matcher_t *matcher;   bool r;   spec = BCON_NEW ("hello", BCON_INT32 (1234));   matcher = mongoc_matcher_new (spec, &error);   BSON_ASSERT (matcher);   r = mongoc_matcher_match (matcher, spec);   BSON_ASSERT (r);   bson_destroy (spec);   mongoc_matcher_destroy (matcher);   spec = BCON_NEW ("hello", BCON_INT32 (1234));   doc = BCON_NEW ("hello", BCON_INT64 (1234));   matcher = mongoc_matcher_new (spec, &error);   BSON_ASSERT (matcher);   r = mongoc_matcher_match (matcher, doc);   BSON_ASSERT (r);   bson_destroy (spec);   bson_destroy (doc);   mongoc_matcher_destroy (matcher);   spec = BCON_NEW ("hello", BCON_INT32 (1234));   doc = BCON_NEW ("hello", BCON_INT64 (4321));   matcher = mongoc_matcher_new (spec, &error);   BSON_ASSERT (matcher);   r = mongoc_matcher_match (matcher, doc);   BSON_ASSERT (!r);   bson_destroy (spec);   bson_destroy (doc);   mongoc_matcher_destroy (matcher);}

static voidbulk5_fail (mongoc_collection_t *collection){   mongoc_bulk_operation_t *bulk;   bson_error_t error;   bson_t *doc;   bson_t reply;   char *str;   bool ret;   bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);   /* Two inserts */   doc = BCON_NEW ("_id", BCON_INT32 (31));   mongoc_bulk_operation_insert (bulk, doc);   bson_destroy (doc);   doc = BCON_NEW ("_id", BCON_INT32 (32));   mongoc_bulk_operation_insert (bulk, doc);   bson_destroy (doc);   /* The above documents do not comply to the schema validation rules    * we created previously, so this will result in an error */   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);}

bson_t *col_view_create (const char *stub, ...){   bson_t *bson;   va_list ap;   ele_t type;   int keep_going = 1;   bcon_append_ctx_t ctx;   bcon_append_ctx_init (&ctx);   va_start (ap, stub);   bson = bson_new ();   while (keep_going) {      type = va_arg (ap, ele_t);      switch (type) {      case ELE_SORT:         BCON_APPEND_CTX (bson, &ctx, "sort", "{");         bcon_append_ctx_va (bson, &ctx, &ap);         BCON_APPEND_CTX (bson, &ctx, "}");         break;      case ELE_LIMIT: {         int i = va_arg (ap, int);         BCON_APPEND_CTX (bson, &ctx, "limit", BCON_INT32 (i));         break;      }      case ELE_QUERY:         BCON_APPEND_CTX (bson, &ctx, "query", "{");         bcon_append_ctx_va (bson, &ctx, &ap);         BCON_APPEND_CTX (bson, &ctx, "}");         break;      case ELE_END:         keep_going = 0;         break;      default:         BSON_ASSERT (0);         break;      }   }   va_end (ap);   return bson;}

static voidtest_int32 (void){   bson_t bcon, expected;   bson_init (&bcon);   bson_init (&expected);   bson_append_int32 (&expected, "foo", -1, 100);   BCON_APPEND (&bcon, "foo", BCON_INT32 (100));   bson_eq_bson (&bcon, &expected);   bson_destroy (&bcon);   bson_destroy (&expected);}

intmain (int argc, char *argv[]){   bson_t *bson;   char *json;   bson = COL_VIEW_CREATE (      SORT ("a", BCON_INT32 (1)), QUERY ("hello", "world"), LIMIT (10));   json = bson_as_canonical_extended_json (bson, NULL);   printf ("%s/n", json);   bson_free (json);   bson_destroy (bson);   return 0;}