libmongocrypt-helper 1.12.0.0.1001 → 1.13.2.0.1001

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) {
@@ -201,7 +201,7 @@ static void _test_canUsePrecisionModeDouble(_mongocrypt_tester_t *tester) {
     {                                                                                                                  \
         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: %" PRIu32, lb, ub, prc);                 \
         bool result = mc_canUsePrecisionModeDouble(lb, ub, prc, &bits_out, status);                                    \
         ASSERT_OK_STATUS(mongocrypt_status_ok(status), status);                                                        \
         ASSERT(result == expected);                                                                                    \
@@ -212,7 +212,7 @@ static void _test_canUsePrecisionModeDouble(_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: %f, max: %f, prc: %" PRIu32, lb, ub, prc);               \
+        TEST_PRINTF("_test_canUsePrecisionModeDecimal errors, min: %f, max: %f, prc: %" PRIu32, 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");                                                  \
@@ -551,14 +551,14 @@ 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=%" PRIu32 "\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;
@@ -599,10 +599,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 +613,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");                                                  \
@@ -986,16 +986,15 @@ 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(

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

@@ -248,124 +248,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=%" 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");
 }
 
 #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
 

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

@@ -87,7 +87,7 @@ static void test_mc_RangeOpts_parse(_mongocrypt_tester_t *tester) {
         testcase *test = tests + i;
         mongocrypt_status_t *status = mongocrypt_status_new();
         mc_RangeOpts_t ro;
-        printf("running test_mc_RangeOpts_parse subtest: %s\n", test->desc);
+        TEST_PRINTF("running test_mc_RangeOpts_parse subtest: %s\n", test->desc);
         bool ret = mc_RangeOpts_parse(&ro, TMP_BSON(test->in), test->useRangeV2, status);
         if (!test->expectError) {
             ASSERT_OK_STATUS(ret, status);
@@ -316,7 +316,7 @@ static void test_mc_RangeOpts_to_FLE2RangeInsertSpec(_mongocrypt_tester_t *teste
         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);
+        TEST_PRINTF("running test_mc_RangeOpts_to_FLE2RangeInsertSpec subtest: %s\n", test->desc);
         ASSERT_OK_STATUS(mc_RangeOpts_parse(&ro, TMP_BSON(test->in), !test->disableRangeV2, status), status);
         bson_t out = BSON_INITIALIZER;
         bool ret = mc_RangeOpts_to_FLE2RangeInsertSpec(&ro, TMP_BSON(test->v), &out, !test->disableRangeV2, status);