libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

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

@@ -0,0 +1,101 @@
+/*
+ * 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,                                                                                  \
+                          (unicode_fold_options_t)(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,
+                      (unicode_fold_options_t)(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/ext/libmongocrypt/libmongocrypt/test/util/HELP.autogen

@@ -101,4 +101,4 @@
 "csfle auto_decrypt --document '{ 'insert' : 'coll', 'documents' : [ { 'ssn' : { '$binary' : { 'base64': 'ARG+PK8ud0RZlDIzKwQmFoMCOuSIPyrfYleSqMZRXgaPCQOAurv0LTLNL6Tn/G7TuVOyf/Qv3j6VxSxCQEeu/yO7vv/UDE5niDE0itjOqjmf5Q==', 'subType' : '06' } } } ] }'\n"
 "\n"
 "csfle explicit_encrypt --key_id 'Eb48ry53RFmUMjMrBCYWgw==' --value '{'v': 'test'}' --algorithm 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic'\n"
-"```\n"
+"```\n"

data/ext/libmongocrypt/libmongocrypt/test/util/csfle.c

@@ -23,7 +23,7 @@
 
 #include "util.h"
 
-const char *help_text = ""
+static const char *help_text = ""
 #include "HELP.autogen"
     ;
 

data/ext/libmongocrypt/libmongocrypt/test/util/util.c

@@ -50,7 +50,7 @@ void _errexit_ctx(mongocrypt_ctx_t *ctx, int line) {
 }
 
 void _errexit_bson(bson_error_t *error, int line) {
-    MONGOC_ERROR("Error at line %d with code %d and msg: %s", line, error->code, error->message);
+    MONGOC_ERROR("Error at line %d with code %" PRIu32 " and msg: %s", line, error->code, error->message);
     exit(1);
 }
 
@@ -111,7 +111,7 @@ static void _status_to_error(mongocrypt_status_t *status, bson_error_t *error) {
  * Returns true if ok, and does not modify @error.
  * Returns false if error, and sets @error.
  */
-bool _test_ctx_check_error(mongocrypt_ctx_t *ctx, bson_error_t *error, bool error_expected) {
+static bool _test_ctx_check_error(mongocrypt_ctx_t *ctx, bson_error_t *error, bool error_expected) {
     mongocrypt_status_t *status;
 
     status = mongocrypt_status_new();
@@ -131,7 +131,7 @@ bool _test_ctx_check_error(mongocrypt_ctx_t *ctx, bson_error_t *error, bool erro
     return true;
 }
 
-bool _test_kms_ctx_check_error(mongocrypt_kms_ctx_t *kms_ctx, bson_error_t *error, bool error_expected) {
+static bool _test_kms_ctx_check_error(mongocrypt_kms_ctx_t *kms_ctx, bson_error_t *error, bool error_expected) {
     mongocrypt_status_t *status;
 
     status = mongocrypt_status_new();
@@ -659,7 +659,7 @@ fail:
     return ret;
 }
 
-const char *_state_string(mongocrypt_ctx_state_t state) {
+static const char *_state_string(mongocrypt_ctx_state_t state) {
     switch (state) {
     case MONGOCRYPT_CTX_ERROR: return "MONGOCRYPT_CTX_ERROR";
     case MONGOCRYPT_CTX_NEED_MONGO_COLLINFO_WITH_DB: return "MONGOCRYPT_CTX_NEED_MONGO_COLLINFO_WITH_DB";
@@ -732,7 +732,7 @@ bool _csfle_state_machine_run(_state_machine_t *state_machine, bson_t *result, b
                 goto fail;
             }
             break;
-        case MONGOCRYPT_CTX_DONE: goto success; break;
+        case MONGOCRYPT_CTX_DONE: goto success;
         }
     }
 

data/ext/libmongocrypt/libmongocrypt/test/util/util.h

@@ -20,19 +20,20 @@
 #include <mongoc/mongoc.h>
 
 void _errexit_mongocrypt(mongocrypt_t *crypt, int line);
-#define ERREXIT_MONGOCRYPT(crypt) _errexit_mongocrypt(crypt, __LINE__);
+#define ERREXIT_MONGOCRYPT(crypt) _errexit_mongocrypt(crypt, __LINE__)
 
 void _errexit_ctx(mongocrypt_ctx_t *ctx, int line);
-#define ERREXIT_CTX(ctx) _errexit_ctx(ctx, __LINE__);
+#define ERREXIT_CTX(ctx) _errexit_ctx(ctx, __LINE__)
 
 void _errexit_bson(bson_error_t *error, int line);
-#define ERREXIT_BSON(err) _errexit_bson(err, __LINE__);
+#define ERREXIT_BSON(err) _errexit_bson(err, __LINE__)
 
 #define ERREXIT(...)                                                                                                   \
-    do {                                                                                                               \
+    if (1) {                                                                                                           \
         MONGOC_ERROR(__VA_ARGS__);                                                                                     \
         abort();                                                                                                       \
-    } while (0)
+    } else                                                                                                             \
+        ((void)0)
 
 void _log_to_stdout(mongocrypt_log_level_t level, const char *message, uint32_t message_len, void *ctx);
 
@@ -71,4 +72,4 @@ bson_t *bson_get_json(bson_t *bson, const char *key);
 
 bson_t *bson_req_json(bson_t *bson, const char *key);
 
-bool bson_get_bool(bson_t *bson, const char *key, bool default_value);
+bool bson_get_bool(bson_t *bson, const char *key, bool default_value);

data/lib/libmongocrypt_helper/version.rb

@@ -1,5 +1,5 @@
 module LibmongocryptHelper
-  VERSION = '1.12.0.0.1001'
+  VERSION = '1.14.0.0.1001'
 
-  LIBMONGOCRYPT_VERSION = '1.12.0'
+  LIBMONGOCRYPT_VERSION = '1.14.0'
 end