/*
* Copyright 2022-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 "test-mongocrypt.h"
#include "mc-check-conversions-private.h"
#include "mc-range-encoding-private.h"
#include <float.h> // DBL_MAX
#include <math.h> // INFINITY, NAN
typedef struct {
mc_getTypeInfo32_args_t args;
mc_OSTType_Int32 expect;
const char *expectError;
} Int32Test;
static void _test_RangeTest_Encode_Int32(_mongocrypt_tester_t *tester) {
Int32Test tests[] = {
/* Test cases copied from server Int32_NoBounds test ... begin */
{.args = {.value = INT32_C(2147483647)},
.expect = {.value = UINT32_C(4294967295), .min = 0, .max = UINT32_MAX}},
{.args = {.value = 1}, .expect = {.value = UINT32_C(2147483649), .min = 0, .max = UINT32_MAX}},
{.args = {.value = 0}, .expect = {.value = UINT32_C(2147483648), .min = 0, .max = UINT32_MAX}},
{.args = {.value = -1}, .expect = {.value = UINT32_C(2147483647), .min = 0, .max = UINT32_MAX}},
{.args = {.value = -2}, .expect = {.value = UINT32_C(2147483646), .min = 0, .max = UINT32_MAX}},
{.args = {.value = INT32_C(-2147483647)}, .expect = {.value = 1, .min = 0, .max = UINT32_MAX}},
{.args = {.value = INT32_MIN}, .expect = {.value = 0, .min = 0, .max = UINT32_MAX}},
/* Test cases copied from server Int32_NoBounds test ... end */
/* Test cases copied from server Int32_Bounds test .. begin */
{.args = {.value = 1, .min = OPT_I32(1), .max = OPT_I32(3)}, .expect = {.value = 0, 0, .max = 2}},
{.args = {.value = 0, .min = OPT_I32(0), .max = OPT_I32(1)}, .expect = {.value = 0, .min = 0, .max = 1}},
{.args = {.value = -1, .min = OPT_I32(-1), .max = OPT_I32(0)}, .expect = {.value = 0, .min = 0, .max = 1}},
{.args = {.value = -2, .min = OPT_I32(-2), .max = OPT_I32(0)}, .expect = {.value = 0, .min = 0, .max = 2}},
{.args = {.value = INT32_C(-2147483647), .min = OPT_I32(INT32_MIN), .max = OPT_I32(1)},
.expect = {.value = 1, .min = 0, .max = UINT32_C(2147483649)}},
{.args = {.value = INT32_MIN, .min = OPT_I32(INT32_MIN), .max = OPT_I32(0)},
.expect = {.value = 0, .min = 0, .max = UINT32_C(2147483648)}},
{.args = {.value = 0, .min = OPT_I32(INT32_MIN), .max = OPT_I32(1)},
.expect = {.value = UINT32_C(2147483648), .min = 0, .max = UINT32_C(2147483649)}},
{.args = {.value = 1, .min = OPT_I32(INT32_MIN), .max = OPT_I32(2)},
.expect = {.value = UINT32_C(2147483649), .min = 0, .max = UINT32_C(2147483650)}},
{.args = {.value = INT32_C(2147483647), .min = OPT_I32(-2147483647), .max = OPT_I32(2147483647)},
.expect = {.value = UINT32_C(4294967294), .min = 0, .max = UINT32_C(4294967294)}},
{.args = {.value = INT32_C(2147483647), .min = OPT_I32(INT32_MIN), .max = OPT_I32(2147483647)},
.expect = {.value = UINT32_C(4294967295), .min = 0, .max = UINT32_C(4294967295)}},
{.args = {.value = 15, .min = OPT_I32(10), .max = OPT_I32(26)}, .expect = {.value = 5, .min = 0, .max = 16}},
{.args = {.value = 15, .min = OPT_I32(-10), .max = OPT_I32(55)}, .expect = {.value = 25, .min = 0, .max = 65}},
/* Test cases copied from server Int32_Bounds test ... end */
/* Test cases copied from server Int32_Errors test ... begin */
{.args = {.value = 1, .max = OPT_I32(2)},
.expectError = "Must specify both a lower and upper bound or no bounds."},
{.args = {.value = 1, .min = OPT_I32(0)},
.expectError = "Must specify both a lower and upper bound or no bounds."},
{.args = {.value = 1, .min = OPT_I32(2), .max = OPT_I32(1)},
.expectError = "The minimum value must be less than the maximum value"},
{.args = {.value = 1, .min = OPT_I32(2), .max = OPT_I32(3)},
.expectError = "Value must be greater than or equal to the minimum "
"value and less than or equal to the maximum value"},
{.args = {.value = 4, .min = OPT_I32(2), .max = OPT_I32(3)},
.expectError = "Value must be greater than or equal to the minimum "
"value and less than or equal to the maximum value"},
{.args = {.value = 4, .min = OPT_I32(INT32_MIN), .max = OPT_I32(INT32_MIN)},
.expectError = "The minimum value must be less than the maximum value"},
/* Test cases copied from server Int32_Errors test ... end */
};
for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
Int32Test *test = tests + i;
mongocrypt_status_t *const status = mongocrypt_status_new();
// Print a description of the test case.
printf("_test_RangeTest_Encode_Int32: value=%" PRId32, test->args.value);
if (test->args.min.set) {
printf(" min=%" PRId32, test->args.min.value);
}
if (test->args.max.set) {
printf(" max=%" PRId32, test->args.max.value);
}
printf("\n");
mc_OSTType_Int32 got;
const bool ok = mc_getTypeInfo32(test->args, &got, status);
if (test->expectError) {
ASSERT_OR_PRINT_MSG(!ok, "expected error, but got none");
ASSERT_STATUS_CONTAINS(status, test->expectError);
} else {
ASSERT_OK_STATUS(ok, status);
ASSERT_CMPUINT32(got.value, ==, test->expect.value);
ASSERT_CMPUINT32(got.min, ==, test->expect.min);
ASSERT_CMPUINT32(got.max, ==, test->expect.max);
}
mongocrypt_status_destroy(status);
}
}
typedef struct {
mc_getTypeInfo64_args_t args;
mc_OSTType_Int64 expect;
const char *expectError;
} Int64Test;
static void _test_RangeTest_Encode_Int64(_mongocrypt_tester_t *tester) {
Int64Test tests[] = {
/* Test cases copied from server Int64_NoBounds test ... begin */
{.args = {.value = INT64_C(9223372036854775807)},
.expect = {.value = UINT64_C(18446744073709551615), .min = 0, .max = UINT64_MAX}},
{.args = {.value = 1}, .expect = {.value = UINT64_C(9223372036854775809), .min = 0, .max = UINT64_MAX}},
{.args = {.value = 0}, .expect = {.value = UINT64_C(9223372036854775808), .min = 0, .max = UINT64_MAX}},
{.args = {.value = -1}, .expect = {.value = UINT64_C(9223372036854775807), .min = 0, .max = UINT64_MAX}},
{.args = {.value = -2}, .expect = {.value = UINT64_C(9223372036854775806), .min = 0, .max = UINT64_MAX}},
{.args = {.value = INT64_C(-9223372036854775807)}, .expect = {.value = 1, .min = 0, .max = UINT64_MAX}},
{.args = {.value = INT64_MIN}, .expect = {.value = 0, .min = 0, .max = UINT64_MAX}},
/* Test cases copied from server Int64_NoBounds test ... end */
/* Test cases copied from server Int64_Bounds test ... begin */
{.args = {.value = 1, .min = OPT_I64(1), .max = OPT_I64(2)}, .expect = {.value = 0, .min = 0, .max = 1}},
{.args = {.value = 0, .min = OPT_I64(0), .max = OPT_I64(1)}, .expect = {.value = 0, .min = 0, .max = 1}},
{.args = {.value = -1, .min = OPT_I64(-1), .max = OPT_I64(0)}, .expect = {.value = 0, .min = 0, .max = 1}},
{.args = {.value = -2, .min = OPT_I64(-2), .max = OPT_I64(0)}, .expect = {.value = 0, .min = 0, .max = 2}},
{.args = {.value = INT64_C(-9223372036854775807), .min = OPT_I64(INT64_MIN), .max = OPT_I64(1)},
.expect = {.value = 1, .min = 0, .max = UINT64_C(9223372036854775809)}},
{.args = {.value = INT64_MIN, .min = OPT_I64(INT64_MIN), .max = OPT_I64(0)},
.expect = {.value = 0, .min = 0, .max = UINT64_C(9223372036854775808)}},
{.args = {.value = 0, .min = OPT_I64(INT64_MIN), .max = OPT_I64(37)},
.expect = {.value = UINT64_C(9223372036854775808), .min = 0, .max = UINT64_C(9223372036854775845)}},
{.args = {.value = 1, .min = OPT_I64(INT64_MIN), .max = OPT_I64(42)},
.expect = {.value = UINT64_C(9223372036854775809), .min = 0, .max = UINT64_C(9223372036854775850)}},
{.args = {.value = INT64_C(9223372036854775807),
.min = OPT_I64(-9223372036854775807),
.max = OPT_I64(9223372036854775807)},
.expect = {.value = UINT64_C(18446744073709551614), .min = 0, .max = UINT64_C(18446744073709551614)}},
{.args = {.value = INT64_C(9223372036854775807),
.min = OPT_I64(INT64_MIN),
.max = OPT_I64(9223372036854775807)},
.expect = {.value = UINT64_C(18446744073709551615), .min = 0, .max = UINT64_C(18446744073709551615)}},
{.args = {.value = 15, .min = OPT_I64(10), .max = OPT_I64(26)}, .expect = {.value = 5, .min = 0, .max = 16}},
{.args = {.value = 15, .min = OPT_I64(-10), .max = OPT_I64(55)}, .expect = {.value = 25, .min = 0, .max = 65}},
/* Test cases copied from server Int64_Bounds test ... end */
/* Test cases copied from server Int64_Errors test ... begin */
{.args = {.value = 1, .max = OPT_I64(2)},
.expectError = "Must specify both a lower and upper bound or no bounds."},
{.args = {.value = 1, .min = OPT_I64(0)},
.expectError = "Must specify both a lower and upper bound or no bounds."},
{.args = {.value = 1, .min = OPT_I64(2), .max = OPT_I64(1)},
.expectError = "The minimum value must be less than the maximum value"},
{.args = {.value = 1, .min = OPT_I64(2), .max = OPT_I64(3)},
.expectError = "Value must be greater than or equal to the minimum "
"value and less than or equal to the maximum value"},
{.args = {.value = 4, .min = OPT_I64(2), .max = OPT_I64(3)},
.expectError = "Value must be greater than or equal to the minimum "
"value and less than or equal to the maximum value"},
{.args = {.value = 4, .min = OPT_I64(INT64_MIN), .max = OPT_I64(INT64_MIN)},
.expectError = "The minimum value must be less than the maximum value"},
/* Test cases copied from server Int64_Errors test ... end */
};
for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
Int64Test *test = tests + i;
mongocrypt_status_t *const status = mongocrypt_status_new();
// Print a description of the test case.
printf("_test_RangeTest_Encode_Int64: value=%" PRId64, test->args.value);
if (test->args.min.set) {
printf(" min=%" PRId64, test->args.min.value);
}
if (test->args.max.set) {
printf(" max=%" PRId64, test->args.max.value);
}
printf("\n");
mc_OSTType_Int64 got;
const bool ok = mc_getTypeInfo64(test->args, &got, status);
if (test->expectError) {
ASSERT_OR_PRINT_MSG(!ok, "expected error, but got none");
ASSERT_STATUS_CONTAINS(status, test->expectError);
} else {
ASSERT_OK_STATUS(ok, status);
ASSERT_CMPUINT64(got.value, ==, test->expect.value);
ASSERT_CMPUINT64(got.min, ==, test->expect.min);
ASSERT_CMPUINT64(got.max, ==, test->expect.max);
}
mongocrypt_status_destroy(status);
}
}
typedef struct {
double value;
mc_optional_double_t min;
mc_optional_double_t max;
mc_optional_uint32_t precision;
uint64_t expect;
mc_optional_uint64_t expectMax;
const char *expectError;
} DoubleTest;
static void _test_RangeTest_Encode_Double(_mongocrypt_tester_t *tester) {
DoubleTest tests[] = {/* Test cases copied from server Double_Bounds test ... begin */
// Larger numbers map to larger uint64
{.value = -1111, .expect = UINT64_C(4570770991734587392)},
{.value = -111, .expect = UINT64_C(4585860689314185216)},
{.value = -11, .expect = UINT64_C(4600989969312382976)},
{.value = -10, .expect = UINT64_C(4601552919265804288)},
{.value = -3, .expect = UINT64_C(4609434218613702656)},
{.value = -2, .expect = UINT64_C(4611686018427387904)},
{.value = -1, .expect = UINT64_C(4616189618054758400)},
{.value = 1, .expect = UINT64_C(13830554455654793216)},
{.value = 22, .expect = UINT64_C(13850257704024539136)},
{.value = 333, .expect = UINT64_C(13867937850999177216)},
// Larger exponents map to larger uint64
{.value = 33E56, .expect = UINT64_C(14690973652625833878)},
{.value = 22E57, .expect = UINT64_C(14703137697061005818)},
{.value = 11E58, .expect = UINT64_C(14713688953586463292)},
// Smaller exponents map to smaller uint64
{.value = 1E-6, .expect = UINT64_C(13740701229962882445)},
{.value = 1E-7, .expect = UINT64_C(13725520251343122248)},
{.value = 1E-8, .expect = UINT64_C(13710498295186492474)},
{.value = 1E-56, .expect = UINT64_C(12992711961033031890)},
{.value = 1E-57, .expect = UINT64_C(12977434315086142017)},
{.value = 1E-58, .expect = UINT64_C(12962510038552207822)},
// Smaller negative exponents map to smaller uint64
{.value = -1E-06, .expect = UINT64_C(4706042843746669171)},
{.value = -1E-07, .expect = UINT64_C(4721223822366429368)},
{.value = -1E-08, .expect = UINT64_C(4736245778523059142)},
{.value = -1E-56, .expect = UINT64_C(5454032112676519726)},
{.value = -1E-57, .expect = UINT64_C(5469309758623409599)},
{.value = -1E-58, .expect = UINT64_C(5484234035157343794)},
// Larger exponents map to larger uint64
{.value = -33E+56, .expect = UINT64_C(3755770421083717738)},
{.value = -22E+57, .expect = UINT64_C(3743606376648545798)},
{.value = -11E+58, .expect = UINT64_C(3733055120123088324)},
{.value = 0, .expect = UINT64_C(9223372036854775808)},
{.value = -0.0, .expect = UINT64_C(9223372036854775808)},
/* Test cases copied from server Double_Bounds test ... end */
/* Test cases copied from server Double_Errors test ... begin */
{.value = INFINITY, .expectError = "Infinity and NaN double values are not supported."},
{.value = NAN, .expectError = "Infinity and NaN double values are not supported."},
/* Test cases copied from server Double_Errors test ... end */
/* Test cases copied from Double_Bounds_Precision ... begin */
{.value = 3.141592653589,
.precision = OPT_U32_C(1),
.min = OPT_DOUBLE_C(-100000),
.max = OPT_DOUBLE_C(100000),
.expect = UINT64_C(1000031),
.expectMax = OPT_U64_C(2097151)},
{.value = 3.141592653589,
.precision = OPT_U32_C(2),
.min = OPT_DOUBLE_C(-100000),
.max = OPT_DOUBLE_C(100000),
.expect = 10000314,
.expectMax = OPT_U64_C(33554431)},
{.value = 3.141592653589,
.precision = OPT_U32_C(3),
.min = OPT_DOUBLE_C(-100000),
.max = OPT_DOUBLE_C(100000),
.expect = 100003141,
.expectMax = OPT_U64_C(268435455)},
{.value = 3.141592653589,
.precision = OPT_U32_C(4),
.min = OPT_DOUBLE_C(-100000),
.max = OPT_DOUBLE_C(100000),
.expect = 1000031415,
.expectMax = OPT_U64_C(2147483647)},
{.value = 3.141592653589,
.precision = OPT_U32_C(5),
.min = OPT_DOUBLE_C(-100000),
.max = OPT_DOUBLE_C(100000),
.expect = 10000314159,
.expectMax = OPT_U64_C(34359738367)},
{.value = 3.141592653589,
.precision = OPT_U32_C(6),
.min = OPT_DOUBLE_C(-100000),
.max = OPT_DOUBLE_C(100000),
.expect = 100003141592,
.expectMax = OPT_U64_C(274877906943)},
{.value = 3.141592653589,
.precision = OPT_U32_C(7),
.min = OPT_DOUBLE_C(-100000),
.max = OPT_DOUBLE_C(100000),
.expect = 1000031415926,
.expectMax = OPT_U64_C(2199023255551)},
{.value = 0,
.max = OPT_DOUBLE_C(1),
.min = OPT_DOUBLE_C(-1),
.precision = OPT_U32_C(3),
.expect = 1000,
.expectMax = OPT_U64_C(4095)},
{.value = 0,
.max = OPT_DOUBLE_C(1),
.min = OPT_DOUBLE_C(-1E5),
.precision = OPT_U32_C(3),
.expect = 100000000,
.expectMax = OPT_U64_C(134217727)},
{.value = -1E-33,
.max = OPT_DOUBLE_C(1),
.min = OPT_DOUBLE_C(-1E5),
.precision = OPT_U32_C(3),
.expect = 100000000,
.expectMax = OPT_U64_C(134217727)},
{.value = 0,
.max = OPT_DOUBLE_C(DBL_MAX),
.min = OPT_DOUBLE_C(-DBL_MAX),
.precision = OPT_U32_C(3),
.expect = UINT64_C(9223372036854775808),
// Expect precision not to be used.
.expectMax = OPT_U64_C(UINT64_MAX)},
{.value = 3.141592653589,
.max = OPT_DOUBLE_C(5),
.min = OPT_DOUBLE_C(0),
.precision = OPT_U32_C(0),
.expect = 3,
.expectMax = OPT_U64_C(7)},
{.value = 3.141592653589,
.max = OPT_DOUBLE_C(5),
.min = OPT_DOUBLE_C(0),
.precision = OPT_U32_C(1),
.expect = 31,
.expectMax = OPT_U64_C(63)},
{.value = 3.141592653589,
.max = OPT_DOUBLE_C(5),
.min = OPT_DOUBLE_C(0),
.precision = OPT_U32_C(2),
.expect = 314,
.expectMax = OPT_U64_C(1023)},
{.value = 3.141592653589,
.max = OPT_DOUBLE_C(5),
.min = OPT_DOUBLE_C(0),
.precision = OPT_U32_C(3),
.expect = 3141,
.expectMax = OPT_U64_C(8191)},
{.value = 3.141592653589,
.max = OPT_DOUBLE_C(5),
.min = OPT_DOUBLE_C(0),
.precision = OPT_U32_C(16),
.expect = 31415926535890000,
.expectMax = OPT_U64_C(72057594037927935)},
{.value = -5,
.max = OPT_DOUBLE_C(-1),
.min = OPT_DOUBLE_C(-10),
.precision = OPT_U32_C(3),
.expect = 5000,
.expectMax = OPT_U64_C(16383)},
{.value = 1E100,
.max = OPT_DOUBLE_C(DBL_MAX),
.min = OPT_DOUBLE_C(-DBL_MAX),
.precision = OPT_U32_C(3),
.expect = 15326393489903895421ULL,
// Expect precision not to be used.
.expectMax = OPT_U64_C(UINT64_MAX)},
{.value = 1E9,
.max = OPT_DOUBLE_C(1E10),
.min = OPT_DOUBLE_C(0),
.precision = OPT_U32_C(3),
.expect = 1000000000000,
.expectMax = OPT_U64_C(17592186044415)},
{.value = 1E9,
.max = OPT_DOUBLE_C(1E10),
.min = OPT_DOUBLE_C(0),
.precision = OPT_U32_C(0),
.expect = 1000000000,
.expectMax = OPT_U64_C(17179869183)},
{.value = -5,
.max = OPT_DOUBLE_C(10),
.min = OPT_DOUBLE_C(-10),
.precision = OPT_U32_C(0),
.expect = 5,
.expectMax = OPT_U64_C(31)},
{.value = -5,
.max = OPT_DOUBLE_C(10),
.min = OPT_DOUBLE_C(-10),
.precision = OPT_U32_C(2),
.expect = 500,
.expectMax = OPT_U64_C(4095)},
{.value = 1E-30,
.max = OPT_DOUBLE_C(10E-30),
.min = OPT_DOUBLE_C(1E-30),
.precision = OPT_U32_C(35),
.expect = 13381399884061196960ULL,
// Expect precision not to be used.
.expectMax = OPT_U64_C(UINT64_MAX)},
/* Test cases copied from Double_Bounds_Precision ... end */
{.value = -1,
.min = OPT_DOUBLE_C(0),
.max = OPT_DOUBLE_C(200),
.precision = OPT_U32_C(1),
.expectError = "greater than or equal to the minimum value"},
{.value = -1,
.min = OPT_DOUBLE_C(0),
.max = OPT_DOUBLE_C(201),
.precision = OPT_U32_C(1),
.expectError = "less than or equal to the maximum value"}};
for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
DoubleTest *test = tests + i;
mongocrypt_status_t *const status = mongocrypt_status_new();
if (test->min.set && test->max.set && test->precision.set) {
printf("_test_RangeTest_Encode_Double: value=%f, min=%f, max=%f, "
"precision=%" PRIu32 "\n",
test->value,
test->min.value,
test->max.value,
test->precision.value);
} else {
printf("_test_RangeTest_Encode_Double: value=%f\n", test->value);
}
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);
if (test->expectError) {
ASSERT_OR_PRINT_MSG(!ok, "expected error, but got none");
ASSERT_STATUS_CONTAINS(status, test->expectError);
} else {
ASSERT_OK_STATUS(ok, status);
ASSERT_CMPUINT64(got.value, ==, test->expect);
ASSERT_CMPUINT64(got.min, ==, 0);
ASSERT_CMPUINT64(got.max, ==, test->expectMax.set ? test->expectMax.value : UINT64_MAX);
}
mongocrypt_status_destroy(status);
}
}
#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
typedef struct {
mc_dec128 value;
mc_optional_dec128_t min;
mc_optional_dec128_t max;
mc_optional_uint32_t precision;
mlib_int128 expect;
const char *expectError;
} Decimal128Test;
static void _test_RangeTest_Encode_Decimal128(_mongocrypt_tester_t *tester) {
Decimal128Test tests[] = {
#define CASE(Value, ExpectStr) \
(Decimal128Test){.value = mc_dec128_from_string(#Value), .expect = mlib_int128_from_string(ExpectStr, NULL)}
/* Test cases copied from server Decimal128_Bounds test ... begin */
// Larger numbers map to larger int128
CASE(-1234567890E7, "108549948892579231731687303715884111887"),
CASE(-1234567890E6, "108559948892579231731687303715884111886"),
CASE(-1234567890E5, "108569948892579231731687303715884111885"),
CASE(-1234567890E4, "108579948892579231731687303715884111884"),
CASE(-1234567890E3, "108589948892579231731687303715884111883"),
CASE(-1234567890E2, "108599948892579231731687303715884111882"),
CASE(-1234567890E1, "108609948892579231731687303715884111881"),
CASE(-123456789012345, "108569948892579108281687303715884111885"),
CASE(-12345678901234, "108579948892579108331687303715884111884"),
CASE(-1234567890123, "108589948892579108731687303715884111883"),
CASE(-123456789012, "108599948892579111731687303715884111882"),
CASE(-12345678901, "108609948892579131731687303715884111881"),
CASE(-1234567890, "108619948892579231731687303715884111880"),
CASE(-99999999, "108631183460569231731687303715884111878"),
CASE(-8888888, "108642294572469231731687303715884111877"),
CASE(-777777, "108653405690469231731687303715884111876"),
CASE(-66666, "108664516860469231731687303715884111875"),
CASE(-5555, "108675628460469231731687303715884111874"),
CASE(-444, "108686743460469231731687303715884111873"),
CASE(-334, "108687843460469231731687303715884111873"),
CASE(-333, "108687853460469231731687303715884111873"),
CASE(-44, "108696783460469231731687303715884111872"),
CASE(-33, "108697883460469231731687303715884111872"),
CASE(-22, "108698983460469231731687303715884111872"),
CASE(-5, "108706183460469231731687303715884111871"),
CASE(-4, "108707183460469231731687303715884111871"),
CASE(-3, "108708183460469231731687303715884111871"),
CASE(-2, "108709183460469231731687303715884111871"),
CASE(-1, "108710183460469231731687303715884111871"),
CASE(0, "170141183460469231731687303715884105728"),
CASE(1, "231572183460469231731687303715884099585"),
CASE(2, "231573183460469231731687303715884099585"),
CASE(3, "231574183460469231731687303715884099585"),
CASE(4, "231575183460469231731687303715884099585"),
CASE(5, "231576183460469231731687303715884099585"),
CASE(22, "231583383460469231731687303715884099584"),
CASE(33, "231584483460469231731687303715884099584"),
CASE(44, "231585583460469231731687303715884099584"),
CASE(333, "231594513460469231731687303715884099583"),
CASE(334, "231594523460469231731687303715884099583"),
CASE(444, "231595623460469231731687303715884099583"),
CASE(5555, "231606738460469231731687303715884099582"),
CASE(66666, "231617850060469231731687303715884099581"),
CASE(777777, "231628961230469231731687303715884099580"),
CASE(8888888, "231640072348469231731687303715884099579"),
CASE(33E56, "232144483460469231731687303715884099528"),
CASE(22E57, "232153383460469231731687303715884099527"),
CASE(11E58, "232162283460469231731687303715884099526"),
// Smaller exponents map to smaller int128
CASE(1E-6, "231512183460469231731687303715884099591"),
CASE(1E-7, "231502183460469231731687303715884099592"),
CASE(1E-8, "231492183460469231731687303715884099593"),
CASE(1E-56, "231012183460469231731687303715884099641"),
CASE(1E-57, "231002183460469231731687303715884099642"),
CASE(1E-58, "230992183460469231731687303715884099643"),
// Smaller negative exponents map to smaller int128
CASE(-1E-6, "108770183460469231731687303715884111865"),
CASE(-1E-7, "108780183460469231731687303715884111864"),
CASE(-1E-8, "108790183460469231731687303715884111863"),
CASE(-1E-56, "109270183460469231731687303715884111815"),
CASE(-1E-57, "109280183460469231731687303715884111814"),
CASE(-1E-58, "109290183460469231731687303715884111813"),
// Larger exponents map to larger int128
CASE(-33E56, "108137883460469231731687303715884111928"),
CASE(-22E57, "108128983460469231731687303715884111929"),
CASE(-11E58, "108120083460469231731687303715884111930"),
(Decimal128Test){.value = MC_DEC128_LARGEST_POSITIVE,
.expect = mlib_int128_from_string("293021183460469231731687303715884093440", NULL)},
(Decimal128Test){.value = MC_DEC128_SMALLEST_POSITIVE,
.expect = mlib_int128_from_string("170141183460469231731687303715884105729", NULL)},
(Decimal128Test){.value = MC_DEC128_LARGEST_NEGATIVE,
.expect = mlib_int128_from_string("47261183460469231731687303715884118016", NULL)},
(Decimal128Test){.value = MC_DEC128_SMALLEST_NEGATIVE,
.expect = mlib_int128_from_string("170141183460469231731687303715884105727", NULL)},
(Decimal128Test){.value = MC_DEC128_NORMALIZED_ZERO,
.expect = mlib_int128_from_string("170141183460469231731687303715884105728", NULL)},
(Decimal128Test){.value = MC_DEC128_NEGATIVE_EXPONENT_ZERO,
.expect = mlib_int128_from_string("170141183460469231731687303715884105728", NULL)},
/* Test cases copied from server Decimal128_Bounds test ... end */
#define ERROR_CASE(Value, Min, Max, Precision, ErrorString) \
(Decimal128Test){ \
.value = Value, \
.min = Min, \
.max = Max, \
.precision = Precision, \
.expectError = ErrorString, \
}
ERROR_CASE(MC_DEC128_C(1),
OPT_NULLOPT,
OPT_MC_DEC128(MC_DEC128_C(2)),
OPT_U32(5),
"min, max, and precision must all be set or must all be unset"),
ERROR_CASE(MC_DEC128_C(1),
OPT_MC_DEC128(MC_DEC128_C(0)),
OPT_NULLOPT,
OPT_U32(5),
"min, max, and precision must all be set or must all be unset"),
ERROR_CASE(MC_DEC128_C(1),
OPT_MC_DEC128(MC_DEC128_C(2)),
OPT_MC_DEC128(MC_DEC128_C(1)),
OPT_U32(5),
"The minimum value must be less than the maximum value"),
ERROR_CASE(MC_DEC128_C(1),
OPT_MC_DEC128(MC_DEC128_C(2)),
OPT_MC_DEC128(MC_DEC128_C(3)),
OPT_U32(5),
"Value must be greater than or equal to the minimum value "
"and less than or equal to the maximum value"),
ERROR_CASE(MC_DEC128_C(4),
OPT_MC_DEC128(MC_DEC128_C(2)),
OPT_MC_DEC128(MC_DEC128_C(3)),
OPT_U32(5),
"Value must be greater than or equal to the minimum value "
"and less than or equal to the maximum value"),
ERROR_CASE(MC_DEC128_POSITIVE_INFINITY,
OPT_NULLOPT,
OPT_NULLOPT,
OPT_NULLOPT,
"Infinity and Nan Decimal128 values are not supported."),
ERROR_CASE(MC_DEC128_NEGATIVE_INFINITY,
OPT_NULLOPT,
OPT_NULLOPT,
OPT_NULLOPT,
"Infinity and Nan Decimal128 values are not supported."),
ERROR_CASE(MC_DEC128_POSITIVE_NAN,
OPT_NULLOPT,
OPT_NULLOPT,
OPT_NULLOPT,
"Infinity and Nan Decimal128 values are not supported."),
ERROR_CASE(MC_DEC128_NEGATIVE_NAN,
OPT_NULLOPT,
OPT_NULLOPT,
OPT_NULLOPT,
"Infinity and Nan Decimal128 values are not supported."),
/* Test cases copied from Decimal128_Bounds_Precision ... begin */
#define ASSERT_EIBP(Value, Precision, Expect) \
(Decimal128Test){ \
.value = mc_dec128_from_string(Value), \
.min = OPT_MC_DEC128(MC_DEC128_C(-100000)), \
.max = OPT_MC_DEC128(MC_DEC128_C(100000)), \
.precision = OPT_U32(Precision), \
.expect = MLIB_INT128(Expect), \
}
ASSERT_EIBP("3.141592653589E-1", 10, 1000003141592653),
ASSERT_EIBP("31.41592653589E-2", 10, 1000003141592653),
ASSERT_EIBP("314.1592653589E-3", 10, 1000003141592653),
ASSERT_EIBP("3141.592653589E-4", 10, 1000003141592653),
ASSERT_EIBP("31415.92653589E-5", 10, 1000003141592653),
ASSERT_EIBP("314159.2653589E-6", 10, 1000003141592653),
ASSERT_EIBP("3141592.653589E-7", 10, 1000003141592653),
ASSERT_EIBP("31415926.53589E-8", 10, 1000003141592653),
#undef ASSERT_EIBP
#define ASSERT_EIBPL(Value, Precision, Expect) \
(Decimal128Test){ \
.value = mc_dec128_from_string(Value), \
.min = OPT_MC_DEC128(MC_DEC128_C(-100000)), \
.max = OPT_MC_DEC128(mc_dec128_from_string("1E22")), \
.precision = OPT_U32(Precision), \
.expect = mlib_int128_from_string(Expect, NULL), \
}
ASSERT_EIBPL("3.1415926535897932384626433832795E20", 5, "31415926535897942384626433"),
ASSERT_EIBPL("3.1415926535897932384626433832795E20", 6, "314159265358979423846264338"),
ASSERT_EIBPL("3.1415926535897932384626433832795E20", 7, "3141592653589794238462643383"),
ASSERT_EIBPL("3.1415926535897932384626433832795E20", 8, "31415926535897942384626433832"),
#undef ASSERT_EIBPL
#define ASSERT_EIBP(Value, Precision, Expect) \
(Decimal128Test){ \
.value = mc_dec128_from_string(#Value), \
.min = OPT_MC_DEC128(MC_DEC128_C(-100000)), \
.max = OPT_MC_DEC128(MC_DEC128_C(100000)), \
.precision = OPT_U32(Precision), \
.expect = MLIB_INT128_CAST(Expect), \
}
ASSERT_EIBP(3.141592653589, 1, 1000031),
ASSERT_EIBP(3.141592653589, 2, 10000314),
ASSERT_EIBP(3.141592653589, 3, 100003141),
ASSERT_EIBP(3.141592653589, 4, 1000031415),
ASSERT_EIBP(3.141592653589, 5, 10000314159),
ASSERT_EIBP(3.141592653589, 6, 100003141592),
ASSERT_EIBP(3.141592653589, 7, 1000031415926),
#undef ASSERT_EIBP
#define ASSERT_EIBB(Val, Max, Min, Precision, Expect) \
(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_U32(Precision), \
.expect = MLIB_INT128_CAST(Expect), \
}
#define ASSERT_EIBB_OVERFLOW(Val, Max, Min, Precision, Expect) \
(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_U32(Precision), .expect = Expect, \
}
ASSERT_EIBB(0, 1, -1, 3, 1000),
ASSERT_EIBB(0, 1, -1E5, 3, 100000000),
ASSERT_EIBB(-1E-33, 1, -1E5, 3, 100000000),
ASSERT_EIBB_OVERFLOW(0,
MC_DEC128_LARGEST_POSITIVE,
MC_DEC128_LARGEST_NEGATIVE,
3,
mlib_int128_from_string("170141183460469231731687303715884105728", NULL)),
ASSERT_EIBB_OVERFLOW(0,
DBL_MAX,
DBL_MIN,
3,
mlib_int128_from_string("170141183460469231731687303715884105728", NULL)),
ASSERT_EIBB(3.141592653589, 5, 0, 0, 3),
ASSERT_EIBB(3.141592653589, 5, 0, 1, 31),
ASSERT_EIBB(3.141592653589, 5, 0, 2, 314),
ASSERT_EIBB(3.141592653589, 5, 0, 3, 3141),
ASSERT_EIBB(3.141592653589, 5, 0, 16, 31415926535890000),
ASSERT_EIBB(-5, -1, -10, 3, 5000),
ASSERT_EIBB_OVERFLOW(1E100,
DBL_MAX,
DBL_MIN,
3,
mlib_int128_from_string("232572183460469231731687303715884099485", NULL)),
ASSERT_EIBB(1E9, 1E10, 0, 3, 1000000000000),
ASSERT_EIBB(1E9, 1E10, 0, 0, 1000000000),
ASSERT_EIBB(-5, 10, -10, 0, 5),
ASSERT_EIBB(-5, 10, -10, 2, 500),
ASSERT_EIBB(5E-30, 10E-30, 1E-30, 35, 400000),
// Test a range that requires > 64 bits.
ASSERT_EIBB(5, 18446744073709551616, .1, 1, 49),
// Test a range that requires > 64 bits.
// min has more places after the decimal than precision.
ASSERT_EIBB(5, 18446744073709551616, .01, 1, 49),
#undef ASSERT_EIBB
#undef ASSERT_EIBB_OVERFLOW
/* Test cases copied from Decimal128_Bounds_Precision ... end */
};
for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
Decimal128Test *test = tests + i;
mongocrypt_status_t *const status = mongocrypt_status_new();
if (test->min.set && test->max.set && test->precision.set) {
printf("_test_RangeTest_Encode_Decimal128: value=%s, min=%s, max=%s, "
"precision=%" PRIu32 "\n",
mc_dec128_to_string(test->value).str,
mc_dec128_to_string(test->min.value).str,
mc_dec128_to_string(test->max.value).str,
test->precision.value);
} else {
printf("_test_RangeTest_Encode_Decimal128: value=%s\n", mc_dec128_to_string(test->value).str);
}
fflush(stdout);
mc_OSTType_Decimal128 got;
const bool ok = mc_getTypeInfoDecimal128((mc_getTypeInfoDecimal128_args_t){.value = test->value,
.min = test->min,
.max = test->max,
.precision = test->precision},
&got,
status);
if (test->expectError) {
ASSERT_OR_PRINT_MSG(!ok, "expected error, but got none");
ASSERT_STATUS_CONTAINS(status, test->expectError);
} else {
ASSERT_OK_STATUS(ok, status);
ASSERT_CMPINT128_EQ(got.value, test->expect);
ASSERT_CMPINT128_EQ(got.min, MLIB_INT128(0));
}
mongocrypt_status_destroy(status);
}
}
#endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
void _mongocrypt_tester_install_range_encoding(_mongocrypt_tester_t *tester) {
INSTALL_TEST(_test_RangeTest_Encode_Int32);
INSTALL_TEST(_test_RangeTest_Encode_Int64);
INSTALL_TEST(_test_RangeTest_Encode_Double);
#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
INSTALL_TEST(_test_RangeTest_Encode_Decimal128);
#endif
}