libmongocrypt-helper 1.8.0.0.1001 → 1.11.0.0.1001

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

@@ -19,6 +19,7 @@
 #include "mc-array-private.h"
 #include "mc-check-conversions-private.h"
 #include "mc-optional-private.h"
+#include "mc-range-encoding-private.h"
 #include "mc-range-mincover-private.h"
 
 enum {
@@ -37,6 +38,7 @@ typedef struct {
     mc_optional_int32_t min;
     mc_optional_int32_t max;
     size_t sparsity;
+    uint32_t trimFactor;
     const char *expectMincoverStrings[MAX_MINCOVER_STRINGS];
     const char *expectError;
 } Int32Test;
@@ -61,7 +63,7 @@ typedef struct {
     size_t sparsity;
     mc_optional_double_t min;
     mc_optional_double_t max;
-    mc_optional_uint32_t precision;
+    mc_optional_int32_t precision;
     const char *expectMincoverStrings[MAX_MINCOVER_STRINGS];
     const char *expectError;
 } DoubleTest;
@@ -75,7 +77,7 @@ typedef struct {
     size_t sparsity;
     mc_optional_dec128_t min;
     mc_optional_dec128_t max;
-    mc_optional_uint32_t precision;
+    mc_optional_int32_t precision;
     const char *expectMincoverStrings[MAX_MINCOVER_STRINGS];
     const char *expectError;
 } Decimal128Test;
@@ -93,19 +95,24 @@ 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,
                                                             .includeUpperBound = test->includeUpperBound,
                                                             .min = test->min,
                                                             .max = test->max,
-                                                            .sparsity = test->sparsity},
-                               status);
+                                                            .sparsity = test->sparsity,
+                                                            .trimFactor = OPT_I32(test->trimFactor)},
+                               status,
+                               use_range_v2);
 }
 
 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;
 
     return mc_getMincoverInt64((mc_getMincoverInt64_args_t){.lowerBound = test->lowerBound,
@@ -114,13 +121,17 @@ static mc_mincover_t *_test_getMincover64(void *tests, size_t idx, mongocrypt_st
                                                             .includeUpperBound = test->includeUpperBound,
                                                             .min = test->min,
                                                             .max = test->max,
-                                                            .sparsity = test->sparsity},
-                               status);
+                                                            .sparsity = test->sparsity,
+                                                            .trimFactor = OPT_I32(trimFactor)},
+                               status,
+                               use_range_v2);
 }
 
 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;
 
     return mc_getMincoverDouble(
@@ -131,8 +142,10 @@ static mc_mincover_t *_test_getMincoverDouble_helper(void *tests, size_t idx, mo
                                       .sparsity = test->sparsity,
                                       .min = test->precision.set ? test->min : (mc_optional_double_t){0},
                                       .max = test->precision.set ? test->max : (mc_optional_double_t){0},
-                                      .precision = test->precision},
-        status);
+                                      .precision = test->precision,
+                                      .trimFactor = OPT_I32(trimFactor)},
+        status,
+        use_range_v2);
 }
 
 #if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
