libmongocrypt-helper 1.11.0.0.1001 → 1.13.2.0.1001

data/ext/libmongocrypt/libmongocrypt/test/data/schema-broker/encryptedFields.json

@@ -0,0 +1,20 @@
+{
+    "escCollection": "enxcol_.coll.esc",
+    "ecocCollection": "enxcol_.coll.ecoc",
+    "fields": [
+        {
+            "keyId": {
+                "$binary": {
+                    "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+                    "subType": "04"
+                }
+            },
+            "path": "encryptedIndexed",
+            "bsonType": "string",
+            "queries": {
+                "queryType": "equality",
+                "contention": 8
+            }
+        }
+    ]
+}

data/ext/libmongocrypt/libmongocrypt/test/data/schema-broker/encryptedFields2.json

@@ -0,0 +1,20 @@
+{
+    "escCollection": "enxcol_.coll2.esc",
+    "ecocCollection": "enxcol_.coll2.ecoc",
+    "fields": [
+        {
+            "keyId": {
+                "$binary": {
+                    "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+                    "subType": "04"
+                }
+            },
+            "path": "encryptedIndexed2",
+            "bsonType": "string",
+            "queries": {
+                "queryType": "equality",
+                "contention": 8
+            }
+        }
+    ]
+}

data/ext/libmongocrypt/libmongocrypt/test/data/schema-broker/encryptedFieldsMap.json

@@ -0,0 +1,42 @@
+{
+    "db.coll": {
+        "escCollection": "enxcol_.coll.esc",
+        "ecocCollection": "enxcol_.coll.ecoc",
+        "fields": [
+            {
+                "keyId": {
+                    "$binary": {
+                        "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+                        "subType": "04"
+                    }
+                },
+                "path": "encryptedIndexed",
+                "bsonType": "string",
+                "queries": {
+                    "queryType": "equality",
+                    "contention": 8
+                }
+            }
+        ]
+    },
+    "db.coll2": {
+        "escCollection": "enxcol_.coll2.esc",
+        "ecocCollection": "enxcol_.coll2.ecoc",
+        "fields": [
+            {
+                "keyId": {
+                    "$binary": {
+                        "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+                        "subType": "04"
+                    }
+                },
+                "path": "encryptedIndexed2",
+                "bsonType": "string",
+                "queries": {
+                    "queryType": "equality",
+                    "contention": 8
+                }
+            }
+        ]
+    }
+}

data/ext/libmongocrypt/libmongocrypt/test/data/schema-broker/jsonSchema.json

@@ -0,0 +1,19 @@
+{
+    "properties": {
+        "encrypted": {
+            "encrypt": {
+                "keyId": [
+                    {
+                        "$binary": {
+                            "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+                            "subType": "04"
+                        }
+                    }
+                ],
+                "bsonType": "string",
+                "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
+            }
+        }
+    },
+    "bsonType": "object"
+}

data/ext/libmongocrypt/libmongocrypt/test/data/schema-broker/jsonSchema2.json

@@ -0,0 +1,19 @@
+{
+    "properties": {
+        "encrypted2": {
+            "encrypt": {
+                "keyId": [
+                    {
+                        "$binary": {
+                            "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+                            "subType": "04"
+                        }
+                    }
+                ],
+                "bsonType": "string",
+                "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
+            }
+        }
+    },
+    "bsonType": "object"
+}

data/ext/libmongocrypt/libmongocrypt/test/data/schema-broker/schemaMap.json

@@ -0,0 +1,40 @@
+{
+    "db.coll": {
+        "properties": {
+            "encrypted": {
+                "encrypt": {
+                    "keyId": [
+                        {
+                            "$binary": {
+                                "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+                                "subType": "04"
+                            }
+                        }
+                    ],
+                    "bsonType": "string",
+                    "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
+                }
+            }
+        },
+        "bsonType": "object"
+    },
+    "db.coll2": {
+        "properties": {
+            "encrypted2": {
+                "encrypt": {
+                    "keyId": [
+                        {
+                            "$binary": {
+                                "base64": "YWFhYWFhYWFhYWFhYWFhYQ==",
+                                "subType": "04"
+                            }
+                        }
+                    ],
+                    "bsonType": "string",
+                    "algorithm": "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
+                }
+            }
+        },
+        "bsonType": "object"
+    }
+}

data/ext/libmongocrypt/libmongocrypt/test/data/tokens/mc.json

@@ -4,7 +4,7 @@
    "contentionFactor": 1234567890,
    "collectionsLevel1Token": "ff2103ff205a36f39704f643c270c129919f008c391d9589a6d2c86a7429d0d3",
    "serverDataEncryptionLevel1Token": "d915ccc1eb81687fb5fc5b799f48c99fbe17e7a011a46a48901b9ae3d790656b",
