libmongocrypt-helper 1.13.2.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-ctx-setopt.c

@@ -28,61 +28,61 @@ static char invalid_utf8[] = {(char)0x80, (char)0x00};
 
 /* Convenience macros for setting options */
 #define ASSERT_MASTERKEY_AWS_OK(region, region_len, cmk, cmk_len)                                                      \
-    ASSERT_OK(mongocrypt_ctx_setopt_masterkey_aws(ctx, region, region_len, cmk, cmk_len), ctx);
+    ASSERT_OK(mongocrypt_ctx_setopt_masterkey_aws(ctx, region, region_len, cmk, cmk_len), ctx)
 #define ASSERT_MASTERKEY_AWS_FAILS(region, region_len, cmk, cmk_len, msg)                                              \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_aws(ctx, region, region_len, cmk, cmk_len), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_aws(ctx, region, region_len, cmk, cmk_len), ctx, msg)
 
-#define ASSERT_MASTERKEY_LOCAL_OK ASSERT_OK(mongocrypt_ctx_setopt_masterkey_local(ctx), ctx);
-#define ASSERT_MASTERKEY_LOCAL_FAILS(msg) ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_local(ctx), ctx, msg);
+#define ASSERT_MASTERKEY_LOCAL_OK ASSERT_OK(mongocrypt_ctx_setopt_masterkey_local(ctx), ctx)
+#define ASSERT_MASTERKEY_LOCAL_FAILS(msg) ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_local(ctx), ctx, msg)
 
-#define ASSERT_KEY_ENCRYPTION_KEY_OK(bin) ASSERT_OK(mongocrypt_ctx_setopt_key_encryption_key(ctx, bin), ctx);
+#define ASSERT_KEY_ENCRYPTION_KEY_OK(bin) ASSERT_OK(mongocrypt_ctx_setopt_key_encryption_key(ctx, bin), ctx)
 #define ASSERT_KEY_ENCRYPTION_KEY_FAILS(bin, msg)                                                                      \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_key_encryption_key(ctx, bin), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_key_encryption_key(ctx, bin), ctx, msg)
 
-#define ASSERT_KEY_ID_OK(key_id) ASSERT_OK(mongocrypt_ctx_setopt_key_id(ctx, key_id), ctx);
-#define ASSERT_KEY_ID_FAILS(key_id, msg) ASSERT_FAILS(mongocrypt_ctx_setopt_key_id(ctx, key_id), ctx, msg);
+#define ASSERT_KEY_ID_OK(key_id) ASSERT_OK(mongocrypt_ctx_setopt_key_id(ctx, key_id), ctx)
+#define ASSERT_KEY_ID_FAILS(key_id, msg) ASSERT_FAILS(mongocrypt_ctx_setopt_key_id(ctx, key_id), ctx, msg)
 
-#define ASSERT_KEY_ALT_NAME_OK(key_alt_name) ASSERT_OK(mongocrypt_ctx_setopt_key_alt_name(ctx, key_alt_name), ctx);
+#define ASSERT_KEY_ALT_NAME_OK(key_alt_name) ASSERT_OK(mongocrypt_ctx_setopt_key_alt_name(ctx, key_alt_name), ctx)
 #define ASSERT_KEY_ALT_NAME_FAILS(key_alt_name, msg)                                                                   \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_key_alt_name(ctx, key_alt_name), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_key_alt_name(ctx, key_alt_name), ctx, msg)
 
-#define ASSERT_KEY_MATERIAL_OK(key_material) ASSERT_OK(mongocrypt_ctx_setopt_key_material(ctx, key_material), ctx);
+#define ASSERT_KEY_MATERIAL_OK(key_material) ASSERT_OK(mongocrypt_ctx_setopt_key_material(ctx, key_material), ctx)
 #define ASSERT_KEY_MATERIAL_FAILS(key_material, msg)                                                                   \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_key_material(ctx, key_material), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_key_material(ctx, key_material), ctx, msg)
 
