libmongocrypt-helper 1.13.2.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/test/test-mc-range-encoding.c

@@ -198,59 +198,67 @@ static void _test_RangeTest_Encode_Int64(_mongocrypt_tester_t *tester) {
 
 static void _test_canUsePrecisionModeDouble(_mongocrypt_tester_t *tester) {
 #define CAN_USE_PRECISION_MODE(lb, ub, prc, expected, expected_bits_out)                                               \
-    {                                                                                                                  \
+    if (1) {                                                                                                           \
         uint32_t bits_out = 0;                                                                                         \
         mongocrypt_status_t *const status = mongocrypt_status_new();                                                   \
-        TEST_PRINTF("_test_canUsePrecisionModeDecimal, min: %f, max: %f, prc: %" PRIu32, lb, ub, prc);                 \
+        TEST_PRINTF("_test_canUsePrecisionModeDecimal, min: %f, max: %f, prc: %" PRId32, lb, ub, prc);                 \
         bool result = mc_canUsePrecisionModeDouble(lb, ub, prc, &bits_out, status);                                    \
         ASSERT_OK_STATUS(mongocrypt_status_ok(status), status);                                                        \
         ASSERT(result == expected);                                                                                    \
         ASSERT_CMPINT32(expected_bits_out, ==, bits_out);                                                              \
         mongocrypt_status_destroy(status);                                                                             \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
 #define CAN_USE_PRECISION_MODE_ERRORS(lb, ub, prc, error)                                                              \
-    {                                                                                                                  \
+    if (1) {                                                                                                           \
         mongocrypt_status_t *const status = mongocrypt_status_new();                                                   \
-        TEST_PRINTF("_test_canUsePrecisionModeDecimal errors, min: %f, max: %f, prc: %" PRIu32, lb, ub, prc);          \
+        TEST_PRINTF("_test_canUsePrecisionModeDecimal errors, min: %f, max: %f, prc: %" PRId32, lb, ub, prc);          \
         uint32_t bits_out = 0;                                                                                         \
         bool result = mc_canUsePrecisionModeDouble(lb, ub, prc, &bits_out, status);                                    \
         ASSERT_OR_PRINT_MSG(!result, "expected error, but got none");                                                  \
         ASSERT_STATUS_CONTAINS(status, error);                                                                         \
         mongocrypt_status_destroy(status);                                                                             \
-    }
+    } else                                                                                                             \
+        ((void)0)
 
-    CAN_USE_PRECISION_MODE(1.0, 16.0, 0, true, 4);
-    CAN_USE_PRECISION_MODE(0.0, 16.0, 0, true, 5);
+    CAN_USE_PRECISION_MODE(1.0, 16.0, INT32_C(0), true, 4);
+    CAN_USE_PRECISION_MODE(0.0, 16.0, INT32_C(0), true, 5);
     // 2^53 + 1 is where double starts to lose precision, so we need to ensure that we get the
     // correct value for max_bits out.
-    CAN_USE_PRECISION_MODE_ERRORS(1.0, 9007199254740992.0, 0, "Invalid upper bound for double precision. Absolute");
-    CAN_USE_PRECISION_MODE_ERRORS(0.0, 9007199254740992.0, 0, "Invalid upper bound for double precision. Absolute");
+    CAN_USE_PRECISION_MODE_ERRORS(1.0,
+                                  9007199254740992.0,
+                                  INT32_C(0),
+                                  "Invalid upper bound for double precision. Absolute");
+    CAN_USE_PRECISION_MODE_ERRORS(0.0,
+                                  9007199254740992.0,
+                                  INT32_C(0),
+                                  "Invalid upper bound for double precision. Absolute");
 
     CAN_USE_PRECISION_MODE(2.718281, 314.159265, 6, true, 29);
 
     CAN_USE_PRECISION_MODE_ERRORS(-1000000000.0,
                                   9223372036844775424.0,
-                                  0,
+                                  INT32_C(0),
                                   "Invalid upper bound for double precision. Absolute");
 
     CAN_USE_PRECISION_MODE_ERRORS(2.710000,
                                   314.150000,
-                                  2,
+                                  INT32_C(2),
                                   "Invalid upper bound for double precision. Fractional digits");
     CAN_USE_PRECISION_MODE_ERRORS(314.150000, 350.0, 2, "Invalid lower bound for double precision. Fractional digits");
 
     CAN_USE_PRECISION_MODE_ERRORS((double)9007199254740992,
                                   INT_64_MAX_DOUBLE,
-                                  0,
+                                  INT32_C(0),
                                   "Invalid upper bound for double precision. Absolute scaled value");
     CAN_USE_PRECISION_MODE_ERRORS(-1 * INT_64_MAX_DOUBLE,
                                   1.0,
-                                  0,
+                                  INT32_C(0),
                                   "Invalid lower bound for double precision. Absolute scaled value");
     CAN_USE_PRECISION_MODE_ERRORS(-92233720368547.0,
                                   92233720368547.0,
-                                  5,
+                                  INT32_C(5),
                                   "Invalid upper bound for double precision. Absolute");
 
 #undef CAN_USE_PRECISION_MODE
@@ -552,7 +560,7 @@ static void _test_RangeTest_Encode_Double(_mongocrypt_tester_t *tester) {
 
         if (test->min.set && test->max.set && test->precision.set) {
             TEST_PRINTF("_test_RangeTest_Encode_Double: value=%f, min=%f, max=%f, "
-                        "precision=%" PRIu32 "\n",
+                        "precision=%" PRId32 "\n",
                         test->value,
                         test->min.value,
                         test->max.value,
@@ -561,15 +569,13 @@ static void _test_RangeTest_Encode_Double(_mongocrypt_tester_t *tester) {
             TEST_PRINTF("_test_RangeTest_Encode_Double: value=%f\n", test->value);
         }
 
-        const bool use_range_v2 = !test->use_range_v1;
         mc_OSTType_Double got;
         const bool ok = mc_getTypeInfoDouble((mc_getTypeInfoDouble_args_t){.value = test->value,
                                                                            .min = test->min,
                                                                            .max = test->max,
                                                                            .precision = test->precision},
                                              &got,
-                                             status,
-                                             use_range_v2);
+                                             status);
         if (test->expectError) {
             ASSERT_OR_PRINT_MSG(!ok, "expected error, but got none");
             ASSERT_STATUS_CONTAINS(status, test->expectError);
@@ -583,7 +589,7 @@ static void _test_RangeTest_Encode_Double(_mongocrypt_tester_t *tester) {
     }
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 typedef struct {
     mc_dec128 value;
     mc_optional_dec128_t min;
@@ -903,15 +909,7 @@ static void _test_RangeTest_Encode_Decimal128(_mongocrypt_tester_t *tester) {
     }
 
 #define ASSERT_EIBB_ERROR(Val, Max, Min, Precision, Expect, Error)                                                     \
-    (Decimal128Test){                                                                                                  \
-        .value = mc_dec128_from_string(#Val),                                                                          \
-        .min = OPT_MC_DEC128(mc_dec128_from_string(#Min)),                                                             \
-        .max = OPT_MC_DEC128(mc_dec128_from_string(#Max)),                                                             \
-        .precision = OPT_I32(Precision),                                                                               \
-        .expect = Expect,                                                                                              \
-        .use_range_v1 = true,                                                                                          \
-    },                                                                                                                 \
-        (Decimal128Test) {                                                                                             \
+    (Decimal128Test) {                                                                                                 \
         .value = mc_dec128_from_string(#Val), .min = OPT_MC_DEC128(mc_dec128_from_string(#Min)),                       \
         .max = OPT_MC_DEC128(mc_dec128_from_string(#Max)), .precision = OPT_I32(Precision), .expectError = Error       \
     }
@@ -996,7 +994,6 @@ static void _test_RangeTest_Encode_Decimal128(_mongocrypt_tester_t *tester) {
             TEST_PRINTF("_test_RangeTest_Encode_Decimal128: value=%s\n", mc_dec128_to_string(test->value).str);
         }
         mc_OSTType_Decimal128 got;
-        const bool use_range_v2 = !test->use_range_v1;
         const bool ok = mc_getTypeInfoDecimal128(
             (mc_getTypeInfoDecimal128_args_t){
                 .value = test->value,
@@ -1005,8 +1002,7 @@ static void _test_RangeTest_Encode_Decimal128(_mongocrypt_tester_t *tester) {
                 .precision = test->precision,
             },
             &got,
-            status,
-            use_range_v2);
+            status);
         if (test->expectError) {
             ASSERT_OR_PRINT_MSG(!ok, "expected error, but got none");
             ASSERT_STATUS_CONTAINS(status, test->expectError);
@@ -1027,7 +1023,7 @@ void _mongocrypt_tester_install_range_encoding(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_RangeTest_Encode_Int64);
     INSTALL_TEST(_test_canUsePrecisionModeDouble);
     INSTALL_TEST(_test_RangeTest_Encode_Double);
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
     INSTALL_TEST(_test_canUsePrecisionModeDecimal);
     INSTALL_TEST(_test_RangeTest_Encode_Decimal128);
 #endif

data/ext/libmongocrypt/libmongocrypt/test/test-mc-range-mincover.c

@@ -68,7 +68,7 @@ typedef struct {
     const char *expectError;
 } DoubleTest;
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 typedef struct {
     mc_dec128 lowerBound;
     bool includeLowerBound;
@@ -95,7 +95,6 @@ static mc_mincover_t *_test_getMincover32(void *tests, size_t idx, mongocrypt_st
 
     Int32Test *test = (Int32Test *)tests + idx;
 
-    const bool use_range_v2 = true;
     return mc_getMincoverInt32((mc_getMincoverInt32_args_t){.lowerBound = test->lowerBound,
                                                             .includeLowerBound = test->includeLowerBound,
                                                             .upperBound = test->upperBound,
@@ -104,14 +103,12 @@ static mc_mincover_t *_test_getMincover32(void *tests, size_t idx, mongocrypt_st
                                                             .max = test->max,
                                                             .sparsity = test->sparsity,
                                                             .trimFactor = OPT_I32(test->trimFactor)},
-                               status,
-                               use_range_v2);
+                               status);
 }
 
 static mc_mincover_t *_test_getMincover64(void *tests, size_t idx, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(tests);
 
-    const bool use_range_v2 = true;
     const uint32_t trimFactor = 0; // At present, all test cases expect trimFactor=0.
     Int64Test *const test = (Int64Test *)tests + idx;
 
@@ -123,14 +120,12 @@ static mc_mincover_t *_test_getMincover64(void *tests, size_t idx, mongocrypt_st
                                                             .max = test->max,
                                                             .sparsity = test->sparsity,
                                                             .trimFactor = OPT_I32(trimFactor)},
-                               status,
-                               use_range_v2);
+                               status);
 }
 
 static mc_mincover_t *_test_getMincoverDouble_helper(void *tests, size_t idx, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(tests);
 
-    const bool use_range_v2 = true;
     const uint32_t trimFactor = 0; // At present, all test cases expect trimFactor=0.
     DoubleTest *const test = (DoubleTest *)tests + idx;
 
@@ -144,17 +139,15 @@ static mc_mincover_t *_test_getMincoverDouble_helper(void *tests, size_t idx, mo
                                       .max = test->precision.set ? test->max : (mc_optional_double_t){0},
                                       .precision = test->precision,
                                       .trimFactor = OPT_I32(trimFactor)},
-        status,
-        use_range_v2);
+        status);
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 static mc_mincover_t *_test_getMincoverDecimal128_helper(void *tests, size_t idx, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(tests);
 
     Decimal128Test *const test = (Decimal128Test *)tests + idx;
 
-    const bool use_range_v2 = true;
     const uint32_t trimFactor = 0; // At present, all test cases expect trimFactor=0.
     return mc_getMincoverDecimal128(
         (mc_getMincoverDecimal128_args_t){.lowerBound = test->lowerBound,
@@ -166,8 +159,7 @@ static mc_mincover_t *_test_getMincoverDecimal128_helper(void *tests, size_t idx
                                           .max = test->precision.set ? test->max : (mc_optional_dec128_t){0},
                                           .precision = test->precision,
                                           .trimFactor = OPT_I32(trimFactor)},
-        status,
-        use_range_v2);
+        status);
 }
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
@@ -202,7 +194,7 @@ static const char *_test_expectErrorDouble(void *tests, size_t idx, mongocrypt_s
     return test->expectError;
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 static const char *_test_expectErrorDecimal128(void *tests, size_t idx, mongocrypt_status_t *status) {
     BSON_ASSERT_PARAM(tests);
     BSON_ASSERT_PARAM(status);
@@ -238,7 +230,7 @@ static const char *const *_test_expectMincoverDouble(void *tests, size_t idx) {
     return ((DoubleTest *)tests + idx)->expectMincoverStrings;
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 static const char *const *_test_expectMincoverDecimal128(void *tests, size_t idx) {
     BSON_ASSERT_PARAM(tests);
     return ((Decimal128Test *)tests + idx)->expectMincoverStrings;
@@ -314,7 +306,7 @@ static void _test_dump_Double(void *tests, size_t idx, mc_mincover_t *got) {
         TEST_STDERR_PRINTF(" max=%f", test->max.value);
     }
     if (test->precision.set) {
-        TEST_STDERR_PRINTF(" precision=%" PRIu32, test->precision.value);
+        TEST_STDERR_PRINTF(" precision=%" PRId32, test->precision.value);
     }
     TEST_STDERR_PRINTF(" sparsity=%zu\n", test->sparsity);
     TEST_STDERR_PRINTF("mincover expected ... begin\n");
@@ -329,7 +321,7 @@ static void _test_dump_Double(void *tests, size_t idx, mc_mincover_t *got) {
     TEST_STDERR_PRINTF("mincover got ... end\n");
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 static void _test_dump_Decimal128(void *tests, size_t idx, mc_mincover_t *got) {
     BSON_ASSERT_PARAM(tests);
     Decimal128Test *const test = (Decimal128Test *)tests + idx;
@@ -594,7 +586,7 @@ static void _test_getMincoverDouble(_mongocrypt_tester_t *tester) {
                                                     .dump = _test_dump_Double});
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 static void _test_getMincoverDecimal128(_mongocrypt_tester_t *tester) {
     Decimal128Test tests[] = {
 #include "./data/range-min-cover/mincover_decimal128.cstruct"
@@ -614,7 +606,7 @@ void _mongocrypt_tester_install_range_mincover(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_getMincoverInt32);
     INSTALL_TEST(_test_getMincoverInt64);
     INSTALL_TEST(_test_getMincoverDouble);
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
     INSTALL_TEST(_test_getMincoverDecimal128);
 #endif
 }

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

@@ -30,7 +30,6 @@ static void test_mc_RangeOpts_parse(_mongocrypt_tester_t *tester) {
         int64_t expectSparsity;
         mc_optional_uint32_t expectPrecision;
         mc_optional_int32_t expectTrimFactor;
-        bool useRangeV2;
     } testcase;
 
     testcase tests[] = {
@@ -62,24 +61,17 @@ static void test_mc_RangeOpts_parse(_mongocrypt_tester_t *tester) {
         {.desc = "Requires precision for double when only min is set",
          .in = RAW_STRING({"min" : 0.0, "sparsity" : {"$numberLong" : "1"}}),
          .expectError = "expected 'precision'"},
-        // Once `use_range_v2` is default true, this test may be removed.
-        {.desc = "Fails when trim factor is set but Range V2 is disabled",
-         .in = RAW_STRING({"trimFactor" : 1, "sparsity" : {"$numberLong" : "1"}}),
-         .expectError = "'trimFactor' is not supported for QE range v1"},
         {.desc = "Works when trim factor is set and Range V2 is enabled",
          .in = RAW_STRING({"trimFactor" : 1, "sparsity" : {"$numberLong" : "1"}}),
-         .useRangeV2 = true,
          .expectSparsity = 1,
          .expectTrimFactor = OPT_I32(1)},
         {.desc = "Does not require sparsity",
          .in = RAW_STRING({"min" : 123, "max" : 456}),
-         .useRangeV2 = true,
          .expectSparsity = mc_FLERangeSparsityDefault,
          .expectMin = OPT_I32_C(123),
          .expectMax = OPT_I32_C(456)},
         {.desc = "Errors on negative trim factor",
          .in = RAW_STRING({"trimFactor" : -1, "sparsity" : {"$numberLong" : "1"}}),
-         .useRangeV2 = true,
          .expectError = "'trimFactor' must be non-negative"},
     };
 
@@ -88,7 +80,7 @@ static void test_mc_RangeOpts_parse(_mongocrypt_tester_t *tester) {
         mongocrypt_status_t *status = mongocrypt_status_new();
         mc_RangeOpts_t ro;
         TEST_PRINTF("running test_mc_RangeOpts_parse subtest: %s\n", test->desc);
-        bool ret = mc_RangeOpts_parse(&ro, TMP_BSON(test->in), test->useRangeV2, status);
+        bool ret = mc_RangeOpts_parse(&ro, TMP_BSON_STR(test->in), status);
         if (!test->expectError) {
             ASSERT_OK_STATUS(ret, status);
             ASSERT_CMPINT(test->expectMin.set, ==, ro.min.set);
@@ -119,8 +111,6 @@ static void test_mc_RangeOpts_to_FLE2RangeInsertSpec(_mongocrypt_tester_t *teste
         const char *v;
         const char *expectError;
         const char *expect;
-        // Most of the tests are for trim factor, so range V2 is default enabled.
-        bool disableRangeV2;
     } testcase;
 
     testcase tests[] = {
@@ -128,11 +118,6 @@ static void test_mc_RangeOpts_to_FLE2RangeInsertSpec(_mongocrypt_tester_t *teste
          .in = RAW_STRING({"min" : 123, "max" : 456, "sparsity" : {"$numberLong" : "1"}}),
          .v = RAW_STRING({"v" : 789}),
          .expect = RAW_STRING({"v" : {"v" : 789, "min" : 123, "max" : 456}})},
-        {.desc = "Trim factor not appended if range V2 disabled",
-         .in = RAW_STRING({"min" : 123, "max" : 456, "sparsity" : {"$numberLong" : "1"}}),
-         .v = RAW_STRING({"v" : 789}),
-         .disableRangeV2 = true,
-         .expect = RAW_STRING({"v" : {"v" : 789, "min" : 123, "max" : 456}})},
         {.desc = "Works with precision",
          .in = RAW_STRING({"min" : 123.0, "max" : 456.0, "precision" : 2, "sparsity" : {"$numberLong" : "1"}}),
          .v = RAW_STRING({"v" : 789.0}),
@@ -260,7 +245,7 @@ static void test_mc_RangeOpts_to_FLE2RangeInsertSpec(_mongocrypt_tester_t *teste
          .expectError = "Trim factor (64) must be less than the total number of bits (64) used to represent any "
                         "element in the domain."},
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
         {.desc = "tf bound check passes correctly for decimal with min, max, precision set (tf = 9, 2^9 < domain size "
                  "< 2^10)",
          .in = RAW_STRING({
@@ -317,12 +302,12 @@ static void test_mc_RangeOpts_to_FLE2RangeInsertSpec(_mongocrypt_tester_t *teste
         mongocrypt_status_t *status = mongocrypt_status_new();
         mc_RangeOpts_t ro;
         TEST_PRINTF("running test_mc_RangeOpts_to_FLE2RangeInsertSpec subtest: %s\n", test->desc);
-        ASSERT_OK_STATUS(mc_RangeOpts_parse(&ro, TMP_BSON(test->in), !test->disableRangeV2, status), status);
+        ASSERT_OK_STATUS(mc_RangeOpts_parse(&ro, TMP_BSON_STR(test->in), status), status);
         bson_t out = BSON_INITIALIZER;
-        bool ret = mc_RangeOpts_to_FLE2RangeInsertSpec(&ro, TMP_BSON(test->v), &out, !test->disableRangeV2, status);
+        bool ret = mc_RangeOpts_to_FLE2RangeInsertSpec(&ro, TMP_BSON_STR(test->v), &out, status);
         if (!test->expectError) {
             ASSERT_OK_STATUS(ret, status);
-            ASSERT_EQUAL_BSON(TMP_BSON(test->expect), &out);
+            ASSERT_EQUAL_BSON(TMP_BSON_STR(test->expect), &out);
         } else {
             ASSERT_FAILS_STATUS(ret, status, test->expectError);
         }

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

@@ -26,7 +26,7 @@ static void _test_mc_reader(_mongocrypt_tester_t *tester) {
     status = mongocrypt_status_new();
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, &input_buf, __func__);
 
     uint8_t value;
     ASSERT_OK_STATUS(mc_reader_read_u8(&reader, &value, status), status);
@@ -57,7 +57,7 @@ static void _test_mc_reader_uuid(_mongocrypt_tester_t *tester) {
     status = mongocrypt_status_new();
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, &input_buf, __func__);
 
     _mongocrypt_buffer_t value;
     ASSERT_OK_STATUS(mc_reader_read_uuid_buffer(&reader, &value, status), status);
@@ -93,7 +93,7 @@ static void _test_mc_reader_prfblock(_mongocrypt_tester_t *tester) {
     status = mongocrypt_status_new();
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, &input_buf, __func__);
 
     _mongocrypt_buffer_t value;
     ASSERT_OK_STATUS(mc_reader_read_prfblock_buffer(&reader, &value, status), status);
@@ -117,7 +117,7 @@ static void _test_mc_reader_ints(_mongocrypt_tester_t *tester) {
     status = mongocrypt_status_new();
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, &input_buf, __func__);
 
     uint32_t u32;
     ASSERT_OK_STATUS(mc_reader_read_u32(&reader, &u32, status), status);
@@ -143,7 +143,7 @@ static void _test_mc_reader_bytes(_mongocrypt_tester_t *tester) {
     status = mongocrypt_status_new();
 
     mc_reader_t reader;
-    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
+    mc_reader_init_from_buffer(&reader, &input_buf, __func__);
 
     const uint8_t *ptr;
     const uint64_t len = 4;

data/ext/libmongocrypt/libmongocrypt/test/test-mc-text-search-str-encode.c

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "mongocrypt.h"
 #include "test-mongocrypt-assert.h"
 #include "test-mongocrypt.h"
 
@@ -138,7 +139,7 @@ static void test_nofold_suffix_prefix_case(_mongocrypt_tester_t *tester,
                 ASSERT_CMPPTR((uint8_t *)affix, ==, sets->base_string->buf.data + start_offset);
                 ASSERT_CMPUINT32(affix_len,
                                  ==,
-                                 sets->base_string->codepoint_offsets[folded_codepoint_len] - start_offset)
+                                 sets->base_string->codepoint_offsets[folded_codepoint_len] - start_offset);
             } else {
                 uint32_t end_offset = sets->base_string->codepoint_offsets[lb + idx];
                 ASSERT_CMPPTR((uint8_t *)affix, ==, sets->base_string->buf.data);
@@ -360,21 +361,21 @@ static void test_nofold_substring_case_multiple_mlen(_mongocrypt_tester_t *teste
     test_nofold_substring_case(tester, str, lb, ub, byte_len + 64, casef, diacf, foldable_codepoints);
 }
 
-const char *normal_ascii_strings[] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f",
-                                      "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v",
-                                      "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
-                                      "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
-const char *ascii_diacritics[] = {"^", "`"};
-const char *normal_unicode_strings[] = {"ぁ", "あ", "ぃ", "い", "ぅ", "う", "ぇ", "え", "ぉ", "お", "か", "が",
-                                        "き", "ぎ", "く", "け", "Ѐ",  "Ё",  "Ђ",  "Ѓ",  "Є",  "Ѕ",  "І",  "Ї",
-                                        "Ј",  "Љ",  "Њ",  "Ћ",  "Ќ",  "Ѝ",  "Ў",  "Џ",  "𓀀",  "𓀁",  "𓀂",  "𓀃",
-                                        "𓀄",  "𓀅",  "𓀆",  "𓀇",  "𓀈",  "𓀉",  "𓀊",  "𓀋",  "𓀌",  "𓀍",  "𓀎",  "𓀏"};
-const char *unicode_diacritics[] = {"̀", "́", "̂", "̃", "̄", "̅",  "̆",  "̇",  "̈",  "̉",  "̊",  "̋",  "̌",  "̍", "̎",
-                                    "̏", "᷄", "᷅", "᷆", "᷇", "᷈",  "᷉",  "᷊",  "᷋",  "᷌",  "᷍",  "᷎",  "᷏",  "︠", "︡",
-                                    "︢", "︣", "︤", "︥", "︦", "︧", "︨", "︩", "︪", "︫", "︬", "︭", "︮", "︯"};
+static const char *normal_ascii_strings[] = {
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k",
+    "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F",
+    "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};
+static const char *ascii_diacritics[] = {"^", "`"};
+static const char *normal_unicode_strings[] = {"ぁ", "あ", "ぃ", "い", "ぅ", "う", "ぇ", "え", "ぉ", "お", "か", "が",
+                                               "き", "ぎ", "く", "け", "Ѐ",  "Ё",  "Ђ",  "Ѓ",  "Є",  "Ѕ",  "І",  "Ї",
+                                               "Ј",  "Љ",  "Њ",  "Ћ",  "Ќ",  "Ѝ",  "Ў",  "Џ",  "𓀀",  "𓀁",  "𓀂",  "𓀃",
+                                               "𓀄",  "𓀅",  "𓀆",  "𓀇",  "𓀈",  "𓀉",  "𓀊",  "𓀋",  "𓀌",  "𓀍",  "𓀎",  "𓀏"};
+static const char *unicode_diacritics[] = {"̀", "́", "̂", "̃", "̄", "̅",  "̆",  "̇",  "̈",  "̉",  "̊",  "̋",  "̌",  "̍", "̎",
+                                           "̏", "᷄", "᷅", "᷆", "᷇", "᷈",  "᷉",  "᷊",  "᷋",  "᷌",  "᷍",  "᷎",  "᷏",  "︠", "︡",
+                                           "︢", "︣", "︤", "︥", "︦", "︧", "︨", "︩", "︪", "︫", "︬", "︭", "︮", "︯"};
 
 // Build a random string which has unfolded_len codepoints, but folds to folded_len codepoints after diacritic folding.
-char *build_random_string_to_fold(uint32_t folded_len, uint32_t unfolded_len) {
+static char *build_random_string_to_fold(uint32_t folded_len, uint32_t unfolded_len) {
     // 1/3 to generate all unicode, 1/3 to be half and half, 1/3 to be all ascii.
     int ascii_ratio = rand() % 3;
     ASSERT_CMPUINT32(unfolded_len, >=, folded_len);
@@ -526,11 +527,11 @@ static void suffix_prefix_run_folding_case(_mongocrypt_tester_t *tester,
     test_nofold_suffix_prefix_case(tester, long_s, 32, 49, casef, diacf, foldable_codepoints);
 }
 
-const uint32_t UNFOLDED_CASES[] = {0, 1, 3, 16};
+static const uint32_t UNFOLDED_CASES[] = {0, 1, 3, 16};
 // Predefined lengths to test a variety of cases
-const uint32_t SHORT_LEN = 9;
-const uint32_t MEDIUM_LEN = 16;
-const uint32_t LONG_LEN = 27;
+static const uint32_t SHORT_LEN = 9;
+static const uint32_t MEDIUM_LEN = 16;
+static const uint32_t LONG_LEN = 27;
 
 static void _test_text_search_str_encode_suffix_prefix(_mongocrypt_tester_t *tester) {
     unsigned int seed = (unsigned int)time(0);
@@ -1198,10 +1199,138 @@ static void _test_text_search_str_encode_empty_string(_mongocrypt_tester_t *test
     }
 }
 
+// Tests mc_text_search_str_query() fails on invalid utf-8.
+static void _test_text_search_str_query_bad_string(_mongocrypt_tester_t *tester) {
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    _mongocrypt_buffer_t out;
+    mc_FLE2TextSearchInsertSpec_t spec = {.v = "\xff\xff\xff\xff\xff\xff\xff\xff\xff", .len = 9};
+
+    bool res = mc_text_search_str_query(&spec, &out, status);
+    ASSERT_FAILS_STATUS(res, status, "not valid UTF-8");
+    mongocrypt_status_destroy(status);
+}
+
+// Tests mc_text_search_str_query() checks the input string codepoint length against lb and ub
+// for substring, suffix, and prefix queries, and not for exact queres.
+static void _test_text_search_str_query_bounds_checking(_mongocrypt_tester_t *tester) {
+    mc_FLE2TextSearchInsertSpec_t substrSpec = {.substr = {{.mlen = 20, .lb = 4, .ub = 7}, .set = true}};
+    mc_FLE2TextSearchInsertSpec_t suffixSpec = {.suffix = {{.lb = 4, .ub = 7}, .set = true}};
+    mc_FLE2TextSearchInsertSpec_t prefixSpec = {.prefix = {{.lb = 4, .ub = 7}, .set = true}};
+    mc_FLE2TextSearchInsertSpec_t *specs[3] = {&substrSpec, &suffixSpec, &prefixSpec};
+
+    char *short_str = build_random_string_to_fold(3, 5);
+    char *long_str = build_random_string_to_fold(8, 10);
+
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    _mongocrypt_buffer_t out;
+
+    for (int i = 0; i < 3; i++) {
+        // long_str always fails regardless of folding
+        for (int d = 0; d < 2; d++) {
+            specs[i]->v = long_str;
+            specs[i]->len = (uint32_t)strlen(specs[i]->v);
+            specs[i]->diacf = d;
+            ASSERT_FAILS_STATUS(mc_text_search_str_query(specs[i], &out, status),
+                                status,
+                                "longer than the maximum query length");
+            _mongocrypt_buffer_cleanup(&out);
+            _mongocrypt_status_reset(status);
+        }
+        // short_str only fails if diacritic folding is on
+        specs[i]->v = short_str;
+        specs[i]->len = (uint32_t)strlen(specs[i]->v);
+        specs[i]->diacf = true;
+        ASSERT_FAILS_STATUS(mc_text_search_str_query(specs[i], &out, status),
+                            status,
+                            "shorter than the minimum query length");
+        _mongocrypt_buffer_cleanup(&out);
+        _mongocrypt_status_reset(status);
+
+        specs[i]->diacf = false;
+        ASSERT_OK_STATUS(mc_text_search_str_query(specs[i], &out, status), status);
+        _mongocrypt_buffer_cleanup(&out);
+        _mongocrypt_status_reset(status);
+    }
+
+    // test no bounds checking performed if no substr/suffix/prefix specs
+    mc_FLE2TextSearchInsertSpec_t exactSpecShort = {.diacf = true, .v = short_str, .len = (uint32_t)strlen(short_str)};
+    mc_FLE2TextSearchInsertSpec_t exactSpecLong = {.diacf = true, .v = long_str, .len = (uint32_t)strlen(long_str)};
+    ASSERT_OK_STATUS(mc_text_search_str_query(&exactSpecShort, &out, status), status);
+    _mongocrypt_buffer_cleanup(&out);
+    _mongocrypt_status_reset(status);
+    ASSERT_OK_STATUS(mc_text_search_str_query(&exactSpecLong, &out, status), status);
+
+    _mongocrypt_buffer_cleanup(&out);
+    mongocrypt_status_destroy(status);
+    bson_free(short_str);
+    bson_free(long_str);
+}
+
+// Tests mc_text_search_str_query() rejects empty string input for substr/suffix/prefix queries,
+// but not for exact match queries.
+static void _test_text_search_str_query_empty_string(_mongocrypt_tester_t *tester) {
+    mc_FLE2TextSearchInsertSpec_t substrSpec = {.substr = {{20, 4, 7}, true}, .v = "", .len = 0};
+    mc_FLE2TextSearchInsertSpec_t suffixSpec = {.suffix = {{4, 7}, true}, .v = "", .len = 0};
+    mc_FLE2TextSearchInsertSpec_t prefixSpec = {.prefix = {{4, 7}, true}, .v = "", .len = 0};
+    mc_FLE2TextSearchInsertSpec_t exactSpec = {.v = "", .len = 0};
+    mc_FLE2TextSearchInsertSpec_t *specs[3] = {&substrSpec, &suffixSpec, &prefixSpec};
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    _mongocrypt_buffer_t out;
+    for (int i = 0; i < 3; i++) {
+        ASSERT_FAILS_STATUS(mc_text_search_str_query(specs[i], &out, status), status, "string value cannot be empty");
+        _mongocrypt_buffer_cleanup(&out);
+        _mongocrypt_status_reset(status);
+    }
+
+    ASSERT_OK_STATUS(mc_text_search_str_query(&exactSpec, &out, status), status);
+    _mongocrypt_buffer_cleanup(&out);
+    mongocrypt_status_destroy(status);
+}
+
+// Tests mc_text_search_str_query() performs folding per the diacf and casef parameters.
+static void _test_text_search_str_query_folding(_mongocrypt_tester_t *tester) {
+    const char *testStr = "Düsseldorf";
+    const char *diacFoldStr = "Dusseldorf";
+    const char *caseFoldStr = "düsseldorf";
+    const char *bothFoldStr = "dusseldorf";
+    mc_FLE2TextSearchInsertSpec_t spec = {.v = testStr, .len = (uint32_t)strlen(testStr)};
+    mongocrypt_status_t *status = mongocrypt_status_new();
+    _mongocrypt_buffer_t out;
+
+    spec.diacf = true;
+    ASSERT_OK_STATUS(mc_text_search_str_query(&spec, &out, status), status);
+    ASSERT_CMPUINT32((uint32_t)strlen(diacFoldStr) + 5, ==, out.len); // +5 for BSON overhead
+    ASSERT_STREQUAL(diacFoldStr, (const char *)(out.data + 4));       // +4 skips past 32-bit size field
+
+    _mongocrypt_buffer_cleanup(&out);
+    _mongocrypt_status_reset(status);
+
+    spec.casef = true;
+    spec.diacf = false;
+    ASSERT_OK_STATUS(mc_text_search_str_query(&spec, &out, status), status);
+    ASSERT_CMPUINT32((uint32_t)strlen(caseFoldStr) + 5, ==, out.len);
+    ASSERT_STREQUAL(caseFoldStr, (const char *)(out.data + 4));
+
+    _mongocrypt_buffer_cleanup(&out);
+    _mongocrypt_status_reset(status);
+
+    spec.diacf = true;
+    ASSERT_OK_STATUS(mc_text_search_str_query(&spec, &out, status), status);
+    ASSERT_CMPUINT32((uint32_t)strlen(bothFoldStr) + 5, ==, out.len);
+    ASSERT_STREQUAL(bothFoldStr, (const char *)(out.data + 4));
+
+    _mongocrypt_buffer_cleanup(&out);
+    mongocrypt_status_destroy(status);
+}
+
 void _mongocrypt_tester_install_text_search_str_encode(_mongocrypt_tester_t *tester) {
     INSTALL_TEST(_test_text_search_str_encode_suffix_prefix);
     INSTALL_TEST(_test_text_search_str_encode_substring);
     INSTALL_TEST(_test_text_search_str_encode_multiple);
     INSTALL_TEST(_test_text_search_str_encode_bad_string);
     INSTALL_TEST(_test_text_search_str_encode_empty_string);
+    INSTALL_TEST(_test_text_search_str_query_bad_string);
+    INSTALL_TEST(_test_text_search_str_query_bounds_checking);
+    INSTALL_TEST(_test_text_search_str_query_empty_string);
+    INSTALL_TEST(_test_text_search_str_query_folding);
 }