-   "serverTokenDerivationLevel1Token": "1adc114b462741e6ac9f52eacf3dcb8cbca19827693c571d9418fda570c29d82",
+   "ServerTokenDerivationLevel1Token": "1adc114b462741e6ac9f52eacf3dcb8cbca19827693c571d9418fda570c29d82",
    "EDCToken": "167d2d2ff8e4144df37ff759db593fde0ecc7d9636f96d62dacad672eccad349",
    "ESCToken": "bfd480f1658f49f48985734737bc07d0bc36b88210277605c55ff3c9c3ef50b0",
    "ECCToken": "9d34f9c182d75a5a3347c2f903e3e647105c651d52cf9555c9420ba07ddd3aa2",
@@ -21,5 +21,31 @@
    "ESCTwiceDerivedValueToken": "34150c6f5ab56dc39ddb935accb7f53e5276322fa937650b76a4dda9723d6fba",
    "serverCountAndContentionFactorEncryptionToken": "a8c4a477e5518a527f718a5a1530919f2dad13b1f3559833e17b479711cbdbb9",
    "serverZerosEncryptionToken": "95fda1e139ef1dc84260d4d3ebaab7627a9676f4af7aeb1b596c7c14a0b3a2ea",
-   "AnchorPaddingTokenRoot": "d5072cc56d9241470b9771292c3f75d950cba1cf842ca6707d1adfec5ec6f3e7"
+   "AnchorPaddingTokenRoot": "d5072cc56d9241470b9771292c3f75d950cba1cf842ca6707d1adfec5ec6f3e7",
+   "AnchorPaddingKeyToken": "4665ff3ea2d8268d3e6c5d85ddbe6a79d74c45898012afdd4f5d2afb4472957e",
+   "AnchorPaddingValueToken": "38cba0ac9914890d646387c9796edbba771b039ce9615457d7cc169df502f78f",
+   "EDCTextExactToken": "be75dff4bbe8671213ea36fcb716f783af51fa00477fdea2558284b8b6d6b290",
+   "EDCTextSubstringToken": "7eff82fa8a912a3cc60be036b0fddbbbcac45366e4cdf41090d49d770d2b28ef",
+   "EDCTextSuffixToken": "d72607e0c681b39af3769ea93fc7c6b533c8963669a2f5f3d4205469d8e2977a",
+   "EDCTextPrefixToken": "26c020f4bb3e50cb094f29da9e40b99fa9a862ea6df9e14a4838d22089f5e48c",
+   "ESCTextExactToken": "591d0e6c50f38bbac01ebbff96b2f602eefbbb138c674fcf1261dcb26508ac36",
+   "ESCTextSubstringToken": "38511f2fc6a90259b1d66f161f4f01893437703b8e07be7013ab2ebe1a5199fd",
+   "ESCTextSuffixToken": "574e5d597c469798871e349e3f4151a9a75aa4fca438e6ffa19020a9a4d239df",
+   "ESCTextPrefixToken": "700b0a35a12f36b5511ed3ea2ca8f7fd41386a6d6d45e5c028edca240ba617d6",
+   "ServerTextExactToken": "1b0b904479d408fe805b14cd8f269b7aa9f022128816da09bc94ddd7021aa2ee",
+   "ServerTextSubstringToken": "dc79b64dab53c09dcbcc2c203e1ed5d88e0fed75b1e3a3a3f192ead85d762e6a",
+   "ServerTextSuffixToken": "a69ea838e79f9c11e2d6bd54e665bf0eee4864d5e517a7c9e9fb763e1a187cbe",
+   "ServerTextPrefixToken": "b89b65fc9274678e1fe107ff8ae485f6ba46400870f87ba08c710bd605792cfc",
+   "EDCTextExactDerivedFromDataTokenAndContentionFactorToken": "5f073c558114c2ff39a56e837d64f64c68328b14ebe2f6f142304e966cb618c4",
+   "EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken": "ac333c5086216d14bcbe9996dc7c9c815625aeef47e6c08d83b348dd6bb62834",
+   "EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken": "bd9a705c59a292635101523014ae997f2f56b8ba2ab4df3573c8f2524f5a9e50",
+   "EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken": "06c4e44724305bb706e404c1caae6fff604c2b0c6809c3bcf79658ff3c93b951",
+   "ESCTextExactDerivedFromDataTokenAndContentionFactorToken": "680b35d73a3f778792b8a03df267aa945cb9718ed4e6925c9da069d354032b7a",
+   "ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken": "380c456ea3c2b9d80324556931764ea22c5e097b2702e658dfe81254b1ec9688",
+   "ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken": "db3418028ec9079fe27643071d575e9f6e0607bdfee185d1380a68921ce58ff6",
+   "ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken": "263cd30dbdce8a4d00bcd24b45b2d40058646f1aa9fb38313c3162b1a455889b",
+   "ServerTextExactDerivedFromDataToken": "42dde13769bb2f18d35654fc673172b82db7fdcc62fb3ddf0767953bddc7e981",
+   "ServerTextSubstringDerivedFromDataToken": "7d474158a817b9c6d45c497d591d6bc1d1f4f40066c40eaaf7e7f3c3ce4e11f0",
+   "ServerTextSuffixDerivedFromDataToken": "3523904f3d15e552cea7c8643396b8090ba591a394eb91921c8b33e6fe07b0a1",
+   "ServerTextPrefixDerivedFromDataToken": "854a5420921027c2a96415191a122d82a6f90d21ecef070e44174527eb4d7f2b"
 }