-#define ASSERT_ALGORITHM_OK(algo, algo_len) ASSERT_OK(mongocrypt_ctx_setopt_algorithm(ctx, algo, algo_len), ctx);
+#define ASSERT_ALGORITHM_OK(algo, algo_len) ASSERT_OK(mongocrypt_ctx_setopt_algorithm(ctx, algo, algo_len), ctx)
 #define ASSERT_ALGORITHM_FAILS(algo, algo_len, msg)                                                                    \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_algorithm(ctx, algo, algo_len), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_algorithm(ctx, algo, algo_len), ctx, msg)
 
-#define ASSERT_QUERY_TYPE_OK(qt, qt_len) ASSERT_OK(mongocrypt_ctx_setopt_query_type(ctx, qt, qt_len), ctx);
+#define ASSERT_QUERY_TYPE_OK(qt, qt_len) ASSERT_OK(mongocrypt_ctx_setopt_query_type(ctx, qt, qt_len), ctx)
 #define ASSERT_QUERY_TYPE_FAILS(qt, qt_len, msg)                                                                       \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_query_type(ctx, qt, qt_len), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_query_type(ctx, qt, qt_len), ctx, msg)
 
 #define ASSERT_ENDPOINT_OK(endpoint, endpoint_len)                                                                     \
-    ASSERT_OK(mongocrypt_ctx_setopt_masterkey_aws_endpoint(ctx, endpoint, endpoint_len), ctx);
+    ASSERT_OK(mongocrypt_ctx_setopt_masterkey_aws_endpoint(ctx, endpoint, endpoint_len), ctx)
 #define ASSERT_ENDPOINT_FAILS(endpoint, endpoint_len, msg)                                                             \
-    ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_aws_endpoint(ctx, endpoint, endpoint_len), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_setopt_masterkey_aws_endpoint(ctx, endpoint, endpoint_len), ctx, msg)
 
-#define ASSERT_DATAKEY_INIT_OK ASSERT_OK(mongocrypt_ctx_datakey_init(ctx), ctx);
-#define ASSERT_DATAKEY_INIT_FAILS(msg) ASSERT_FAILS(mongocrypt_ctx_datakey_init(ctx), ctx, msg);
+#define ASSERT_DATAKEY_INIT_OK ASSERT_OK(mongocrypt_ctx_datakey_init(ctx), ctx)
+#define ASSERT_DATAKEY_INIT_FAILS(msg) ASSERT_FAILS(mongocrypt_ctx_datakey_init(ctx), ctx, msg)
 
-#define ASSERT_ENCRYPT_INIT_OK(db, db_len, cmd) ASSERT_OK(mongocrypt_ctx_encrypt_init(ctx, db, db_len, cmd), ctx);
+#define ASSERT_ENCRYPT_INIT_OK(db, db_len, cmd) ASSERT_OK(mongocrypt_ctx_encrypt_init(ctx, db, db_len, cmd), ctx)
 #define ENCRYPT_INIT_FAILS(db, db_len, cmd, msg)                                                                       \
-    ASSERT_FAILS(mongocrypt_ctx_encrypt_init(ctx, db, db_len, cmd), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_encrypt_init(ctx, db, db_len, cmd), ctx, msg)
 
-#define ASSERT_EX_ENCRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_explicit_encrypt_init(ctx, bin), ctx);
-#define ASSERT_EX_ENCRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_explicit_encrypt_init(ctx, bin), ctx, msg);
+#define ASSERT_EX_ENCRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_explicit_encrypt_init(ctx, bin), ctx)
+#define ASSERT_EX_ENCRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_explicit_encrypt_init(ctx, bin), ctx, msg)
 
 #define ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bin)                                                                      \
-    ASSERT_OK(mongocrypt_ctx_explicit_encrypt_expression_init(ctx, bin), ctx);
+    ASSERT_OK(mongocrypt_ctx_explicit_encrypt_expression_init(ctx, bin), ctx)
 #define ASSERT_EX_ENCRYPT_EXPRESSION_INIT_FAILS(bin, msg)                                                              \
-    ASSERT_FAILS(mongocrypt_ctx_explicit_encrypt_expression_init(ctx, bin), ctx, msg);
+    ASSERT_FAILS(mongocrypt_ctx_explicit_encrypt_expression_init(ctx, bin), ctx, msg)
 
