libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

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

@@ -25,31 +25,51 @@
 
 #include <stdio.h>
 
-#define TEST_ERROR(...)                                                                                                \
-    do {                                                                                                               \
-        fprintf(stderr, "test error %s:%d %s(): ", __FILE__, __LINE__, __FUNCTION__);                                  \
+// TEST_PRINTF ensures stdout and stderr are flushed.
+#define TEST_PRINTF(...)                                                                                               \
+    if (1) {                                                                                                           \
+        fflush(stderr);                                                                                                \
+        fprintf(stdout, __VA_ARGS__);                                                                                  \
+        fflush(stdout);                                                                                                \
+    } else                                                                                                             \
+        ((void)0)
+
+// TEST_STDERR_PRINTF ensures stdout and stderr are flushed.
+#define TEST_STDERR_PRINTF(...)                                                                                        \
+    if (1) {                                                                                                           \
+        fflush(stdout);                                                                                                \
         fprintf(stderr, __VA_ARGS__);                                                                                  \
-        fprintf(stderr, "\n");                                                                                         \
         fflush(stderr);                                                                                                \
+    } else                                                                                                             \
+        ((void)0)
+
+#define TEST_ERROR(...)                                                                                                \
+    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);                                                   \
@@ -58,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);                                                   \
@@ -73,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)
 
@@ -84,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);                                                                                                \
@@ -93,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)
@@ -167,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);                                         \
@@ -177,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));                                                 \
@@ -192,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

@@ -16,6 +16,7 @@
 
 #include <mongocrypt-marking-private.h>
 
+#include "mongocrypt-buffer-private.h"
 #include "test-mongocrypt-assert.h"
 #include "test-mongocrypt.h"
 
@@ -34,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;
@@ -47,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));
 
@@ -232,6 +233,29 @@ static void _test_mongocrypt_buffer_from_subrange(_mongocrypt_tester_t *tester)
     _mongocrypt_buffer_cleanup(&input);
 }
 
+static void _test_mongocrypt_buffer_copy_from_string_as_bson_value(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t buf;
+    _mongocrypt_buffer_t expectedLenBuf;
+    const char *data = "foobar";
+
+    // expect output to contain 4-byte length + data + null string terminator
+    size_t expectedLen = sizeof(int32_t) + strlen(data) + sizeof(uint8_t);
+    _mongocrypt_buffer_copy_from_hex(&expectedLenBuf, "07000000");
+
+    _mongocrypt_buffer_copy_from_string_as_bson_value(&buf, data, (int)strlen(data));
+    ASSERT(buf.len == expectedLen);
+
+    // check 4-byte length
+    ASSERT_CMPBYTES(expectedLenBuf.data, expectedLenBuf.len, buf.data, expectedLenBuf.len);
+    // check data + null byte
+    ASSERT_CMPBYTES((const uint8_t *)data,
+                    strlen(data) + 1,
+                    buf.data + expectedLenBuf.len,
+                    buf.len - expectedLenBuf.len);
+    _mongocrypt_buffer_cleanup(&buf);
+    _mongocrypt_buffer_cleanup(&expectedLenBuf);
+}
+
 void _mongocrypt_tester_install_buffer(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_mongocrypt_buffer_from_iter);
     INSTALL_TEST(_test_mongocrypt_buffer_copy_from_data_and_size);
@@ -239,4 +263,5 @@ void _mongocrypt_tester_install_buffer(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_mongocrypt_buffer_steal_from_string);
     INSTALL_TEST(_test_mongocrypt_buffer_copy_from_uint64_le);
     INSTALL_TEST(_test_mongocrypt_buffer_from_subrange);
+    INSTALL_TEST(_test_mongocrypt_buffer_copy_from_string_as_bson_value);
 }

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");
@@ -86,8 +86,9 @@ static void _test_cache_expiration(_mongocrypt_tester_t *tester) {
     BSON_ASSERT(bson_equal(entry, tmp));
     bson_destroy(tmp);
 
-    /* Sleep for 100 milliseconds */
-    _usleep(1000 * 100);
+    // Sleep to trigger cache expiration.
+    // Cache entries expire after 1ms, but use 20ms to avoid timing errors observed on Windows distros: CDRIVER-4526
+    _usleep(20 * 1000);
 
     BSON_ASSERT(_mongocrypt_cache_get(&cache, "1", (void **)&tmp));
     BSON_ASSERT(!tmp);
@@ -220,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);
     }