data/ext/libmongocrypt/libmongocrypt/test/data/tokens/server.json

@@ -3,7 +3,7 @@
    "value": "c07c0df51257948e1a0fc70dd4568e3af99b23b3434c9858237ca7db62db9766",
    "contentionFactor": 1234567890,
    "collectionsLevel1Token": "BD53ACAC665EDD01E0CA30CB648B2B8F4967544047FD4E7D12B1A9BF07339928",
-   "serverTokenDerivationLevel1Token": "C17FDF249DE234F9AB15CD95137EA7EC82AE4E5B51F6BFB0FC1B8FEB6800F74C",
+   "ServerTokenDerivationLevel1Token": "C17FDF249DE234F9AB15CD95137EA7EC82AE4E5B51F6BFB0FC1B8FEB6800F74C",
    "serverDataEncryptionLevel1Token": "EB9A73F7912D86A4297E81D2F675AF742874E4057E3A890FEC651A23EEE3F3EC",
    "EDCToken": "82B0AB0F8F1D31AEB6F4DBC915EF17CBA2FE21E36EC436984EB63BECEC173831",
    "ESCToken": "279C575B52B73677EEF07D9C1126EBDF08C35369570A9B75E44A9AFDCCA96B6D",
@@ -21,5 +21,31 @@
    "ESCTwiceDerivedValueToken": "53F0A51A43447B9881D5E79BA4C5F78E80BC2BC6AA42B00C81079EBF4C9D5A7C",
    "serverCountAndContentionFactorEncryptionToken": "2F30DBCC06B722B60BC1FF018FC28D5FAEE2F222496BE34A264EF3267E811DA0",
    "serverZerosEncryptionToken": "986F23F132FF7F14F748AC69373CFC982AD0AD4BAD25BE92008B83AB43E96029",
-   "AnchorPaddingTokenRoot": "4312890F621FE3CA7497C3405DFD8AAF46A578C77F7404D28C12BA853A4D3327"
+   "AnchorPaddingTokenRoot": "4312890F621FE3CA7497C3405DFD8AAF46A578C77F7404D28C12BA853A4D3327",
+   "AnchorPaddingKeyToken": "EF6D80379C462FC724CE8C245DC177ED507154B4EBB04DED780FA0DDAF1A2247",
+   "AnchorPaddingValueToken": "A3308597F3C5271D5BAB640F749E619E9272A2C33F4CD372680F55F84CC4DF7F",
+   "EDCTextExactToken": "17dde6bd0c0d783aa2bf84e255b162b9362032e5ebd6d655d6b478c4d77dc077",
+   "EDCTextSubstringToken": "4dde679aa0568701a0fda6b1cae21e99da32500541e4ad832ea83db94497478f",
+   "EDCTextSuffixToken": "61fa8b8f02a5e7f3cfd2c3e58d3fb8c2d1bfe8a1acc32e43f26478a52944af78",
+   "EDCTextPrefixToken": "926e96d7142b2d187d10579a26a11499d6c30aac2e3fdd56eb1cd536875decfd",
+   "ESCTextExactToken": "2fea10a92e84cce913ea0ffd7fd59964507e9e96cdffa4f1b861521f3e653260",
+   "ESCTextSubstringToken": "d6a94cacc9f5dd10b2b980bd4c4044e16ff1b29ad50c692e603487c46cbe610e",
+   "ESCTextSuffixToken": "336f39da6fa984a3477261ea19147b77f02e843f82511c94a91ec77bd72dca68",
+   "ESCTextPrefixToken": "2575c2a275e8135ec73093ae2edc793f6a3a0b8ed89767c3a8695ad93f1c6e9e",
+   "ServerTextExactToken": "2ae33773be27c9fe3522ff0459f621670e93a7423166e63e9a43687a503c7438",
+   "ServerTextSubstringToken": "183ff338509675d5377d09978e9becd31b197458e2c8cd45b670c672ceb6dc53",
+   "ServerTextSuffixToken": "baf7c9392bb37607c6aa1f04163f4db8628872e7e7122e754bcd72771934ccbd",
+   "ServerTextPrefixToken": "52387ea6942d9299a89f70a2a4d8a4209ea1dfe56e29f6c0e3182ca7818b5c9c",
+   "EDCTextExactDerivedFromDataTokenAndContentionFactorToken": "3551507189d32cc7768390cdd83071deeb3055ca86c4756b16bb740024b23610",
+   "EDCTextSubstringDerivedFromDataTokenAndContentionFactorToken": "4b52f6daf3b688971eb5819820c3468b3c79ba45fd3e86134351f9baf203e0d1",
+   "EDCTextSuffixDerivedFromDataTokenAndContentionFactorToken": "c1f273913631a9a1b36fea884b3c8a3a141c9e21556981094ba15f262e540ac7",
+   "EDCTextPrefixDerivedFromDataTokenAndContentionFactorToken": "a8d68ebdb0e2d31754f693c56071b0b1d225e6ec5568aff875bd4f7c48c24f66",
+   "ESCTextExactDerivedFromDataTokenAndContentionFactorToken": "4cd82a4883ab0a6224a24937066f94827f5107e8bb2f0fa841e10aff8d49e8e4",
+   "ESCTextSubstringDerivedFromDataTokenAndContentionFactorToken": "94f116183f14442e335902756e5b730683cd998c683b90d04dc9e8f48684bdb2",
+   "ESCTextSuffixDerivedFromDataTokenAndContentionFactorToken": "13390024c674c2d131771cf95af9787c8c7ef76b5d63078b3dc482cb4075a634",
+   "ESCTextPrefixDerivedFromDataTokenAndContentionFactorToken": "9d0d5f84de779360c43be8e61710deb4b2705b6bf1e11ee41fba09fd4486b7c6",
+   "ServerTextExactDerivedFromDataToken": "ae210cd90c230bb8cb96a4e840c9cf88740ae156f3514260d3f1ce94b0bf941e",
+   "ServerTextSubstringDerivedFromDataToken": "7b514ede2cd6d364f2da2580bf173a4e68f9e0617c123aee8b9dda4d8d4b47d7",
+   "ServerTextSuffixDerivedFromDataToken": "3e242be8d4c8a5894e81aa5fe0729cf48355dbe219c5c6b5ceb8b0eef124ba40",
+   "ServerTextPrefixDerivedFromDataToken": "8d8d41ac0618b0e98b086d662a2466f4aa1527d6536acdbcf220c724073331eb"
 }