-#define ASSERT_DECRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_decrypt_init(ctx, bin), ctx);
-#define ASSERT_DECRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_decrypt_init(ctx, bin), ctx, msg);
+#define ASSERT_DECRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_decrypt_init(ctx, bin), ctx)
+#define ASSERT_DECRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_decrypt_init(ctx, bin), ctx, msg)
 
-#define ASSERT_EX_DECRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_explicit_decrypt_init(ctx, bin), ctx);
-#define ASSERT_EX_DECRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_explicit_decrypt_init(ctx, bin), ctx, msg);
+#define ASSERT_EX_DECRYPT_INIT_OK(bin) ASSERT_OK(mongocrypt_ctx_explicit_decrypt_init(ctx, bin), ctx)
+#define ASSERT_EX_DECRYPT_INIT_FAILS(bin, msg) ASSERT_FAILS(mongocrypt_ctx_explicit_decrypt_init(ctx, bin), ctx, msg)
 
 #define REFRESH                                                                                                        \
     do {                                                                                                               \
@@ -296,11 +296,13 @@ static void _test_setopt_key_alt_name(_mongocrypt_tester_t *tester) {
 }
 
 static void _test_setopt_key_material(_mongocrypt_tester_t *tester) {
+#define KEY_MATERIAL_PATTERN "{'keyMaterial': {'$binary': {'base64': '%s', 'subType': '00'}}%s}"
+
     /* "0123456789abcef", repeated 6 times. */
     const char *const material = "MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWYwMTIzNDU2Nzg5YWJjZGVmMDEyMzQ1"
                                  "Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWYwMTIzNDU2Nzg5YWJjZGVm";
-    const char *const pattern = "{'keyMaterial': {'$binary': {'base64': '%s', 'subType': '00'}}%s}";
-    mongocrypt_binary_t *const valid = TEST_BSON(pattern, material, "");
+
+    mongocrypt_binary_t *const valid = TEST_BSON(KEY_MATERIAL_PATTERN, material, "");
 
     mongocrypt_t *crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
     mongocrypt_ctx_t *ctx = NULL;
@@ -320,18 +322,19 @@ static void _test_setopt_key_material(_mongocrypt_tester_t *tester) {
 
     /* Test empty key material. */
     REFRESH;
-    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(pattern, "", ""), "keyMaterial should have length 96, but has length 0");
+    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(KEY_MATERIAL_PATTERN, "", ""),
+                              "keyMaterial should have length 96, but has length 0");
 
     /* Test too short key material. */
     REFRESH;
-    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(pattern,
+    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(KEY_MATERIAL_PATTERN,
                                         "dG9vc2hvcnQ=", /* "tooshort" */
                                         ""),
                               "keyMaterial should have length 96, but has length 8");
 
     /* Test too long key material. */
     REFRESH;
-    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(pattern,
+    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(KEY_MATERIAL_PATTERN,
                                         /* "0123456789abcdef", repeated 6 times, followed by "toolong". */
                                         "MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWYwMTIzNDU2Nzg5YWJjZGVmMDEyM"
                                         "zQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWYwMTIzNDU2Nzg5YWJjZGVmdG9vbG9uZw"
@@ -351,7 +354,7 @@ static void _test_setopt_key_material(_mongocrypt_tester_t *tester) {
 
     /* Test extra key. */
     REFRESH;
-    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(pattern, material, ", 'a': 1"),
+    ASSERT_KEY_MATERIAL_FAILS(TEST_BSON(KEY_MATERIAL_PATTERN, material, ", 'a': 1"),
                               "unrecognized field, only keyMaterial expected");
 
     /* Test error propagation. */
@@ -361,6 +364,8 @@ static void _test_setopt_key_material(_mongocrypt_tester_t *tester) {
 
     mongocrypt_ctx_destroy(ctx);
     mongocrypt_destroy(crypt);
+
+#undef KEY_MATERIAL_PATTERN
 }
 
 static void _test_setopt_algorithm(_mongocrypt_tester_t *tester) {
@@ -393,7 +398,7 @@ static void _test_setopt_algorithm(_mongocrypt_tester_t *tester) {
 
     REFRESH;
     _mongocrypt_ctx_fail_w_msg(ctx, "test");
-    ASSERT_ALGORITHM_FAILS(RAND, -1, "test")
+    ASSERT_ALGORITHM_FAILS(RAND, -1, "test");
 
     /* Test case insensitive. */
     REFRESH;
@@ -435,7 +440,7 @@ static void _test_setopt_query_type(_mongocrypt_tester_t *tester) {
     /* Test with failed context. */
     REFRESH;
     _mongocrypt_ctx_fail_w_msg(ctx, "test");
-    ASSERT_QUERY_TYPE_FAILS(MONGOCRYPT_QUERY_TYPE_EQUALITY_STR, -1, "test")
+    ASSERT_QUERY_TYPE_FAILS(MONGOCRYPT_QUERY_TYPE_EQUALITY_STR, -1, "test");
 
     /* Test case insensitive. */
     REFRESH;
@@ -652,7 +657,7 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
 
     REFRESH;
     ASSERT_ALGORITHM_OK(RAND, -1);
-    ASSERT_EX_ENCRYPT_INIT_FAILS(bson, "key id or key alt name required")
+    ASSERT_EX_ENCRYPT_INIT_FAILS(bson, "key id or key alt name required");
 
     REFRESH;
     ASSERT_KEY_ID_OK(uuid);
@@ -843,7 +848,7 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
     {
         // Create a crypt with rangeV2 enabled.
         mongocrypt_destroy(crypt);
-        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT | TESTER_MONGOCRYPT_WITH_RANGE_V2);
+        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT | TESTER_MONGOCRYPT_DEFAULT);
         REFRESH_CTX;
         /* Set key ID to get past the 'either key id or key alt name required'
          * error */
@@ -899,7 +904,7 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
     // Can't use "rangePreview" algorithm or query type with range V2.
     {
         mongocrypt_destroy(crypt);
-        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_WITH_RANGE_V2);
+        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
         REFRESH_CTX;
         ASSERT_KEY_ID_OK(uuid);
         ASSERT_FAILS(mongocrypt_ctx_setopt_algorithm(ctx, MONGOCRYPT_ALGORITHM_RANGEPREVIEW_DEPRECATED_STR, -1),
@@ -907,7 +912,7 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
                      "'rangePreview' is deprecated");
 
         mongocrypt_destroy(crypt);
-        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_WITH_RANGE_V2);
+        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
         REFRESH_CTX;
         ASSERT_KEY_ID_OK(uuid);
         ASSERT_FAILS(mongocrypt_ctx_setopt_query_type(ctx, MONGOCRYPT_QUERY_TYPE_RANGEPREVIEW_DEPRECATED_STR, -1),
@@ -915,58 +920,12 @@ static void _test_setopt_for_explicit_encrypt(_mongocrypt_tester_t *tester) {
                      "'rangePreview' is deprecated");
     }
 
-    /* Error if query type == "rangePreview" and algorithm == "range" for range V1. */
-    // Explanation: Algorithm "rangePreview" accepts both query type "rangePreview" (for compatibility) and "range" (new
-    // behavior), but algorithm "range" only accepts query type "range". This is because if we are using the new
-    // algorithm type, we don't need to support the deprecated name for compatibility.
+    /* If query type == algorithm == "range", succeeds. */
     {
         REFRESH;
         ASSERT_KEY_ID_OK(uuid);
         ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
         ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGE_STR, -1);
-        ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGEPREVIEW_DEPRECATED_STR, -1);
-        ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
-        ASSERT_EX_ENCRYPT_EXPRESSION_INIT_FAILS(bson, "must match index_type");
-    }
-
-    /* If query type == "range" and algorithm == "rangePreview", succeeds for range V1 */
-    {
-        REFRESH;
-        ASSERT_KEY_ID_OK(uuid);
-        ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
-        ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGEPREVIEW_DEPRECATED_STR, -1);
-        ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGE_STR, -1);
-        ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
-        ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bson);
-    }
-
-    /* If query type == algorithm == "rangePreview", succeeds for range V1. */
-    {
-        REFRESH;
-        ASSERT_KEY_ID_OK(uuid);
-        ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
-        ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGEPREVIEW_DEPRECATED_STR, -1);
-        ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGEPREVIEW_DEPRECATED_STR, -1);
-        ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
-        ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bson);
-    }
-
-    /* If query type == algorithm == "range", succeeds for both V2 and V1. */
-    {
-        REFRESH;
-        ASSERT_KEY_ID_OK(uuid);
-        ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
-        ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGE_STR, -1);
-        ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGE_STR, -1);
-        ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
-        ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bson);
-
-        mongocrypt_destroy(crypt);
-        crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_WITH_RANGE_V2);
-        REFRESH_CTX;
-        ASSERT_KEY_ID_OK(uuid);
-        ASSERT_OK(mongocrypt_ctx_setopt_algorithm_range(ctx, rangeopts), ctx);
-        ASSERT_ALGORITHM_OK(MONGOCRYPT_ALGORITHM_RANGE_STR, -1);
         ASSERT_QUERY_TYPE_OK(MONGOCRYPT_QUERY_TYPE_RANGE_STR, -1);
         ASSERT_OK(mongocrypt_ctx_setopt_contention_factor(ctx, 0), ctx);
         ASSERT_EX_ENCRYPT_EXPRESSION_INIT_OK(bson);
