libmongocrypt-helper 1.11.0.0.1001 → 1.13.2.0.1001

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

@@ -22,7 +22,7 @@
     F(value)                                                                                                           \
     F(collectionsLevel1Token)                                                                                          \
     F(serverDataEncryptionLevel1Token)                                                                                 \
-    F(serverTokenDerivationLevel1Token)                                                                                \
+    F(ServerTokenDerivationLevel1Token)                                                                                \
     F(EDCToken)                                                                                                        \
     F(ESCToken)                                                                                                        \
     F(ECCToken)                                                                                                        \
@@ -39,7 +39,33 @@
     F(ESCTwiceDerivedValueToken)                                                                                       \
     F(serverCountAndContentionFactorEncryptionToken)                                                                   \
     F(serverZerosEncryptionToken)                                                                                      \
-    F(AnchorPaddingTokenRoot)
+    F(AnchorPaddingTokenRoot)                                                                                          \
+    F(AnchorPaddingKeyToken)                                                                                           \
+    F(AnchorPaddingValueToken)                                                                                         \
+    F(EDCTextExactToken)                                                                                               \
+    F(EDCTextSubstringToken)                                                                                           \
+    F(EDCTextSuffixToken)                                                                                              \
+    F(EDCTextPrefixToken)                                                                                              \
+    F(ESCTextExactToken)                                                                                               \
+    F(ESCTextSubstringToken)                                                                                           \
+    F(ESCTextSuffixToken)                                                                                              \
+    F(ESCTextPrefixToken)                                                                                              \
+    F(ServerTextExactToken)                                                                                            \
+    F(ServerTextSubstringToken)                                                                                        \
+    F(ServerTextSuffixToken)                                                                                           \
+    F(ServerTextPrefixToken)                                                                                           \
+    F(EDCTextExactDerivedFromDataTokenAndContentionFactorToken)                                                        \
+    F(EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken)                                                    \
+    F(EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken)                                                       \
+    F(EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken)                                                       \
+    F(ESCTextExactDerivedFromDataTokenAndContentionFactorToken)                                                        \
+    F(ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken)                                                    \
+    F(ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken)                                                       \
+    F(ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken)                                                       \
+    F(ServerTextExactDerivedFromDataToken)                                                                             \
+    F(ServerTextSubstringDerivedFromDataToken)                                                                         \
+    F(ServerTextSuffixDerivedFromDataToken)                                                                            \
+    F(ServerTextPrefixDerivedFromDataToken)
 
 typedef struct {
 #define DECLARE_FIELD(f) _mongocrypt_buffer_t f;
@@ -55,7 +81,7 @@ static void _mc_token_test_cleanup(_mc_token_test *test) {
 }
 
 static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
-    printf("Loading test from %s...\n", path);
+    TEST_PRINTF("Loading test from %s...\n", path);
 
     mongocrypt_binary_t *test_bin = TEST_FILE(path);
     if (!test_bin) {
@@ -121,11 +147,11 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
                   test.serverDataEncryptionLevel1Token);
 
     // ServerTokenDerivationLevel1Token
-    mc_ServerTokenDerivationLevel1Token_t *serverTokenDerivationLevel1Token =
+    mc_ServerTokenDerivationLevel1Token_t *ServerTokenDerivationLevel1Token =
         mc_ServerTokenDerivationLevel1Token_new(crypt->crypto, &test.root, status);
-    ASSERT_OR_PRINT(serverTokenDerivationLevel1Token, status);
-    ASSERT_CMPBUF(*mc_ServerTokenDerivationLevel1Token_get(serverTokenDerivationLevel1Token),
-                  test.serverTokenDerivationLevel1Token);
+    ASSERT_OR_PRINT(ServerTokenDerivationLevel1Token, status);
+    ASSERT_CMPBUF(*mc_ServerTokenDerivationLevel1Token_get(ServerTokenDerivationLevel1Token),
+                  test.ServerTokenDerivationLevel1Token);
 
 // (EDC|ESC|ECC|ECOC)Token
 #define TEST_COLL_TOKEN(Name)                                                                                          \
@@ -138,32 +164,25 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     TEST_COLL_TOKEN(ECOC)
 #undef TEST_COLL_TOKEN
 
+#define TEST_HELPER(Base, BaseSuffix, TokenSuffix, ExtraArgsToNew)                                                     \
+    mc_##Base##TokenSuffix##_t *Base##TokenSuffix =                                                                    \
+        mc_##Base##TokenSuffix##_new(crypt->crypto, Base##BaseSuffix, ExtraArgsToNew status);                          \
+    ASSERT_OR_PRINT(Base##TokenSuffix, status);                                                                        \
+    ASSERT_CMPBUF(*mc_##Base##TokenSuffix##_get(Base##TokenSuffix), test.Base##TokenSuffix)
+
+#define COMMA ,
+
 // (EDC|ESC|ECC)DerivedFromDataToken(AndContentionFactor)?
 #define TEST_DERIVED(Name)                                                                                             \
-    mc_##Name##DerivedFromDataToken_t *Name##DerivedFromDataToken =                                                    \
-        mc_##Name##DerivedFromDataToken_new(crypt->crypto, Name##Token, &test.value, status);                          \
-    ASSERT_OR_PRINT(Name##DerivedFromDataToken, status);                                                               \
-    ASSERT_CMPBUF(*mc_##Name##DerivedFromDataToken_get(Name##DerivedFromDataToken), test.Name##DerivedFromDataToken);  \
-    mc_##Name##DerivedFromDataTokenAndContentionFactor_t *Name##DerivedFromDataTokenAndContentionFactor =              \
-        mc_##Name##DerivedFromDataTokenAndContentionFactor_new(crypt->crypto,                                          \
-                                                               Name##DerivedFromDataToken,                             \
-                                                               test.contentionFactor,                                  \
-                                                               status);                                                \
-    ASSERT_OR_PRINT(Name##DerivedFromDataTokenAndContentionFactor, status);                                            \
-    ASSERT_CMPBUF(                                                                                                     \
-        *mc_##Name##DerivedFromDataTokenAndContentionFactor_get(Name##DerivedFromDataTokenAndContentionFactor),        \
-        test.Name##DerivedFromDataTokenAndContentionFactor);
-    TEST_DERIVED(EDC)
-    TEST_DERIVED(ESC)
-    TEST_DERIVED(ECC)
-#undef TEST_DERIVED_FROM_DATA_TOKEN
+    TEST_HELPER(Name, Token, DerivedFromDataToken, &test.value COMMA);                                                 \
+    TEST_HELPER(Name, DerivedFromDataToken, DerivedFromDataTokenAndContentionFactor, test.contentionFactor COMMA)
+    TEST_DERIVED(EDC);
+    TEST_DERIVED(ESC);
+    TEST_DERIVED(ECC);
+#undef TEST_DERIVED
 
 // (EDC|ESC)TwiceDerivedToken(Tag|Value)?
-#define TEST_TWICE(Name, Suffix)                                                                                       \
-    mc_##Name##TwiceDerived##Suffix##_t *Name##TwiceDerived##Suffix =                                                  \
-        mc_##Name##TwiceDerived##Suffix##_new(crypt->crypto, Name##DerivedFromDataTokenAndContentionFactor, status);   \
-    ASSERT_OR_PRINT(Name##TwiceDerived##Suffix, status);                                                               \
-    ASSERT_CMPBUF(*mc_##Name##TwiceDerived##Suffix##_get(Name##TwiceDerived##Suffix), test.Name##TwiceDerived##Suffix);
+#define TEST_TWICE(Name, Suffix) TEST_HELPER(Name, DerivedFromDataTokenAndContentionFactor, TwiceDerived##Suffix, )
     TEST_TWICE(EDC, Token);
     TEST_TWICE(ESC, TagToken);
     TEST_TWICE(ESC, ValueToken);
@@ -171,7 +190,7 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
 
     // ServerDerivedFromDataToken
     mc_ServerDerivedFromDataToken_t *serverDerivedFromDataToken =
-        mc_ServerDerivedFromDataToken_new(crypt->crypto, serverTokenDerivationLevel1Token, &test.value, status);
+        mc_ServerDerivedFromDataToken_new(crypt->crypto, ServerTokenDerivationLevel1Token, &test.value, status);
     ASSERT_OR_PRINT(serverDerivedFromDataToken, status);
     ASSERT_CMPBUF(*mc_ServerDerivedFromDataToken_get(serverDerivedFromDataToken), test.serverDerivedFromDataToken);
 
@@ -193,7 +212,88 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     ASSERT_OR_PRINT(padding, status);
     ASSERT_CMPBUF(*mc_AnchorPaddingTokenRoot_get(padding), test.AnchorPaddingTokenRoot);
 
+    mc_AnchorPaddingKeyToken_t *paddingKey = mc_AnchorPaddingKeyToken_new(crypt->crypto, padding, status);
+    ASSERT_OR_PRINT(paddingKey, status);
+    ASSERT_CMPBUF(*mc_AnchorPaddingKeyToken_get(paddingKey), test.AnchorPaddingKeyToken);
+
+    mc_AnchorPaddingValueToken_t *paddingValue = mc_AnchorPaddingValueToken_new(crypt->crypto, padding, status);
+    ASSERT_OR_PRINT(paddingValue, status);
+    ASSERT_CMPBUF(*mc_AnchorPaddingValueToken_get(paddingValue), test.AnchorPaddingValueToken);
+
+#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)
+
+    TEST_TEXT(EDC, Exact);
+    TEST_TEXT(EDC, Substring);
+    TEST_TEXT(EDC, Suffix);
+    TEST_TEXT(EDC, Prefix);
+
+    TEST_TEXT(ESC, Exact);
+    TEST_TEXT(ESC, Substring);
+    TEST_TEXT(ESC, Suffix);
+    TEST_TEXT(ESC, Prefix);
+
+    TEST_TEXT_EXTRA(Server, Exact, TokenDerivationLevel1);
+    TEST_TEXT_EXTRA(Server, Substring, TokenDerivationLevel1);
+    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(ServerTextExact);
+    TEST_TEXT_DERIVED_FROM_DATA(ServerTextSubstring);
+    TEST_TEXT_DERIVED_FROM_DATA(ServerTextPrefix);
+    TEST_TEXT_DERIVED_FROM_DATA(ServerTextSuffix);
+
     // Done.
+    mc_ServerTextPrefixDerivedFromDataToken_destroy(ServerTextPrefixDerivedFromDataToken);
+    mc_ServerTextSuffixDerivedFromDataToken_destroy(ServerTextSuffixDerivedFromDataToken);
+    mc_ServerTextSubstringDerivedFromDataToken_destroy(ServerTextSubstringDerivedFromDataToken);
+    mc_ServerTextExactDerivedFromDataToken_destroy(ServerTextExactDerivedFromDataToken);
+    mc_ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken);
+    mc_ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken);
+    mc_ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken_destroy(
+        ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken);
+    mc_ESCTextExactDerivedFromDataTokenAndContentionFactorToken_destroy(
+        ESCTextExactDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextExactDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextExactDerivedFromDataTokenAndContentionFactorToken);
+    mc_ServerTextPrefixToken_destroy(ServerTextPrefixToken);
+    mc_ServerTextSuffixToken_destroy(ServerTextSuffixToken);
+    mc_ServerTextSubstringToken_destroy(ServerTextSubstringToken);
+    mc_ServerTextExactToken_destroy(ServerTextExactToken);
+    mc_ESCTextPrefixToken_destroy(ESCTextPrefixToken);
+    mc_ESCTextSuffixToken_destroy(ESCTextSuffixToken);
+    mc_ESCTextSubstringToken_destroy(ESCTextSubstringToken);
+    mc_ESCTextExactToken_destroy(ESCTextExactToken);
+    mc_EDCTextPrefixToken_destroy(EDCTextPrefixToken);
+    mc_EDCTextSuffixToken_destroy(EDCTextSuffixToken);
+    mc_EDCTextSubstringToken_destroy(EDCTextSubstringToken);
+    mc_EDCTextExactToken_destroy(EDCTextExactToken);
+    mc_AnchorPaddingValueToken_destroy(paddingValue);
+    mc_AnchorPaddingKeyToken_destroy(paddingKey);
     mc_AnchorPaddingTokenRoot_destroy(padding);
     mc_ServerZerosEncryptionToken_destroy(serverZeros);
     mc_ServerCountAndContentionFactorEncryptionToken_destroy(serverCACFET);
@@ -211,14 +311,14 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     mc_ECCToken_destroy(ECCToken);
     mc_ESCToken_destroy(ESCToken);
     mc_EDCToken_destroy(EDCToken);
-    mc_ServerTokenDerivationLevel1Token_destroy(serverTokenDerivationLevel1Token);
+    mc_ServerTokenDerivationLevel1Token_destroy(ServerTokenDerivationLevel1Token);
     mc_ServerDataEncryptionLevel1Token_destroy(serverDataEncryptionLevel1Token);
     mc_CollectionsLevel1Token_destroy(collectionsLevel1Token);
     _mc_token_test_cleanup(&test);
     mongocrypt_destroy(crypt);
     mongocrypt_status_destroy(status);
 
-    printf("Finished tests in %s\n", path);
+    TEST_PRINTF("Finished tests in %s\n", path);
 }
 
 static void _test_mc_tokens(_mongocrypt_tester_t *tester) {
@@ -247,14 +347,16 @@ static void _test_mc_tokens_error(_mongocrypt_tester_t *tester) {
 }
 
 static void _test_mc_tokens_raw_buffer(_mongocrypt_tester_t *tester) {
-    mc_ServerDataEncryptionLevel1Token_t *token;
+    mc_ServerDataEncryptionLevel1Token_t *token1;
+    mc_ServerDataEncryptionLevel1Token_t *token2;
     _mongocrypt_buffer_t test_input;
     _mongocrypt_buffer_t expected;
 
     _mongocrypt_buffer_copy_from_hex(&test_input, "6c6a349956c19f9c5e638e612011a71fbb71921edb540310c17cd0208b7f548b");
 
     /* Make a token from a raw buffer */
-    token = mc_ServerDataEncryptionLevel1Token_new_from_buffer(&test_input);
+    token1 = mc_ServerDataEncryptionLevel1Token_new_from_buffer(&test_input);
+    token2 = mc_ServerDataEncryptionLevel1Token_new_from_buffer_copy(&test_input);
 
     /* Assert new_from_buffer did not steal ownership. */
     ASSERT(test_input.owned);
@@ -262,16 +364,21 @@ static void _test_mc_tokens_raw_buffer(_mongocrypt_tester_t *tester) {
 
     _mongocrypt_buffer_copy_from_hex(&expected, "6c6a349956c19f9c5e638e612011a71fbb71921edb540310c17cd0208b7f548b");
 
-    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token), expected);
+    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token1), expected);
+    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token2), expected);
 
     /* Assert new_from_buffer references original buffer instead of a copy. */
     test_input.data[0] = '0';
     expected.data[0] = '0';
-    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token), expected);
+    ASSERT_CMPBUF(*mc_ServerDataEncryptionLevel1Token_get(token1), expected);
+
+    // Assert new_from_buffer_copy references a new buffer.
+    ASSERT_CMPUINT8(mc_ServerDataEncryptionLevel1Token_get(token2)->data[0], !=, expected.data[0]);
 
     _mongocrypt_buffer_cleanup(&test_input);
     _mongocrypt_buffer_cleanup(&expected);
