libmongocrypt-helper 1.13.2.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/test/test-mc-tokens.c

@@ -54,6 +54,14 @@
     F(ServerTextSubstringToken)                                                                                        \
     F(ServerTextSuffixToken)                                                                                           \
     F(ServerTextPrefixToken)                                                                                           \
+    F(EDCTextExactDerivedFromDataToken)                                                                                \
+    F(EDCTextSubstringDerivedFromDataToken)                                                                            \
+    F(EDCTextSuffixDerivedFromDataToken)                                                                               \
+    F(EDCTextPrefixDerivedFromDataToken)                                                                               \
+    F(ESCTextExactDerivedFromDataToken)                                                                                \
+    F(ESCTextSubstringDerivedFromDataToken)                                                                            \
+    F(ESCTextSuffixDerivedFromDataToken)                                                                               \
+    F(ESCTextPrefixDerivedFromDataToken)                                                                               \
     F(EDCTextExactDerivedFromDataTokenAndContentionFactorToken)                                                        \
     F(EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken)                                                    \
     F(EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken)                                                       \
@@ -222,12 +230,9 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
 
 #define TEST_TEXT(Name, Suffix) TEST_HELPER(Name, Token, Text##Suffix##Token, )
 #define TEST_TEXT_EXTRA(Name, Suffix, BaseSuffix) TEST_HELPER(Name, BaseSuffix##Token, Text##Suffix##Token, )
-#define TEST_TEXT_DERIVED_FROM_BOTH(Name)                                                                              \
-    TEST_HELPER(Name,                                                                                                  \
-                Token,                                                                                                 \
-                DerivedFromDataTokenAndContentionFactorToken,                                                          \
-                &test.value COMMA test.contentionFactor COMMA)
 #define TEST_TEXT_DERIVED_FROM_DATA(Name) TEST_HELPER(Name, Token, DerivedFromDataToken, &test.value COMMA)
+#define TEST_TEXT_DERIVED_FROM_CONTENTION(Name)                                                                        \
+    TEST_HELPER(Name, Token, TokenAndContentionFactorToken, test.contentionFactor COMMA)
 
     TEST_TEXT(EDC, Exact);
     TEST_TEXT(EDC, Substring);
@@ -244,15 +249,23 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     TEST_TEXT_EXTRA(Server, Suffix, TokenDerivationLevel1);
     TEST_TEXT_EXTRA(Server, Prefix, TokenDerivationLevel1);
 
-    TEST_TEXT_DERIVED_FROM_BOTH(EDCTextExact);
-    TEST_TEXT_DERIVED_FROM_BOTH(EDCTextSubstring);
-    TEST_TEXT_DERIVED_FROM_BOTH(EDCTextPrefix);
-    TEST_TEXT_DERIVED_FROM_BOTH(EDCTextSuffix);
-
-    TEST_TEXT_DERIVED_FROM_BOTH(ESCTextExact);
-    TEST_TEXT_DERIVED_FROM_BOTH(ESCTextSubstring);
-    TEST_TEXT_DERIVED_FROM_BOTH(ESCTextPrefix);
-    TEST_TEXT_DERIVED_FROM_BOTH(ESCTextSuffix);
+    TEST_TEXT_DERIVED_FROM_DATA(EDCTextExact);
+    TEST_TEXT_DERIVED_FROM_DATA(EDCTextSubstring);
+    TEST_TEXT_DERIVED_FROM_DATA(EDCTextSuffix);
+    TEST_TEXT_DERIVED_FROM_DATA(EDCTextPrefix);
+    TEST_TEXT_DERIVED_FROM_CONTENTION(EDCTextExactDerivedFromData);
+    TEST_TEXT_DERIVED_FROM_CONTENTION(EDCTextSubstringDerivedFromData);
+    TEST_TEXT_DERIVED_FROM_CONTENTION(EDCTextSuffixDerivedFromData);
+    TEST_TEXT_DERIVED_FROM_CONTENTION(EDCTextPrefixDerivedFromData);
+
+    TEST_TEXT_DERIVED_FROM_DATA(ESCTextExact);
+    TEST_TEXT_DERIVED_FROM_DATA(ESCTextSubstring);
+    TEST_TEXT_DERIVED_FROM_DATA(ESCTextSuffix);
+    TEST_TEXT_DERIVED_FROM_DATA(ESCTextPrefix);
+    TEST_TEXT_DERIVED_FROM_CONTENTION(ESCTextExactDerivedFromData);
+    TEST_TEXT_DERIVED_FROM_CONTENTION(ESCTextSubstringDerivedFromData);
+    TEST_TEXT_DERIVED_FROM_CONTENTION(ESCTextSuffixDerivedFromData);
+    TEST_TEXT_DERIVED_FROM_CONTENTION(ESCTextPrefixDerivedFromData);
 
     TEST_TEXT_DERIVED_FROM_DATA(ServerTextExact);
     TEST_TEXT_DERIVED_FROM_DATA(ServerTextSubstring);