data/ext/libmongocrypt/libmongocrypt/test/example-state-machine.c

@@ -108,7 +108,7 @@ static void _print_binary_as_bson(mongocrypt_binary_t *binary) {
     BSON_ASSERT(binary);
 
     bson_init_static(&as_bson, mongocrypt_binary_data(binary), mongocrypt_binary_len(binary));
-    str = bson_as_json(&as_bson, NULL);
+    str = bson_as_relaxed_extended_json(&as_bson, NULL);
     printf("%s\n", str);
     bson_free(str);
 }

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

@@ -0,0 +1,304 @@
+/*
+ * Copyright 2018-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// `test-mc-cmp.h` is a modified copy of `test-bson-cmp.c` from libbson 1.28.0.
+
+#include "test-mongocrypt.h"
+
+#include "mc-cmp-private.h"
+
+static void test_mc_cmp_equal(_mongocrypt_tester_t *tester) {
+    (void)tester;
+
+    ASSERT(mc_cmp_equal_ss(0, 0));
+    ASSERT(!mc_cmp_equal_ss(0, -1));
+    ASSERT(!mc_cmp_equal_ss(0, 1));
+    ASSERT(!mc_cmp_equal_ss(-1, 0));
+    ASSERT(mc_cmp_equal_ss(-1, -1));
+    ASSERT(!mc_cmp_equal_ss(-1, 1));
+    ASSERT(!mc_cmp_equal_ss(1, 0));
+    ASSERT(!mc_cmp_equal_ss(1, -1));
+    ASSERT(mc_cmp_equal_ss(1, 1));
+
+    ASSERT(mc_cmp_equal_uu(0u, 0u));
+    ASSERT(!mc_cmp_equal_uu(0u, 1u));
+    ASSERT(!mc_cmp_equal_uu(1u, 0u));
+    ASSERT(mc_cmp_equal_uu(1u, 1u));
+
+    ASSERT(mc_cmp_equal_su(0, 0u));
+    ASSERT(!mc_cmp_equal_su(0, 1u));
+    ASSERT(!mc_cmp_equal_su(-1, 0u));
+    ASSERT(!mc_cmp_equal_su(-1, 1u));
+    ASSERT(!mc_cmp_equal_su(1, 0u));
+    ASSERT(mc_cmp_equal_su(1, 1u));
+
+    ASSERT(mc_cmp_equal_us(0u, 0));
+    ASSERT(!mc_cmp_equal_us(0u, -1));
+    ASSERT(!mc_cmp_equal_us(0u, 1));
+    ASSERT(!mc_cmp_equal_us(1u, 0));
+    ASSERT(!mc_cmp_equal_us(1u, -1));
+    ASSERT(mc_cmp_equal_us(1u, 1));
+}
+
+static void test_mc_cmp_not_equal(_mongocrypt_tester_t *tester) {
+    (void)tester;
+
+    ASSERT(!mc_cmp_not_equal_ss(0, 0));
+    ASSERT(mc_cmp_not_equal_ss(0, -1));
+    ASSERT(mc_cmp_not_equal_ss(0, 1));
+    ASSERT(mc_cmp_not_equal_ss(-1, 0));
+    ASSERT(!mc_cmp_not_equal_ss(-1, -1));
+    ASSERT(mc_cmp_not_equal_ss(-1, 1));
+    ASSERT(mc_cmp_not_equal_ss(1, 0));
+    ASSERT(mc_cmp_not_equal_ss(1, -1));
+    ASSERT(!mc_cmp_not_equal_ss(1, 1));
+
+    ASSERT(!mc_cmp_not_equal_uu(0u, 0u));
+    ASSERT(mc_cmp_not_equal_uu(0u, 1u));
+    ASSERT(mc_cmp_not_equal_uu(1u, 0u));
+    ASSERT(!mc_cmp_not_equal_uu(1u, 1u));
+
+    ASSERT(!mc_cmp_not_equal_su(0, 0u));
+    ASSERT(mc_cmp_not_equal_su(0, 1u));
+    ASSERT(mc_cmp_not_equal_su(-1, 0u));
+    ASSERT(mc_cmp_not_equal_su(-1, 1u));
+    ASSERT(mc_cmp_not_equal_su(1, 0u));
+    ASSERT(!mc_cmp_not_equal_su(1, 1u));
+
+    ASSERT(!mc_cmp_not_equal_us(0u, 0));
+    ASSERT(mc_cmp_not_equal_us(0u, -1));
+    ASSERT(mc_cmp_not_equal_us(0u, 1));
+    ASSERT(mc_cmp_not_equal_us(1u, 0));
+    ASSERT(mc_cmp_not_equal_us(1u, -1));
+    ASSERT(!mc_cmp_not_equal_us(1u, 1));
+}
+
+static void test_mc_cmp_less(_mongocrypt_tester_t *tester) {
+    (void)tester;
+
+    ASSERT(!mc_cmp_less_ss(0, 0));
+    ASSERT(!mc_cmp_less_ss(0, -1));
+    ASSERT(mc_cmp_less_ss(0, 1));
+    ASSERT(mc_cmp_less_ss(-1, 0));
+    ASSERT(!mc_cmp_less_ss(-1, -1));
+    ASSERT(mc_cmp_less_ss(-1, 1));
+    ASSERT(!mc_cmp_less_ss(1, 0));
+    ASSERT(!mc_cmp_less_ss(1, -1));
+    ASSERT(!mc_cmp_less_ss(1, 1));
+
+    ASSERT(!mc_cmp_less_uu(0u, 0u));
+    ASSERT(mc_cmp_less_uu(0u, 1u));
+    ASSERT(!mc_cmp_less_uu(1u, 0u));
+    ASSERT(!mc_cmp_less_uu(1u, 1u));
+
+    ASSERT(!mc_cmp_less_su(0, 0u));
+    ASSERT(mc_cmp_less_su(0, 1u));
+    ASSERT(mc_cmp_less_su(-1, 0u));
+    ASSERT(mc_cmp_less_su(-1, 1u));
+    ASSERT(!mc_cmp_less_su(1, 0u));
+    ASSERT(!mc_cmp_less_su(1, 1u));
+
+    ASSERT(!mc_cmp_less_us(0u, 0));
+    ASSERT(!mc_cmp_less_us(0u, -1));
+    ASSERT(mc_cmp_less_us(0u, 1));
+    ASSERT(!mc_cmp_less_us(1u, 0));
+    ASSERT(!mc_cmp_less_us(1u, -1));
+    ASSERT(!mc_cmp_less_us(1u, 1));
+}
+
+static void test_mc_cmp_greater(_mongocrypt_tester_t *tester) {
+    (void)tester;
+
+    ASSERT(!mc_cmp_greater_ss(0, 0));
+    ASSERT(mc_cmp_greater_ss(0, -1));
+    ASSERT(!mc_cmp_greater_ss(0, 1));
+    ASSERT(!mc_cmp_greater_ss(-1, 0));
+    ASSERT(!mc_cmp_greater_ss(-1, -1));
+    ASSERT(!mc_cmp_greater_ss(-1, 1));
+    ASSERT(mc_cmp_greater_ss(1, 0));
+    ASSERT(mc_cmp_greater_ss(1, -1));
+    ASSERT(!mc_cmp_greater_ss(1, 1));
+
+    ASSERT(!mc_cmp_greater_uu(0u, 0u));
+    ASSERT(!mc_cmp_greater_uu(0u, 1u));
+    ASSERT(mc_cmp_greater_uu(1u, 0u));
+    ASSERT(!mc_cmp_greater_uu(1u, 1u));
+
+    ASSERT(!mc_cmp_greater_su(0, 0u));
+    ASSERT(!mc_cmp_greater_su(0, 1u));
+    ASSERT(!mc_cmp_greater_su(-1, 0u));
+    ASSERT(!mc_cmp_greater_su(-1, 1u));
+    ASSERT(mc_cmp_greater_su(1, 0u));
+    ASSERT(!mc_cmp_greater_su(1, 1u));
+
+    ASSERT(!mc_cmp_greater_us(0u, 0));
+    ASSERT(mc_cmp_greater_us(0u, -1));
+    ASSERT(!mc_cmp_greater_us(0u, 1));
+    ASSERT(mc_cmp_greater_us(1u, 0));
+    ASSERT(mc_cmp_greater_us(1u, -1));
+    ASSERT(!mc_cmp_greater_us(1u, 1));
+}
+
+static void test_mc_cmp_less_equal(_mongocrypt_tester_t *tester) {
+    (void)tester;
+
+    ASSERT(mc_cmp_less_equal_ss(0, 0));
+    ASSERT(!mc_cmp_less_equal_ss(0, -1));
+    ASSERT(mc_cmp_less_equal_ss(0, 1));
+    ASSERT(mc_cmp_less_equal_ss(-1, 0));
+    ASSERT(mc_cmp_less_equal_ss(-1, -1));
+    ASSERT(mc_cmp_less_equal_ss(-1, 1));
+    ASSERT(!mc_cmp_less_equal_ss(1, 0));
+    ASSERT(!mc_cmp_less_equal_ss(1, -1));
+    ASSERT(mc_cmp_less_equal_ss(1, 1));
+
+    ASSERT(mc_cmp_less_equal_uu(0u, 0u));
+    ASSERT(mc_cmp_less_equal_uu(0u, 1u));
+    ASSERT(!mc_cmp_less_equal_uu(1u, 0u));
+    ASSERT(mc_cmp_less_equal_uu(1u, 1u));
+
+    ASSERT(mc_cmp_less_equal_su(0, 0u));
+    ASSERT(mc_cmp_less_equal_su(0, 1u));
+    ASSERT(mc_cmp_less_equal_su(-1, 0u));
+    ASSERT(mc_cmp_less_equal_su(-1, 1u));
+    ASSERT(!mc_cmp_less_equal_su(1, 0u));
+    ASSERT(mc_cmp_less_equal_su(1, 1u));
+
+    ASSERT(mc_cmp_less_equal_us(0u, 0));
+    ASSERT(!mc_cmp_less_equal_us(0u, -1));
+    ASSERT(mc_cmp_less_equal_us(0u, 1));
+    ASSERT(!mc_cmp_less_equal_us(1u, 0));
+    ASSERT(!mc_cmp_less_equal_us(1u, -1));
+    ASSERT(mc_cmp_less_equal_us(1u, 1));
+}
+
+static void test_mc_cmp_greater_equal(_mongocrypt_tester_t *tester) {
+    (void)tester;
+
+    ASSERT(mc_cmp_greater_equal_ss(0, 0));
+    ASSERT(mc_cmp_greater_equal_ss(0, -1));
+    ASSERT(!mc_cmp_greater_equal_ss(0, 1));
+    ASSERT(!mc_cmp_greater_equal_ss(-1, 0));
+    ASSERT(mc_cmp_greater_equal_ss(-1, -1));
+    ASSERT(!mc_cmp_greater_equal_ss(-1, 1));
+    ASSERT(mc_cmp_greater_equal_ss(1, 0));
+    ASSERT(mc_cmp_greater_equal_ss(1, -1));
+    ASSERT(mc_cmp_greater_equal_ss(1, 1));
+
+    ASSERT(mc_cmp_greater_equal_uu(0u, 0u));
+    ASSERT(!mc_cmp_greater_equal_uu(0u, 1u));
+    ASSERT(mc_cmp_greater_equal_uu(1u, 0u));
+    ASSERT(mc_cmp_greater_equal_uu(1u, 1u));
+
+    ASSERT(mc_cmp_greater_equal_su(0, 0u));
+    ASSERT(!mc_cmp_greater_equal_su(0, 1u));
+    ASSERT(!mc_cmp_greater_equal_su(-1, 0u));
+    ASSERT(!mc_cmp_greater_equal_su(-1, 1u));
+    ASSERT(mc_cmp_greater_equal_su(1, 0u));
+    ASSERT(mc_cmp_greater_equal_su(1, 1u));
+
+    ASSERT(mc_cmp_greater_equal_us(0u, 0));
+    ASSERT(mc_cmp_greater_equal_us(0u, -1));
+    ASSERT(!mc_cmp_greater_equal_us(0u, 1));
+    ASSERT(mc_cmp_greater_equal_us(1u, 0));
+    ASSERT(mc_cmp_greater_equal_us(1u, -1));
+    ASSERT(mc_cmp_greater_equal_us(1u, 1));
+}
+
+static void test_mc_in_range(_mongocrypt_tester_t *tester) {
+    (void)tester;
+
+    const int64_t int8_min = INT8_MIN;
+    const int64_t int8_max = INT8_MAX;
+    const int64_t int32_min = INT32_MIN;
+    const int64_t int32_max = INT32_MAX;
+
+    const uint64_t uint8_max = UINT8_MAX;
+    const uint64_t uint32_max = UINT32_MAX;
+
+    const ssize_t ssize_min = SSIZE_MIN;
+    const ssize_t ssize_max = SSIZE_MAX;
+
+    ASSERT(!mc_in_range_signed(int8_t, int8_min - 1));
+    ASSERT(mc_in_range_signed(int8_t, int8_min));
+    ASSERT(mc_in_range_signed(int8_t, 0));
+    ASSERT(mc_in_range_signed(int8_t, int8_max));
+    ASSERT(!mc_in_range_signed(int8_t, int8_max + 1));
+
+    ASSERT(mc_in_range_unsigned(int8_t, 0u));
+    ASSERT(mc_in_range_unsigned(int8_t, (uint64_t)int8_max));
+    ASSERT(!mc_in_range_unsigned(int8_t, (uint64_t)(int8_max + 1)));
+
+    ASSERT(!mc_in_range_signed(uint8_t, int8_min - 1));
+    ASSERT(!mc_in_range_signed(uint8_t, int8_min));
+    ASSERT(mc_in_range_signed(uint8_t, 0));
+    ASSERT(mc_in_range_signed(uint8_t, int8_max));
+    ASSERT(mc_in_range_signed(uint8_t, int8_max + 1));
+    ASSERT(mc_in_range_signed(uint8_t, (int64_t)uint8_max));
+    ASSERT(!mc_in_range_signed(uint8_t, (int64_t)uint8_max + 1));
+
+    ASSERT(mc_in_range_unsigned(uint8_t, 0u));
+    ASSERT(mc_in_range_unsigned(uint8_t, uint8_max));
+    ASSERT(!mc_in_range_unsigned(uint8_t, uint8_max + 1u));
+
+    ASSERT(!mc_in_range_signed(int32_t, int32_min - 1));
+    ASSERT(mc_in_range_signed(int32_t, int32_min));
+    ASSERT(mc_in_range_signed(int32_t, 0));
+    ASSERT(mc_in_range_signed(int32_t, int32_max));
+    ASSERT(!mc_in_range_signed(int32_t, int32_max + 1));
+
+    ASSERT(mc_in_range_unsigned(int32_t, 0u));
+    ASSERT(mc_in_range_unsigned(int32_t, (uint64_t)int32_max));
+    ASSERT(!mc_in_range_unsigned(int32_t, (uint64_t)(int32_max + 1)));
+
+    ASSERT(!mc_in_range_signed(uint32_t, int32_min - 1));
+    ASSERT(!mc_in_range_signed(uint32_t, int32_min));
+    ASSERT(mc_in_range_signed(uint32_t, 0));
+    ASSERT(mc_in_range_signed(uint32_t, int32_max));
+    ASSERT(mc_in_range_signed(uint32_t, int32_max + 1));
+    ASSERT(mc_in_range_signed(uint32_t, (int64_t)uint32_max));
+    ASSERT(!mc_in_range_signed(uint32_t, (int64_t)uint32_max + 1));
+
+    ASSERT(mc_in_range_unsigned(uint32_t, 0u));
+    ASSERT(mc_in_range_unsigned(uint32_t, uint32_max));
+    ASSERT(!mc_in_range_unsigned(uint32_t, uint32_max + 1u));
+
+    ASSERT(mc_in_range_signed(ssize_t, ssize_min));
+    ASSERT(mc_in_range_signed(ssize_t, 0));
+    ASSERT(mc_in_range_signed(ssize_t, ssize_max));
+
+    ASSERT(mc_in_range_unsigned(ssize_t, 0u));
+    ASSERT(mc_in_range_unsigned(ssize_t, (size_t)ssize_max));
+    ASSERT(!mc_in_range_unsigned(ssize_t, (size_t)ssize_max + 1u));
+
+    ASSERT(!mc_in_range_signed(size_t, ssize_min));
+    ASSERT(mc_in_range_signed(size_t, 0));
+    ASSERT(mc_in_range_signed(size_t, ssize_max));
+
+    ASSERT(mc_in_range_unsigned(size_t, 0u));
+    ASSERT(mc_in_range_unsigned(size_t, (size_t)ssize_max));
+    ASSERT(mc_in_range_unsigned(size_t, (size_t)ssize_max + 1u));
+}
+
+void _mongocrypt_tester_install_mc_cmp(_mongocrypt_tester_t *tester) {
+    INSTALL_TEST(test_mc_cmp_equal);
+    INSTALL_TEST(test_mc_cmp_not_equal);
+    INSTALL_TEST(test_mc_cmp_less);
+    INSTALL_TEST(test_mc_cmp_greater);
+    INSTALL_TEST(test_mc_cmp_less_equal);
+    INSTALL_TEST(test_mc_cmp_greater_equal);
+    INSTALL_TEST(test_mc_in_range);
+}

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

@@ -39,6 +39,19 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
     {
         _load_test_file(tester, "./test/data/efc/efc-oneField.json", &efc_bson);
         ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 0);
+        ptr = efc.fields;
+        ASSERT(ptr);
+        ASSERT_STREQUAL(ptr->path, "firstName");
+        ASSERT_CMPBUF(expect_keyId1, ptr->keyId);
+        ASSERT(ptr->next == NULL);
+        mc_EncryptedFieldConfig_cleanup(&efc);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-oneField-goodVersionSet.json", &efc_bson);
+        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 1);
         ptr = efc.fields;
         ASSERT(ptr);
         ASSERT_STREQUAL(ptr->path, "firstName");
@@ -50,6 +63,7 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
     {
         _load_test_file(tester, "./test/data/efc/efc-extraField.json", &efc_bson);
         ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 0);
         ptr = efc.fields;
         ASSERT(ptr);
         ASSERT_STREQUAL(ptr->path, "firstName");
@@ -61,6 +75,7 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
     {
         _load_test_file(tester, "./test/data/efc/efc-twoFields.json", &efc_bson);
         ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 0);
         ptr = efc.fields;
         ASSERT(ptr);
         ASSERT_STREQUAL(ptr->path, "lastName");
@@ -79,6 +94,61 @@ static void _test_efc(_mongocrypt_tester_t *tester) {
                             status,
                             "unable to find 'keyId' in 'field' document");
         mc_EncryptedFieldConfig_cleanup(&efc);
+        _mongocrypt_status_reset(status);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-oneField-badVersionSet.json", &efc_bson);
+        ASSERT_FAILS_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2),
+                            status,
+                            "'strEncodeVersion' of 99 is not supported");
+        mc_EncryptedFieldConfig_cleanup(&efc);
+        _mongocrypt_status_reset(status);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-textSearchFields.json", &efc_bson);
+        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, LATEST_STR_ENCODE_VERSION);
+        ptr = efc.fields;
+        ASSERT(ptr);
+        ASSERT_STREQUAL(ptr->path, "lastName");
+        ASSERT_CMPBUF(expect_keyId2, ptr->keyId);
+        ASSERT(ptr->supported_queries == (SUPPORTS_SUFFIX_PREVIEW_QUERIES | SUPPORTS_PREFIX_PREVIEW_QUERIES));
+        ASSERT(ptr->next != NULL);
+        ptr = ptr->next;
+        ASSERT_STREQUAL(ptr->path, "firstName");
+        ASSERT_CMPBUF(expect_keyId1, ptr->keyId);
+        ASSERT(ptr->supported_queries == SUPPORTS_SUBSTRING_PREVIEW_QUERIES);
+        ASSERT(ptr->next == NULL);
+        mc_EncryptedFieldConfig_cleanup(&efc);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-textSearchFields-goodVersionSet.json", &efc_bson);
+        ASSERT_OK_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2), status);
+        ASSERT_CMPUINT8(efc.str_encode_version, ==, 1);
+        ptr = efc.fields;
+        ASSERT(ptr);
+        ASSERT_STREQUAL(ptr->path, "lastName");
+        ASSERT_CMPBUF(expect_keyId2, ptr->keyId);
+        ASSERT(ptr->supported_queries == (SUPPORTS_SUFFIX_PREVIEW_QUERIES | SUPPORTS_PREFIX_PREVIEW_QUERIES));
+        ASSERT(ptr->next != NULL);
+        ptr = ptr->next;
+        ASSERT_STREQUAL(ptr->path, "firstName");
+        ASSERT_CMPBUF(expect_keyId1, ptr->keyId);
+        ASSERT(ptr->supported_queries == SUPPORTS_SUBSTRING_PREVIEW_QUERIES);
+        ASSERT(ptr->next == NULL);
+        mc_EncryptedFieldConfig_cleanup(&efc);
+    }
+
+    {
+        _load_test_file(tester, "./test/data/efc/efc-textSearchFields-badVersionSet.json", &efc_bson);
+        ASSERT_FAILS_STATUS(mc_EncryptedFieldConfig_parse(&efc, &efc_bson, status, use_range_v2),
+                            status,
+                            "'strEncodeVersion' of 99 is not supported");
+        mc_EncryptedFieldConfig_cleanup(&efc);
+        _mongocrypt_status_reset(status);
     }
 
     _mongocrypt_buffer_cleanup(&expect_keyId2);