libmongocrypt-helper 1.11.0.0.1001 → 1.13.2.0.1001

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

@@ -52,7 +52,7 @@ void _load_json_as_bson(const char *path, bson_t *out) {
 
     reader = bson_json_reader_new_from_file(path, &error);
     if (!reader) {
-        fprintf(stderr, "error reading: %s\n", path);
+        TEST_STDERR_PRINTF("error reading: %s\n", path);
     }
     ASSERT_OR_PRINT_BSON(reader, error);
     bson_init(out);
@@ -62,6 +62,24 @@ void _load_json_as_bson(const char *path, bson_t *out) {
     bson_json_reader_destroy(reader);
 }
 
+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
+}
+
 #define TEST_DATA_COUNT_INC(var)                                                                                       \
     (var)++;                                                                                                           \
     if ((var) >= TEST_DATA_COUNT) {                                                                                    \
@@ -100,7 +118,7 @@ static void _load_http(_mongocrypt_tester_t *tester, const char *path) {
     }
 
     if (n_read < 0) {
-        fprintf(stderr, "failed to read %s\n", path);
+        TEST_STDERR_PRINTF("failed to read %s\n", path);
         abort();
     }
 
@@ -140,12 +158,12 @@ void _mongocrypt_tester_install(_mongocrypt_tester_t *tester,
 #endif
 
     if (crypto_spec == CRYPTO_REQUIRED && !crypto_enabled) {
-        printf("Skipping test: %s – requires crypto to be enabled\n", name);
+        TEST_PRINTF("Skipping test: %s – requires crypto to be enabled\n", name);
         return;
     }
 
     if (crypto_spec == CRYPTO_PROHIBITED && crypto_enabled) {
-        printf("Skipping test: %s – requires crypto to be disabled\n", name);
+        TEST_PRINTF("Skipping test: %s – requires crypto to be disabled\n", name);
         return;
     }
 
@@ -180,6 +198,14 @@ mongocrypt_binary_t *_mongocrypt_tester_file(_mongocrypt_tester_t *tester, const
     return to_return;
 }
 
+bson_t *_mongocrypt_tester_file_as_bson(_mongocrypt_tester_t *tester, const char *path) {
+    mongocrypt_binary_t *bin = _mongocrypt_tester_file(tester, path);
+    bson_t *bson = &tester->test_bson[tester->bson_count];
+    TEST_DATA_COUNT_INC(tester->bson_count);
+    ASSERT(_mongocrypt_binary_to_bson(bin, bson));
+    return bson;
+}
+
 bson_t *_mongocrypt_tester_bson_from_json(_mongocrypt_tester_t *tester, const char *json, ...) {
     va_list ap;
     char *full_json;
@@ -200,13 +226,69 @@ bson_t *_mongocrypt_tester_bson_from_json(_mongocrypt_tester_t *tester, const ch
     bson = &tester->test_bson[tester->bson_count];
     TEST_DATA_COUNT_INC(tester->bson_count);
     if (!bson_init_from_json(bson, full_json, strlen(full_json), &error)) {
-        fprintf(stderr, "%s", error.message);
+        TEST_STDERR_PRINTF("%s", error.message);
         abort();
     }
     bson_free(full_json);
     return bson;
 }
 
+bson_t *tmp_bsonf(_mongocrypt_tester_t *tester, const char *fmt, ...) {
+    va_list arg;
+    va_start(arg, fmt);
+
+    size_t dst_capacity = strlen(fmt);
+    char *dst = bson_malloc(dst_capacity);
+    size_t dst_len = 0;
+
+#define ENSURE_CAPACITY(len)                                                                                           \
+    if (1) {                                                                                                           \
+        if ((len) + dst_len >= dst_capacity) {                                                                         \
+            dst_capacity = (len) + dst_len;                                                                            \
+            dst_capacity *= 2;                                                                                         \
+            dst = bson_realloc(dst, dst_capacity);                                                                     \
+        }                                                                                                              \
+    } else                                                                                                             \
+        (void)0
+
+    for (const char *ptr = fmt; *ptr != '\0'; ptr++) {
+        // TODO: consider optimizing this loop to use strstr to find MC_STR or MC_BSON.
+        if (0 == strncmp(ptr, "MC_STR", strlen("MC_STR"))) {
+            const char *src = va_arg(arg, const char *);
+            const size_t src_len = strlen(src);
+            ENSURE_CAPACITY(src_len + 2);
+            dst[dst_len++] = '"';
+            memcpy(dst + dst_len, src, src_len);
+            dst_len += src_len;
+            dst[dst_len++] = '"';
+            ptr += strlen("MC_STR") - 1;
+            continue;
+        }
+
+        if (0 == strncmp(ptr, "MC_BSON", strlen("MC_BSON"))) {
+            const bson_t *src_bson = va_arg(arg, const bson_t *);
+            size_t src_len;
+            char *src = bson_as_canonical_extended_json(src_bson, &src_len);
+            ENSURE_CAPACITY(src_len);
+            strcpy(dst + dst_len, src);
+            dst_len += src_len;
+            bson_free(src);
+            ptr += strlen("MC_BSON") - 1;
+            continue;
+        }
+
+        ENSURE_CAPACITY(1);
+        dst[dst_len++] = *ptr;
+    }
+#undef ENSURE_CAPACITY
+
+    dst[dst_len] = '\0';
+    bson_t *tmp = TMP_BSON(dst);
+    va_end(arg);
+    bson_free(dst);
+    return tmp;
+}
+
 mongocrypt_binary_t *_mongocrypt_tester_bin_from_json(_mongocrypt_tester_t *tester, const char *json, ...) {
     va_list ap;
     char *full_json;
@@ -228,7 +310,7 @@ mongocrypt_binary_t *_mongocrypt_tester_bin_from_json(_mongocrypt_tester_t *test
     bson = &tester->test_bson[tester->bson_count];
     TEST_DATA_COUNT_INC(tester->bson_count);
     if (!bson_init_from_json(bson, full_json, strlen(full_json), &error)) {
-        fprintf(stderr, "failed to parse JSON %s: %s", error.message, json);
+        TEST_STDERR_PRINTF("failed to parse JSON %s: %s", error.message, json);
         abort();
     }
     bin = mongocrypt_binary_new();
@@ -345,7 +427,7 @@ void _mongocrypt_tester_run_ctx_to(_mongocrypt_tester_t *tester,
             break;
         case MONGOCRYPT_CTX_ERROR:
             mongocrypt_ctx_status(ctx, status);
-            fprintf(stderr, "Got error: %s\n", mongocrypt_status_message(status, NULL));
+            TEST_STDERR_PRINTF("Got error: %s\n", mongocrypt_status_message(status, NULL));
             ASSERT_STATE_EQUAL(state, stop_state);
             mongocrypt_status_destroy(status);
             return;
@@ -461,6 +543,7 @@ mongocrypt_t *_mongocrypt_tester_mongocrypt(tester_mongocrypt_flags flags) {
     crypt = mongocrypt_new();
     mongocrypt_setopt_log_handler(crypt, _mongocrypt_stdout_log_fn, NULL);
     mongocrypt_setopt_kms_provider_aws(crypt, "example", -1, "example", -1);
+    mongocrypt_setopt_retry_kms(crypt, true);
     localkey = mongocrypt_binary_new_from_data((uint8_t *)localkey_data, sizeof localkey_data);
     mongocrypt_setopt_kms_provider_local(crypt, localkey);
     mongocrypt_binary_destroy(localkey);
@@ -489,9 +572,6 @@ mongocrypt_t *_mongocrypt_tester_mongocrypt(tester_mongocrypt_flags flags) {
     ASSERT_OK(mongocrypt_setopt_kms_providers(crypt, bin), crypt);
     bson_destroy(kms_providers);
     mongocrypt_binary_destroy(bin);
-    if (flags & TESTER_MONGOCRYPT_WITH_CRYPT_V1) {
-        ASSERT(mongocrypt_setopt_fle2v2(crypt, false));
-    }
     if (flags & TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB) {
         mongocrypt_setopt_append_crypt_shared_lib_search_path(crypt, "$ORIGIN");
     }
@@ -500,12 +580,18 @@ mongocrypt_t *_mongocrypt_tester_mongocrypt(tester_mongocrypt_flags flags) {
     } else {
         crypt->opts.use_range_v2 = false;
     }
-    ASSERT_OK(mongocrypt_init(crypt), crypt);
-    if (flags & TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB) {
-        if (mongocrypt_crypt_shared_lib_version(crypt) == 0) {
-            BSON_ASSERT(false
-                        && "tester mongocrypt requested WITH_CRYPT_SHARED_LIB, but "
-                           "no crypt_shared library was loaded by mongocrypt_init");
+    if (flags & TESTER_MONGOCRYPT_WITH_SHORT_CACHE) {
+        ASSERT(mongocrypt_setopt_key_expiration(crypt, 1));
+    }
+    ASSERT_OK(mongocrypt_setopt_enable_multiple_collinfo(crypt), crypt);
+    if (!(flags & TESTER_MONGOCRYPT_SKIP_INIT)) {
+        ASSERT_OK(mongocrypt_init(crypt), crypt);
+        if (flags & TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB) {
+            if (mongocrypt_crypt_shared_lib_version(crypt) == 0) {
+                BSON_ASSERT(false
+                            && "tester mongocrypt requested WITH_CRYPT_SHARED_LIB, but "
+                               "no crypt_shared library was loaded by mongocrypt_init");
+            }
         }
     }
     return crypt;
@@ -834,14 +920,24 @@ static void _test_setopt_kms_providers(_mongocrypt_tester_t *tester) {
     }
 }
 
+static void test_tmp_bsonf(_mongocrypt_tester_t *tester) {
+    bson_t *one = TMP_BSONF("{'foo' : MC_STR}", "bar");
+    ASSERT_EQUAL_BSON(one, TMP_BSONF("{'foo': 'bar'}"));
+    bson_t *two = TMP_BSONF("{'blah': MC_BSON}", one);
+    ASSERT_EQUAL_BSON(two, TMP_BSONF("{'blah': {'foo': 'bar'}}"));
+}
+
 bool _aes_ctr_is_supported_by_os = true;
 
 int main(int argc, char **argv) {
     _mongocrypt_tester_t tester = {0};
     int i;
 
-    printf("Pass a list of test names to run only specific tests. E.g.:\n");
-    printf("test-mongocrypt _mongocrypt_test_mcgrew\n\n");
+    TEST_PRINTF("Pass a list of patterns to run a subset of tests.\n");
+    TEST_PRINTF("Patterns may be exact matches or include a trailing wildcard (*). Examples:\n");
+    TEST_PRINTF("  test-mongocrypt _mongocrypt_test_mcgrew\n");
+    TEST_PRINTF("  test-mongocrypt 'test_mc_*'\n");
+    TEST_PRINTF("  test-mongocrypt test_mc_named_kms_provider_parse test_mc_named_kms_provider_map\n");
 
     /* Install all tests. */
     _mongocrypt_tester_install_crypto(&tester);
@@ -886,12 +982,14 @@ int main(int argc, char **argv) {
     _mongocrypt_tester_install_efc(&tester);
     _mongocrypt_tester_install_cleanup(&tester);
     _mongocrypt_tester_install_compact(&tester);
+    _mongocrypt_tester_install_fle2_encryption_placeholder(&tester);
     _mongocrypt_tester_install_fle2_payload_uev(&tester);
     _mongocrypt_tester_install_fle2_payload_uev_v2(&tester);
     _mongocrypt_tester_install_fle2_payload_iup(&tester);
     _mongocrypt_tester_install_fle2_payload_iup_v2(&tester);
     _mongocrypt_tester_install_fle2_payload_find_equality_v2(&tester);
     _mongocrypt_tester_install_fle2_payload_find_range_v2(&tester);
+    _mongocrypt_tester_install_fle2_tag_and_encrypted_metadata_block(&tester);
     _mongocrypt_tester_install_range_encoding(&tester);
     _mongocrypt_tester_install_range_edge_generation(&tester);
     _mongocrypt_tester_install_range_mincover(&tester);
@@ -902,6 +1000,11 @@ int main(int argc, char **argv) {
     _mongocrypt_tester_install_mc_writer(&tester);
     _mongocrypt_tester_install_opts(&tester);
     _mongocrypt_tester_install_named_kms_providers(&tester);
+    _mongocrypt_tester_install_mc_cmp(&tester);
+    _mongocrypt_tester_install_text_search_str_encode(&tester);
+    _mongocrypt_tester_install_unicode_fold(&tester);
+    _mongocrypt_tester_install(&tester, "test_tmp_bsonf", test_tmp_bsonf, CRYPTO_OPTIONAL);
+    _mongocrypt_tester_install_mc_schema_broker(&tester);
 
 #ifdef MONGOCRYPT_ENABLE_CRYPTO_COMMON_CRYPTO
     char osversion[32];
@@ -930,32 +1033,39 @@ int main(int argc, char **argv) {
 get_os_version_failed:
 #endif
 
-    printf("Running tests...\n");
+    TEST_PRINTF("Running tests...\n");
     for (i = 0; tester.test_names[i]; i++) {
-        int j;
-        bool found = false;
-
         if (argc > 1) {
-            for (j = 1; j < argc; j++) {
-                found = (0 == strcmp(argv[j], tester.test_names[i]));
-                if (found) {
-                    break;
+            for (int j = 1; j < argc; j++) {
+                char *const pattern = argv[j];
+                const size_t pattern_len = strlen(pattern);
+                const bool match_prefix_only = pattern_len > 0u && pattern[pattern_len - 1u] == '*';
+
+                if (match_prefix_only) {
+                    if (0 == strncmp(pattern, tester.test_names[i], pattern_len - 1u)) {
+                        goto found_match;
+                    }
+                } else {
+                    if (0 == strcmp(pattern, tester.test_names[i])) {
+                        goto found_match;
+                    }
                 }
             }
-            if (!found) {
-                continue;
-            }
+
+            continue; // No match found.
         }
-        printf("  begin %s\n", tester.test_names[i]);
+    found_match : {}
+
+        TEST_PRINTF("  begin %s\n", tester.test_names[i]);
         tester.test_fns[i](&tester);
         /* Clear state. */
         memset(&tester.paths, 0, sizeof(tester.paths));
-        printf("  end %s\n", tester.test_names[i]);
+        TEST_PRINTF("  end %s\n", tester.test_names[i]);
     }
-    printf("... done running tests\n");
+    TEST_PRINTF("... done running tests\n");
 
     if (i == 0) {
-        printf("WARNING - no tests run.\n");
+        TEST_PRINTF("WARNING - no tests run.\n");
     }
 
     /* Clean up tester. */

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

@@ -40,15 +40,18 @@ typedef enum tester_mongocrypt_flags {
     /// crypt_shared library must be present in the same directory as the test
     /// executable.
     TESTER_MONGOCRYPT_WITH_CRYPT_SHARED_LIB = 1 << 0,
-    /// Enable wire protocol version v1
-    TESTER_MONGOCRYPT_WITH_CRYPT_V1 = 1 << 1,
     /// Enable range V2
     TESTER_MONGOCRYPT_WITH_RANGE_V2 = 1 << 2,
+    /// Short cache expiration
+    TESTER_MONGOCRYPT_WITH_SHORT_CACHE = 1 << 3,
+    /// Do not call `mongocrypt_init` yet to allow for further configuration of the resulting `mongocrypt_t`.
+    TESTER_MONGOCRYPT_SKIP_INIT = 1 << 4,
 } tester_mongocrypt_flags;
 
-/* Arbitrary max of 2048 instances of temporary test data. Increase as needed.
+/* Arbitrary max of 2148 instances of temporary test data. Increase as needed.
+ * TODO(MONGOCRYPT-775) increasing further (e.g. 3000+) causes a segfault on Windows test runs. Revise.
  */
-#define TEST_DATA_COUNT 2048
+#define TEST_DATA_COUNT 2148
 
 typedef struct __mongocrypt_tester_t {
     int test_count;
@@ -79,6 +82,10 @@ typedef struct __mongocrypt_tester_t {
     _mongocrypt_buffer_t encrypted_doc;
 } _mongocrypt_tester_t;
 
+// `_mongocrypt_tester_t` inherits extended alignment from libbson. To dynamically allocate, use aligned allocation
+// (e.g. BSON_ALIGNED_ALLOC)
+BSON_STATIC_ASSERT2(alignof__mongocrypt_tester_t, BSON_ALIGNOF(_mongocrypt_tester_t) >= BSON_ALIGNOF(bson_t));
+
 /* Load a .json file as bson */
 void _load_json_as_bson(const char *path, bson_t *out);
 
@@ -174,6 +181,8 @@ void _mongocrypt_tester_install_cleanup(_mongocrypt_tester_t *tester);
 
 void _mongocrypt_tester_install_compact(_mongocrypt_tester_t *tester);
 
+void _mongocrypt_tester_install_fle2_encryption_placeholder(_mongocrypt_tester_t *tester);
+
 void _mongocrypt_tester_install_fle2_payload_uev(_mongocrypt_tester_t *tester);
 
 void _mongocrypt_tester_install_fle2_payload_uev_v2(_mongocrypt_tester_t *tester);
@@ -186,6 +195,8 @@ void _mongocrypt_tester_install_fle2_payload_find_equality_v2(_mongocrypt_tester
 
 void _mongocrypt_tester_install_fle2_payload_find_range_v2(_mongocrypt_tester_t *tester);
 
+void _mongocrypt_tester_install_fle2_tag_and_encrypted_metadata_block(_mongocrypt_tester_t *tester);
+
 void _mongocrypt_tester_install_gcp_auth(_mongocrypt_tester_t *tester);
 
 void _mongocrypt_tester_install_range_encoding(_mongocrypt_tester_t *tester);
@@ -206,12 +217,34 @@ void _mongocrypt_tester_install_opts(_mongocrypt_tester_t *tester);
 
 void _mongocrypt_tester_install_named_kms_providers(_mongocrypt_tester_t *tester);
 
+void _mongocrypt_tester_install_mc_cmp(_mongocrypt_tester_t *tester);
+
+void _mongocrypt_tester_install_text_search_str_encode(_mongocrypt_tester_t *tester);
+
+void _mongocrypt_tester_install_unicode_fold(_mongocrypt_tester_t *tester);
+
+void _mongocrypt_tester_install_mc_schema_broker(_mongocrypt_tester_t *tester);
+
 /* Conveniences for getting test data. */
 
 /* Get a temporary bson_t from a JSON string. Do not free it. */
 bson_t *_mongocrypt_tester_bson_from_json(_mongocrypt_tester_t *tester, const char *json, ...);
 #define TMP_BSON(...) _mongocrypt_tester_bson_from_json(tester, __VA_ARGS__)
 
+// TMP_BSONF builds a temporary bson_t from an extended JSON string. Do not free it.
+// Useful with BSON_STR to write JSON in-place.
+// Supports tokens MC_BSON and MC_STR.
+//
+// Examples:
+// bson_t *b = TMP_BSONF(BSON_STR({"foo": MC_STR}), "bar"); // { "foo" : "bar" }
+// bson_t *b2 = TMP_BSONF(BSON_STR({"buzz": MC_BSON }), b); // { "buzz": { "foo": "bar" }}
+bson_t *tmp_bsonf(_mongocrypt_tester_t *tester, const char *fmt, ...);
+#define TMP_BSONF(...) tmp_bsonf(tester, __VA_ARGS__)
+
+/* Get a temporary bson_t from a JSON file. Do not free it. */
+bson_t *_mongocrypt_tester_file_as_bson(_mongocrypt_tester_t *tester, const char *path);
+#define TEST_FILE_AS_BSON(path) _mongocrypt_tester_file_as_bson(tester, path)
+
 /* Get a temporary binary from a JSON string. Do not free it. */
 mongocrypt_binary_t *_mongocrypt_tester_bin_from_json(_mongocrypt_tester_t *tester, const char *json, ...);
 #define TEST_BSON(...) _mongocrypt_tester_bin_from_json(tester, __VA_ARGS__)
@@ -237,4 +270,6 @@ void _test_ctx_wrap_and_feed_key(mongocrypt_ctx_t *ctx,
                                  _mongocrypt_buffer_t *key,
                                  mongocrypt_status_t *status);
 
+void _usleep(int64_t usec);
+
 #endif

data/ext/libmongocrypt/libmongocrypt/test/test-unicode-fold.c

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mongocrypt-status-private.h"
+#include "test-mongocrypt-assert.h"
+#include "test-mongocrypt.h"
+#include "unicode/fold.h"
+
+#define TEST_UNICODE_FOLD(expected, expected_len, input, input_len, options)                                           \
+    do {                                                                                                               \
+        char *_buf;                                                                                                    \
+        size_t _len;                                                                                                   \
+        ASSERT_OR_PRINT(unicode_fold(input, input_len, options, &_buf, &_len, status), status);                        \
+        TEST_PRINTF("Testing: input=%.*s, expected=%.*s, output=%.*s\n",                                               \
+                    (int)input_len,                                                                                    \
+                    input,                                                                                             \
+                    (int)expected_len,                                                                                 \
+                    expected,                                                                                          \
+                    (int)_len,                                                                                         \
+                    _buf);                                                                                             \
+        ASSERT_CMPSIZE_T(_len, ==, expected_len);                                                                      \
+        ASSERT_CMPBYTES((uint8_t *)_buf, _len, (uint8_t *)expected, expected_len);                                     \
+        ASSERT_CMPUINT8((uint8_t)(_buf[_len]), ==, 0);                                                                 \
+        bson_free(_buf);                                                                                               \
+    } while (0)
+
+#define TEST_UNICODE_FOLD_ALL_CASES(input, case_folded, dia_folded, both_folded)                                       \
+    do {                                                                                                               \
+        size_t _input_len = strlen(input);                                                                             \
+        size_t _cf_len = strlen(case_folded);                                                                          \
+        size_t _df_len = strlen(dia_folded);                                                                           \
+        size_t _both_len = strlen(both_folded);                                                                        \
+        TEST_UNICODE_FOLD(case_folded, _cf_len, input, _input_len, kUnicodeFoldToLower);                               \
+        TEST_UNICODE_FOLD(dia_folded, _df_len, input, _input_len, kUnicodeFoldRemoveDiacritics);                       \
+        TEST_UNICODE_FOLD(both_folded,                                                                                 \
+                          _both_len,                                                                                   \
+                          input,                                                                                       \
+                          _input_len,                                                                                  \
+                          kUnicodeFoldToLower | kUnicodeFoldRemoveDiacritics);                                         \
+    } while (0)
+
+static void test_unicode_fold(_mongocrypt_tester_t *tester) {
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    // Test all ascii chars.
+    char *buf1 = bson_malloc0(2);
+    char *buf2 = bson_malloc0(2);
+    for (unsigned char ch = 0; ch <= 0x7f; ch++) {
+        buf1[0] = ch;
+        if (ch >= 'A' && ch <= 'Z') {
+            // Caps
+            buf2[0] = ch + 0x20;
+            TEST_UNICODE_FOLD_ALL_CASES(buf1, buf2, buf1, buf2);
+        } else if (ch == '^' || ch == '`') {
+            // Diacritics
+            TEST_UNICODE_FOLD_ALL_CASES(buf1, buf1, "", "");
+        } else {
+            // Characters with no transformations
+            TEST_UNICODE_FOLD_ALL_CASES(buf1, buf1, buf1, buf1);
+        }
+    }
+    bson_free(buf1);
+    bson_free(buf2);
+    TEST_UNICODE_FOLD_ALL_CASES("abc", "abc", "abc", "abc");
+    // Tests of composed unicode
+    TEST_UNICODE_FOLD_ALL_CASES("¿CUÁNTOS AÑOS tienes Tú?",
+                                "¿cuántos años tienes tú?",
+                                "¿CUANTOS ANOS tienes Tu?",
+                                "¿cuantos anos tienes tu?");
+    TEST_UNICODE_FOLD_ALL_CASES("СКОЛЬКО ТЕБЕ ЛЕТ?", "сколько тебе лет?", "СКОЛЬКО ТЕБЕ ЛЕТ?", "сколько тебе лет?");
+    TEST_UNICODE_FOLD_ALL_CASES("Πόσο χρονών είσαι?", "πόσο χρονών είσαι?", "Ποσο χρονων εισαι?", "ποσο χρονων εισαι?");
+    // Tests of decomposed unicode
+    TEST_UNICODE_FOLD_ALL_CASES("Cafe\xcc\x81", "cafe\xcc\x81", "Cafe", "cafe");
+    TEST_UNICODE_FOLD_ALL_CASES("CafE\xcc\x81", "cafe\xcc\x81", "CafE", "cafe");
+    // Test string with null bytes
+    TEST_UNICODE_FOLD("fo\0bar", 6, "fo\0bar", 6, kUnicodeFoldToLower | kUnicodeFoldRemoveDiacritics);
+    // Test strings with folded representations longer in bytes than the input
+    TEST_UNICODE_FOLD("\xe2\xb1\xa6", 3, "\xc8\xbe", 2, kUnicodeFoldToLower);
+    TEST_UNICODE_FOLD("\xf0\xa4\x8b\xae", 4, "\xef\xa9\xac", 3, kUnicodeFoldRemoveDiacritics);
+    mongocrypt_status_destroy(status);
+}
+
+void _mongocrypt_tester_install_unicode_fold(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(test_unicode_fold);
+}

data/lib/libmongocrypt_helper/version.rb

@@ -1,5 +1,5 @@
 module LibmongocryptHelper
-  VERSION = '1.11.0.0.1001'
+  VERSION = '1.13.2.0.1001'
 
-  LIBMONGOCRYPT_VERSION = '1.11.0'
+  LIBMONGOCRYPT_VERSION = '1.13.2'
 end