@@ -1148,7 +1107,7 @@ static void _test_setopt_endpoint(_mongocrypt_tester_t *tester) {
 
     REFRESH;
     _mongocrypt_ctx_fail_w_msg(ctx, "test");
-    ASSERT_ENDPOINT_FAILS(RAND, -1, "test")
+    ASSERT_ENDPOINT_FAILS(RAND, -1, "test");
 
     mongocrypt_ctx_destroy(ctx);
     mongocrypt_destroy(crypt);
@@ -1169,7 +1128,7 @@ static void _test_createdatakey_with_wrong_kms_provider_helper(_mongocrypt_teste
     mongocrypt_setopt_use_need_kms_credentials_state(crypt);
     ASSERT_OK(_mongocrypt_init_for_test(crypt), crypt);
     ctx = mongocrypt_ctx_new(crypt);
-    ASSERT_OK(mongocrypt_ctx_setopt_key_encryption_key(ctx, TEST_BSON(kek)), ctx);
+    ASSERT_OK(mongocrypt_ctx_setopt_key_encryption_key(ctx, TEST_BSON_STR(kek)), ctx);
     ASSERT_FAILS(mongocrypt_ctx_datakey_init(ctx), ctx, "kms provider required by datakey is not configured");
 
     mongocrypt_ctx_destroy(ctx);

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

@@ -539,7 +539,7 @@ static void _test_create_datakey_with_retry(_mongocrypt_tester_t *tester) {
             const char *str = (const char *)mongocrypt_binary_data(bin);
             ASSERT_STRCONTAINS(str, "oauth2");
             mongocrypt_binary_destroy(bin);
-        };
+        }
 
         // Feed a successful response.
         ASSERT_OK(mongocrypt_kms_ctx_feed(kms_ctx, TEST_FILE("./test/data/kms-azure/oauth-response.txt")), kms_ctx);

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

@@ -13,10 +13,13 @@ static void _test_load_simple_library(_mongocrypt_tester_t *t) {
     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.raw.data);
+    BSON_ASSERT(lib.error_string.raw.len == 0);
+
+    MC_BEGIN_CAST_FUNCTION_TYPE_STRICT_IGNORE
+    int (*say_hello)(void) = (int (*)(void))mcr_dll_sym(lib, "say_hello");
+    MC_END_CAST_FUNCTION_TYPE_STRICT_IGNORE
 
-    int (*say_hello)(void) = mcr_dll_sym(lib, "say_hello");
     BSON_ASSERT(say_hello != NULL);
 
     int rval = say_hello();
@@ -31,7 +34,7 @@ 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);
+    BSON_ASSERT(lib.error_string.raw.len > 0);
     mcr_dll_close(lib);
 }
 

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

