libmongocrypt-helper 1.7.4.0.1001 → 1.8.0.0.1001

data/ext/libmongocrypt/libmongocrypt/test/test-mongocrypt-assert-match-bson.c

@@ -26,101 +26,75 @@
 #endif
 
 /* The following matching logic is copied from libmongoc. */
-bool
-bson_init_from_value (bson_t *b, const bson_value_t *v);
+bool bson_init_from_value(bson_t *b, const bson_value_t *v);
 
-char *
-single_quotes_to_double (const char *str);
+char *single_quotes_to_double(const char *str);
 
 /* match_action_t determines if default check for a field is overridden. */
 typedef enum {
-   MATCH_ACTION_SKIP,    /* do not use the default check. */
-   MATCH_ACTION_ABORT,   /* an error occurred, stop checking. */
-   MATCH_ACTION_CONTINUE /* use the default check. */
+    MATCH_ACTION_SKIP,    /* do not use the default check. */
+    MATCH_ACTION_ABORT,   /* an error occurred, stop checking. */
+    MATCH_ACTION_CONTINUE /* use the default check. */
 } match_action_t;
 
 struct _match_ctx_t;
 /* doc_iter may be null if the pattern field is not found. */
-typedef match_action_t (*match_visitor_fn) (struct _match_ctx_t *ctx,
-                                            bson_iter_t *pattern_iter,
-                                            bson_iter_t *doc_iter);
+typedef match_action_t (*match_visitor_fn)(struct _match_ctx_t *ctx, bson_iter_t *pattern_iter, bson_iter_t *doc_iter);
 
 typedef struct _match_ctx_t {
-   char errmsg[1000];
-   bool strict_numeric_types;
-   /* if retain_dots_in_keys is true, then don't consider a path with dots to
-    * indicate recursing into a sub document. */
-   bool retain_dots_in_keys;
-   /* if allow_placeholders is true, treats 42 and "42" as placeholders. I.e.
-    * comparing 42 to anything is ok. */
-   bool allow_placeholders;
-   /* path is the dot separated breadcrumb trail of keys. */
-   char path[1000];
-   /* if visitor_fn is not NULL, this is called on for every key in the pattern.
-    * The returned match_action_t can override the default match behavior. */
-   match_visitor_fn visitor_fn;
-   void *visitor_ctx;
-   /* if is_command is true, then compare the first key case insensitively. */
-   bool is_command;
+    char errmsg[1000];
+    bool strict_numeric_types;
+    /* if retain_dots_in_keys is true, then don't consider a path with dots to
+     * indicate recursing into a sub document. */
+    bool retain_dots_in_keys;
+    /* if allow_placeholders is true, treats 42 and "42" as placeholders. I.e.
+     * comparing 42 to anything is ok. */
+    bool allow_placeholders;
+    /* path is the dot separated breadcrumb trail of keys. */
+    char path[1000];
+    /* if visitor_fn is not NULL, this is called on for every key in the pattern.
+     * The returned match_action_t can override the default match behavior. */
+    match_visitor_fn visitor_fn;
+    void *visitor_ctx;
+    /* if is_command is true, then compare the first key case insensitively. */
+    bool is_command;
 } match_ctx_t;
 
-void
-assert_match_bson (const bson_t *doc, const bson_t *pattern, bool is_command);
+void assert_match_bson(const bson_t *doc, const bson_t *pattern, bool is_command);
 
-bool
-match_bson (const bson_t *doc, const bson_t *pattern, bool is_command);
+bool match_bson(const bson_t *doc, const bson_t *pattern, bool is_command);
 
-int64_t
-bson_value_as_int64 (const bson_value_t *value);
+int64_t bson_value_as_int64(const bson_value_t *value);
 
-bool
-match_bson_value (const bson_value_t *doc,
-                  const bson_value_t *pattern,
-                  match_ctx_t *ctx);
+bool match_bson_value(const bson_value_t *doc, const bson_value_t *pattern, match_ctx_t *ctx);
 
-bool
-match_bson_with_ctx (const bson_t *doc,
-                     const bson_t *pattern,
-                     match_ctx_t *ctx);
+bool match_bson_with_ctx(const bson_t *doc, const bson_t *pattern, match_ctx_t *ctx);
 
-bool
-match_json (const bson_t *doc,
-            bool is_command,
-            const char *filename,
-            int lineno,
-            const char *funcname,
-            const char *json_pattern,
-            ...);
+bool match_json(const bson_t *doc,
+                bool is_command,
+                const char *filename,
+                int lineno,
+                const char *funcname,
+                const char *json_pattern,
+                ...);
 
-#define ASSERT_MATCH(doc, ...)                                                 \
-   do {                                                                        \
-      BSON_ASSERT (                                                            \
-         match_json (doc, false, __FILE__, __LINE__, BSON_FUNC, __VA_ARGS__)); \
-   } while (0)
+#define ASSERT_MATCH(doc, ...)                                                                                         \
+    do {                                                                                                               \
+        BSON_ASSERT(match_json(doc, false, __FILE__, __LINE__, BSON_FUNC, __VA_ARGS__));                               \
+    } while (0)
 
-const char *
-_mongoc_bson_type_to_str (bson_type_t t);
+const char *_mongoc_bson_type_to_str(bson_type_t t);
 
-static bool
-get_exists_operator (const bson_value_t *value, bool *exists);
+static bool get_exists_operator(const bson_value_t *value, bool *exists);
 
-static bool
-get_empty_operator (const bson_value_t *value, bool *exists);
+static bool get_empty_operator(const bson_value_t *value, bool *exists);
 
-static bool
-get_type_operator (const bson_value_t *value, bson_type_t *out);
+static bool get_type_operator(const bson_value_t *value, bson_type_t *out);
 
-static bool
-is_empty_doc_or_array (const bson_value_t *value);
+static bool is_empty_doc_or_array(const bson_value_t *value);
 
 static bool
-find (bson_iter_t *iter,
-      const bson_t *doc,
-      const char *key,
-      bool is_command,
-      bool is_first,
-      bool retain_dots_in_keys);
-
+find(bson_iter_t *iter, const bson_t *doc, const char *key, bool is_command, bool is_first, bool retain_dots_in_keys);
 
 /*--------------------------------------------------------------------------
  *
@@ -137,22 +111,19 @@ find (bson_iter_t *iter,
  *--------------------------------------------------------------------------
  */
 
