libmongocrypt-helper 1.7.4.0.1001 → 1.8.0.0.1001

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

@@ -14,161 +14,127 @@
  * limitations under the License.
  */
 
-#include "test-mongocrypt.h"
 #include "mc-rangeopts-private.h"
+#include "test-mongocrypt.h"
 
 #define RAW_STRING(...) #__VA_ARGS__
 
-static void
-test_mc_RangeOpts_parse (_mongocrypt_tester_t *tester)
-{
-   typedef struct {
-      const char *desc;
-      const char *in;
-      const char *expectError;
-      mc_optional_int32_t expectMin;
-      mc_optional_int32_t expectMax;
-      int64_t expectSparsity;
-      mc_optional_uint32_t expectPrecision;
-   } testcase;
+static void test_mc_RangeOpts_parse(_mongocrypt_tester_t *tester) {
+    typedef struct {
+        const char *desc;
+        const char *in;
+        const char *expectError;
+        mc_optional_int32_t expectMin;
+        mc_optional_int32_t expectMax;
+        int64_t expectSparsity;
+        mc_optional_uint32_t expectPrecision;
+    } testcase;
 
-   testcase tests[] = {
-      {.desc = "Works",
-       .in = RAW_STRING (
-          {"min" : 123, "max" : 456, "sparsity" : {"$numberLong" : "1"}}),
-       .expectSparsity = 1,
-       .expectMin = OPT_I32_C (123),
-       .expectMax = OPT_I32_C (456)},
-      {.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'"},
-      {.desc = "Errors if min/max types mismatch",
-       .in = RAW_STRING (
-          {"min" : 123, "max" : 456.0, "sparsity" : {"$numberLong" : "1"}}),
-       .expectError = "expected 'min' and 'max' to be same type"},
-      {
-         .desc = "Does not require min/max",
-         .in = RAW_STRING ({"sparsity" : {"$numberLong" : "1"}}),
+    testcase tests[] = {
+        {.desc = "Works",
+         .in = RAW_STRING({"min" : 123, "max" : 456, "sparsity" : {"$numberLong" : "1"}}),
          .expectSparsity = 1,
-      },
-      {.desc = "Requires precision for double when min/max is set",
-       .in = RAW_STRING (
-          {"min" : 0.0, "max" : 1.0, "sparsity" : {"$numberLong" : "1"}}),
-       .expectError = "expected 'precision'"},
-      {.desc = "Requires min/max for double when precision is set",
-       .in = RAW_STRING ({"precision" : 1, "sparsity" : {"$numberLong" : "1"}}),
-       .expectError = "setting precision requires min"},
-      {.desc = "Requires precision for double when only min is set",
-       .in = RAW_STRING ({"min" : 0.0, "sparsity" : {"$numberLong" : "1"}}),
-       .expectError = "expected 'precision'"},
-   };
+         .expectMin = OPT_I32_C(123),
+         .expectMax = OPT_I32_C(456)},
+        {.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'"},
+        {.desc = "Errors if min/max types mismatch",
+         .in = RAW_STRING({"min" : 123, "max" : 456.0, "sparsity" : {"$numberLong" : "1"}}),
+         .expectError = "expected 'min' and 'max' to be same type"},
+        {
+            .desc = "Does not require min/max",
+            .in = RAW_STRING({"sparsity" : {"$numberLong" : "1"}}),
+            .expectSparsity = 1,
+        },
+        {.desc = "Requires precision for double when min/max is set",
+         .in = RAW_STRING({"min" : 0.0, "max" : 1.0, "sparsity" : {"$numberLong" : "1"}}),
+         .expectError = "expected 'precision'"},
+        {.desc = "Requires min/max for double when precision is set",
+         .in = RAW_STRING({"precision" : 1, "sparsity" : {"$numberLong" : "1"}}),
+         .expectError = "setting precision requires min"},
+        {.desc = "Requires precision for double when only min is set",
+         .in = RAW_STRING({"min" : 0.0, "sparsity" : {"$numberLong" : "1"}}),
+         .expectError = "expected 'precision'"},
+    };
 
-   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_parse subtest: %s\n", test->desc);
-      bool ret = mc_RangeOpts_parse (&ro, TMP_BSON (test->in), status);
-      if (!test->expectError) {
-         ASSERT_OK_STATUS (ret, status);
-         ASSERT_CMPINT (test->expectMin.set, ==, ro.min.set);
-         if (test->expectMin.set) {
-            ASSERT_CMPINT32 (
-               test->expectMin.value, ==, bson_iter_int32 (&ro.min.value));
-         }
-         ASSERT_CMPINT (test->expectMax.set, ==, ro.max.set);
-         if (test->expectMax.set) {
-            ASSERT_CMPINT32 (
-               test->expectMax.value, ==, bson_iter_int32 (&ro.max.value));
-         }
-         ASSERT_CMPINT64 (test->expectSparsity, ==, ro.sparsity);
-         ASSERT_CMPINT (test->expectPrecision.set, ==, ro.precision.set);
-         ASSERT_CMPINT (test->expectPrecision.value, ==, ro.precision.value);
-      } else {
-         ASSERT_FAILS_STATUS (ret, status, test->expectError);
-      }
-      mc_RangeOpts_cleanup (&ro);
-      mongocrypt_status_destroy (status);
-   }
+    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_parse subtest: %s\n", test->desc);
+        bool ret = mc_RangeOpts_parse(&ro, TMP_BSON(test->in), status);
+        if (!test->expectError) {
+            ASSERT_OK_STATUS(ret, status);
+            ASSERT_CMPINT(test->expectMin.set, ==, ro.min.set);
+            if (test->expectMin.set) {
+                ASSERT_CMPINT32(test->expectMin.value, ==, bson_iter_int32(&ro.min.value));
+            }
+            ASSERT_CMPINT(test->expectMax.set, ==, ro.max.set);
+            if (test->expectMax.set) {
+                ASSERT_CMPINT32(test->expectMax.value, ==, bson_iter_int32(&ro.max.value));
+            }
+            ASSERT_CMPINT64(test->expectSparsity, ==, ro.sparsity);
+            ASSERT_CMPINT(test->expectPrecision.set, ==, ro.precision.set);
+            ASSERT_CMPINT(test->expectPrecision.value, ==, ro.precision.value);
+        } else {
+            ASSERT_FAILS_STATUS(ret, status, test->expectError);
+        }
+        mc_RangeOpts_cleanup(&ro);
+        mongocrypt_status_destroy(status);
+    }
 }
 
-static void
-test_mc_RangeOpts_to_FLE2RangeInsertSpec (_mongocrypt_tester_t *tester)
-{
-   typedef struct {
-      const char *desc;
-      const char *in;
-      const char *v;
-      const char *expectError;
-      const char *expect;
-   } testcase;
+static void test_mc_RangeOpts_to_FLE2RangeInsertSpec(_mongocrypt_tester_t *tester) {
+    typedef struct {
+        const char *desc;
+        const char *in;
+        const char *v;
+        const char *expectError;
+        const char *expect;
+    } testcase;
 
-   testcase tests[] = {
-      {.desc = "Works",
-       .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 = "Works with precision",
-       .in = RAW_STRING ({
-          "min" : 123.0,
-          "max" : 456.0,
-          "precision" : 2,
-          "sparsity" : {"$numberLong" : "1"}
-       }),
-       .v = RAW_STRING ({"v" : 789.0}),
-       .expect = RAW_STRING ({
-          "v" : {"v" : 789.0, "min" : 123.0, "max" : 456.0, "precision" : 2}
-       })},
-      {.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'"}};
+    testcase tests[] = {
+        {.desc = "Works",
+         .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 = "Works with precision",
+         .in = RAW_STRING({"min" : 123.0, "max" : 456.0, "precision" : 2, "sparsity" : {"$numberLong" : "1"}}),
+         .v = RAW_STRING({"v" : 789.0}),
+         .expect = RAW_STRING({"v" : {"v" : 789.0, "min" : 123.0, "max" : 456.0, "precision" : 2}})},
+        {.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'"}};
 
-   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);
-      bson_t out = BSON_INITIALIZER;
-      bool ret = mc_RangeOpts_to_FLE2RangeInsertSpec (
-         &ro, TMP_BSON (test->v), &out, status);
-      if (!test->expectError) {
-         ASSERT_OK_STATUS (ret, status);
-         ASSERT_EQUAL_BSON (TMP_BSON (test->expect), &out);
-      } else {
-         ASSERT_FAILS_STATUS (ret, status, test->expectError);
-      }
-      bson_destroy (&out);
-      mc_RangeOpts_cleanup (&ro);
-      mongocrypt_status_destroy (status);
-   }
+    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);
+        bson_t out = BSON_INITIALIZER;
+        bool ret = mc_RangeOpts_to_FLE2RangeInsertSpec(&ro, TMP_BSON(test->v), &out, status);
+        if (!test->expectError) {
+            ASSERT_OK_STATUS(ret, status);
+            ASSERT_EQUAL_BSON(TMP_BSON(test->expect), &out);
+        } else {
+            ASSERT_FAILS_STATUS(ret, status, test->expectError);
+        }
+        bson_destroy(&out);
+        mc_RangeOpts_cleanup(&ro);
+        mongocrypt_status_destroy(status);
+    }
 }
 
-void
-_mongocrypt_tester_install_mc_RangeOpts (_mongocrypt_tester_t *tester)
-{
-   INSTALL_TEST (test_mc_RangeOpts_parse);
-   INSTALL_TEST (test_mc_RangeOpts_to_FLE2RangeInsertSpec);
+void _mongocrypt_tester_install_mc_RangeOpts(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(test_mc_RangeOpts_parse);
+    INSTALL_TEST(test_mc_RangeOpts_to_FLE2RangeInsertSpec);
 }

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

@@ -18,234 +18,151 @@
 #include "test-mongocrypt-assert.h"
 #include "test-mongocrypt.h"
 
-static void
-_test_mc_reader (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_buffer_t input_buf;
-   _mongocrypt_buffer_copy_from_hex (&input_buf, "ABCD");
-
-   mongocrypt_status_t *status;
-   status = mongocrypt_status_new ();
-
-   mc_reader_t reader;
-   mc_reader_init_from_buffer (&reader, &input_buf, __FUNCTION__);
-
-   uint8_t value;
-   ASSERT_OK_STATUS (mc_reader_read_u8 (&reader, &value, status), status);
-   ASSERT_CMPUINT (value, ==, 0xAB);
-   ASSERT_CMPUINT64 (mc_reader_get_consumed_length (&reader), ==, 1);
-   ASSERT_CMPUINT64 (mc_reader_get_remaining_length (&reader), ==, 1);
-
-   ASSERT_OK_STATUS (mc_reader_read_u8 (&reader, &value, status), status);
-   ASSERT_CMPUINT (value, ==, 0xCD);
-   ASSERT_CMPUINT64 (mc_reader_get_consumed_length (&reader), ==, 2);
-   ASSERT_CMPUINT64 (mc_reader_get_remaining_length (&reader), ==, 0);
-
-   ASSERT_FAILS_STATUS (mc_reader_read_u8 (&reader, &value, status),
-                        status,
-                        "expected byte length >= 3 got: 2");
-
-   _mongocrypt_buffer_cleanup (&input_buf);
-   mongocrypt_status_destroy (status);
+static void _test_mc_reader(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t input_buf;
+    _mongocrypt_buffer_copy_from_hex(&input_buf, "ABCD");
+
+    mongocrypt_status_t *status;
+    status = mongocrypt_status_new();
+
+    mc_reader_t reader;
+    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
+
+    uint8_t value;
+    ASSERT_OK_STATUS(mc_reader_read_u8(&reader, &value, status), status);
+    ASSERT_CMPUINT(value, ==, 0xAB);
+    ASSERT_CMPUINT64(mc_reader_get_consumed_length(&reader), ==, 1);
+    ASSERT_CMPUINT64(mc_reader_get_remaining_length(&reader), ==, 1);
+
+    ASSERT_OK_STATUS(mc_reader_read_u8(&reader, &value, status), status);
+    ASSERT_CMPUINT(value, ==, 0xCD);
+    ASSERT_CMPUINT64(mc_reader_get_consumed_length(&reader), ==, 2);
+    ASSERT_CMPUINT64(mc_reader_get_remaining_length(&reader), ==, 0);
+
+    ASSERT_FAILS_STATUS(mc_reader_read_u8(&reader, &value, status), status, "expected byte length >= 3 got: 2");
+
+    _mongocrypt_buffer_cleanup(&input_buf);
+    mongocrypt_status_destroy(status);
 }
 
-static void
-_test_mc_reader_uuid (_mongocrypt_tester_t *tester)
-{
-   const uint8_t expected_bytes[] = {0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x90,
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x90,
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x90,
-                                     0x12};
-   uint64_t expected_len = sizeof (expected_bytes);
-
-   _mongocrypt_buffer_t input_buf;
-   _mongocrypt_buffer_copy_from_hex (&input_buf,
-                                     "12345678901234567890123456789012");
-
-   mongocrypt_status_t *status;
-   status = mongocrypt_status_new ();
-
-   mc_reader_t reader;
-   mc_reader_init_from_buffer (&reader, &input_buf, __FUNCTION__);
-
-   _mongocrypt_buffer_t value;
-   ASSERT_OK_STATUS (mc_reader_read_uuid_buffer (&reader, &value, status),
-                     status);
-   ASSERT (value.subtype == BSON_SUBTYPE_UUID);
-
-   ASSERT_CMPBYTES (
-      expected_bytes, (size_t) expected_len, value.data, value.len);
-
-
-   uint8_t ui;
-   ASSERT_FAILS_STATUS (mc_reader_read_u8 (&reader, &ui, status),
-                        status,
-                        "expected byte length >= 17 got: 16");
-
-   _mongocrypt_buffer_cleanup (&input_buf);
-   _mongocrypt_buffer_cleanup (&value);
-   mongocrypt_status_destroy (status);
+static void _test_mc_reader_uuid(_mongocrypt_tester_t *tester) {
+    const uint8_t expected_bytes[] =
+        {0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12};
+    uint64_t expected_len = sizeof(expected_bytes);
+
+    _mongocrypt_buffer_t input_buf;
+    _mongocrypt_buffer_copy_from_hex(&input_buf, "12345678901234567890123456789012");
+
+    mongocrypt_status_t *status;
+    status = mongocrypt_status_new();
+
+    mc_reader_t reader;
+    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
+
+    _mongocrypt_buffer_t value;
+    ASSERT_OK_STATUS(mc_reader_read_uuid_buffer(&reader, &value, status), status);
+    ASSERT(value.subtype == BSON_SUBTYPE_UUID);
+
+    ASSERT_CMPBYTES(expected_bytes, (size_t)expected_len, value.data, value.len);
+
+    uint8_t ui;
+    ASSERT_FAILS_STATUS(mc_reader_read_u8(&reader, &ui, status), status, "expected byte length >= 17 got: 16");
+
+    _mongocrypt_buffer_cleanup(&input_buf);
+    _mongocrypt_buffer_cleanup(&value);
+    mongocrypt_status_destroy(status);
 }
 
-static void
-_test_mc_reader_prfblock (_mongocrypt_tester_t *tester)
-{
-   const uint8_t expected_bytes[] = {0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78, // 4
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78, // 8
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78, // 16
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78};
-   uint64_t expected_len = sizeof (expected_bytes);
-
-   _mongocrypt_buffer_t input_buf;
-   _mongocrypt_buffer_copy_from_hex (&input_buf,
+static void _test_mc_reader_prfblock(_mongocrypt_tester_t *tester) {
+    const uint8_t expected_bytes[] = {0x12, 0x34, 0x56,
+                                      0x78, // 4
+                                      0x12, 0x34, 0x56,
+                                      0x78, // 8
+                                      0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56,
+                                      0x78, // 16
+                                      0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78,
+                                      0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78};
+    uint64_t expected_len = sizeof(expected_bytes);
+
+    _mongocrypt_buffer_t input_buf;
+    _mongocrypt_buffer_copy_from_hex(&input_buf,
                                      "12345678123456781234567812345678"
                                      "12345678123456781234567812345678");
 
-   mongocrypt_status_t *status;
-   status = mongocrypt_status_new ();
-
-   mc_reader_t reader;
-   mc_reader_init_from_buffer (&reader, &input_buf, __FUNCTION__);
+    mongocrypt_status_t *status;
+    status = mongocrypt_status_new();
 
-   _mongocrypt_buffer_t value;
-   ASSERT_OK_STATUS (mc_reader_read_prfblock_buffer (&reader, &value, status),
-                     status);
-   ASSERT (value.subtype == BSON_SUBTYPE_ENCRYPTED);
+    mc_reader_t reader;
+    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
 
-   ASSERT_CMPBYTES (
-      expected_bytes, (size_t) expected_len, value.data, value.len);
+    _mongocrypt_buffer_t value;
+    ASSERT_OK_STATUS(mc_reader_read_prfblock_buffer(&reader, &value, status), status);
+    ASSERT(value.subtype == BSON_SUBTYPE_ENCRYPTED);
 
+    ASSERT_CMPBYTES(expected_bytes, (size_t)expected_len, value.data, value.len);
 
-   uint8_t ui;
-   ASSERT_FAILS_STATUS (mc_reader_read_u8 (&reader, &ui, status),
-                        status,
-                        "expected byte length >= 33 got: 32");
+    uint8_t ui;
+    ASSERT_FAILS_STATUS(mc_reader_read_u8(&reader, &ui, status), status, "expected byte length >= 33 got: 32");
 
-   _mongocrypt_buffer_cleanup (&input_buf);
-   _mongocrypt_buffer_cleanup (&value);
-   mongocrypt_status_destroy (status);
+    _mongocrypt_buffer_cleanup(&input_buf);
+    _mongocrypt_buffer_cleanup(&value);
+    mongocrypt_status_destroy(status);
 }
 
+static void _test_mc_reader_ints(_mongocrypt_tester_t *tester) {
+    _mongocrypt_buffer_t input_buf;
+    _mongocrypt_buffer_copy_from_hex(&input_buf, "001122330011223344556677");
 
-static void
-_test_mc_reader_ints (_mongocrypt_tester_t *tester)
-{
-   _mongocrypt_buffer_t input_buf;
-   _mongocrypt_buffer_copy_from_hex (&input_buf, "001122330011223344556677");
+    mongocrypt_status_t *status;
+    status = mongocrypt_status_new();
 
-   mongocrypt_status_t *status;
-   status = mongocrypt_status_new ();
+    mc_reader_t reader;
+    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
 
-   mc_reader_t reader;
-   mc_reader_init_from_buffer (&reader, &input_buf, __FUNCTION__);
+    uint32_t u32;
+    ASSERT_OK_STATUS(mc_reader_read_u32(&reader, &u32, status), status);
+    ASSERT_CMPUINT32(u32, ==, 0x33221100);
 
-   uint32_t u32;
-   ASSERT_OK_STATUS (mc_reader_read_u32 (&reader, &u32, status), status);
-   ASSERT_CMPUINT32 (u32, ==, 0x33221100);
+    uint64_t u64;
+    ASSERT_OK_STATUS(mc_reader_read_u64(&reader, &u64, status), status);
+    ASSERT_CMPUINT64(u64, ==, 0x7766554433221100ULL);
 
-   uint64_t u64;
-   ASSERT_OK_STATUS (mc_reader_read_u64 (&reader, &u64, status), status);
-   ASSERT_CMPUINT64 (u64, ==, 0x7766554433221100ULL);
-
-   _mongocrypt_buffer_cleanup (&input_buf);
-   mongocrypt_status_destroy (status);
+    _mongocrypt_buffer_cleanup(&input_buf);
+    mongocrypt_status_destroy(status);
 }
 
-static void
-_test_mc_reader_bytes (_mongocrypt_tester_t *tester)
-{
-   const uint8_t expected_bytes[] = {0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x90,
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x90,
-                                     0x12,
-                                     0x34,
-                                     0x56,
-                                     0x78,
-                                     0x90,
-                                     0x12};
-   uint64_t expected_len = sizeof (expected_bytes);
-
-   _mongocrypt_buffer_t input_buf;
-   _mongocrypt_buffer_copy_from_hex (&input_buf,
-                                     "12345678901234567890123456789012");
-
-   mongocrypt_status_t *status;
-   status = mongocrypt_status_new ();
-
-   mc_reader_t reader;
-   mc_reader_init_from_buffer (&reader, &input_buf, __FUNCTION__);
-
-   const uint8_t *ptr;
-   const uint64_t len = 4;
-   ASSERT_OK_STATUS (
-      mc_reader_read_bytes (&reader, (const uint8_t **) &ptr, len, status),
-      status);
-   ASSERT_CMPBYTES (expected_bytes, 4, ptr, (size_t) len);
-
-   _mongocrypt_buffer_t value_buf;
-   ASSERT_OK_STATUS (mc_reader_read_buffer_to_end (&reader, &value_buf, status),
-                     status);
-   ASSERT_CMPBYTES (
-      expected_bytes + 4u, (size_t)expected_len - 4u, value_buf.data, value_buf.len);
-
-   _mongocrypt_buffer_cleanup (&input_buf);
-   _mongocrypt_buffer_cleanup (&value_buf);
-   mongocrypt_status_destroy (status);
+static void _test_mc_reader_bytes(_mongocrypt_tester_t *tester) {
+    const uint8_t expected_bytes[] =
+        {0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12};
+    uint64_t expected_len = sizeof(expected_bytes);
+
+    _mongocrypt_buffer_t input_buf;
+    _mongocrypt_buffer_copy_from_hex(&input_buf, "12345678901234567890123456789012");
+
+    mongocrypt_status_t *status;
+    status = mongocrypt_status_new();
+
+    mc_reader_t reader;
+    mc_reader_init_from_buffer(&reader, &input_buf, __FUNCTION__);
+
+    const uint8_t *ptr;
+    const uint64_t len = 4;
+    ASSERT_OK_STATUS(mc_reader_read_bytes(&reader, (const uint8_t **)&ptr, len, status), status);
+    ASSERT_CMPBYTES(expected_bytes, 4, ptr, (size_t)len);
+
+    _mongocrypt_buffer_t value_buf;
+    ASSERT_OK_STATUS(mc_reader_read_buffer_to_end(&reader, &value_buf, status), status);
+    ASSERT_CMPBYTES(expected_bytes + 4u, (size_t)expected_len - 4u, value_buf.data, value_buf.len);
+
+    _mongocrypt_buffer_cleanup(&input_buf);
+    _mongocrypt_buffer_cleanup(&value_buf);
+    mongocrypt_status_destroy(status);
 }
 
-void
-_mongocrypt_tester_install_mc_reader (_mongocrypt_tester_t *tester)
-{
-   INSTALL_TEST (_test_mc_reader);
-   INSTALL_TEST (_test_mc_reader_uuid);
-   INSTALL_TEST (_test_mc_reader_prfblock);
-   INSTALL_TEST (_test_mc_reader_ints);
-   INSTALL_TEST (_test_mc_reader_bytes);
+void _mongocrypt_tester_install_mc_reader(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(_test_mc_reader);
+    INSTALL_TEST(_test_mc_reader_uuid);
+    INSTALL_TEST(_test_mc_reader_prfblock);
+    INSTALL_TEST(_test_mc_reader_ints);
+    INSTALL_TEST(_test_mc_reader_bytes);
 }