@@ -141,6 +154,8 @@ static mc_mincover_t *_test_getMincoverDecimal128_helper(void *tests, size_t idx
 
     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,
                                           .includeLowerBound = test->includeLowerBound,
@@ -149,8 +164,10 @@ static mc_mincover_t *_test_getMincoverDecimal128_helper(void *tests, size_t idx
                                           .sparsity = test->sparsity,
                                           .min = test->precision.set ? test->min : (mc_optional_dec128_t){0},
                                           .max = test->precision.set ? test->max : (mc_optional_dec128_t){0},
-                                          .precision = test->precision},
-        status);
+                                          .precision = test->precision,
+                                          .trimFactor = OPT_I32(trimFactor)},
+        status,
+        use_range_v2);
 }
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
@@ -166,13 +183,42 @@ static const char *_test_expectError64(void *tests, size_t idx) {
 
 static const char *_test_expectErrorDouble(void *tests, size_t idx) {
     BSON_ASSERT_PARAM(tests);
-    return ((DoubleTest *)tests + idx)->expectError;
+    DoubleTest *test = ((DoubleTest *)tests + idx);
+    if (test->min.set && test->max.set && test->precision.set) {
+        // Expect an error for tests including an invalid min/max/precision.
+        uint32_t ignored;
+        mongocrypt_status_t *const status = mongocrypt_status_new();
+        if (!mc_canUsePrecisionModeDouble(test->min.value, test->max.value, test->precision.value, &ignored, status)) {
+            if (!mongocrypt_status_ok(status)) {
+                return mongocrypt_status_message(status, NULL);
+            }
+
+            return "The domain of double values specified by the min, max, and precision cannot be represented in "
+                   "fewer than 64 bits";
+        }
+        mongocrypt_status_destroy(status);
+    }
+    return test->expectError;
 }
 
 #if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 static const char *_test_expectErrorDecimal128(void *tests, size_t idx) {
     BSON_ASSERT_PARAM(tests);
-    return ((Decimal128Test *)tests + idx)->expectError;
+    Decimal128Test *test = ((Decimal128Test *)tests + idx);
+    if (test->min.set && test->max.set && test->precision.set) {
+        // Expect an error for tests including an invalid min/max/precision.
+        uint32_t ignored;
+        mongocrypt_status_t *const status = mongocrypt_status_new();
+        if (!mc_canUsePrecisionModeDecimal(test->min.value, test->max.value, test->precision.value, &ignored, status)) {
+            if (!mongocrypt_status_ok(status)) {
+                return mongocrypt_status_message(status, NULL);
+            }
+
+            return "The domain of decimal values specified by the min, max, and precision cannot be represented in "
+                   "fewer than 128 bits";
+        }
+    }
+    return test->expectError;
 }
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
@@ -429,6 +475,42 @@ static void _test_getMincoverInt32(_mongocrypt_tester_t *tester) {
          .max = OPT_I32_C(7),
          .sparsity = 1,
          .expectError = "less than or equal to the maximum value"},
+        {.lowerBound = 0,
+         .includeLowerBound = true,
+         .upperBound = 7,
+         .includeUpperBound = true,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 1,
+         .expectMincoverStrings = {"root"}},
+        {.lowerBound = 0,
+         .includeLowerBound = true,
+         .upperBound = 7,
+         .includeUpperBound = true,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 1,
+         .trimFactor = 1,
+         .expectMincoverStrings = {"0", "1"}},
+        {.lowerBound = 0,
+         .includeLowerBound = true,
+         .upperBound = 7,
+         .includeUpperBound = true,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 1,
+         .trimFactor = 2,
+         .expectMincoverStrings = {"00", "01", "10", "11"}},
+        {.lowerBound = 0,
+         .includeLowerBound = true,
+         .upperBound = 7,
+         .includeUpperBound = true,
+         .min = OPT_I32_C(0),
+         .max = OPT_I32_C(7),
+         .sparsity = 1,
+         .trimFactor = 3,
+         .expectError =
+             "Trim factor must be less than the number of bits (3) used to represent an element of the domain"},
 
 #include "./data/range-min-cover/mincover_int32.cstruct"
 

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "mc-range-encoding-private.h"
 #include "mc-rangeopts-private.h"
 #include "test-mongocrypt.h"
 