-    mc_ServerDataEncryptionLevel1Token_destroy(token);
+    mc_ServerDataEncryptionLevel1Token_destroy(token1);
+    mc_ServerDataEncryptionLevel1Token_destroy(token2);
 }
 
 void _mongocrypt_tester_install_mc_tokens(_mongocrypt_tester_t *tester) {

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

@@ -167,7 +167,7 @@ bool match_json(const bson_t *doc,
     pattern = bson_new_from_json((const uint8_t *)double_quoted, -1, &error);
 
     if (!pattern) {
-        fprintf(stderr, "couldn't parse JSON: %s\n", error.message);
+        TEST_STDERR_PRINTF("couldn't parse JSON: %s\n", error.message);
         abort();
     }
 
@@ -176,18 +176,17 @@ bool match_json(const bson_t *doc,
 
     if (!matches) {
         char *as_string = doc ? bson_as_canonical_extended_json(doc, NULL) : NULL;
-        fprintf(stderr,
-                "ASSERT_MATCH failed with document:\n\n"
-                "%s\n"
-                "pattern:\n%s\n"
-                "%s\n"
-                "%s:%d %s()\n",
-                as_string ? as_string : "{}",
-                double_quoted,
-                ctx.errmsg,
-                filename,
-                lineno,
-                funcname);
+        TEST_STDERR_PRINTF("ASSERT_MATCH failed with document:\n\n"
+                           "%s\n"
+                           "pattern:\n%s\n"
+                           "%s\n"
+                           "%s:%d %s()\n",
+                           as_string ? as_string : "{}",
+                           double_quoted,
+                           ctx.errmsg,
+                           filename,
+                           lineno,
+                           funcname);
         bson_free(as_string);
     }
 
@@ -580,7 +579,7 @@ static bool get_type_operator(const bson_value_t *value, bson_type_t *out) {
         } else if (0 == strcasecmp("maxKey", value_string)) {
             *out = BSON_TYPE_MAXKEY;
         } else {
-            fprintf(stderr, "unrecognized $$type value: %s\n", value_string);
+            TEST_STDERR_PRINTF("unrecognized $$type value: %s\n", value_string);
             abort();
         }
         return true;

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

@@ -26,8 +26,8 @@ bool _check_match_bson(const bson_t *doc, const bson_t *pattern, char *errmsg, s
     if (1) {                                                                                                           \
         char errmsg[1024] = "";                                                                                        \
         if (!_check_match_bson(doc, pattern, errmsg, sizeof(errmsg))) {                                                \
-            char *doc_str = bson_as_json(doc, NULL);                                                                   \
-            char *pattern_str = bson_as_json(pattern, NULL);                                                           \
+            char *doc_str = bson_as_relaxed_extended_json(doc, NULL);                                                  \
+            char *pattern_str = bson_as_relaxed_extended_json(pattern, NULL);                                          \
                                                                                                                        \
             TEST_ERROR("ASSERT_MATCH failed with document:\n\n"                                                        \
                        "%s\n"                                                                                          \

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

@@ -25,12 +25,29 @@
 
 #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(...)                                                                                                \
+    do {                                                                                                               \
+        TEST_STDERR_PRINTF("test error %s:%d %s(): ", __FILE__, __LINE__, __FUNCTION__);                               \
+        TEST_STDERR_PRINTF(__VA_ARGS__);                                                                               \
+        TEST_STDERR_PRINTF("\n");                                                                                      \
         abort();                                                                                                       \
     } while (0)
 

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"
 
@@ -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

@@ -68,24 +68,6 @@ void _test_cache(_mongocrypt_tester_t *tester) {
     bson_destroy(entry2);
 }
 
-static void _usleep(int64_t usec) {
-#ifdef _WIN32
-    LARGE_INTEGER ft;
-    HANDLE timer;
-
-    BSON_ASSERT(usec >= 0);
-
-    ft.QuadPart = -(10 * usec);
-    timer = CreateWaitableTimer(NULL, true, NULL);
-    SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);
-    WaitForSingleObject(timer, INFINITE);
-    CloseHandle(timer);
-#else
-    BSON_ASSERT(usec >= 0);
-    usleep((useconds_t)usec);
-#endif
-}
-
 static void _test_cache_expiration(_mongocrypt_tester_t *tester) {
     _mongocrypt_cache_t cache;
     mongocrypt_status_t *status;
@@ -104,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);