@@ -18,7 +18,7 @@
 
 #include "test-mongocrypt.h"
 
-void _test_mongocrypt_endpoint(_mongocrypt_tester_t *tester) {
+static void _test_mongocrypt_endpoint(_mongocrypt_tester_t *tester) {
     _mongocrypt_endpoint_t *endpoint;
     mongocrypt_status_t *status;
     _mongocrypt_endpoint_parse_opts_t opts;

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

@@ -81,7 +81,7 @@ static void _run_one_test(_mongocrypt_tester_t *tester, bson_t *test) {
     mongocrypt_status_destroy(status);
 }
 
-void test_mongocrypt_kek_parsing(_mongocrypt_tester_t *tester) {
+static void test_mongocrypt_kek_parsing(_mongocrypt_tester_t *tester) {
     bson_t test_file;
     bson_iter_t iter;
 

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-key-cache.c

@@ -30,7 +30,7 @@ typedef struct {
 
 /* The JSON spec tests refer to key ids by a shorthand integer.
  * This function maps that integer to a UUID buffer. */
-void lookup_key_id(uint32_t index, _mongocrypt_buffer_t *buf) {
+static void lookup_key_id(uint32_t index, _mongocrypt_buffer_t *buf) {
     const char *key_ids[] = {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
                              "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
                              "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"};
@@ -44,10 +44,8 @@ void lookup_key_id(uint32_t index, _mongocrypt_buffer_t *buf) {
 /* Generate a realistic key document given a @key_description, which contains an
  * _id
  * and possible keyAltNames. key_out and key_doc_out are NULLable outputs. */
-void gen_key(_mongocrypt_tester_t *tester,
-             bson_t *key_description,
-             bson_t *key_out,
-             _mongocrypt_key_doc_t *key_doc_out) {
+static void
+gen_key(_mongocrypt_tester_t *tester, bson_t *key_description, bson_t *key_out, _mongocrypt_key_doc_t *key_doc_out) {
     bson_iter_t iter;
     _mongocrypt_buffer_t key_material;
     _mongocrypt_buffer_t key_id;

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-kms-ctx.c

@@ -611,7 +611,7 @@ static void _test_mongocrypt_kms_ctx_kmip_encrypt(_mongocrypt_tester_t *tester)
     _mongocrypt_endpoint_t *endpoint;
 
     _mongocrypt_buffer_t plaintext = {0};
-    ASSERT(_mongocrypt_buffer_copy_from_data_and_size(&plaintext, PLAINTEXT, sizeof(PLAINTEXT)))
+    ASSERT(_mongocrypt_buffer_copy_from_data_and_size(&plaintext, PLAINTEXT, sizeof(PLAINTEXT)));
 
     status = mongocrypt_status_new();
     endpoint = _mongocrypt_endpoint_new("example.com", -1, NULL /* opts */, status);
@@ -748,7 +748,7 @@ static void _test_mongocrypt_kms_ctx_kmip_decrypt(_mongocrypt_tester_t *tester)
     key_doc.kek.kms_provider = MONGOCRYPT_KMS_PROVIDER_KMIP;
     key_doc.kek.provider.kmip.delegated = true;
     key_doc.kek.provider.kmip.key_id = (char *)KEK_UNIQUE_IDENTIFIER;
-    ASSERT(_mongocrypt_buffer_copy_from_data_and_size(&key_doc.key_material, IV_CIPHERTEXT, sizeof(IV_CIPHERTEXT)))
+    ASSERT(_mongocrypt_buffer_copy_from_data_and_size(&key_doc.key_material, IV_CIPHERTEXT, sizeof(IV_CIPHERTEXT)));
 
     status = mongocrypt_status_new();
     endpoint = _mongocrypt_endpoint_new("example.com", -1, NULL /* opts */, status);

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-local-kms.c

@@ -75,4 +75,4 @@ static void _test_local_roundtrip(_mongocrypt_tester_t *tester) {
 
 void _mongocrypt_tester_install_local_kms(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_local_roundtrip);
-}
+}

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

@@ -88,10 +88,10 @@ static void _test_trace_log(_mongocrypt_tester_t *tester) {
 
 #if defined(__GLIBC__) || defined(__APPLE__)
 static void _test_no_log(_mongocrypt_tester_t *tester) {
-    const int buffer_size = BUFSIZ;
     mongocrypt_t *crypt;
     mongocrypt_status_t *status;
-    char captured_logs[buffer_size];
+    char captured_logs[BUFSIZ];
+    const int buffer_size = sizeof(captured_logs);
     int saved_stdout = dup(1);
 
     /* Redirect stdout to /dev/null and capture output in a buffer