libmongocrypt-helper 1.12.0.0.1001 → 1.14.0.0.1001

data/ext/libmongocrypt/libmongocrypt/test/test-mc-range-edge-generation.c

@@ -38,20 +38,19 @@ typedef struct {
 #undef MAX_INT32_EDGES
 
 static void print_edges_compared(mc_edges_t *edgesGot, const char *const *edgesExpected) {
-    fflush(stdout); // Avoid incomplete stdout output from prior tests on error
-    fprintf(stderr, "edges got ... begin\n");
+    TEST_STDERR_PRINTF("edges got ... begin\n");
     for (size_t i = 0; i < mc_edges_len(edgesGot); i++) {
-        fprintf(stderr, "  %s\n", mc_edges_get(edgesGot, i));
+        TEST_STDERR_PRINTF("  %s\n", mc_edges_get(edgesGot, i));
     }
-    fprintf(stderr, "edges got ... end\n");
+    TEST_STDERR_PRINTF("edges got ... end\n");
 
-    fprintf(stderr, "edges expected ... begin\n");
+    TEST_STDERR_PRINTF("edges expected ... begin\n");
     const char *const *iter = edgesExpected;
     while (*iter != NULL) {
-        fprintf(stderr, "  %s\n", *iter);
+        TEST_STDERR_PRINTF("  %s\n", *iter);
         iter++;
     }
-    fprintf(stderr, "edges expected ... end\n");
+    TEST_STDERR_PRINTF("edges expected ... end\n");
 }
 
 static void _test_getEdgesInt32(_mongocrypt_tester_t *tester) {
@@ -117,8 +116,7 @@ static void _test_getEdgesInt32(_mongocrypt_tester_t *tester) {
                                         .max = test->max,
                                         .sparsity = test->sparsity,
                                         .trimFactor = OPT_I32(test->trimFactor)};
-        const bool use_range_v2 = true;
-        mc_edges_t *got = mc_getEdgesInt32(args, status, use_range_v2);
+        mc_edges_t *got = mc_getEdgesInt32(args, status);
         if (test->expectError != NULL) {
             ASSERT_OR_PRINT_MSG(NULL == got, "expected error, got success");
             ASSERT_STATUS_CONTAINS(status, test->expectError);
@@ -210,8 +208,7 @@ static void _test_getEdgesInt64(_mongocrypt_tester_t *tester) {
                                         .max = test->max,
                                         .sparsity = test->sparsity,
                                         .trimFactor = OPT_I32(test->trimFactor)};
-        const bool use_range_v2 = true;
-        mc_edges_t *got = mc_getEdgesInt64(args, status, use_range_v2);
+        mc_edges_t *got = mc_getEdgesInt64(args, status);
         if (test->expectError != NULL) {
             ASSERT_OR_PRINT_MSG(NULL == got, "expected error, got success");
             ASSERT_STATUS_CONTAINS(status, test->expectError);
@@ -271,8 +268,7 @@ static void _test_getEdgesDouble(_mongocrypt_tester_t *tester) {
         mc_getEdgesDouble_args_t args = {.value = test->value,
                                          .sparsity = test->sparsity,
                                          .trimFactor = OPT_I32(trimFactor)};
-        const bool use_range_v2 = true;
-        mc_edges_t *got = mc_getEdgesDouble(args, status, use_range_v2);
+        mc_edges_t *got = mc_getEdgesDouble(args, status);
 
         if (test->expectError != NULL) {
             if (NULL != got) {
@@ -309,7 +305,7 @@ static void _test_getEdgesDouble(_mongocrypt_tester_t *tester) {
     }
 }
 
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
 #define MAX_DEC128_EDGES 129
 
 typedef struct {
@@ -339,8 +335,7 @@ static void _test_getEdgesDecimal128(_mongocrypt_tester_t *tester) {
                                              //  .max = test->max,
                                              .sparsity = (size_t)test->sparsity,
                                              .trimFactor = OPT_I32(trimFactor)};
-        const bool use_range_v2 = true;
-        mc_edges_t *got = mc_getEdgesDecimal128(args, status, use_range_v2);
+        mc_edges_t *got = mc_getEdgesDecimal128(args, status);
 
         if (test->expectError != NULL) {
             if (NULL != got) {
@@ -493,7 +488,7 @@ void _mongocrypt_tester_install_range_edge_generation(_mongocrypt_tester_t *test
     INSTALL_TEST(_test_getEdgesInt32);
     INSTALL_TEST(_test_getEdgesInt64);
     INSTALL_TEST(_test_getEdgesDouble);
-#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
+#if MONGOCRYPT_HAVE_DECIMAL128_SUPPORT()
     INSTALL_TEST(_test_getEdgesDecimal128);
 #endif
     INSTALL_TEST(_test_count_leading_zeros);

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

@@ -83,14 +83,14 @@ static void _test_RangeTest_Encode_Int32(_mongocrypt_tester_t *tester) {
         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);
+        TEST_PRINTF("_test_RangeTest_Encode_Int32: value=%" PRId32, test->args.value);
         if (test->args.min.set) {
-            printf(" min=%" PRId32, test->args.min.value);
+            TEST_PRINTF(" min=%" PRId32, test->args.min.value);
         }
         if (test->args.max.set) {
-            printf(" max=%" PRId32, test->args.max.value);
+            TEST_PRINTF(" max=%" PRId32, test->args.max.value);
         }
-        printf("\n");
+        TEST_PRINTF("\n");
         mc_OSTType_Int32 got;
         const bool ok = mc_getTypeInfo32(test->args, &got, status);
         if (test->expectError) {
@@ -171,14 +171,14 @@ static void _test_RangeTest_Encode_Int64(_mongocrypt_tester_t *tester) {
         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);
+        TEST_PRINTF("_test_RangeTest_Encode_Int64: value=%" PRId64, test->args.value);
         if (test->args.min.set) {
-            printf(" min=%" PRId64, test->args.min.value);
+            TEST_PRINTF(" min=%" PRId64, test->args.min.value);
         }
         if (test->args.max.set) {
-            printf(" max=%" PRId64, test->args.max.value);
+            TEST_PRINTF(" max=%" PRId64, test->args.max.value);
         }
-        printf("\n");
+        TEST_PRINTF("\n");
         mc_OSTType_Int64 got;
         const bool ok = mc_getTypeInfo64(test->args, &got, status);
         if (test->expectError) {
@@ -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();                                                   \
-        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();                                                   \
-        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
@@ -551,25 +559,23 @@ static void _test_RangeTest_Encode_Double(_mongocrypt_tester_t *tester) {
         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);
+            TEST_PRINTF("_test_RangeTest_Encode_Double: value=%f, min=%f, max=%f, "
+                        "precision=%" PRId32 "\n",
+                        test->value,
+                        test->min.value,
+                        test->max.value,
+                        test->precision.value);
         } else {
-            printf("_test_RangeTest_Encode_Double: value=%f\n", test->value);
+            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;
@@ -599,10 +605,10 @@ static void _test_canUsePrecisionModeDecimal(_mongocrypt_tester_t *tester) {
     {                                                                                                                  \
         uint32_t bits_out = 0;                                                                                         \
         mongocrypt_status_t *const status = mongocrypt_status_new();                                                   \
-        printf("_test_canUsePrecisionModeDecimal, min: %s, max: %s, prc: %" PRIu32,                                    \
-               mc_dec128_to_string(lb).str,                                                                            \
-               mc_dec128_to_string(ub).str,                                                                            \
-               prc);                                                                                                   \
+        TEST_PRINTF("_test_canUsePrecisionModeDecimal, min: %s, max: %s, prc: %" PRIu32,                               \
+                    mc_dec128_to_string(lb).str,                                                                       \
+                    mc_dec128_to_string(ub).str,                                                                       \
+                    prc);                                                                                              \
         bool result = mc_canUsePrecisionModeDecimal(lb, ub, prc, &bits_out, status);                                   \
         ASSERT_OK_STATUS(mongocrypt_status_ok(status), status);                                                        \
         ASSERT(result == expected);                                                                                    \
@@ -613,10 +619,10 @@ static void _test_canUsePrecisionModeDecimal(_mongocrypt_tester_t *tester) {
 #define CAN_USE_PRECISION_MODE_ERRORS(lb, ub, prc, error)                                                              \
     {                                                                                                                  \
         mongocrypt_status_t *const status = mongocrypt_status_new();                                                   \
-        printf("_test_canUsePrecisionModeDecimal errors, min: %s, max: %s, prc: %" PRIu32,                             \
-               mc_dec128_to_string(lb).str,                                                                            \
-               mc_dec128_to_string(ub).str,                                                                            \
-               prc);                                                                                                   \
+        TEST_PRINTF("_test_canUsePrecisionModeDecimal errors, min: %s, max: %s, prc: %" PRIu32,                        \
+                    mc_dec128_to_string(lb).str,                                                                       \
+                    mc_dec128_to_string(ub).str,                                                                       \
+                    prc);                                                                                              \
         uint32_t bits_out = 0;                                                                                         \
         bool result = mc_canUsePrecisionModeDecimal(lb, ub, prc, &bits_out, status);                                   \
         ASSERT_OR_PRINT_MSG(!result, "expected error, but got none");                                                  \
@@ -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       \
     }
@@ -986,18 +984,16 @@ static void _test_RangeTest_Encode_Decimal128(_mongocrypt_tester_t *tester) {
         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);
+            TEST_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);
+            TEST_PRINTF("_test_RangeTest_Encode_Decimal128: value=%s\n", mc_dec128_to_string(test->value).str);
         }
-        fflush(stdout);
         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,
@@ -1006,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);
@@ -1028,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;
@@ -248,124 +240,116 @@ static const char *const *_test_expectMincoverDecimal128(void *tests, size_t idx
 static void _test_dump_32(void *tests, size_t idx, mc_mincover_t *got) {
     BSON_ASSERT_PARAM(tests);
     Int32Test *const test = (Int32Test *)tests + idx;
-    fflush(stdout); // Avoid incomplete stdout output from prior tests on error
-    fprintf(stderr,
-            "testcase: lowerBound=%" PRId32 " (%s) upperBound=%" PRId32 " (%s)",
-            test->lowerBound,
-            test->includeLowerBound ? "inclusive" : "exclusive",
-            test->upperBound,
-            test->includeUpperBound ? "inclusive" : "exclusive");
+    TEST_STDERR_PRINTF("testcase: lowerBound=%" PRId32 " (%s) upperBound=%" PRId32 " (%s)",
+                       test->lowerBound,
+                       test->includeLowerBound ? "inclusive" : "exclusive",
+                       test->upperBound,
+                       test->includeUpperBound ? "inclusive" : "exclusive");
     if (test->min.set) {
-        fprintf(stderr, " min=%" PRId32, test->min.value);
+        TEST_STDERR_PRINTF(" min=%" PRId32, test->min.value);
     }
     if (test->max.set) {
-        fprintf(stderr, " max=%" PRId32, test->max.value);
+        TEST_STDERR_PRINTF(" max=%" PRId32, test->max.value);
     }
-    fprintf(stderr, " sparsity=%zu\n", test->sparsity);
-    fprintf(stderr, "mincover expected ... begin\n");
+    TEST_STDERR_PRINTF(" sparsity=%zu\n", test->sparsity);
+    TEST_STDERR_PRINTF("mincover expected ... begin\n");
     for (const char **p = test->expectMincoverStrings; *p; ++p) {
-        fprintf(stderr, "  %s\n", *p);
+        TEST_STDERR_PRINTF("  %s\n", *p);
     }
-    fprintf(stderr, "mincover expected ... end\n");
-    fprintf(stderr, "mincover got ... begin\n");
+    TEST_STDERR_PRINTF("mincover expected ... end\n");
+    TEST_STDERR_PRINTF("mincover got ... begin\n");
     for (size_t i = 0; i < mc_mincover_len(got); i++) {
-        fprintf(stderr, "  %s\n", mc_mincover_get(got, i));
+        TEST_STDERR_PRINTF("  %s\n", mc_mincover_get(got, i));
     }
-    fprintf(stderr, "mincover got ... end\n");
+    TEST_STDERR_PRINTF("mincover got ... end\n");
 }
 
 static void _test_dump_64(void *tests, size_t idx, mc_mincover_t *got) {
     BSON_ASSERT_PARAM(tests);
     Int64Test *const test = (Int64Test *)tests + idx;
-    fflush(stdout); // Avoid incomplete stdout output from prior tests on error
-    fprintf(stderr,
-            "testcase: lowerBound=%" PRId64 " (%s) upperBound=%" PRId64 " (%s)",
-            test->lowerBound,
-            test->includeLowerBound ? "inclusive" : "exclusive",
-            test->upperBound,
-            test->includeUpperBound ? "inclusive" : "exclusive");
+    TEST_STDERR_PRINTF("testcase: lowerBound=%" PRId64 " (%s) upperBound=%" PRId64 " (%s)",
+                       test->lowerBound,
+                       test->includeLowerBound ? "inclusive" : "exclusive",
+                       test->upperBound,
+                       test->includeUpperBound ? "inclusive" : "exclusive");
     if (test->min.set) {
-        fprintf(stderr, " min=%" PRId64, test->min.value);
+        TEST_STDERR_PRINTF(" min=%" PRId64, test->min.value);
     }
     if (test->max.set) {
-        fprintf(stderr, " max=%" PRId64, test->max.value);
+        TEST_STDERR_PRINTF(" max=%" PRId64, test->max.value);
     }
-    fprintf(stderr, " sparsity=%zu\n", test->sparsity);
-    fprintf(stderr, "mincover expected ... begin\n");
+    TEST_STDERR_PRINTF(" sparsity=%zu\n", test->sparsity);
+    TEST_STDERR_PRINTF("mincover expected ... begin\n");
     for (const char **p = test->expectMincoverStrings; *p; ++p) {
-        fprintf(stderr, "  %s\n", *p);
+        TEST_STDERR_PRINTF("  %s\n", *p);
     }
-    fprintf(stderr, "mincover expected ... end\n");
-    fprintf(stderr, "mincover got ... begin\n");
+    TEST_STDERR_PRINTF("mincover expected ... end\n");
+    TEST_STDERR_PRINTF("mincover got ... begin\n");
     for (size_t i = 0; i < mc_mincover_len(got); i++) {
-        fprintf(stderr, "  %s\n", mc_mincover_get(got, i));
+        TEST_STDERR_PRINTF("  %s\n", mc_mincover_get(got, i));
     }
-    fprintf(stderr, "mincover got ... end\n");
+    TEST_STDERR_PRINTF("mincover got ... end\n");
 }
 
 static void _test_dump_Double(void *tests, size_t idx, mc_mincover_t *got) {
     BSON_ASSERT_PARAM(tests);
     DoubleTest *const test = (DoubleTest *)tests + idx;
-    fflush(stdout); // Avoid incomplete stdout output from prior tests on error
-    fprintf(stderr,
-            "testcase: lowerBound=%f (%s) upperBound=%f (%s)",
-            test->lowerBound,
-            test->includeLowerBound ? "inclusive" : "exclusive",
-            test->upperBound,
-            test->includeUpperBound ? "inclusive" : "exclusive");
+    TEST_STDERR_PRINTF("testcase: lowerBound=%f (%s) upperBound=%f (%s)",
+                       test->lowerBound,
+                       test->includeLowerBound ? "inclusive" : "exclusive",
+                       test->upperBound,
+                       test->includeUpperBound ? "inclusive" : "exclusive");
     if (test->min.set) {
-        fprintf(stderr, " min=%f", test->min.value);
+        TEST_STDERR_PRINTF(" min=%f", test->min.value);
     }
     if (test->max.set) {
-        fprintf(stderr, " max=%f", test->max.value);
+        TEST_STDERR_PRINTF(" max=%f", test->max.value);
     }
     if (test->precision.set) {
-        fprintf(stderr, " precision=%" PRIu32, test->precision.value);
+        TEST_STDERR_PRINTF(" precision=%" PRId32, test->precision.value);
     }
-    fprintf(stderr, " sparsity=%zu\n", test->sparsity);
-    fprintf(stderr, "mincover expected ... begin\n");
+    TEST_STDERR_PRINTF(" sparsity=%zu\n", test->sparsity);
+    TEST_STDERR_PRINTF("mincover expected ... begin\n");
     for (const char **p = test->expectMincoverStrings; *p; ++p) {
-        fprintf(stderr, "  %s\n", *p);
+        TEST_STDERR_PRINTF("  %s\n", *p);
     }
-    fprintf(stderr, "mincover expected ... end\n");
-    fprintf(stderr, "mincover got ... begin\n");
+    TEST_STDERR_PRINTF("mincover expected ... end\n");
+    TEST_STDERR_PRINTF("mincover got ... begin\n");
     for (size_t i = 0; i < mc_mincover_len(got); i++) {
-        fprintf(stderr, "  %s\n", mc_mincover_get(got, i));
+        TEST_STDERR_PRINTF("  %s\n", mc_mincover_get(got, i));
     }
-    fprintf(stderr, "mincover got ... end\n");
+    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;
-    fflush(stdout); // Avoid incomplete stdout output from prior tests on error
-    fprintf(stderr,
-            "testcase: lowerBound=%s (%s) upperBound=%s (%s)",
-            mc_dec128_to_string(test->lowerBound).str,
-            test->includeLowerBound ? "inclusive" : "exclusive",
-            mc_dec128_to_string(test->upperBound).str,
-            test->includeUpperBound ? "inclusive" : "exclusive");
+    TEST_STDERR_PRINTF("testcase: lowerBound=%s (%s) upperBound=%s (%s)",
+                       mc_dec128_to_string(test->lowerBound).str,
+                       test->includeLowerBound ? "inclusive" : "exclusive",
+                       mc_dec128_to_string(test->upperBound).str,
+                       test->includeUpperBound ? "inclusive" : "exclusive");
     if (test->min.set) {
-        fprintf(stderr, " min=%s", mc_dec128_to_string(test->min.value).str);
+        TEST_STDERR_PRINTF(" min=%s", mc_dec128_to_string(test->min.value).str);
     }
     if (test->max.set) {
-        fprintf(stderr, " max=%s", mc_dec128_to_string(test->max.value).str);
+        TEST_STDERR_PRINTF(" max=%s", mc_dec128_to_string(test->max.value).str);
     }
     if (test->precision.set) {
-        fprintf(stderr, " precision=%" PRIu32, test->precision.value);
+        TEST_STDERR_PRINTF(" precision=%" PRIu32, test->precision.value);
     }
-    fprintf(stderr, " sparsity=%zu\n", test->sparsity);
-    fprintf(stderr, "mincover expected ... begin\n");
+    TEST_STDERR_PRINTF(" sparsity=%zu\n", test->sparsity);
+    TEST_STDERR_PRINTF("mincover expected ... begin\n");
     for (const char **p = test->expectMincoverStrings; *p; ++p) {
-        fprintf(stderr, "  %s\n", *p);
+        TEST_STDERR_PRINTF("  %s\n", *p);
     }
-    fprintf(stderr, "mincover expected ... end\n");
-    fprintf(stderr, "mincover got ... begin\n");
+    TEST_STDERR_PRINTF("mincover expected ... end\n");
+    TEST_STDERR_PRINTF("mincover got ... begin\n");
     for (size_t i = 0; i < mc_mincover_len(got); i++) {
-        fprintf(stderr, "  %s\n", mc_mincover_get(got, i));
+        TEST_STDERR_PRINTF("  %s\n", mc_mincover_get(got, i));
     }
-    fprintf(stderr, "mincover got ... end\n");
+    TEST_STDERR_PRINTF("mincover got ... end\n");
 }
 #endif // MONGOCRYPT_HAVE_DECIMAL128_SUPPORT
 
@@ -602,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"
@@ -622,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
 }