@@ -272,6 +285,10 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
         ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken);
     mc_ESCTextExactDerivedFromDataTokenAndContentionFactorToken_destroy(
         ESCTextExactDerivedFromDataTokenAndContentionFactorToken);
+    mc_ESCTextPrefixDerivedFromDataToken_destroy(ESCTextPrefixDerivedFromDataToken);
+    mc_ESCTextSuffixDerivedFromDataToken_destroy(ESCTextSuffixDerivedFromDataToken);
+    mc_ESCTextSubstringDerivedFromDataToken_destroy(ESCTextSubstringDerivedFromDataToken);
+    mc_ESCTextExactDerivedFromDataToken_destroy(ESCTextExactDerivedFromDataToken);
     mc_EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken_destroy(
         EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken);
     mc_EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken_destroy(
@@ -280,6 +297,10 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
         EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken);
     mc_EDCTextExactDerivedFromDataTokenAndContentionFactorToken_destroy(
         EDCTextExactDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextPrefixDerivedFromDataToken_destroy(EDCTextPrefixDerivedFromDataToken);
+    mc_EDCTextSuffixDerivedFromDataToken_destroy(EDCTextSuffixDerivedFromDataToken);
+    mc_EDCTextSubstringDerivedFromDataToken_destroy(EDCTextSubstringDerivedFromDataToken);
+    mc_EDCTextExactDerivedFromDataToken_destroy(EDCTextExactDerivedFromDataToken);
     mc_ServerTextPrefixToken_destroy(ServerTextPrefixToken);
     mc_ServerTextSuffixToken_destroy(ServerTextSuffixToken);
     mc_ServerTextSubstringToken_destroy(ServerTextSubstringToken);

data/ext/libmongocrypt/libmongocrypt/test/test-mc-writer.c

@@ -28,13 +28,13 @@ static void _test_mc_writer_ints(_mongocrypt_tester_t *tester) {
         _mongocrypt_buffer_init_size(&write_buffer, sizeof(uint8_t));
 
         mc_writer_t writer;
-        mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+        mc_writer_init_from_buffer(&writer, &write_buffer, __func__);
 
         uint8_t num = 4;
         ASSERT_OK_STATUS(mc_writer_write_u8(&writer, num, status), status);
 
         mc_reader_t reader;
-        mc_reader_init_from_buffer(&reader, &write_buffer, __FUNCTION__);
+        mc_reader_init_from_buffer(&reader, &write_buffer, __func__);
 
         uint8_t out;
         ASSERT_OK_STATUS(mc_reader_read_u8(&reader, &out, status), status);
@@ -53,13 +53,13 @@ static void _test_mc_writer_ints(_mongocrypt_tester_t *tester) {
         _mongocrypt_buffer_init_size(&write_buffer, sizeof(uint32_t));
 
         mc_writer_t writer;
-        mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+        mc_writer_init_from_buffer(&writer, &write_buffer, __func__);
 
         uint32_t num = 23832405;
         ASSERT_OK_STATUS(mc_writer_write_u32(&writer, num, status), status);
 
         mc_reader_t reader;
-        mc_reader_init_from_buffer(&reader, &write_buffer, __FUNCTION__);
+        mc_reader_init_from_buffer(&reader, &write_buffer, __func__);
 
         uint32_t out;
         ASSERT_OK_STATUS(mc_reader_read_u32(&reader, &out, status), status);
@@ -78,13 +78,13 @@ static void _test_mc_writer_ints(_mongocrypt_tester_t *tester) {
         _mongocrypt_buffer_init_size(&write_buffer, sizeof(uint64_t));
 
         mc_writer_t writer;
-        mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+        mc_writer_init_from_buffer(&writer, &write_buffer, __func__);
 
         uint64_t num = 23832405;
         ASSERT_OK_STATUS(mc_writer_write_u64(&writer, num, status), status);
 
         mc_reader_t reader;
-        mc_reader_init_from_buffer(&reader, &write_buffer, __FUNCTION__);
+        mc_reader_init_from_buffer(&reader, &write_buffer, __func__);
 
         uint64_t out;
         ASSERT_OK_STATUS(mc_reader_read_u64(&reader, &out, status), status);
@@ -109,13 +109,13 @@ static void _test_mc_writer_buffer(_mongocrypt_tester_t *tester) {
     _mongocrypt_buffer_init_size(&write_buffer, input_buffer.len);
 
     mc_writer_t writer;
-    mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+    mc_writer_init_from_buffer(&writer, &write_buffer, __func__);
 
     ASSERT_OK_STATUS(mc_writer_write_buffer(&writer, &input_buffer, input_buffer.len, status), status);
 
     _mongocrypt_buffer_t read_buffer;
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, &write_buffer, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, &write_buffer, __func__);
     ASSERT_OK_STATUS(mc_reader_read_buffer(&reader, &read_buffer, write_buffer.len, status), status);
 
     ASSERT_CMPBUF(input_buffer, read_buffer);
@@ -137,7 +137,7 @@ static void _test_mc_writer_prf(_mongocrypt_tester_t *tester) {
     _mongocrypt_buffer_init_size(&write_buffer, input_buffer.len);
 
     mc_writer_t writer;
-    mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+    mc_writer_init_from_buffer(&writer, &write_buffer, __func__);
 
     ASSERT_OK_STATUS(mc_writer_write_prfblock_buffer(&writer, &input_buffer, status), status);
     ASSERT_CMPBUF(input_buffer, write_buffer);
@@ -158,7 +158,7 @@ static void _test_mc_writer_uuid(_mongocrypt_tester_t *tester) {
     _mongocrypt_buffer_init_size(&write_buffer, input_buffer.len);
 
     mc_writer_t writer;
-    mc_writer_init_from_buffer(&writer, &write_buffer, __FUNCTION__);
+    mc_writer_init_from_buffer(&writer, &write_buffer, __func__);
 
     ASSERT_OK_STATUS(mc_writer_write_uuid_buffer(&writer, &input_buffer, status), status);
     ASSERT_CMPBUF(input_buffer, write_buffer);

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-assert-match-bson.c

@@ -78,11 +78,6 @@ bool match_json(const bson_t *doc,
                 const char *json_pattern,
                 ...);
 
-#define ASSERT_MATCH(doc, ...)                                                                                         \
-    do {                                                                                                               \
-        BSON_ASSERT(match_json(doc, false, __FILE__, __LINE__, BSON_FUNC, __VA_ARGS__));                               \
-    } while (0)
-
 const char *_mongoc_bson_type_to_str(bson_type_t t);
 
 static bool get_exists_operator(const bson_value_t *value, bool *exists);
@@ -225,7 +220,7 @@ bool match_bson(const bson_t *doc, const bson_t *pattern, bool is_command) {
 
 MLIB_ANNOTATE_PRINTF(2, 3)
 
-void match_err(match_ctx_t *ctx, const char *fmt, ...) {
+static void match_err(match_ctx_t *ctx, const char *fmt, ...) {
     va_list args;
     char *formatted;
 
@@ -849,7 +844,8 @@ bool match_bson_value(const bson_value_t *doc, const bson_value_t *pattern, matc
                       "numeric values may be equal)");
         }
         break;
-    default: match_err(ctx, "unexpected value type %d: %s", doc->value_type, _mongoc_bson_type_to_str(doc->value_type));
+    default:
+        match_err(ctx, "unexpected value type %d: %s", (int)doc->value_type, _mongoc_bson_type_to_str(doc->value_type));
     }
 
     if (!ret) {

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-assert.h

@@ -44,29 +44,32 @@
         ((void)0)
 
 #define TEST_ERROR(...)                                                                                                \
-    do {                                                                                                               \
-        TEST_STDERR_PRINTF("test error %s:%d %s(): ", __FILE__, __LINE__, __FUNCTION__);                               \
+    if (1) {                                                                                                           \
+        TEST_STDERR_PRINTF("test error %s:%d %s(): ", __FILE__, __LINE__, __func__);                                   \
         TEST_STDERR_PRINTF(__VA_ARGS__);                                                                               \
         TEST_STDERR_PRINTF("\n");                                                                                      \
         abort();                                                                                                       \
-    } while (0)
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT(stmt)                                                                                                   \
     if (!(stmt)) {                                                                                                     \
         TEST_ERROR("statement failed %s", #stmt);                                                                      \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_OR_PRINT_MSG(_statement, msg)                                                                           \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         if (!(_statement)) {                                                                                           \
             TEST_ERROR("%s failed with msg: %s", #_statement, (msg));                                                  \
         }                                                                                                              \
-    } while (0)
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_OR_PRINT(_statement, _err) ASSERT_OR_PRINT_MSG(_statement, mongocrypt_status_message(_err, NULL))
 
 #define ASSERT_OK_STATUS(_stmt, _status)                                                                               \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         bool _retval = (_stmt);                                                                                        \
         bool _status_ok = mongocrypt_status_ok(_status);                                                               \
         const char *_msg = mongocrypt_status_message(_status, NULL);                                                   \
@@ -75,10 +78,11 @@
         } else if (!_status_ok) {                                                                                      \
             TEST_ERROR("%s resulted in unexpected error status: %s\n", #_stmt, _msg);                                  \
         }                                                                                                              \
-    } while (0)
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_FAILS_STATUS(_stmt, _status, _msg_pattern)                                                              \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         bool _retval = (_stmt);                                                                                        \
         bool _status_ok = mongocrypt_status_ok(_status);                                                               \
         const char *_msg = mongocrypt_status_message(_status, NULL);                                                   \
@@ -90,7 +94,8 @@
         } else if (!_found_msg) {                                                                                      \
             TEST_ERROR("'%s' does not contain '%s'\n", _msg, _msg_pattern);                                            \
         }                                                                                                              \
-    } while (0)
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_OK(_stmt, _obj) ASSERT_OK_STATUS(_stmt, (_obj)->status)
 
@@ -101,7 +106,7 @@
 #define ASSERT_STATUS_CONTAINS(status, _msg_pattern) ASSERT_FAILS_STATUS(false, status, _msg_pattern)
 
 #define ASSERT_STREQUAL(_expr_a, _expr_b)                                                                              \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         const char *_str_a = (_expr_a);                                                                                \
         const char *_str_b = (_expr_b);                                                                                \
         ASSERT(_str_a);                                                                                                \
@@ -110,47 +115,52 @@
         if (_ret != 0) {                                                                                               \
             TEST_ERROR("strings not equal:\n%s\nvs.\n%s\n", _str_a, _str_b);                                           \
         }                                                                                                              \
-    } while (0);
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_STRCONTAINS(_expr_a, _expr_b)                                                                           \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         const char *_str_a = (_expr_a);                                                                                \
         const char *_str_b = (_expr_b);                                                                                \
         char *_ret = strstr(_str_a, _str_b);                                                                           \
         if (_ret == NULL) {                                                                                            \
             TEST_ERROR("string %s does not contain %s\n", _str_a, _str_b);                                             \
         }                                                                                                              \
-    } while (0);
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_STATE_EQUAL(actual, expected)                                                                           \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         if (actual != expected) {                                                                                      \
             TEST_ERROR("actual state: %s, but expected state: %s\n",                                                   \
                        mongocrypt_ctx_state_to_string(actual),                                                         \
                        mongocrypt_ctx_state_to_string(expected));                                                      \
             abort();                                                                                                   \
         }                                                                                                              \
-    } while (0)
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_CMPBYTES(expected_bytes, expected_len, actual_bytes, actual_len)                                        \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         char *_actual_hex = data_to_hex(actual_bytes, actual_len);                                                     \
         char *_expected_hex = data_to_hex(expected_bytes, expected_len);                                               \
         ASSERT_STREQUAL(_actual_hex, _expected_hex);                                                                   \
         free(_actual_hex);                                                                                             \
         free(_expected_hex);                                                                                           \
-    } while (0)
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_CMPBUF(expected, actual) ASSERT_CMPBYTES((expected).data, (expected).len, (actual).data, (actual).len)
 
 #define ASSERT_CMP_HELPER(_a, _operator, _b, fmt, type)                                                                \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         type _a_value = (_a);                                                                                          \
         type _b_value = (_b);                                                                                          \
         if (!(_a_value _operator _b_value)) {                                                                          \
             TEST_ERROR("comparison failed: %" fmt " %s %" fmt, _a_value, #_operator, _b_value);                        \
         }                                                                                                              \
-    } while (0);
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_CMPINT(a, eq, b) ASSERT_CMP_HELPER(a, eq, b, "d", int)
 #define ASSERT_CMPUINT(a, eq, b) ASSERT_CMP_HELPER(a, eq, b, "u", unsigned int)
@@ -184,7 +194,7 @@
         ((void)0)
 
 #define ASSERT_EQUAL_BSON(expected, actual)                                                                            \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         bson_t *_expected_bson = expected, *_actual_bson = actual;                                                     \
         char *_expected_str, *_actual_str;                                                                             \
         _expected_str = bson_as_canonical_extended_json(_expected_bson, NULL);                                         \
@@ -194,10 +204,11 @@
         }                                                                                                              \
         bson_free(_actual_str);                                                                                        \
         bson_free(_expected_str);                                                                                      \
-    } while (0)
+    } else                                                                                                             \
+        ((void)0)
 
 #define ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(expected, actual)                                                          \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         bson_t _expected_bson, _actual_bson;                                                                           \
         char *_expected_str, *_actual_str;                                                                             \
         ASSERT(_mongocrypt_binary_to_bson(expected, &_expected_bson));                                                 \