-char *
-single_quotes_to_double (const char *str)
-{
-   char *result = bson_strdup (str);
-   char *p;
+char *single_quotes_to_double(const char *str) {
+    char *result = bson_strdup(str);
+    char *p;
 
-   for (p = result; *p; p++) {
-      if (*p == '\'') {
-         *p = '"';
-      }
-   }
+    for (p = result; *p; p++) {
+        if (*p == '\'') {
+            *p = '"';
+        }
+    }
 
-   return result;
+    return result;
 }
 
-
 /*--------------------------------------------------------------------------
  *
  * match_json --
@@ -171,66 +142,62 @@ single_quotes_to_double (const char *str)
  *--------------------------------------------------------------------------
  */
 
-MLIB_ANNOTATE_PRINTF (6, 7)
-bool
-match_json (const bson_t *doc,
-            bool is_command,
-            const char *filename,
-            int lineno,
-            const char *funcname,
-            const char *json_pattern,
-            ...)
-{
-   va_list args;
-   char *json_pattern_formatted;
-   char *double_quoted;
-   bson_error_t error;
-   bson_t *pattern;
-   match_ctx_t ctx = {{0}};
-   bool matches;
-
-   va_start (args, json_pattern);
-   json_pattern_formatted =
-      bson_strdupv_printf (json_pattern ? json_pattern : "{}", args);
-   va_end (args);
-
-   double_quoted = single_quotes_to_double (json_pattern_formatted);
-   pattern = bson_new_from_json ((const uint8_t *) double_quoted, -1, &error);
-
-   if (!pattern) {
-      fprintf (stderr, "couldn't parse JSON: %s\n", error.message);
-      abort ();
-   }
-
-   ctx.is_command = is_command;
-   matches = match_bson_with_ctx (doc, pattern, &ctx);
-
-   if (!matches) {
-      char *as_string =
-         doc ? bson_as_canonical_extended_json (doc, NULL) : NULL;
-      fprintf (stderr,
-               "ASSERT_MATCH failed with document:\n\n"
-               "%s\n"
-               "pattern:\n%s\n"
-               "%s\n"
-               "%s:%d %s()\n",
-               as_string ? as_string : "{}",
-               double_quoted,
-               ctx.errmsg,
-               filename,
-               lineno,
-               funcname);
-      bson_free (as_string);
-   }
-
-   bson_destroy (pattern);
-   bson_free (json_pattern_formatted);
-   bson_free (double_quoted);
-
-   return matches;
+MLIB_ANNOTATE_PRINTF(6, 7)
+
+bool match_json(const bson_t *doc,
+                bool is_command,
+                const char *filename,
+                int lineno,
+                const char *funcname,
+                const char *json_pattern,
+                ...) {
+    va_list args;
+    char *json_pattern_formatted;
+    char *double_quoted;
+    bson_error_t error;
+    bson_t *pattern;
+    match_ctx_t ctx = {{0}};
+    bool matches;
+
+    va_start(args, json_pattern);
+    json_pattern_formatted = bson_strdupv_printf(json_pattern ? json_pattern : "{}", args);
+    va_end(args);
+
+    double_quoted = single_quotes_to_double(json_pattern_formatted);
+    pattern = bson_new_from_json((const uint8_t *)double_quoted, -1, &error);
+
+    if (!pattern) {
+        fprintf(stderr, "couldn't parse JSON: %s\n", error.message);
+        abort();
+    }
+
+    ctx.is_command = is_command;
+    matches = match_bson_with_ctx(doc, pattern, &ctx);
+
+    if (!matches) {
+        char *as_string = doc ? bson_as_canonical_extended_json(doc, NULL) : NULL;
+        fprintf(stderr,
+                "ASSERT_MATCH failed with document:\n\n"
+                "%s\n"
+                "pattern:\n%s\n"
+                "%s\n"
+                "%s:%d %s()\n",
+                as_string ? as_string : "{}",
+                double_quoted,
+                ctx.errmsg,
+                filename,
+                lineno,
+                funcname);
+        bson_free(as_string);
+    }
+
+    bson_destroy(pattern);
+    bson_free(json_pattern_formatted);
+    bson_free(double_quoted);
+
+    return matches;
 }
 
-
 /*--------------------------------------------------------------------------
  *
  * match_bson --
@@ -248,64 +215,54 @@ match_json (const bson_t *doc,
  *--------------------------------------------------------------------------
  */
 
-bool
-match_bson (const bson_t *doc, const bson_t *pattern, bool is_command)
-{
-   match_ctx_t ctx = {{0}};
+bool match_bson(const bson_t *doc, const bson_t *pattern, bool is_command) {
+    match_ctx_t ctx = {{0}};
 
-   ctx.strict_numeric_types = true;
-   ctx.is_command = is_command;
+    ctx.strict_numeric_types = true;
+    ctx.is_command = is_command;
 
-   return match_bson_with_ctx (doc, pattern, &ctx);
+    return match_bson_with_ctx(doc, pattern, &ctx);
 }
 
+MLIB_ANNOTATE_PRINTF(2, 3)
 
-MLIB_ANNOTATE_PRINTF (2, 3)
-void
-match_err (match_ctx_t *ctx, const char *fmt, ...)
-{
-   va_list args;
-   char *formatted;
+void match_err(match_ctx_t *ctx, const char *fmt, ...) {
+    va_list args;
+    char *formatted;
 
-   BSON_ASSERT (ctx);
+    BSON_ASSERT(ctx);
 
-   va_start (args, fmt);
-   formatted = bson_strdupv_printf (fmt, args);
-   va_end (args);
+    va_start(args, fmt);
+    formatted = bson_strdupv_printf(fmt, args);
+    va_end(args);
 
-   bson_snprintf (
-      ctx->errmsg, sizeof ctx->errmsg, "%s: %s", ctx->path, formatted);
+    bson_snprintf(ctx->errmsg, sizeof ctx->errmsg, "%s: %s", ctx->path, formatted);
 
-   bson_free (formatted);
+    bson_free(formatted);
 }
 
-
 /* When matching two docs, and preparing to recurse to match two subdocs with
  * the given key, derive context for matching them from the current context. */
-static void
-derive (match_ctx_t *ctx, match_ctx_t *derived, const char *key)
-{
-   BSON_ASSERT (ctx);
-   BSON_ASSERT (derived);
-   BSON_ASSERT (key);
-
-   derived->strict_numeric_types = ctx->strict_numeric_types;
-
-   if (strlen (ctx->path) > 0) {
-      bson_snprintf (
-         derived->path, sizeof derived->path, "%s.%s", ctx->path, key);
-   } else {
-      bson_snprintf (derived->path, sizeof derived->path, "%s", key);
-   }
-   derived->retain_dots_in_keys = ctx->retain_dots_in_keys;
-   derived->allow_placeholders = ctx->allow_placeholders;
-   derived->visitor_ctx = ctx->visitor_ctx;
-   derived->visitor_fn = ctx->visitor_fn;
-   derived->is_command = false;
-   derived->errmsg[0] = 0;
+static void derive(match_ctx_t *ctx, match_ctx_t *derived, const char *key) {
+    BSON_ASSERT(ctx);
+    BSON_ASSERT(derived);
+    BSON_ASSERT(key);
+
+    derived->strict_numeric_types = ctx->strict_numeric_types;
+
+    if (strlen(ctx->path) > 0) {
+        bson_snprintf(derived->path, sizeof derived->path, "%s.%s", ctx->path, key);
+    } else {
+        bson_snprintf(derived->path, sizeof derived->path, "%s", key);
+    }
+    derived->retain_dots_in_keys = ctx->retain_dots_in_keys;
+    derived->allow_placeholders = ctx->allow_placeholders;
+    derived->visitor_ctx = ctx->visitor_ctx;
+    derived->visitor_fn = ctx->visitor_fn;
+    derived->is_command = false;
+    derived->errmsg[0] = 0;
 }
 
-
 /*--------------------------------------------------------------------------
  *
  * match_bson_with_ctx --
@@ -339,116 +296,107 @@ derive (match_ctx_t *ctx, match_ctx_t *derived, const char *key)
  *--------------------------------------------------------------------------
  */
 
-bool
-match_bson_with_ctx (const bson_t *doc, const bson_t *pattern, match_ctx_t *ctx)
-{
-   bson_iter_t pattern_iter;
-   const char *key;
-   const bson_value_t *value;
-   bool is_first = true;
-   bool is_exists_operator;
-   bool is_empty_operator;
-   bool is_type_operator;
-   bool exists;
-   bool empty = false;
-   bson_type_t bson_type = (bson_type_t) 0;
-   bool found;
-   bson_iter_t doc_iter;
-   bson_value_t doc_value;
-   match_ctx_t derived;
-
-   if (bson_empty0 (pattern)) {
-      /* matches anything */
-      return true;
-   }
-
-   BSON_ASSERT (bson_iter_init (&pattern_iter, pattern));
-
-   while (bson_iter_next (&pattern_iter)) {
-      key = bson_iter_key (&pattern_iter);
-      value = bson_iter_value (&pattern_iter);
-
-      found = find (&doc_iter,
-                    doc,
-                    key,
-                    ctx->is_command,
-                    is_first,
-                    ctx->retain_dots_in_keys);
-      if (found) {
-         bson_value_copy (bson_iter_value (&doc_iter), &doc_value);
-      }
-
-      /* is value {"$exists": true} or {"$exists": false} ? */
-      is_exists_operator = get_exists_operator (value, &exists);
-
-      /* is value {"$empty": true} or {"$empty": false} ? */
-      is_empty_operator = get_empty_operator (value, &empty);
-
-      /* is value {"$$type": "string" } ? */
-      is_type_operator = get_type_operator (value, &bson_type);
-
-      derive (ctx, &derived, key);
-
-      if (ctx->visitor_fn) {
-         match_action_t action =
-            ctx->visitor_fn (ctx, &pattern_iter, found ? &doc_iter : NULL);
-         if (action == MATCH_ACTION_ABORT) {
-            goto fail;
-         } else if (action == MATCH_ACTION_SKIP) {
-            goto next;
-         }
-      }
-
-      if (value->value_type == BSON_TYPE_NULL && found) {
-         /* pattern has "key": null, and "key" is in doc */
-         if (doc_value.value_type != BSON_TYPE_NULL) {
-            match_err (&derived, "%s should be null or absent", key);
+bool match_bson_with_ctx(const bson_t *doc, const bson_t *pattern, match_ctx_t *ctx) {
+    bson_iter_t pattern_iter;
+    const char *key;
+    const bson_value_t *value;
+    bool is_first = true;
+    bool is_exists_operator;
+    bool is_empty_operator;
+    bool is_type_operator;
+    bool exists;
+    bool empty = false;
+    bson_type_t bson_type = (bson_type_t)0;
+    bool found;
+    bson_iter_t doc_iter;
+    bson_value_t doc_value;
+    match_ctx_t derived;
+
+    if (bson_empty0(pattern)) {
+        /* matches anything */
+        return true;
+    }
+
+    BSON_ASSERT(bson_iter_init(&pattern_iter, pattern));
+
+    while (bson_iter_next(&pattern_iter)) {
+        key = bson_iter_key(&pattern_iter);
+        value = bson_iter_value(&pattern_iter);
+
+        found = find(&doc_iter, doc, key, ctx->is_command, is_first, ctx->retain_dots_in_keys);
+        if (found) {
+            bson_value_copy(bson_iter_value(&doc_iter), &doc_value);
+        }
+
+        /* is value {"$exists": true} or {"$exists": false} ? */
+        is_exists_operator = get_exists_operator(value, &exists);
+
+        /* is value {"$empty": true} or {"$empty": false} ? */
+        is_empty_operator = get_empty_operator(value, &empty);
+
+        /* is value {"$$type": "string" } ? */
+        is_type_operator = get_type_operator(value, &bson_type);
+
+        derive(ctx, &derived, key);
+
+        if (ctx->visitor_fn) {
+            match_action_t action = ctx->visitor_fn(ctx, &pattern_iter, found ? &doc_iter : NULL);
+            if (action == MATCH_ACTION_ABORT) {
+                goto fail;
+            } else if (action == MATCH_ACTION_SKIP) {
+                goto next;
+            }
+        }
+
+        if (value->value_type == BSON_TYPE_NULL && found) {
+            /* pattern has "key": null, and "key" is in doc */
+            if (doc_value.value_type != BSON_TYPE_NULL) {
+                match_err(&derived, "%s should be null or absent", key);
+                goto fail;
+            }
+        } else if (is_exists_operator) {
+            if (exists != found) {
+                match_err(&derived, "%s found", found ? "" : "not");
+                goto fail;
+            }
+        } else if (!found) {
+            match_err(&derived, "not found");
             goto fail;
-         }
-      } else if (is_exists_operator) {
-         if (exists != found) {
-            match_err (&derived, "%s found", found ? "" : "not");
+        } else if (is_empty_operator) {
+            if (empty != is_empty_doc_or_array(&doc_value)) {
+                match_err(&derived, "%s found", empty ? "" : " not");
+                goto fail;
+            }
+        } else if (is_type_operator) {
+            if (doc_value.value_type != bson_type) {
+                match_err(&derived, "incorrect type");
+                goto fail;
+            }
+        } else if (!match_bson_value(&doc_value, value, &derived)) {
             goto fail;
-         }
-      } else if (!found) {
-         match_err (&derived, "not found");
-         goto fail;
-      } else if (is_empty_operator) {
-         if (empty != is_empty_doc_or_array (&doc_value)) {
-            match_err (&derived, "%s found", empty ? "" : " not");
-            goto fail;
-         }
-      } else if (is_type_operator) {
-         if (doc_value.value_type != bson_type) {
-            match_err (&derived, "incorrect type");
-            goto fail;
-         }
-      } else if (!match_bson_value (&doc_value, value, &derived)) {
-         goto fail;
-      }
+        }
 
-   next:
-      is_first = false;
-      if (found) {
-         bson_value_destroy (&doc_value);
-      }
-   }
+    next:
+        is_first = false;
+        if (found) {
+            bson_value_destroy(&doc_value);
+        }
+    }
 
-   return true;
+    return true;
 
 fail:
-   if (found) {
-      bson_value_destroy (&doc_value);
-   }
+    if (found) {
+        bson_value_destroy(&doc_value);
+    }
 
-   if (strlen (derived.errmsg) > 0) {
-      memcpy (ctx->errmsg, derived.errmsg, sizeof (derived.errmsg));
-   }
+    if (strlen(derived.errmsg) > 0) {
+        memcpy(ctx->errmsg, derived.errmsg, sizeof(derived.errmsg));
+    }
 
-   return false;
+    return false;
 }
 
-
 /*--------------------------------------------------------------------------
  *
  * find --
@@ -464,65 +412,54 @@ fail:
  *--------------------------------------------------------------------------
  */
 
-static bool
-find (bson_iter_t *iter_out,
-      const bson_t *doc,
-      const char *key,
-      bool is_command,
-      bool is_first,
-      bool retain_dots_in_keys)
-{
-   bson_iter_t iter;
-   bson_iter_t descendent;
-
-   bson_iter_init (&iter, doc);
-
-   if (!retain_dots_in_keys && strchr (key, '.')) {
-      if (!bson_iter_find_descendant (&iter, key, &descendent)) {
-         return false;
-      }
-
-      memcpy (iter_out, &descendent, sizeof (bson_iter_t));
-      return true;
-   } else if (is_command && is_first) {
-      if (!bson_iter_find_case (&iter, key)) {
-         return false;
-      }
-   } else if (!bson_iter_find (&iter, key)) {
-      return false;
-   }
-
-   memcpy (iter_out, &iter, sizeof (bson_iter_t));
-   return true;
+static bool find(bson_iter_t *iter_out,
+                 const bson_t *doc,
+                 const char *key,
+                 bool is_command,
+                 bool is_first,
+                 bool retain_dots_in_keys) {
+    bson_iter_t iter;
+    bson_iter_t descendent;
+
+    bson_iter_init(&iter, doc);
+
+    if (!retain_dots_in_keys && strchr(key, '.')) {
+        if (!bson_iter_find_descendant(&iter, key, &descendent)) {
+            return false;
+        }
+
+        memcpy(iter_out, &descendent, sizeof(bson_iter_t));
+        return true;
+    } else if (is_command && is_first) {
+        if (!bson_iter_find_case(&iter, key)) {
+            return false;
+        }
+    } else if (!bson_iter_find(&iter, key)) {
+        return false;
+    }
+
+    memcpy(iter_out, &iter, sizeof(bson_iter_t));
+    return true;
 }
 
+bool bson_init_from_value(bson_t *b, const bson_value_t *v) {
+    BSON_ASSERT(v->value_type == BSON_TYPE_ARRAY || v->value_type == BSON_TYPE_DOCUMENT);
 
-bool
-bson_init_from_value (bson_t *b, const bson_value_t *v)
-{
-   BSON_ASSERT (v->value_type == BSON_TYPE_ARRAY ||
-                v->value_type == BSON_TYPE_DOCUMENT);
-
-   return bson_init_static (b, v->value.v_doc.data, v->value.v_doc.data_len);
+    return bson_init_static(b, v->value.v_doc.data, v->value.v_doc.data_len);
 }
 
+static bool _is_operator(const char *op_name, const bson_value_t *value, bool *op_val) {
+    bson_t bson;
+    bson_iter_t iter;
 
-static bool
-_is_operator (const char *op_name, const bson_value_t *value, bool *op_val)
-{
-   bson_t bson;
-   bson_iter_t iter;
-
-   if (value->value_type == BSON_TYPE_DOCUMENT &&
-       bson_init_from_value (&bson, value) &&
-       bson_iter_init_find (&iter, &bson, op_name)) {
-      *op_val = bson_iter_as_bool (&iter);
-      return true;
-   }
-
-   return false;
-}
+    if (value->value_type == BSON_TYPE_DOCUMENT && bson_init_from_value(&bson, value)
+        && bson_iter_init_find(&iter, &bson, op_name)) {
+        *op_val = bson_iter_as_bool(&iter);
+        return true;
+    }
 
+    return false;
+}
 
 /*--------------------------------------------------------------------------
  *
@@ -541,21 +478,18 @@ _is_operator (const char *op_name, const bson_value_t *value, bool *op_val)
  *--------------------------------------------------------------------------
  */
 
-static bool
-get_exists_operator (const bson_value_t *value, bool *exists)
-{
-   if (_is_operator ("$exists", value, exists)) {
-      return true;
-   }
-
-   if (value->value_type == BSON_TYPE_NULL) {
-      *exists = false;
-      return true;
-   }
-
-   return false;
-}
+static bool get_exists_operator(const bson_value_t *value, bool *exists) {
+    if (_is_operator("$exists", value, exists)) {
+        return true;
+    }
 
+    if (value->value_type == BSON_TYPE_NULL) {
+        *exists = false;
+        return true;
+    }
+
+    return false;
+}
 
 /*--------------------------------------------------------------------------
  *
@@ -573,13 +507,10 @@ get_exists_operator (const bson_value_t *value, bool *exists)
  *--------------------------------------------------------------------------
  */
 
-bool
-get_empty_operator (const bson_value_t *value, bool *empty)
-{
-   return _is_operator ("$empty", value, empty);
+bool get_empty_operator(const bson_value_t *value, bool *empty) {
+    return _is_operator("$empty", value, empty);
 }
 
-
 /*--------------------------------------------------------------------------
  *
  * get_type_operator --
@@ -596,72 +527,68 @@ get_empty_operator (const bson_value_t *value, bool *empty)
  *--------------------------------------------------------------------------
  */
 
-static bool
-get_type_operator (const bson_value_t *value, bson_type_t *out)
-{
-   bson_t bson;
-   bson_iter_t iter;
-   const char *value_string;
-
-   /* See list of aliases on this page:
-    * https://docs.mongodb.com/manual/reference/bson-types/ */
-   if (value->value_type == BSON_TYPE_DOCUMENT &&
-       bson_init_from_value (&bson, value) &&
-       bson_iter_init_find (&iter, &bson, "$$type")) {
-      value_string = bson_iter_utf8 (&iter, NULL);
-      if (0 == strcasecmp ("double", value_string)) {
-         *out = BSON_TYPE_DOUBLE;
-      } else if (0 == strcasecmp ("string", value_string)) {
-         *out = BSON_TYPE_UTF8;
-      } else if (0 == strcasecmp ("object", value_string)) {
-         *out = BSON_TYPE_DOCUMENT;
-      } else if (0 == strcasecmp ("array", value_string)) {
-         *out = BSON_TYPE_ARRAY;
-      } else if (0 == strcasecmp ("binData", value_string)) {
-         *out = BSON_TYPE_BINARY;
-      } else if (0 == strcasecmp ("undefined", value_string)) {
-         *out = BSON_TYPE_UNDEFINED;
-      } else if (0 == strcasecmp ("objectId", value_string)) {
-         *out = BSON_TYPE_OID;
-      } else if (0 == strcasecmp ("bool", value_string)) {
-         *out = BSON_TYPE_BOOL;
-      } else if (0 == strcasecmp ("date", value_string)) {
-         *out = BSON_TYPE_DATE_TIME;
-      } else if (0 == strcasecmp ("null", value_string)) {
-         *out = BSON_TYPE_NULL;
-      } else if (0 == strcasecmp ("regex", value_string)) {
-         *out = BSON_TYPE_REGEX;
-      } else if (0 == strcasecmp ("dbPointer", value_string)) {
-         *out = BSON_TYPE_DBPOINTER;
-      } else if (0 == strcasecmp ("javascript", value_string)) {
-         *out = BSON_TYPE_CODE;
-      } else if (0 == strcasecmp ("symbol", value_string)) {
-         *out = BSON_TYPE_SYMBOL;
-      } else if (0 == strcasecmp ("javascriptWithScope", value_string)) {
-         *out = BSON_TYPE_CODEWSCOPE;
-      } else if (0 == strcasecmp ("int", value_string)) {
-         *out = BSON_TYPE_INT32;
-      } else if (0 == strcasecmp ("timestamp", value_string)) {
-         *out = BSON_TYPE_TIMESTAMP;
-      } else if (0 == strcasecmp ("long", value_string)) {
-         *out = BSON_TYPE_INT64;
-      } else if (0 == strcasecmp ("decimal", value_string)) {
-         *out = BSON_TYPE_DECIMAL128;
-      } else if (0 == strcasecmp ("minKey", value_string)) {
-         *out = BSON_TYPE_MINKEY;
-      } else if (0 == strcasecmp ("maxKey", value_string)) {
-         *out = BSON_TYPE_MAXKEY;
-      } else {
-         fprintf (stderr, "unrecognized $$type value: %s\n", value_string);
-         abort ();
-      }
-      return true;
-   }
-
-   return false;
+static bool get_type_operator(const bson_value_t *value, bson_type_t *out) {
+    bson_t bson;
+    bson_iter_t iter;
+    const char *value_string;
+
+    /* See list of aliases on this page:
+     * https://docs.mongodb.com/manual/reference/bson-types/ */
+    if (value->value_type == BSON_TYPE_DOCUMENT && bson_init_from_value(&bson, value)
+        && bson_iter_init_find(&iter, &bson, "$$type")) {
+        value_string = bson_iter_utf8(&iter, NULL);
+        if (0 == strcasecmp("double", value_string)) {
+            *out = BSON_TYPE_DOUBLE;
+        } else if (0 == strcasecmp("string", value_string)) {
+            *out = BSON_TYPE_UTF8;
+        } else if (0 == strcasecmp("object", value_string)) {
+            *out = BSON_TYPE_DOCUMENT;
+        } else if (0 == strcasecmp("array", value_string)) {
+            *out = BSON_TYPE_ARRAY;
+        } else if (0 == strcasecmp("binData", value_string)) {
+            *out = BSON_TYPE_BINARY;
+        } else if (0 == strcasecmp("undefined", value_string)) {
+            *out = BSON_TYPE_UNDEFINED;
+        } else if (0 == strcasecmp("objectId", value_string)) {
+            *out = BSON_TYPE_OID;
+        } else if (0 == strcasecmp("bool", value_string)) {
+            *out = BSON_TYPE_BOOL;
+        } else if (0 == strcasecmp("date", value_string)) {
+            *out = BSON_TYPE_DATE_TIME;
+        } else if (0 == strcasecmp("null", value_string)) {
+            *out = BSON_TYPE_NULL;
+        } else if (0 == strcasecmp("regex", value_string)) {
+            *out = BSON_TYPE_REGEX;
+        } else if (0 == strcasecmp("dbPointer", value_string)) {
+            *out = BSON_TYPE_DBPOINTER;
+        } else if (0 == strcasecmp("javascript", value_string)) {
+            *out = BSON_TYPE_CODE;
+        } else if (0 == strcasecmp("symbol", value_string)) {
+            *out = BSON_TYPE_SYMBOL;
+        } else if (0 == strcasecmp("javascriptWithScope", value_string)) {
+            *out = BSON_TYPE_CODEWSCOPE;
+        } else if (0 == strcasecmp("int", value_string)) {
+            *out = BSON_TYPE_INT32;
+        } else if (0 == strcasecmp("timestamp", value_string)) {
+            *out = BSON_TYPE_TIMESTAMP;
+        } else if (0 == strcasecmp("long", value_string)) {
+            *out = BSON_TYPE_INT64;
+        } else if (0 == strcasecmp("decimal", value_string)) {
+            *out = BSON_TYPE_DECIMAL128;
+        } else if (0 == strcasecmp("minKey", value_string)) {
+            *out = BSON_TYPE_MINKEY;
+        } else if (0 == strcasecmp("maxKey", value_string)) {
+            *out = BSON_TYPE_MAXKEY;
+        } else {
+            fprintf(stderr, "unrecognized $$type value: %s\n", value_string);
+            abort();
+        }
+        return true;
+    }
+
+    return false;
 }
 
-
 /*--------------------------------------------------------------------------
  *
  * is_empty_doc_or_array --
@@ -671,409 +598,309 @@ get_type_operator (const bson_value_t *value, bson_type_t *out)
  *--------------------------------------------------------------------------
  */
 
-static bool
-is_empty_doc_or_array (const bson_value_t *value)
-{
-   bson_t doc;
-
-   if (!(value->value_type == BSON_TYPE_ARRAY ||
-         value->value_type == BSON_TYPE_DOCUMENT)) {
-      return false;
-   }
-   BSON_ASSERT (bson_init_static (
-      &doc, value->value.v_doc.data, value->value.v_doc.data_len));
-
-   return bson_count_keys (&doc) == 0;
-}
+static bool is_empty_doc_or_array(const bson_value_t *value) {
+    bson_t doc;
 
+    if (!(value->value_type == BSON_TYPE_ARRAY || value->value_type == BSON_TYPE_DOCUMENT)) {
+        return false;
+    }
+    BSON_ASSERT(bson_init_static(&doc, value->value.v_doc.data, value->value.v_doc.data_len));
 
-static bool
-match_bson_arrays (const bson_t *array, const bson_t *pattern, match_ctx_t *ctx)
-{
-   uint32_t array_count;
-   uint32_t pattern_count;
-   bson_iter_t array_iter;
-   bson_iter_t pattern_iter;
-   const bson_value_t *array_value;
-   const bson_value_t *pattern_value;
-   match_ctx_t derived;
-
-   array_count = bson_count_keys (array);
-   pattern_count = bson_count_keys (pattern);
-
-   if (array_count != pattern_count) {
-      match_err (ctx,
-                 "expected %" PRIu32 " keys, not %" PRIu32,
-                 pattern_count,
-                 array_count);
-      return false;
-   }
-
-   BSON_ASSERT (bson_iter_init (&array_iter, array));
-   BSON_ASSERT (bson_iter_init (&pattern_iter, pattern));
-
-   while (bson_iter_next (&array_iter)) {
-      BSON_ASSERT (bson_iter_next (&pattern_iter));
-      array_value = bson_iter_value (&array_iter);
-      pattern_value = bson_iter_value (&pattern_iter);
-
-      derive (ctx, &derived, bson_iter_key (&array_iter));
-
-      if (!match_bson_value (array_value, pattern_value, &derived)) {
-         return false;
-      }
-   }
-
-   return true;
+    return bson_count_keys(&doc) == 0;
 }
 
+static bool match_bson_arrays(const bson_t *array, const bson_t *pattern, match_ctx_t *ctx) {
+    uint32_t array_count;
+    uint32_t pattern_count;
+    bson_iter_t array_iter;
+    bson_iter_t pattern_iter;
+    const bson_value_t *array_value;
+    const bson_value_t *pattern_value;
+    match_ctx_t derived;
 
-static bool
-is_number_type (bson_type_t t)
-{
-   if (t == BSON_TYPE_DOUBLE || t == BSON_TYPE_INT32 || t == BSON_TYPE_INT64) {
-      return true;
-   }
+    array_count = bson_count_keys(array);
+    pattern_count = bson_count_keys(pattern);
+
+    if (array_count != pattern_count) {
+        match_err(ctx, "expected %" PRIu32 " keys, not %" PRIu32, pattern_count, array_count);
+        return false;
+    }
 
-   return false;
+    BSON_ASSERT(bson_iter_init(&array_iter, array));
+    BSON_ASSERT(bson_iter_init(&pattern_iter, pattern));
+
+    while (bson_iter_next(&array_iter)) {
+        BSON_ASSERT(bson_iter_next(&pattern_iter));
+        array_value = bson_iter_value(&array_iter);
+        pattern_value = bson_iter_value(&pattern_iter);
+
+        derive(ctx, &derived, bson_iter_key(&array_iter));
+
+        if (!match_bson_value(array_value, pattern_value, &derived)) {
+            return false;
+        }
+    }
+
+    return true;
 }
 
+static bool is_number_type(bson_type_t t) {
+    if (t == BSON_TYPE_DOUBLE || t == BSON_TYPE_INT32 || t == BSON_TYPE_INT64) {
+        return true;
+    }
 
-int64_t
-bson_value_as_int64 (const bson_value_t *value)
-{
-   if (value->value_type == BSON_TYPE_DOUBLE) {
-      return (int64_t) value->value.v_double;
-   } else if (value->value_type == BSON_TYPE_INT32) {
-      return (int64_t) value->value.v_int32;
-   } else if (value->value_type == BSON_TYPE_INT64) {
-      return value->value.v_int64;
-   } else {
-      return -123;
-   }
+    return false;
 }
 
+int64_t bson_value_as_int64(const bson_value_t *value) {
+    if (value->value_type == BSON_TYPE_DOUBLE) {
+        return (int64_t)value->value.v_double;
+    } else if (value->value_type == BSON_TYPE_INT32) {
+        return (int64_t)value->value.v_int32;
+    } else if (value->value_type == BSON_TYPE_INT64) {
+        return value->value.v_int64;
+    } else {
+        return -123;
+    }
+}
+
+bool match_bson_value(const bson_value_t *doc, const bson_value_t *pattern, match_ctx_t *ctx) {
+    bson_t subdoc;
+    bson_t pattern_subdoc;
+    int64_t doc_int64;
+    int64_t pattern_int64;
+    bool ret = false;
+
+    if (ctx && ctx->allow_placeholders) {
+        /* The change streams spec tests use the value 42 as a placeholder. */
+        bool is_placeholder = false;
+        if (is_number_type(pattern->value_type) && bson_value_as_int64(pattern) == 42) {
+            is_placeholder = true;
+        }
+        if (pattern->value_type == BSON_TYPE_UTF8 && !strcmp(pattern->value.v_utf8.str, "42")) {
+            is_placeholder = true;
+        }
+        if (is_placeholder) {
+            return true;
+        }
+    }
+
+    if (is_number_type(doc->value_type) && is_number_type(pattern->value_type) && ctx && !ctx->strict_numeric_types) {
+        doc_int64 = bson_value_as_int64(doc);
+        pattern_int64 = bson_value_as_int64(pattern);
+
+        if (doc_int64 != pattern_int64) {
+            match_err(ctx, "expected %" PRId64 ", got %" PRId64, pattern_int64, doc_int64);
+            return false;
+        }
+
+        return true;
+    }
+
+    if (doc->value_type != pattern->value_type) {
+        match_err(ctx,
+                  "expected type %s, got %s",
+                  _mongoc_bson_type_to_str(pattern->value_type),
+                  _mongoc_bson_type_to_str(doc->value_type));
+        return false;
+    }
+
+    switch (doc->value_type) {
+    case BSON_TYPE_ARRAY:
+    case BSON_TYPE_DOCUMENT:
+
+        if (!bson_init_from_value(&subdoc, doc)) {
+            return false;
+        }
+
+        if (!bson_init_from_value(&pattern_subdoc, pattern)) {
+            bson_destroy(&subdoc);
+            return false;
+        }
+
+        if (doc->value_type == BSON_TYPE_ARRAY) {
+            ret = match_bson_arrays(&subdoc, &pattern_subdoc, ctx);
+        } else {
+            ret = match_bson_with_ctx(&subdoc, &pattern_subdoc, ctx);
+        }
+
+        bson_destroy(&subdoc);
+        bson_destroy(&pattern_subdoc);
+
+        return ret;
+
+    case BSON_TYPE_BINARY:
+        ret = doc->value.v_binary.data_len == pattern->value.v_binary.data_len
+           && !memcmp(doc->value.v_binary.data, pattern->value.v_binary.data, doc->value.v_binary.data_len);
+        break;
+
+    case BSON_TYPE_BOOL:
+        ret = doc->value.v_bool == pattern->value.v_bool;
+
+        if (!ret) {
+            match_err(ctx, "expected %d, got %d", pattern->value.v_bool, doc->value.v_bool);
+        }
+
+        return ret;
+
+    case BSON_TYPE_CODE:
+        ret = doc->value.v_code.code_len == pattern->value.v_code.code_len
+           && !memcmp(doc->value.v_code.code, pattern->value.v_code.code, doc->value.v_code.code_len);
+
+        break;
+
+    case BSON_TYPE_CODEWSCOPE:
+        ret = doc->value.v_codewscope.code_len == pattern->value.v_codewscope.code_len
+           && !memcmp(doc->value.v_codewscope.code, pattern->value.v_codewscope.code, doc->value.v_codewscope.code_len)
+           && doc->value.v_codewscope.scope_len == pattern->value.v_codewscope.scope_len
+           && !memcmp(doc->value.v_codewscope.scope_data,
+                      pattern->value.v_codewscope.scope_data,
+                      doc->value.v_codewscope.scope_len);
+
+        break;
+
+    case BSON_TYPE_DATE_TIME:
+        ret = doc->value.v_datetime == pattern->value.v_datetime;
+
+        if (!ret) {
+            match_err(ctx, "expected %" PRId64 ", got %" PRId64, pattern->value.v_datetime, doc->value.v_datetime);
+        }
+
+        return ret;
+
+    case BSON_TYPE_DOUBLE:
+        ret = doc->value.v_double == pattern->value.v_double;
+
+        if (!ret) {
+            match_err(ctx, "expected %f, got %f", pattern->value.v_double, doc->value.v_double);
+        }
+
+        return ret;
+
+    case BSON_TYPE_INT32:
+        ret = doc->value.v_int32 == pattern->value.v_int32;
+
+        if (!ret) {
+            match_err(ctx, "expected %" PRId32 ", got %" PRId32, pattern->value.v_int32, doc->value.v_int32);
+        }
+
+        return ret;
+
+    case BSON_TYPE_INT64:
+        ret = doc->value.v_int64 == pattern->value.v_int64;
+
+        if (!ret) {
+            match_err(ctx, "expected %" PRId64 ", got %" PRId64, pattern->value.v_int64, doc->value.v_int64);
+        }
+
+        return ret;
+
+    case BSON_TYPE_OID: ret = bson_oid_equal(&doc->value.v_oid, &pattern->value.v_oid); break;
+
+    case BSON_TYPE_REGEX:
+        ret = !strcmp(doc->value.v_regex.regex, pattern->value.v_regex.regex)
+           && !strcmp(doc->value.v_regex.options, pattern->value.v_regex.options);
+
+        break;
+
+    case BSON_TYPE_SYMBOL:
+        ret = doc->value.v_symbol.len == pattern->value.v_symbol.len
+           && !strncmp(doc->value.v_symbol.symbol, pattern->value.v_symbol.symbol, doc->value.v_symbol.len);
+
+        break;
+
+    case BSON_TYPE_TIMESTAMP:
+        ret = doc->value.v_timestamp.timestamp == pattern->value.v_timestamp.timestamp
+           && doc->value.v_timestamp.increment == pattern->value.v_timestamp.increment;
+
+        break;
+
+    case BSON_TYPE_UTF8:
+        ret = doc->value.v_utf8.len == pattern->value.v_utf8.len
+           && !strncmp(doc->value.v_utf8.str, pattern->value.v_utf8.str, doc->value.v_utf8.len);
+
+        if (!ret) {
+            match_err(ctx, "expected \"%s\", got \"%s\"", pattern->value.v_utf8.str, doc->value.v_utf8.str);
+        }
+
+        return ret;
+
+    /* these are empty types, if "a" and "b" are the same type they're equal */
+    case BSON_TYPE_EOD:
+    case BSON_TYPE_MAXKEY:
+    case BSON_TYPE_MINKEY:
+    case BSON_TYPE_NULL:
+    case BSON_TYPE_UNDEFINED: return true;
+
+    case BSON_TYPE_DBPOINTER:
+        ret = (0 == strcmp(doc->value.v_dbpointer.collection, pattern->value.v_dbpointer.collection)
+               && bson_oid_equal(&doc->value.v_dbpointer.oid, &pattern->value.v_dbpointer.oid));
+        break;
+
+    case BSON_TYPE_DECIMAL128:
+        ret = (doc->value.v_decimal128.low == pattern->value.v_decimal128.low
+               && doc->value.v_decimal128.high == pattern->value.v_decimal128.high);
+        if (!ret) {
+            match_err(ctx,
+                      "Decimal128 is not an exact binary match (though "
+                      "numeric values may be equal)");
+        }
+        break;
+    default: match_err(ctx, "unexpected value type %d: %s", doc->value_type, _mongoc_bson_type_to_str(doc->value_type));
+    }
+
+    if (!ret) {
+        match_err(ctx, "%s values mismatch", _mongoc_bson_type_to_str(pattern->value_type));
+    }
 
-bool
-match_bson_value (const bson_value_t *doc,
-                  const bson_value_t *pattern,
-                  match_ctx_t *ctx)
-{
-   bson_t subdoc;
-   bson_t pattern_subdoc;
-   int64_t doc_int64;
-   int64_t pattern_int64;
-   bool ret = false;
-
-   if (ctx && ctx->allow_placeholders) {
-      /* The change streams spec tests use the value 42 as a placeholder. */
-      bool is_placeholder = false;
-      if (is_number_type (pattern->value_type) &&
-          bson_value_as_int64 (pattern) == 42) {
-         is_placeholder = true;
-      }
-      if (pattern->value_type == BSON_TYPE_UTF8 &&
-          !strcmp (pattern->value.v_utf8.str, "42")) {
-         is_placeholder = true;
-      }
-      if (is_placeholder) {
-         return true;
-      }
-   }
-
-   if (is_number_type (doc->value_type) &&
-       is_number_type (pattern->value_type) && ctx &&
-       !ctx->strict_numeric_types) {
-      doc_int64 = bson_value_as_int64 (doc);
-      pattern_int64 = bson_value_as_int64 (pattern);
-
-      if (doc_int64 != pattern_int64) {
-         match_err (ctx,
-                    "expected %" PRId64 ", got %" PRId64,
-                    pattern_int64,
-                    doc_int64);
-         return false;
-      }
-
-      return true;
-   }
-
-   if (doc->value_type != pattern->value_type) {
-      match_err (ctx,
-                 "expected type %s, got %s",
-                 _mongoc_bson_type_to_str (pattern->value_type),
-                 _mongoc_bson_type_to_str (doc->value_type));
-      return false;
-   }
-
-   switch (doc->value_type) {
-   case BSON_TYPE_ARRAY:
-   case BSON_TYPE_DOCUMENT:
-
-      if (!bson_init_from_value (&subdoc, doc)) {
-         return false;
-      }
-
-      if (!bson_init_from_value (&pattern_subdoc, pattern)) {
-         bson_destroy (&subdoc);
-         return false;
-      }
-
-      if (doc->value_type == BSON_TYPE_ARRAY) {
-         ret = match_bson_arrays (&subdoc, &pattern_subdoc, ctx);
-      } else {
-         ret = match_bson_with_ctx (&subdoc, &pattern_subdoc, ctx);
-      }
-
-      bson_destroy (&subdoc);
-      bson_destroy (&pattern_subdoc);
-
-      return ret;
-
-   case BSON_TYPE_BINARY:
-      ret = doc->value.v_binary.data_len == pattern->value.v_binary.data_len &&
-            !memcmp (doc->value.v_binary.data,
-                     pattern->value.v_binary.data,
-                     doc->value.v_binary.data_len);
-      break;
-
-   case BSON_TYPE_BOOL:
-      ret = doc->value.v_bool == pattern->value.v_bool;
-
-      if (!ret) {
-         match_err (ctx,
-                    "expected %d, got %d",
-                    pattern->value.v_bool,
-                    doc->value.v_bool);
-      }
-
-      return ret;
-
-   case BSON_TYPE_CODE:
-      ret = doc->value.v_code.code_len == pattern->value.v_code.code_len &&
-            !memcmp (doc->value.v_code.code,
-                     pattern->value.v_code.code,
-                     doc->value.v_code.code_len);
-
-      break;
-
-   case BSON_TYPE_CODEWSCOPE:
-      ret = doc->value.v_codewscope.code_len ==
-               pattern->value.v_codewscope.code_len &&
-            !memcmp (doc->value.v_codewscope.code,
-                     pattern->value.v_codewscope.code,
-                     doc->value.v_codewscope.code_len) &&
-            doc->value.v_codewscope.scope_len ==
-               pattern->value.v_codewscope.scope_len &&
-            !memcmp (doc->value.v_codewscope.scope_data,
-                     pattern->value.v_codewscope.scope_data,
-                     doc->value.v_codewscope.scope_len);
-
-      break;
-
-   case BSON_TYPE_DATE_TIME:
-      ret = doc->value.v_datetime == pattern->value.v_datetime;
-
-      if (!ret) {
-         match_err (ctx,
-                    "expected %" PRId64 ", got %" PRId64,
-                    pattern->value.v_datetime,
-                    doc->value.v_datetime);
-      }
-
-      return ret;
-
-   case BSON_TYPE_DOUBLE:
-      ret = doc->value.v_double == pattern->value.v_double;
-
-      if (!ret) {
-         match_err (ctx,
-                    "expected %f, got %f",
-                    pattern->value.v_double,
-                    doc->value.v_double);
-      }
-
-      return ret;
-
-   case BSON_TYPE_INT32:
-      ret = doc->value.v_int32 == pattern->value.v_int32;
-
-      if (!ret) {
-         match_err (ctx,
-                    "expected %" PRId32 ", got %" PRId32,
-                    pattern->value.v_int32,
-                    doc->value.v_int32);
-      }
-
-      return ret;
-
-   case BSON_TYPE_INT64:
-      ret = doc->value.v_int64 == pattern->value.v_int64;
-
-      if (!ret) {
-         match_err (ctx,
-                    "expected %" PRId64 ", got %" PRId64,
-                    pattern->value.v_int64,
-                    doc->value.v_int64);
-      }
-
-      return ret;
-
-   case BSON_TYPE_OID:
-      ret = bson_oid_equal (&doc->value.v_oid, &pattern->value.v_oid);
-      break;
-
-   case BSON_TYPE_REGEX:
-      ret =
-         !strcmp (doc->value.v_regex.regex, pattern->value.v_regex.regex) &&
-         !strcmp (doc->value.v_regex.options, pattern->value.v_regex.options);
-
-      break;
-
-   case BSON_TYPE_SYMBOL:
-      ret = doc->value.v_symbol.len == pattern->value.v_symbol.len &&
-            !strncmp (doc->value.v_symbol.symbol,
-                      pattern->value.v_symbol.symbol,
-                      doc->value.v_symbol.len);
-
-      break;
-
-   case BSON_TYPE_TIMESTAMP:
-      ret = doc->value.v_timestamp.timestamp ==
-               pattern->value.v_timestamp.timestamp &&
-            doc->value.v_timestamp.increment ==
-               pattern->value.v_timestamp.increment;
-
-      break;
-
-   case BSON_TYPE_UTF8:
-      ret = doc->value.v_utf8.len == pattern->value.v_utf8.len &&
-            !strncmp (doc->value.v_utf8.str,
-                      pattern->value.v_utf8.str,
-                      doc->value.v_utf8.len);
-
-      if (!ret) {
-         match_err (ctx,
-                    "expected \"%s\", got \"%s\"",
-                    pattern->value.v_utf8.str,
-                    doc->value.v_utf8.str);
-      }
-
-      return ret;
-
-
-   /* these are empty types, if "a" and "b" are the same type they're equal */
-   case BSON_TYPE_EOD:
-   case BSON_TYPE_MAXKEY:
-   case BSON_TYPE_MINKEY:
-   case BSON_TYPE_NULL:
-   case BSON_TYPE_UNDEFINED:
-      return true;
-
-   case BSON_TYPE_DBPOINTER:
-      ret = (0 == strcmp (doc->value.v_dbpointer.collection,
-                          pattern->value.v_dbpointer.collection) &&
-             bson_oid_equal (&doc->value.v_dbpointer.oid,
-                             &pattern->value.v_dbpointer.oid));
-      break;
-
-   case BSON_TYPE_DECIMAL128:
-      ret = (doc->value.v_decimal128.low == pattern->value.v_decimal128.low &&
-             doc->value.v_decimal128.high == pattern->value.v_decimal128.high);
-      if (!ret) {
-         match_err (ctx,
-                    "Decimal128 is not an exact binary match (though "
-                    "numeric values may be equal)");
-      }
-      break;
-   default:
-      match_err (ctx,
-                 "unexpected value type %d: %s",
-                 doc->value_type,
-                 _mongoc_bson_type_to_str (doc->value_type));
-   }
-
-   if (!ret) {
-      match_err (ctx,
-                 "%s values mismatch",
-                 _mongoc_bson_type_to_str (pattern->value_type));
-   }
-
-   return ret;
+    return ret;
 }
 
-const char *
-_mongoc_bson_type_to_str (bson_type_t t)
-{
-   switch (t) {
-   case BSON_TYPE_EOD:
-      return "EOD";
-   case BSON_TYPE_DOUBLE:
-      return "DOUBLE";
-   case BSON_TYPE_UTF8:
-      return "UTF8";
-   case BSON_TYPE_DOCUMENT:
-      return "DOCUMENT";
-   case BSON_TYPE_ARRAY:
-      return "ARRAY";
-   case BSON_TYPE_BINARY:
-      return "BINARY";
-   case BSON_TYPE_UNDEFINED:
-      return "UNDEFINED";
-   case BSON_TYPE_OID:
-      return "OID";
-   case BSON_TYPE_BOOL:
-      return "BOOL";
-   case BSON_TYPE_DATE_TIME:
-      return "DATE_TIME";
-   case BSON_TYPE_NULL:
-      return "NULL";
-   case BSON_TYPE_REGEX:
-      return "REGEX";
-   case BSON_TYPE_DBPOINTER:
-      return "DBPOINTER";
-   case BSON_TYPE_CODE:
-      return "CODE";
-   case BSON_TYPE_SYMBOL:
-      return "SYMBOL";
-   case BSON_TYPE_CODEWSCOPE:
-      return "CODEWSCOPE";
-   case BSON_TYPE_INT32:
-      return "INT32";
-   case BSON_TYPE_TIMESTAMP:
-      return "TIMESTAMP";
-   case BSON_TYPE_INT64:
-      return "INT64";
-   case BSON_TYPE_MAXKEY:
-      return "MAXKEY";
-   case BSON_TYPE_MINKEY:
-      return "MINKEY";
-   case BSON_TYPE_DECIMAL128:
-      return "DECIMAL128";
-   default:
-      return "Unknown";
-   }
+const char *_mongoc_bson_type_to_str(bson_type_t t) {
+    switch (t) {
+    case BSON_TYPE_EOD: return "EOD";
+    case BSON_TYPE_DOUBLE: return "DOUBLE";
+    case BSON_TYPE_UTF8: return "UTF8";
+    case BSON_TYPE_DOCUMENT: return "DOCUMENT";
+    case BSON_TYPE_ARRAY: return "ARRAY";
+    case BSON_TYPE_BINARY: return "BINARY";
+    case BSON_TYPE_UNDEFINED: return "UNDEFINED";
+    case BSON_TYPE_OID: return "OID";
+    case BSON_TYPE_BOOL: return "BOOL";
+    case BSON_TYPE_DATE_TIME: return "DATE_TIME";
+    case BSON_TYPE_NULL: return "NULL";
+    case BSON_TYPE_REGEX: return "REGEX";
+    case BSON_TYPE_DBPOINTER: return "DBPOINTER";
+    case BSON_TYPE_CODE: return "CODE";
+    case BSON_TYPE_SYMBOL: return "SYMBOL";
+    case BSON_TYPE_CODEWSCOPE: return "CODEWSCOPE";
+    case BSON_TYPE_INT32: return "INT32";
+    case BSON_TYPE_TIMESTAMP: return "TIMESTAMP";
+    case BSON_TYPE_INT64: return "INT64";
+    case BSON_TYPE_MAXKEY: return "MAXKEY";
+    case BSON_TYPE_MINKEY: return "MINKEY";
+    case BSON_TYPE_DECIMAL128: return "DECIMAL128";
+    default: return "Unknown";
+    }
 }
 
-void
-_assert_match_bson (const bson_t *doc, const bson_t *pattern)
-{
-   match_ctx_t ctx;
-
-   memset (&ctx, 0, sizeof (match_ctx_t));
-   if (!match_bson_with_ctx (doc, pattern, &ctx)) {
-      char *doc_str = doc ? bson_as_json (doc, NULL) : NULL;
-      char *pattern_str = bson_as_json (pattern, NULL);
-
-      TEST_ERROR ("ASSERT_MATCH failed with document:\n\n"
-                  "%s\n"
-                  "pattern:\n%s\n"
-                  "%s\n",
-                  doc_str ? doc_str : "{}",
-                  pattern_str,
-                  ctx.errmsg);
-
-      bson_free (doc_str);
-      bson_free (pattern_str);
-   }
+void _assert_match_bson(const bson_t *doc, const bson_t *pattern) {
+    match_ctx_t ctx;
+
+    memset(&ctx, 0, sizeof(match_ctx_t));
+    if (!match_bson_with_ctx(doc, pattern, &ctx)) {
+        char *doc_str = doc ? bson_as_json(doc, NULL) : NULL;
+        char *pattern_str = bson_as_json(pattern, NULL);
+
+        TEST_ERROR("ASSERT_MATCH failed with document:\n\n"
+                   "%s\n"
+                   "pattern:\n%s\n"
+                   "%s\n",
+                   doc_str ? doc_str : "{}",
+                   pattern_str,
+                   ctx.errmsg);
+
+        bson_free(doc_str);
+        bson_free(pattern_str);
+    }
 }