@@ -28,6 +29,8 @@ static void test_mc_RangeOpts_parse(_mongocrypt_tester_t *tester) {
         mc_optional_int32_t expectMax;
         int64_t expectSparsity;
         mc_optional_uint32_t expectPrecision;
+        mc_optional_int32_t expectTrimFactor;
+        bool useRangeV2;
     } testcase;
 
     testcase tests[] = {
@@ -39,9 +42,6 @@ static void test_mc_RangeOpts_parse(_mongocrypt_tester_t *tester) {
         {.desc = "Errors if precision is set with int min/max",
          .in = RAW_STRING({"min" : 123, "max" : 456, "precision" : 2, "sparsity" : {"$numberLong" : "1"}}),
          .expectError = "expected 'precision' to be set with double or decimal128 index"},
-        {.desc = "Errors on missing fields",
-         .in = RAW_STRING({"min" : 123, "max" : 456}),
-         .expectError = "Missing field 'sparsity'"},
         {.desc = "Errors on extra fields",
          .in = RAW_STRING({"min" : 123, "max" : 456, "sparsity" : {"$numberLong" : "1"}, "foo" : 1}),
          .expectError = "Unrecognized field: 'foo'"},
@@ -62,6 +62,25 @@ 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"},
     };
 
     for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
@@ -69,7 +88,7 @@ static void test_mc_RangeOpts_parse(_mongocrypt_tester_t *tester) {
         mongocrypt_status_t *status = mongocrypt_status_new();
         mc_RangeOpts_t ro;
         printf("running test_mc_RangeOpts_parse subtest: %s\n", test->desc);
-        bool ret = mc_RangeOpts_parse(&ro, TMP_BSON(test->in), status);
+        bool ret = mc_RangeOpts_parse(&ro, TMP_BSON(test->in), test->useRangeV2, status);
         if (!test->expectError) {
             ASSERT_OK_STATUS(ret, status);
             ASSERT_CMPINT(test->expectMin.set, ==, ro.min.set);
@@ -83,6 +102,8 @@ static void test_mc_RangeOpts_parse(_mongocrypt_tester_t *tester) {
             ASSERT_CMPINT64(test->expectSparsity, ==, ro.sparsity);
             ASSERT_CMPINT(test->expectPrecision.set, ==, ro.precision.set);
             ASSERT_CMPINT(test->expectPrecision.value, ==, ro.precision.value);
+            ASSERT_CMPINT(test->expectTrimFactor.set, ==, ro.trimFactor.set);
+            ASSERT_CMPINT(test->expectTrimFactor.value, ==, ro.trimFactor.value);
         } else {
             ASSERT_FAILS_STATUS(ret, status, test->expectError);
         }
@@ -98,6 +119,8 @@ 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[] = {
@@ -105,6 +128,11 @@ 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}),
@@ -112,16 +140,186 @@ static void test_mc_RangeOpts_to_FLE2RangeInsertSpec(_mongocrypt_tester_t *teste
         {.desc = "Errors with missing 'v'",
          .in = RAW_STRING({"min" : 123, "max" : 456, "sparsity" : {"$numberLong" : "1"}}),
          .v = RAW_STRING({"foo" : "bar"}),
-         .expectError = "Unable to find 'v'"}};
+         .expectError = "Unable to find 'v'"},
+        // Tests of trim factor
+        {.desc = "tf = 0 works",
+         .in = RAW_STRING({"trimFactor" : 0, "min" : 0, "max" : 1, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0}),
+         .expect = RAW_STRING({"v" : {"v" : 0, "min" : 0, "max" : 1, "trimFactor" : 0}})},
+        {.desc = "tf = 1 fails when domain size is 2 = 2^1",
+         .in = RAW_STRING({"trimFactor" : 1, "min" : 0, "max" : 1, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0}),
+         .expectError = "Trim factor (1) must be less than the total number of bits (1) used to represent any element "
+                        "in the domain."},
+        {.desc = "tf = 1 works when domain size is 3 > 2^1",
+         .in = RAW_STRING({"trimFactor" : 1, "min" : 0, "max" : 2, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0}),
+         .expect = RAW_STRING({"v" : {"v" : 0, "min" : 0, "max" : 2, "trimFactor" : 1}})},
+        {.desc = "tf = 2 fails when domain size is 3 <= 2^2",
+         .in = RAW_STRING({"trimFactor" : 2, "min" : 0, "max" : 2, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0}),
+         .expectError = "Trim factor (2) must be less than the total number of bits (2) used to represent any element "
+                        "in the domain."},
+
+        // min = INT32_MIN, max = INT32_MAX
+        {.desc = "tf = 31 works for unbounded int32 (domain size = 2^32)",
+         .in = RAW_STRING(
+             {"trimFactor" : 31, "min" : -2147483648, "max" : 2147483647, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0}),
+         .expect = RAW_STRING({"v" : {"v" : 0, "min" : -2147483648, "max" : 2147483647, "trimFactor" : 31}})},
+        {.desc = "tf = 32 fails for unbounded int32 (domain size = 2^32)",
+         .in = RAW_STRING(
+             {"trimFactor" : 32, "min" : -2147483648, "max" : 2147483647, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0}),
+         .expectError = "Trim factor (32) must be less than the total number of bits (32) used to represent any "
+                        "element in the domain."},
+
+        // min = INT64_MIN, max = INT64_MAX
+        {.desc = "tf = 63 works for int64 with no min/max (domain size = 2^64)",
+         .in = RAW_STRING({
+             "trimFactor" : 63,
+             "min" : -9223372036854775808,
+             "max" : 9223372036854775807,
+             "sparsity" : {"$numberLong" : "1"}
+         }),
+         .v = RAW_STRING({"v" : {"$numberLong" : "0"}}),
+         .expect = RAW_STRING({
+             "v" : {
+                 "v" : {"$numberLong" : "0"},
+                 "min" : {"$numberLong" : "-9223372036854775808"},
+                 "max" : {"$numberLong" : "9223372036854775807"},
+                 "trimFactor" : 63
+             }
+         })},
+        {.desc = "tf = 64 fails for int64 with no min/max (domain size = 2^64)",
+         .in = RAW_STRING({
+             "trimFactor" : 64,
+             "min" : -9223372036854775808,
+             "max" : 9223372036854775807,
+             "sparsity" : {"$numberLong" : "1"}
+         }),
+         .v = RAW_STRING({"v" : {"$numberLong" : "0"}}),
+         .expectError = "Trim factor (64) must be less than the total number of bits (64) used to represent any "
+                        "element in the domain."},
+
+        {.desc = "tf = 63 works for date with no min/max (domain size = 2^64)",
+         .in = RAW_STRING({
+             "trimFactor" : 63,
+             "min" : {"$date" : {"$numberLong" : "-9223372036854775808"}},
+             "max" : {"$date" : {"$numberLong" : "9223372036854775807"}},
+             "sparsity" : {"$numberLong" : "1"}
+         }),
+         .v = RAW_STRING({"v" : {"$date" : {"$numberLong" : "0"}}}),
+         .expect = RAW_STRING({
+             "v" : {
+                 "v" : {"$date" : {"$numberLong" : "0"}},
+                 "min" : {"$date" : {"$numberLong" : "-9223372036854775808"}},
+                 "max" : {"$date" : {"$numberLong" : "9223372036854775807"}},
+                 "trimFactor" : 63
+             }
+         })},
+        {.desc = "tf = 64 fails for date with no min/max (domain size = 2^64)",
+         .in = RAW_STRING({
+             "trimFactor" : 64,
+             "min" : {"$date" : {"$numberLong" : "-9223372036854775808"}},
+             "max" : {"$date" : {"$numberLong" : "9223372036854775807"}},
+             "sparsity" : {"$numberLong" : "1"}
+         }),
+         .v = RAW_STRING({"v" : {"$date" : {"$numberLong" : "0"}}}),
+         .expectError = "Trim factor (64) must be less than the total number of bits (64) used to represent any "
+                        "element in the domain."},
+
+        {.desc = "tf bound check passes correctly for double with min, max, precision set (tf = 9, 2^9 < domain size < "
+                 "2^10)",
+         .in = RAW_STRING(
+             {"trimFactor" : 9, "min" : 0.0, "max" : 100.0, "precision" : 1, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0.0}),
+         .expect = RAW_STRING({"v" : {"v" : 0.0, "min" : 0.0, "max" : 100.0, "precision" : 1, "trimFactor" : 9}})},
+        {.desc = "tf bound check fails correctly for double with min, max, precision set (tf = 10, domain size < 2^10)",
+         .in = RAW_STRING(
+             {"trimFactor" : 10, "min" : 0.0, "max" : 100.0, "precision" : 1, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0.0}),
+         .expectError = "Trim factor (10) must be less than the total number of bits (10) used to represent any "
+                        "element in the domain."},
+
+        {.desc = "tf = 63 works for unbounded double (domain size = 2^64)",
+         .in = RAW_STRING({"trimFactor" : 63, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0.0}),
+         // note - when min and max are unset, they are added into the insert spec.
+         .expect = RAW_STRING({
+             "v" : {
+                 "v" : 0.0,
+                 "min" : {"$numberDouble" : "-1.7976931348623157081e+308"},
+                 "max" : {"$numberDouble" : "1.7976931348623157081e+308"},
+                 "trimFactor" : 63
+             }
+         })},
+        {.desc = "tf = 64 fails for unbounded double (domain size = 2^64))",
+         .in = RAW_STRING({"trimFactor" : 64, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 0.0}),
+         .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
+        {.desc = "tf bound check passes correctly for decimal with min, max, precision set (tf = 9, 2^9 < domain size "
+                 "< 2^10)",
+         .in = RAW_STRING({
+             "trimFactor" : 9,
+             "min" : {"$numberDecimal" : "0"},
+             "max" : {"$numberDecimal" : "100"},
+             "precision" : 1,
+             "sparsity" : {"$numberLong" : "1"}
+         }),
+         .v = RAW_STRING({"v" : {"$numberDecimal" : "0"}}),
+         .expect = RAW_STRING({
+             "v" : {
+                 "v" : {"$numberDecimal" : "0"},
+                 "min" : {"$numberDecimal" : "0"},
+                 "max" : {"$numberDecimal" : "100"},
+                 "precision" : 1,
+                 "trimFactor" : 9
+             }
+         })},
+        {.desc =
+             "tf bound check fails correctly for decimal with min, max, precision set (tf = 10, domain size < 2^10)",
+         .in = RAW_STRING({
+             "trimFactor" : 10,
+             "min" : {"$numberDecimal" : "0"},
+             "max" : {"$numberDecimal" : "100"},
+             "precision" : 1,
+             "sparsity" : {"$numberLong" : "1"}
+         }),
+         .v = RAW_STRING({"v" : {"$numberDecimal" : "0"}}),
+         .expectError = "Trim factor (10) must be less than the total number of bits (10) used to represent any "
+                        "element in the domain."},
+
+        {.desc = "tf = 127 works for unbounded decimal (domain size = 2^128)",
+         .in = RAW_STRING({"trimFactor" : 127, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : {"$numberDecimal" : "0"}}),
+         .expect = RAW_STRING({
+             "v" : {
+                 "v" : {"$numberDecimal" : "0"},
+                 "min" : {"$numberDecimal" : "-9.999999999999999999999999999999999E+6144"},
+                 "max" : {"$numberDecimal" : "9.999999999999999999999999999999999E+6144"},
+                 "trimFactor" : 127
+             }
+         })},
+        {.desc = "tf = 128 fails for unbounded decimal (domain size = 2^128)",
+         .in = RAW_STRING({"trimFactor" : 128, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : {"$numberDecimal" : "0"}}),
+         .expectError = "Trim factor (128) must be less than the total number of bits (128) used to represent any "
+                        "element in the domain."},
+#endif
+    };
 
     for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
         testcase *test = tests + i;
         mongocrypt_status_t *status = mongocrypt_status_new();
         mc_RangeOpts_t ro;
         printf("running test_mc_RangeOpts_to_FLE2RangeInsertSpec subtest: %s\n", test->desc);
-        ASSERT_OK_STATUS(mc_RangeOpts_parse(&ro, TMP_BSON(test->in), status), status);
+        ASSERT_OK_STATUS(mc_RangeOpts_parse(&ro, TMP_BSON(test->in), !test->disableRangeV2, status), status);
         bson_t out = BSON_INITIALIZER;
-        bool ret = mc_RangeOpts_to_FLE2RangeInsertSpec(&ro, TMP_BSON(test->v), &out, status);
+        bool ret = mc_RangeOpts_to_FLE2RangeInsertSpec(&ro, TMP_BSON(test->v), &out, !test->disableRangeV2, status);
         if (!test->expectError) {
             ASSERT_OK_STATUS(ret, status);
             ASSERT_EQUAL_BSON(TMP_BSON(test->expect), &out);

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "mc-tokens-private.h"
+#include "test-mongocrypt-assert.h"
 #include "test-mongocrypt.h"
 
 #define FOREACH_FIELD(F)                                                                                               \
@@ -30,17 +31,21 @@
     F(ESCDerivedFromDataToken)                                                                                         \
     F(ECCDerivedFromDataToken)                                                                                         \
     F(serverDerivedFromDataToken)                                                                                      \
-    F(EDCDerivedFromDataTokenAndCounter)                                                                               \
-    F(ESCDerivedFromDataTokenAndCounter)                                                                               \
-    F(ECCDerivedFromDataTokenAndCounter)                                                                               \
+    F(EDCDerivedFromDataTokenAndContentionFactor)                                                                      \
+    F(ESCDerivedFromDataTokenAndContentionFactor)                                                                      \
+    F(ECCDerivedFromDataTokenAndContentionFactor)                                                                      \
+    F(EDCTwiceDerivedToken)                                                                                            \
+    F(ESCTwiceDerivedTagToken)                                                                                         \
+    F(ESCTwiceDerivedValueToken)                                                                                       \
     F(serverCountAndContentionFactorEncryptionToken)                                                                   \
-    F(serverZerosEncryptionToken)
+    F(serverZerosEncryptionToken)                                                                                      \
+    F(AnchorPaddingTokenRoot)
 
 typedef struct {
 #define DECLARE_FIELD(f) _mongocrypt_buffer_t f;
     FOREACH_FIELD(DECLARE_FIELD)
 #undef DECLARE_FIELD
-    uint64_t counter;
+    uint64_t contentionFactor;
 } _mc_token_test;
 
 static void _mc_token_test_cleanup(_mc_token_test *test) {
@@ -64,7 +69,7 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     ASSERT(bson_init_static(&test_bson, test_bin->data, test_bin->len));
     ASSERT(bson_validate(&test_bson, BSON_VALIDATE_NONE, NULL));
 
-    bool hasCounter = false;
+    bool hasContentionFactor = false;
     _mc_token_test test = {{0}};
     bson_iter_t it;
     ASSERT(bson_iter_init(&it, &test_bson));
@@ -83,11 +88,11 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
         FOREACH_FIELD(PARSE_FIELD)
 #undef PARSE_FIELD
         /* else */
-        if (!strcmp(field, "counter")) {
-            ASSERT_OR_PRINT_MSG(!hasCounter, "Duplicate field 'counter' in test");
+        if (!strcmp(field, "contentionFactor")) {
+            ASSERT_OR_PRINT_MSG(!hasContentionFactor, "Duplicate field 'contentionFactor' in test");
             ASSERT(BSON_ITER_HOLDS_INT32(&it) || BSON_ITER_HOLDS_INT64(&it));
-            test.counter = bson_iter_as_int64(&it);
-            hasCounter = true;
+            test.contentionFactor = bson_iter_as_int64(&it);
+            hasContentionFactor = true;
         } else {
             TEST_ERROR("Unknown field '%s'", field);
         }
@@ -96,7 +101,7 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
 #define CHECK_FIELD(f) ASSERT_OR_PRINT_MSG(test.f.data, "Missing field '" #f "' in test");
     FOREACH_FIELD(CHECK_FIELD)
 #undef CHECK_FIELD
-    ASSERT_OR_PRINT_MSG(hasCounter, "Missing field 'counter' in test");
+    ASSERT_OR_PRINT_MSG(hasContentionFactor, "Missing field 'contentionFactor' in test");
 
     // Run the actual test.
     mongocrypt_status_t *status = mongocrypt_status_new();
@@ -133,25 +138,37 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     TEST_COLL_TOKEN(ECOC)
 #undef TEST_COLL_TOKEN
 
-// (EDC|ESC|ECC)DerivedFromDataToken(AndCounter)?
+// (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##DerivedFromDataTokenAndCounter_t *Name##DerivedFromDataTokenAndCounter =                                \
-        mc_##Name##DerivedFromDataTokenAndCounter_new(crypt->crypto,                                                   \
-                                                      Name##DerivedFromDataToken,                                      \
-                                                      test.counter,                                                    \
-                                                      status);                                                         \
-    ASSERT_OR_PRINT(Name##DerivedFromDataTokenAndCounter, status);                                                     \
-    ASSERT_CMPBUF(*mc_##Name##DerivedFromDataTokenAndCounter_get(Name##DerivedFromDataTokenAndCounter),                \
-                  test.Name##DerivedFromDataTokenAndCounter);
+    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
 
+// (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);
+    TEST_TWICE(EDC, Token);
+    TEST_TWICE(ESC, TagToken);
+    TEST_TWICE(ESC, ValueToken);
+#undef TEST_TWICE
+
     // ServerDerivedFromDataToken
     mc_ServerDerivedFromDataToken_t *serverDerivedFromDataToken =
         mc_ServerDerivedFromDataToken_new(crypt->crypto, serverTokenDerivationLevel1Token, &test.value, status);
@@ -171,13 +188,22 @@ static void _mc_token_test_run(_mongocrypt_tester_t *tester, const char *path) {
     ASSERT_OR_PRINT(serverZeros, status);
     ASSERT_CMPBUF(*mc_ServerZerosEncryptionToken_get(serverZeros), test.serverZerosEncryptionToken);
 
+    // AnchorPaddingTokenRoot
+    mc_AnchorPaddingTokenRoot_t *padding = mc_AnchorPaddingTokenRoot_new(crypt->crypto, ESCToken, status);
+    ASSERT_OR_PRINT(padding, status);
+    ASSERT_CMPBUF(*mc_AnchorPaddingTokenRoot_get(padding), test.AnchorPaddingTokenRoot);
+
     // Done.
+    mc_AnchorPaddingTokenRoot_destroy(padding);
     mc_ServerZerosEncryptionToken_destroy(serverZeros);
     mc_ServerCountAndContentionFactorEncryptionToken_destroy(serverCACFET);
     mc_ServerDerivedFromDataToken_destroy(serverDerivedFromDataToken);
-    mc_ECCDerivedFromDataTokenAndCounter_destroy(ECCDerivedFromDataTokenAndCounter);
-    mc_ESCDerivedFromDataTokenAndCounter_destroy(ESCDerivedFromDataTokenAndCounter);
-    mc_EDCDerivedFromDataTokenAndCounter_destroy(EDCDerivedFromDataTokenAndCounter);
+    mc_ESCTwiceDerivedValueToken_destroy(ESCTwiceDerivedValueToken);
+    mc_ESCTwiceDerivedTagToken_destroy(ESCTwiceDerivedTagToken);
+    mc_EDCTwiceDerivedToken_destroy(EDCTwiceDerivedToken);
+    mc_ECCDerivedFromDataTokenAndContentionFactor_destroy(ECCDerivedFromDataTokenAndContentionFactor);
+    mc_ESCDerivedFromDataTokenAndContentionFactor_destroy(ESCDerivedFromDataTokenAndContentionFactor);
+    mc_EDCDerivedFromDataTokenAndContentionFactor_destroy(EDCDerivedFromDataTokenAndContentionFactor);
     mc_ECCDerivedFromDataToken_destroy(ECCDerivedFromDataToken);
     mc_ESCDerivedFromDataToken_destroy(ESCDerivedFromDataToken);
     mc_EDCDerivedFromDataToken_destroy(EDCDerivedFromDataToken);