@@ -209,6 +220,7 @@
         }                                                                                                              \
         bson_free(_actual_str);                                                                                        \
         bson_free(_expected_str);                                                                                      \
-    } while (0)
+    } else                                                                                                             \
+        ((void)0)
 
 #endif /* TEST_MONGOCRYPT_ASSERT_H */

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

@@ -35,7 +35,7 @@ static void _get_bytes(const void *in, char *out, int len) {
     dest[-1] = '\0';
 }
 
-bool assert_excess_bytes_removed(char *key, char *wrapped, char *unwrapped, uint32_t type, bson_value_t *out) {
+static bool assert_excess_bytes_removed(char *key, char *wrapped, char *unwrapped, uint32_t type, bson_value_t *out) {
     _mongocrypt_buffer_t plaintext = {0};
     _mongocrypt_marking_t marking = {0};
     bson_iter_t iter;
@@ -48,13 +48,13 @@ bool assert_excess_bytes_removed(char *key, char *wrapped, char *unwrapped, uint
     BSON_APPEND_INT32(&bson, "int_key", TEST_INT);
 
     bson_iter_init_find(&iter, &bson, key);
-    memcpy(&marking.v_iter, &iter, sizeof(bson_iter_t));
+    memcpy(&marking.u.fle1.v_iter, &iter, sizeof(bson_iter_t));
 
-    bson_append_iter(&wrapper, "", 0, &marking.v_iter);
+    bson_append_iter(&wrapper, "", 0, &marking.u.fle1.v_iter);
     _get_bytes(bson_get_data(&wrapper), actual, wrapper.len);
     BSON_ASSERT(0 == strcmp(wrapped, actual));
 
-    _mongocrypt_buffer_from_iter(&plaintext, &(&marking)->v_iter);
+    _mongocrypt_buffer_from_iter(&plaintext, &(&marking)->u.fle1.v_iter);
     _get_bytes(plaintext.data, actual, plaintext.len);
     BSON_ASSERT(0 == strcmp(unwrapped, actual));
 

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

@@ -18,7 +18,7 @@
 #include "mongocrypt-crypto-private.h"
 #include "test-mongocrypt.h"
 
-void _test_cache(_mongocrypt_tester_t *tester) {
+static void _test_cache(_mongocrypt_tester_t *tester) {
     _mongocrypt_cache_t cache;
     mongocrypt_status_t *status;
     bson_t *entry = BCON_NEW("a", "b"), *entry2 = BCON_NEW("c", "d");
@@ -221,4 +221,4 @@ void _mongocrypt_tester_install_cache(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_cache);
     INSTALL_TEST(_test_cache_expiration);
     INSTALL_TEST(_test_cache_duplicates);
-}
+}

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

@@ -91,7 +91,7 @@ static void _test_malformed_ciphertext(_mongocrypt_tester_t *tester) {
     mongocrypt_status_destroy(status);
 }
 
-void _test_ciphertext_algorithm(_mongocrypt_tester_t *tester) {
+static void _test_ciphertext_algorithm(_mongocrypt_tester_t *tester) {
     mongocrypt_t *crypt;
     mongocrypt_ctx_t *ctx;
     mongocrypt_status_t *status;
@@ -118,10 +118,10 @@ void _test_ciphertext_algorithm(_mongocrypt_tester_t *tester) {
     ctx = mongocrypt_ctx_new(crypt);
     ASSERT_OK(mongocrypt_ctx_encrypt_init(ctx, "test", -1, TEST_FILE("./test/example/cmd.json")), ctx);
 
-    _mongocrypt_buffer_from_binary(&marking.key_id, TEST_BIN(16));
-    marking.key_id.subtype = BSON_SUBTYPE_UUID;
+    _mongocrypt_buffer_from_binary(&marking.u.fle1.key_id, TEST_BIN(16));
+    marking.u.fle1.key_id.subtype = BSON_SUBTYPE_UUID;
     kb = &ctx->kb;
-    _mongocrypt_key_broker_add_test_key(kb, &marking.key_id);
+    _mongocrypt_key_broker_add_test_key(kb, &marking.u.fle1.key_id);
 
     bson = BCON_NEW("v", "a", "v", "b");
     bson_iter_init(&a_iter, bson);
@@ -131,26 +131,26 @@ void _test_ciphertext_algorithm(_mongocrypt_tester_t *tester) {
     bson_iter_next(&b_iter);
 
     /* Marking type = 1, plaintext = a */
-    marking.algorithm = 1;
-    memcpy(&marking.v_iter, &a_iter, sizeof(bson_iter_t));
+    marking.u.fle1.algorithm = 1;
+    memcpy(&marking.u.fle1.v_iter, &a_iter, sizeof(bson_iter_t));
     res = _mongocrypt_marking_to_ciphertext((void *)kb, &marking, &type1_valueA, status);
     ASSERT_OR_PRINT(res, status);
 
     /* Marking type = 1, plaintext = a */
-    marking.algorithm = 1;
-    memcpy(&marking.v_iter, &a_iter, sizeof(bson_iter_t));
+    marking.u.fle1.algorithm = 1;
+    memcpy(&marking.u.fle1.v_iter, &a_iter, sizeof(bson_iter_t));
     res = _mongocrypt_marking_to_ciphertext((void *)kb, &marking, &type1_valueA_again, status);
     ASSERT_OR_PRINT(res, status);
 
     /* Marking type = 2, plaintext = a */
-    marking.algorithm = 2;
-    memcpy(&marking.v_iter, &a_iter, sizeof(bson_iter_t));
+    marking.u.fle1.algorithm = 2;
+    memcpy(&marking.u.fle1.v_iter, &a_iter, sizeof(bson_iter_t));
     res = _mongocrypt_marking_to_ciphertext((void *)kb, &marking, &type2_valueA, status);
     ASSERT_OR_PRINT(res, status);
 
     /* Marking type = 1, plaintext = b */
-    marking.algorithm = 1;
-    memcpy(&marking.v_iter, &b_iter, sizeof(bson_iter_t));
+    marking.u.fle1.algorithm = 1;
+    memcpy(&marking.u.fle1.v_iter, &b_iter, sizeof(bson_iter_t));
     res = _mongocrypt_marking_to_ciphertext((void *)kb, &marking, &type1_valueB, status);
     ASSERT_OR_PRINT(res, status);
 
@@ -184,7 +184,7 @@ void _test_ciphertext_algorithm(_mongocrypt_tester_t *tester) {
     mongocrypt_status_destroy(status);
 }
 
-void _test_ciphertext_serialize_associated_data(_mongocrypt_tester_t *tester) {
+static void _test_ciphertext_serialize_associated_data(_mongocrypt_tester_t *tester) {
     _mongocrypt_ciphertext_t ciphertext;
     _mongocrypt_buffer_t serialized;
     /* Expected associated data is:

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

@@ -17,59 +17,50 @@
 #include "test-mongocrypt.h"
 
 static void _test_cleanup_success(_mongocrypt_tester_t *tester) {
-    for (int use_range_v2 = 0; use_range_v2 <= 1; use_range_v2++) {
-        mongocrypt_t *crypt;
-        mongocrypt_ctx_t *ctx;
-
-        crypt =
-            _mongocrypt_tester_mongocrypt(use_range_v2 ? TESTER_MONGOCRYPT_WITH_RANGE_V2 : TESTER_MONGOCRYPT_DEFAULT);
-        ctx = mongocrypt_ctx_new(crypt);
-
-        ASSERT_OK(mongocrypt_ctx_encrypt_init(ctx, "db", -1, TEST_FILE("./test/data/cleanup/success/cmd.json")), ctx);
-
-        ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_NEED_MONGO_COLLINFO);
-        {
-            ASSERT_OK(mongocrypt_ctx_mongo_feed(ctx, TEST_FILE("./test/data/cleanup/success/collinfo.json")), ctx);
-            ASSERT_OK(mongocrypt_ctx_mongo_done(ctx), ctx);
-        }
-
-        ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_NEED_MONGO_KEYS);
-        {
-            ASSERT_OK(mongocrypt_ctx_mongo_feed(ctx,
-                                                TEST_FILE("./test/data/keys/"
-                                                          "12345678123498761234123456789012-local-document.json")),
-                      ctx);
-            ASSERT_OK(mongocrypt_ctx_mongo_feed(ctx,
-                                                TEST_FILE("./test/data/keys/"
-                                                          "ABCDEFAB123498761234123456789012-local-document.json")),
-                      ctx);
-            ASSERT_OK(mongocrypt_ctx_mongo_feed(ctx,
-                                                TEST_FILE("./test/data/keys/"
-                                                          "12345678123498761234123456789013-local-document.json")),
-                      ctx);
-            ASSERT_OK(mongocrypt_ctx_mongo_done(ctx), ctx);
-        }
-
-        ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_READY);
-        {
-            mongocrypt_binary_t *out = mongocrypt_binary_new();
-            ASSERT_OK(mongocrypt_ctx_finalize(ctx, out), ctx);
-            if (use_range_v2) {
-                ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(
-                    TEST_FILE("./test/data/cleanup/success/encrypted-payload-range-v2.json"),
-                    out);
-            } else {
-                ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(TEST_FILE("./test/data/cleanup/success/encrypted-payload.json"),
-                                                    out);
-            }
-            mongocrypt_binary_destroy(out);
-        }
-
-        ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_DONE);
-
-        mongocrypt_ctx_destroy(ctx);
-        mongocrypt_destroy(crypt);
+    mongocrypt_t *crypt;
+    mongocrypt_ctx_t *ctx;
+
+    crypt = _mongocrypt_tester_mongocrypt(TESTER_MONGOCRYPT_DEFAULT);
+    ctx = mongocrypt_ctx_new(crypt);
+
+    ASSERT_OK(mongocrypt_ctx_encrypt_init(ctx, "db", -1, TEST_FILE("./test/data/cleanup/success/cmd.json")), ctx);
+
+    ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_NEED_MONGO_COLLINFO);
+    {
+        ASSERT_OK(mongocrypt_ctx_mongo_feed(ctx, TEST_FILE("./test/data/cleanup/success/collinfo.json")), ctx);
+        ASSERT_OK(mongocrypt_ctx_mongo_done(ctx), ctx);
     }
+
+    ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_NEED_MONGO_KEYS);
+    {
+        ASSERT_OK(mongocrypt_ctx_mongo_feed(ctx,
+                                            TEST_FILE("./test/data/keys/"
+                                                      "12345678123498761234123456789012-local-document.json")),
+                  ctx);
+        ASSERT_OK(mongocrypt_ctx_mongo_feed(ctx,
+                                            TEST_FILE("./test/data/keys/"
+                                                      "ABCDEFAB123498761234123456789012-local-document.json")),
+                  ctx);
+        ASSERT_OK(mongocrypt_ctx_mongo_feed(ctx,
+                                            TEST_FILE("./test/data/keys/"
+                                                      "12345678123498761234123456789013-local-document.json")),
+                  ctx);
+        ASSERT_OK(mongocrypt_ctx_mongo_done(ctx), ctx);
+    }
+
+    ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_READY);
+    {
+        mongocrypt_binary_t *out = mongocrypt_binary_new();
+        ASSERT_OK(mongocrypt_ctx_finalize(ctx, out), ctx);
+        ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(TEST_FILE("./test/data/cleanup/success/encrypted-payload-range-v2.json"),
+                                            out);
+        mongocrypt_binary_destroy(out);
+    }
+
+    ASSERT_STATE_EQUAL(mongocrypt_ctx_state(ctx), MONGOCRYPT_CTX_DONE);
+
+    mongocrypt_ctx_destroy(ctx);
+    mongocrypt_destroy(crypt);
 }
 
 static void _test_cleanup_nonlocal_kms(_mongocrypt_tester_t *tester) {
@@ -135,7 +126,8 @@ static void _test_cleanup_nonlocal_kms(_mongocrypt_tester_t *tester) {
     {
         mongocrypt_binary_t *out = mongocrypt_binary_new();
         ASSERT_OK(mongocrypt_ctx_finalize(ctx, out), ctx);
-        ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(TEST_FILE("./test/data/cleanup/success/encrypted-payload.json"), out);
+        ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(TEST_FILE("./test/data/cleanup/success/encrypted-payload-range-v2.json"),
+                                            out);
         mongocrypt_binary_destroy(out);
     }
 
@@ -269,7 +261,8 @@ static void _test_cleanup_need_kms_credentials(_mongocrypt_tester_t *tester) {
     {
         mongocrypt_binary_t *out = mongocrypt_binary_new();
         ASSERT_OK(mongocrypt_ctx_finalize(ctx, out), ctx);
-        ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(TEST_FILE("./test/data/cleanup/success/encrypted-payload.json"), out);
+        ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(TEST_FILE("./test/data/cleanup/success/encrypted-payload-range-v2.json"),
+                                            out);
         mongocrypt_binary_destroy(out);
     }
 
@@ -353,7 +346,8 @@ static void _test_cleanup_from_encrypted_field_config_map(_mongocrypt_tester_t *
     {
         mongocrypt_binary_t *out = mongocrypt_binary_new();
         ASSERT_OK(mongocrypt_ctx_finalize(ctx, out), ctx);
-        ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(TEST_FILE("./test/data/cleanup/success/encrypted-payload.json"), out);
+        ASSERT_MONGOCRYPT_BINARY_EQUAL_BSON(TEST_FILE("./test/data/cleanup/success/encrypted-payload-range-v2.json"),
+                                            out);
         mongocrypt_binary_destroy(out);
     }