libmongocrypt-helper 1.7.4.0.1001 → 1.8.0.0.1001

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-dll.c

@@ -6,43 +6,36 @@
 
 #include "test-mongocrypt.h"
 
-static void
-_test_load_simple_library (_mongocrypt_tester_t *t)
-{
-   (void) t;
-   mstr self_path = mstr_copy_cstr (TEST_MONGOCRYPT_OUTPUT_PATH);
+static void _test_load_simple_library(_mongocrypt_tester_t *t) {
+    (void)t;
+    mstr self_path = mstr_copy_cstr(TEST_MONGOCRYPT_OUTPUT_PATH);
 
-   mstr dll_path = mpath_join (mpath_parent (self_path.view, MPATH_NATIVE),
-                               mstrv_view_cstr ("test-dll.dll"),
-                               MPATH_NATIVE);
+    mstr dll_path =
+        mpath_join(mpath_parent(self_path.view, MPATH_NATIVE), mstrv_view_cstr("test-dll.dll"), MPATH_NATIVE);
 
-   mcr_dll lib = mcr_dll_open (dll_path.data);
-   BSON_ASSERT (lib.error_string.len == 0);
+    mcr_dll lib = mcr_dll_open(dll_path.data);
+    BSON_ASSERT(lib.error_string.len == 0);
 
-   int (*say_hello) (void) = mcr_dll_sym (lib, "say_hello");
-   BSON_ASSERT (say_hello != NULL);
+    int (*say_hello)(void) = mcr_dll_sym(lib, "say_hello");
+    BSON_ASSERT(say_hello != NULL);
 
-   int rval = say_hello ();
-   ASSERT_CMPINT (rval, ==, 42);
+    int rval = say_hello();
+    ASSERT_CMPINT(rval, ==, 42);
 
-   mcr_dll_close (lib);
-   mstr_free (dll_path);
-   mstr_free (self_path);
+    mcr_dll_close(lib);
+    mstr_free(dll_path);
+    mstr_free(self_path);
 }
 
-static void
-_test_load_nonesuch (_mongocrypt_tester_t *t)
-{
-   (void) t;
-   mcr_dll lib = mcr_dll_open ("no-such-directory/no-such-lib.dll");
-   BSON_ASSERT (lib._native_handle == NULL);
-   BSON_ASSERT (lib.error_string.len > 0);
-   mcr_dll_close (lib);
+static void _test_load_nonesuch(_mongocrypt_tester_t *t) {
+    (void)t;
+    mcr_dll lib = mcr_dll_open("no-such-directory/no-such-lib.dll");
+    BSON_ASSERT(lib._native_handle == NULL);
+    BSON_ASSERT(lib.error_string.len > 0);
+    mcr_dll_close(lib);
 }
 
-void
-_mongocrypt_tester_install_dll (_mongocrypt_tester_t *tester)
-{
-   INSTALL_TEST (_test_load_simple_library);
-   INSTALL_TEST (_test_load_nonesuch);
+void _mongocrypt_tester_install_dll(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(_test_load_simple_library);
+    INSTALL_TEST(_test_load_nonesuch);
 }

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-endpoint.c

@@ -18,121 +18,108 @@
 
 #include "test-mongocrypt.h"
 
-void
-_test_mongocrypt_endpoint (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_endpoint_t *endpoint;
-   mongocrypt_status_t *status;
-   _mongocrypt_endpoint_parse_opts_t opts;
-
-   status = mongocrypt_status_new ();
-
-   endpoint = _mongocrypt_endpoint_new (
-      "https://kevin.keyvault.azure.net:443/some/path/?query=value",
-      -1,
-      NULL /* opts */,
-      status);
-   ASSERT_STREQUAL (endpoint->host, "kevin.keyvault.azure.net");
-   ASSERT_STREQUAL (endpoint->domain, "keyvault.azure.net");
-   ASSERT_STREQUAL (endpoint->subdomain, "kevin");
-   ASSERT_STREQUAL (endpoint->protocol, "https");
-   ASSERT_STREQUAL (endpoint->port, "443");
-   ASSERT_STREQUAL (endpoint->path, "some/path");
-   ASSERT_STREQUAL (endpoint->query, "query=value");
-   BSON_ASSERT (mongocrypt_status_ok (status));
-   _mongocrypt_endpoint_destroy (endpoint);
-
-   endpoint = _mongocrypt_endpoint_new (
-      "kevin.keyvault.azure.net:443", -1, NULL /* opts */, status);
-   ASSERT_STREQUAL (endpoint->host, "kevin.keyvault.azure.net");
-   ASSERT_STREQUAL (endpoint->domain, "keyvault.azure.net");
-   ASSERT_STREQUAL (endpoint->subdomain, "kevin");
-   BSON_ASSERT (!endpoint->protocol);
-   ASSERT_STREQUAL (endpoint->port, "443");
-   BSON_ASSERT (!endpoint->path);
-   BSON_ASSERT (!endpoint->query);
-   BSON_ASSERT (mongocrypt_status_ok (status));
-   _mongocrypt_endpoint_destroy (endpoint);
-
-   endpoint = _mongocrypt_endpoint_new (
-      "kevin.keyvault.azure.net", -1, NULL /* opts */, status);
-   ASSERT_STREQUAL (endpoint->host, "kevin.keyvault.azure.net");
-   ASSERT_STREQUAL (endpoint->domain, "keyvault.azure.net");
-   ASSERT_STREQUAL (endpoint->subdomain, "kevin");
-   BSON_ASSERT (!endpoint->protocol);
-   BSON_ASSERT (!endpoint->port);
-   BSON_ASSERT (!endpoint->path);
-   BSON_ASSERT (!endpoint->query);
-   BSON_ASSERT (mongocrypt_status_ok (status));
-   _mongocrypt_endpoint_destroy (endpoint);
-
-   endpoint =
-      _mongocrypt_endpoint_new ("malformed", -1, NULL /* opts */, status);
-   BSON_ASSERT (!endpoint);
-   ASSERT_STATUS_CONTAINS (
-      status,
-      "Invalid endpoint, expected dot separator in host, but got: malformed");
-   _mongocrypt_endpoint_destroy (endpoint);
-
-   /* A host without a dot separator is valid if the "allow_empty_subdomain"
-    * option is true. */
-   memset (&opts, 0, sizeof (opts));
-   opts.allow_empty_subdomain = true;
-   endpoint = _mongocrypt_endpoint_new ("localhost", -1, &opts, status);
-   ASSERT_STREQUAL (endpoint->host, "localhost");
-   ASSERT_STREQUAL (endpoint->domain, "localhost");
-   BSON_ASSERT (!endpoint->subdomain);
-   BSON_ASSERT (!endpoint->protocol);
-   BSON_ASSERT (!endpoint->port);
-   BSON_ASSERT (!endpoint->path);
-   BSON_ASSERT (!endpoint->query);
-   BSON_ASSERT (mongocrypt_status_ok (status));
-   _mongocrypt_endpoint_destroy (endpoint);
-
-   memset (&opts, 0, sizeof (opts));
-   opts.allow_empty_subdomain = true;
-   endpoint = _mongocrypt_endpoint_new ("localhost:1234", -1, &opts, status);
-   ASSERT_STREQUAL (endpoint->host, "localhost");
-   ASSERT_STREQUAL (endpoint->domain, "localhost");
-   BSON_ASSERT (!endpoint->subdomain);
-   BSON_ASSERT (!endpoint->protocol);
-   ASSERT_STREQUAL (endpoint->port, "1234");
-   BSON_ASSERT (!endpoint->path);
-   BSON_ASSERT (!endpoint->query);
-   BSON_ASSERT (mongocrypt_status_ok (status));
-   _mongocrypt_endpoint_destroy (endpoint);
-
-   /* A host without a dot separator is invalid if the "allow_empty_subdomain"
-    * option is false. */
-   memset (&opts, 0, sizeof (opts));
-   opts.allow_empty_subdomain = false;
-   endpoint = _mongocrypt_endpoint_new ("localhost", -1, &opts, status);
-   ASSERT_STATUS_CONTAINS (
-      status,
-      "Invalid endpoint, expected dot separator in host, but got: localhost");
-   BSON_ASSERT (!endpoint);
-
-   mongocrypt_status_destroy (status);
+void _test_mongocrypt_endpoint(_mongocrypt_tester_t *tester) {
+    _mongocrypt_endpoint_t *endpoint;
+    mongocrypt_status_t *status;
+    _mongocrypt_endpoint_parse_opts_t opts;
+
+    status = mongocrypt_status_new();
+
+    endpoint = _mongocrypt_endpoint_new("https://kevin.keyvault.azure.net:443/some/path/?query=value",
+                                        -1,
+                                        NULL /* opts */,
+                                        status);
+    ASSERT_STREQUAL(endpoint->host, "kevin.keyvault.azure.net");
+    ASSERT_STREQUAL(endpoint->domain, "keyvault.azure.net");
+    ASSERT_STREQUAL(endpoint->subdomain, "kevin");
+    ASSERT_STREQUAL(endpoint->protocol, "https");
+    ASSERT_STREQUAL(endpoint->port, "443");
+    ASSERT_STREQUAL(endpoint->path, "some/path");
+    ASSERT_STREQUAL(endpoint->query, "query=value");
+    BSON_ASSERT(mongocrypt_status_ok(status));
+    _mongocrypt_endpoint_destroy(endpoint);
+
+    endpoint = _mongocrypt_endpoint_new("kevin.keyvault.azure.net:443", -1, NULL /* opts */, status);
+    ASSERT_STREQUAL(endpoint->host, "kevin.keyvault.azure.net");
+    ASSERT_STREQUAL(endpoint->domain, "keyvault.azure.net");
+    ASSERT_STREQUAL(endpoint->subdomain, "kevin");
+    BSON_ASSERT(!endpoint->protocol);
+    ASSERT_STREQUAL(endpoint->port, "443");
+    BSON_ASSERT(!endpoint->path);
+    BSON_ASSERT(!endpoint->query);
+    BSON_ASSERT(mongocrypt_status_ok(status));
+    _mongocrypt_endpoint_destroy(endpoint);
+
+    endpoint = _mongocrypt_endpoint_new("kevin.keyvault.azure.net", -1, NULL /* opts */, status);
+    ASSERT_STREQUAL(endpoint->host, "kevin.keyvault.azure.net");
+    ASSERT_STREQUAL(endpoint->domain, "keyvault.azure.net");
+    ASSERT_STREQUAL(endpoint->subdomain, "kevin");
+    BSON_ASSERT(!endpoint->protocol);
+    BSON_ASSERT(!endpoint->port);
+    BSON_ASSERT(!endpoint->path);
+    BSON_ASSERT(!endpoint->query);
+    BSON_ASSERT(mongocrypt_status_ok(status));
+    _mongocrypt_endpoint_destroy(endpoint);
+
+    endpoint = _mongocrypt_endpoint_new("malformed", -1, NULL /* opts */, status);
+    BSON_ASSERT(!endpoint);
+    ASSERT_STATUS_CONTAINS(status, "Invalid endpoint, expected dot separator in host, but got: malformed");
+    _mongocrypt_endpoint_destroy(endpoint);
+
+    /* A host without a dot separator is valid if the "allow_empty_subdomain"
+     * option is true. */
+    memset(&opts, 0, sizeof(opts));
+    opts.allow_empty_subdomain = true;
+    endpoint = _mongocrypt_endpoint_new("localhost", -1, &opts, status);
+    ASSERT_STREQUAL(endpoint->host, "localhost");
+    ASSERT_STREQUAL(endpoint->domain, "localhost");
+    BSON_ASSERT(!endpoint->subdomain);
+    BSON_ASSERT(!endpoint->protocol);
+    BSON_ASSERT(!endpoint->port);
+    BSON_ASSERT(!endpoint->path);
+    BSON_ASSERT(!endpoint->query);
+    BSON_ASSERT(mongocrypt_status_ok(status));
+    _mongocrypt_endpoint_destroy(endpoint);
+
+    memset(&opts, 0, sizeof(opts));
+    opts.allow_empty_subdomain = true;
+    endpoint = _mongocrypt_endpoint_new("localhost:1234", -1, &opts, status);
+    ASSERT_STREQUAL(endpoint->host, "localhost");
+    ASSERT_STREQUAL(endpoint->domain, "localhost");
+    BSON_ASSERT(!endpoint->subdomain);
+    BSON_ASSERT(!endpoint->protocol);
+    ASSERT_STREQUAL(endpoint->port, "1234");
+    BSON_ASSERT(!endpoint->path);
+    BSON_ASSERT(!endpoint->query);
+    BSON_ASSERT(mongocrypt_status_ok(status));
+    _mongocrypt_endpoint_destroy(endpoint);
+
+    /* A host without a dot separator is invalid if the "allow_empty_subdomain"
+     * option is false. */
+    memset(&opts, 0, sizeof(opts));
+    opts.allow_empty_subdomain = false;
+    endpoint = _mongocrypt_endpoint_new("localhost", -1, &opts, status);
+    ASSERT_STATUS_CONTAINS(status, "Invalid endpoint, expected dot separator in host, but got: localhost");
+    BSON_ASSERT(!endpoint);
+
+    mongocrypt_status_destroy(status);
 }
 
-static void
-_test_mongocrypt_apply_default_port (_mongocrypt_tester_t *tester) {
-   char *endpoint;
+static void _test_mongocrypt_apply_default_port(_mongocrypt_tester_t *tester) {
+    char *endpoint;
 
-   endpoint = bson_strdup ("example.com");
-   _mongocrypt_apply_default_port (&endpoint, "12");
-   ASSERT_STREQUAL (endpoint, "example.com:12");
-   bson_free (endpoint);
+    endpoint = bson_strdup("example.com");
+    _mongocrypt_apply_default_port(&endpoint, "12");
+    ASSERT_STREQUAL(endpoint, "example.com:12");
+    bson_free(endpoint);
 
-   endpoint = bson_strdup ("example.com:34");
-   _mongocrypt_apply_default_port (&endpoint, "12");
-   ASSERT_STREQUAL (endpoint, "example.com:34");
-   bson_free (endpoint);
+    endpoint = bson_strdup("example.com:34");
+    _mongocrypt_apply_default_port(&endpoint, "12");
+    ASSERT_STREQUAL(endpoint, "example.com:34");
+    bson_free(endpoint);
 }
 
-void
-_mongocrypt_tester_install_endpoint (_mongocrypt_tester_t *tester)
-{
-   INSTALL_TEST (_test_mongocrypt_endpoint);
-   INSTALL_TEST (_test_mongocrypt_apply_default_port);
+void _mongocrypt_tester_install_endpoint(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(_test_mongocrypt_endpoint);
+    INSTALL_TEST(_test_mongocrypt_apply_default_port);
 }

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-kek.c

@@ -14,91 +14,88 @@
  * limitations under the License.
  */
 
-#include <bson/bson.h>
-#include "test-mongocrypt.h"
-#include "test-mongocrypt-assert-match-bson.h"
 #include "mongocrypt-kek-private.h"
+#include "test-mongocrypt-assert-match-bson.h"
+#include "test-mongocrypt.h"
+#include <bson/bson.h>
 
-static void _run_one_test (_mongocrypt_tester_t *tester, bson_t *test) {
+static void _run_one_test(_mongocrypt_tester_t *tester, bson_t *test) {
     bson_iter_t iter;
     bson_t input;
     char *input_str;
     mongocrypt_status_t *status;
     _mongocrypt_kek_t kek;
-    const char* expect;
+    const char *expect;
     bool ret;
     bson_t out;
-    const char* expect_append;
+    const char *expect_append;
 
-    status = mongocrypt_status_new ();
-    memset (&kek, 0, sizeof (_mongocrypt_kek_t));
-    BSON_ASSERT (bson_iter_init_find (&iter, test, "input"));
-    bson_iter_bson (&iter, &input);
-    BSON_ASSERT (bson_iter_init_find (&iter, test, "expect"));
-    expect = bson_iter_utf8 (&iter, NULL);
+    status = mongocrypt_status_new();
+    memset(&kek, 0, sizeof(_mongocrypt_kek_t));
+    BSON_ASSERT(bson_iter_init_find(&iter, test, "input"));
+    bson_iter_bson(&iter, &input);
+    BSON_ASSERT(bson_iter_init_find(&iter, test, "expect"));
+    expect = bson_iter_utf8(&iter, NULL);
 
     /* Tests may include an optional different expectation for calling
      * _mongocrypt_kek_append. */
-    if (bson_iter_init_find (&iter, test, "expect_append")) {
-        expect_append = bson_iter_utf8 (&iter, NULL);
+    if (bson_iter_init_find(&iter, test, "expect_append")) {
+        expect_append = bson_iter_utf8(&iter, NULL);
     } else {
         expect_append = expect;
     }
 
-    input_str = bson_as_json (&input, NULL);
-    printf ("- testcase: %s\n", input_str);
-    bson_free (input_str);
+    input_str = bson_as_json(&input, NULL);
+    printf("- testcase: %s\n", input_str);
+    bson_free(input_str);
 
-    ret = _mongocrypt_kek_parse_owned (&input, &kek, status);
-    if (0 == strcmp (expect, "ok")) {
-        ASSERT_OK_STATUS (ret, status);
-        bson_init (&out);
-        ret = _mongocrypt_kek_append (&kek, &out, status);
-        if (0 == strcmp (expect_append, "ok")) {
+    ret = _mongocrypt_kek_parse_owned(&input, &kek, status);
+    if (0 == strcmp(expect, "ok")) {
+        ASSERT_OK_STATUS(ret, status);
+        bson_init(&out);
+        ret = _mongocrypt_kek_append(&kek, &out, status);
+        if (0 == strcmp(expect_append, "ok")) {
             _mongocrypt_kek_t kek_copy;
 
-            ASSERT_OK_STATUS (ret, status);
+            ASSERT_OK_STATUS(ret, status);
             /* This should round trip. */
-            _assert_match_bson (&out, &input);
+            _assert_match_bson(&out, &input);
 
             /* Check that copy works as well. */
-            bson_reinit (&out);
-            _mongocrypt_kek_copy_to (&kek, &kek_copy);
-            ret = _mongocrypt_kek_append (&kek_copy, &out, status);
-            ASSERT_OK_STATUS (ret, status);
-            _assert_match_bson (&out, &input);
-            _mongocrypt_kek_cleanup (&kek_copy);
+            bson_reinit(&out);
+            _mongocrypt_kek_copy_to(&kek, &kek_copy);
+            ret = _mongocrypt_kek_append(&kek_copy, &out, status);
+            ASSERT_OK_STATUS(ret, status);
+            _assert_match_bson(&out, &input);
+            _mongocrypt_kek_cleanup(&kek_copy);
         } else {
-            ASSERT_FAILS_STATUS (ret, status, expect_append);
+            ASSERT_FAILS_STATUS(ret, status, expect_append);
         }
 
-        bson_destroy (&out);
+        bson_destroy(&out);
     } else {
-        ASSERT_FAILS_STATUS (ret, status, expect);
+        ASSERT_FAILS_STATUS(ret, status, expect);
     }
 
-    _mongocrypt_kek_cleanup (&kek);
-    mongocrypt_status_destroy (status);
+    _mongocrypt_kek_cleanup(&kek);
+    mongocrypt_status_destroy(status);
 }
 
-void
-test_mongocrypt_kek_parsing (_mongocrypt_tester_t *tester) {
-   bson_t test_file;
-   bson_iter_t iter;
+void test_mongocrypt_kek_parsing(_mongocrypt_tester_t *tester) {
+    bson_t test_file;
+    bson_iter_t iter;
 
-   _load_json_as_bson ("./test/data/kek-tests.json", &test_file);
-   for (bson_iter_init (&iter, &test_file); bson_iter_next (&iter);) {
-      bson_t test;
+    _load_json_as_bson("./test/data/kek-tests.json", &test_file);
+    for (bson_iter_init(&iter, &test_file); bson_iter_next(&iter);) {
+        bson_t test;
 
-      bson_iter_bson (&iter, &test);
-      _run_one_test (tester, &test);
-      bson_destroy (&test);
-   }
-   bson_destroy (&test_file);
+        bson_iter_bson(&iter, &test);
+        _run_one_test(tester, &test);
+        bson_destroy(&test);
+    }
+    bson_destroy(&test_file);
 }
 
-void
-_mongocrypt_tester_install_kek (_mongocrypt_tester_t *tester)
-{
-   INSTALL_TEST (test_mongocrypt_kek_parsing);
+void _mongocrypt_tester_install_kek(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(test_mongocrypt_kek_parsing);
 }