libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.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,41 @@
     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(EDCTextExactDerivedFromDataToken)                                                                                \
+    F(EDCTextSubstringDerivedFromDataToken)                                                                            \
+    F(EDCTextSuffixDerivedFromDataToken)                                                                               \
+    F(EDCTextPrefixDerivedFromDataToken)                                                                               \
+    F(ESCTextExactDerivedFromDataToken)                                                                                \
+    F(ESCTextSubstringDerivedFromDataToken)                                                                            \
+    F(ESCTextSuffixDerivedFromDataToken)                                                                               \
+    F(ESCTextPrefixDerivedFromDataToken)                                                                               \
+    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 +89,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 +155,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 +172,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 +198,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 +220,101 @@ 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_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);
+    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_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);
+    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_ESCTextPrefixDerivedFromDataToken_destroy(ESCTextPrefixDerivedFromDataToken);
+    mc_ESCTextSuffixDerivedFromDataToken_destroy(ESCTextSuffixDerivedFromDataToken);
+    mc_ESCTextSubstringDerivedFromDataToken_destroy(ESCTextSubstringDerivedFromDataToken);
+    mc_ESCTextExactDerivedFromDataToken_destroy(ESCTextExactDerivedFromDataToken);
+    mc_EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken_destroy(
+        EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken);
+    mc_EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken_destroy(
+        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);
+    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 +332,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 +368,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 +385,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-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);
@@ -167,7 +162,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 +171,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);
     }
 
@@ -226,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;
 
@@ -580,7 +574,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;
@@ -850,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) {