diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/__init__.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_arity.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_arity.py
new file mode 100644
index 000000000..f48172eb1
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_arity.py
@@ -0,0 +1,80 @@
+"""$toDecimal arity and field path syntax tests."""
+
+import pytest
+from bson import Decimal128
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import (
+    FAILED_TO_PARSE_ERROR,
+    INVALID_DOLLAR_FIELD_PATH,
+    TO_TYPE_ARITY_ERROR,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+
+# Property [Arity]: $toDecimal unwraps a single-element literal array at parse time;
+# empty and multi-element arrays are arity errors.
+TODECIMAL_ARITY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "single_element",
+        msg="Single-element literal array argument is unwrapped to a scalar",
+        expression={"$toDecimal": [42]},
+        expected=Decimal128("42"),
+    ),
+    ExpressionTestCase(
+        "single_null",
+        msg="Single-element literal array wrapping null unwraps and returns null",
+        expression={"$toDecimal": [None]},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "empty_array",
+        msg="Empty literal array argument is an arity error",
+        expression={"$toDecimal": []},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+    ExpressionTestCase(
+        "multi_element",
+        msg="Multi-element literal array argument is an arity error",
+        expression={"$toDecimal": [1, 2]},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+    ExpressionTestCase(
+        "large_array",
+        msg="Large literal array argument is an arity error",
+        expression={"$toDecimal": list(range(100))},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+]
+
+# Property [Invalid Field Path]: $toDecimal rejects malformed field path syntax.
+TODECIMAL_INVALID_FIELD_PATH_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "bare_dollar",
+        msg="Bare '$' is an invalid field path",
+        expression={"$toDecimal": "$"},
+        error_code=INVALID_DOLLAR_FIELD_PATH,
+    ),
+    ExpressionTestCase(
+        "double_dollar",
+        msg="'$$' is rejected as an empty variable name",
+        expression={"$toDecimal": "$$"},
+        error_code=FAILED_TO_PARSE_ERROR,
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TODECIMAL_ARITY_TESTS + TODECIMAL_INVALID_FIELD_PATH_TESTS)
+)
+def test_toDecimal_arity(collection, test: ExpressionTestCase):
+    """$toDecimal literal array arguments are unwrapped or rejected based on arity."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_datetime.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_datetime.py
new file mode 100644
index 000000000..b65c98f5e
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_datetime.py
@@ -0,0 +1,169 @@
+"""$toDecimal datetime conversion tests and unsupported BSON type errors."""
+
+from datetime import datetime, timezone
+
+import pytest
+from bson import Binary, Code, Decimal128, MaxKey, MinKey, ObjectId, Regex, Timestamp
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DATE_BEFORE_EPOCH,
+    DATE_EPOCH,
+    DATE_YEAR_1,
+    DATE_YEAR_9999,
+    DECIMAL128_ZERO,
+)
+
+# Property [Datetime]: $toDecimal converts datetime to milliseconds since Unix epoch as Decimal128.
+TODECIMAL_DATETIME_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "datetime_epoch",
+        msg="Epoch datetime converts to Decimal128('0')",
+        expression={"$toDecimal": DATE_EPOCH},
+        expected=DECIMAL128_ZERO,
+    ),
+    ExpressionTestCase(
+        "datetime_1ms_after_epoch",
+        msg="1 ms after epoch converts to Decimal128('1')",
+        expression={"$toDecimal": datetime(1970, 1, 1, 0, 0, 0, 1_000, tzinfo=timezone.utc)},
+        expected=Decimal128("1"),
+    ),
+    ExpressionTestCase(
+        "datetime_one_day",
+        msg="One day after epoch converts to Decimal128('86400000')",
+        expression={"$toDecimal": datetime(1970, 1, 2, 0, 0, 0, tzinfo=timezone.utc)},
+        expected=Decimal128("86400000"),
+    ),
+    ExpressionTestCase(
+        "datetime_before_epoch",
+        msg="1 ms before epoch converts to Decimal128('-1')",
+        expression={"$toDecimal": DATE_BEFORE_EPOCH},
+        expected=Decimal128("-1"),
+    ),
+    ExpressionTestCase(
+        "datetime_pre_epoch",
+        msg="Pre-epoch date (1960-01-01) converts to negative ms value",
+        expression={"$toDecimal": datetime(1960, 1, 1, tzinfo=timezone.utc)},
+        expected=Decimal128("-315619200000"),
+    ),
+    ExpressionTestCase(
+        "datetime_with_millis",
+        msg="Datetime with sub-second precision preserves milliseconds",
+        expression={"$toDecimal": datetime(2018, 3, 27, 5, 4, 47, 890_000, tzinfo=timezone.utc)},
+        expected=Decimal128("1522127087890"),
+    ),
+    ExpressionTestCase(
+        "datetime_2024",
+        msg="A modern date converts to its ms-since-epoch value",
+        expression={"$toDecimal": datetime(2024, 1, 1, 0, 0, 0, tzinfo=timezone.utc)},
+        expected=Decimal128("1704067200000"),
+    ),
+    ExpressionTestCase(
+        "datetime_millisecond_precision",
+        msg="Datetime preserves millisecond precision",
+        expression={"$toDecimal": datetime(1970, 1, 1, 0, 0, 0, 500_000, tzinfo=timezone.utc)},
+        expected=Decimal128("500"),
+    ),
+    ExpressionTestCase(
+        "datetime_far_past",
+        msg="Far-past datetime (year 1) converts to its ms-since-epoch value",
+        expression={"$toDecimal": DATE_YEAR_1},
+        expected=Decimal128("-62135596800000"),
+    ),
+    ExpressionTestCase(
+        "datetime_far_future",
+        msg="Far-future datetime (year 9999) converts to its ms-since-epoch value",
+        expression={"$toDecimal": DATE_YEAR_9999},
+        expected=Decimal128("253402300799999"),
+    ),
+]
+
+# Property [Unsupported Types]: $toDecimal fails with a conversion error for BSON types it
+# cannot convert (object, binary, ObjectId, regex, timestamp, code, MinKey, MaxKey, array).
+TODECIMAL_UNSUPPORTED_TYPE_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "type_object",
+        msg="Object BSON type is a conversion failure",
+        expression={"$toDecimal": {"$literal": {"a": 1}}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_binary",
+        msg="Binary BSON type is a conversion failure",
+        expression={"$toDecimal": Binary(b"data")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_binary_uuid",
+        msg="Binary UUID subtype 4 is a conversion failure",
+        expression={"$toDecimal": Binary(b"\x00" * 16, 4)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_objectid",
+        msg="ObjectId BSON type is a conversion failure",
+        expression={"$toDecimal": ObjectId("507f1f77bcf86cd799439011")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_regex",
+        msg="Regex BSON type is a conversion failure",
+        expression={"$toDecimal": Regex("abc")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_timestamp",
+        msg="Timestamp BSON type is a conversion failure",
+        expression={"$toDecimal": Timestamp(1, 1)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_code",
+        msg="Code BSON type is a conversion failure",
+        expression={"$toDecimal": Code("function() {}")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_minkey",
+        msg="MinKey BSON type is a conversion failure",
+        expression={"$toDecimal": MinKey()},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_maxkey",
+        msg="MaxKey BSON type is a conversion failure",
+        expression={"$toDecimal": MaxKey()},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_array",
+        msg="Array value (from $literal) is a conversion failure",
+        expression={"$toDecimal": {"$literal": [1, 2]}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_nested_array",
+        msg="Nested literal array after single-element unwrap is a conversion failure",
+        expression={"$toDecimal": [["hello"]]},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TODECIMAL_DATETIME_TESTS = TODECIMAL_DATETIME_TESTS + TODECIMAL_UNSUPPORTED_TYPE_TESTS
+
+
+@pytest.mark.parametrize("test", pytest_params(TODECIMAL_DATETIME_TESTS))
+def test_toDecimal_datetime(collection, test: ExpressionTestCase):
+    """$toDecimal converts datetime to ms-since-epoch Decimal128; rejects unsupported types."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_decimal128.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_decimal128.py
new file mode 100644
index 000000000..3c9fbf975
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_decimal128.py
@@ -0,0 +1,140 @@
+"""$toDecimal Decimal128 passthrough tests: identity, trailing zeros, exponent, and specials."""
+
+import pytest
+from bson import Decimal128
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_INFINITY,
+    DECIMAL128_LARGE_EXPONENT,
+    DECIMAL128_MANY_TRAILING_ZEROS,
+    DECIMAL128_MAX,
+    DECIMAL128_MAX_COEFFICIENT,
+    DECIMAL128_MAX_NEGATIVE,
+    DECIMAL128_MIN,
+    DECIMAL128_MIN_POSITIVE,
+    DECIMAL128_NAN,
+    DECIMAL128_NEGATIVE_INFINITY,
+    DECIMAL128_NEGATIVE_NAN,
+    DECIMAL128_NEGATIVE_ONE_AND_HALF,
+    DECIMAL128_NEGATIVE_ZERO,
+    DECIMAL128_TRAILING_ZERO,
+    DECIMAL128_ZERO,
+)
+
+# Property [Decimal128 Passthrough]: $toDecimal is the identity function for Decimal128 inputs,
+# preserving trailing zeros, exponent form, sign bits, and special values exactly.
+TODECIMAL_DECIMAL128_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "dec128_zero",
+        msg="Decimal128 zero passes through unchanged",
+        expression={"$toDecimal": DECIMAL128_ZERO},
+        expected=DECIMAL128_ZERO,
+    ),
+    ExpressionTestCase(
+        "dec128_negative_zero",
+        msg="Decimal128 negative zero passes through preserving sign",
+        expression={"$toDecimal": DECIMAL128_NEGATIVE_ZERO},
+        expected=DECIMAL128_NEGATIVE_ZERO,
+    ),
+    ExpressionTestCase(
+        "dec128_one",
+        msg="Decimal128 1 passes through unchanged",
+        expression={"$toDecimal": Decimal128("1")},
+        expected=Decimal128("1"),
+    ),
+    ExpressionTestCase(
+        "dec128_trailing_zero",
+        msg="Decimal128 trailing zero (1.0) passes through preserving the trailing zero",
+        expression={"$toDecimal": DECIMAL128_TRAILING_ZERO},
+        expected=DECIMAL128_TRAILING_ZERO,
+    ),
+    ExpressionTestCase(
+        "dec128_many_trailing_zeros",
+        msg="Decimal128 with many trailing zeros passes through preserving all zeros",
+        expression={"$toDecimal": DECIMAL128_MANY_TRAILING_ZEROS},
+        expected=DECIMAL128_MANY_TRAILING_ZEROS,
+    ),
+    ExpressionTestCase(
+        "dec128_exponent_form",
+        msg="Decimal128 in exponent form (1E+6144) passes through preserving exponent",
+        expression={"$toDecimal": DECIMAL128_LARGE_EXPONENT},
+        expected=DECIMAL128_LARGE_EXPONENT,
+    ),
+    ExpressionTestCase(
+        "dec128_negative",
+        msg="Decimal128 negative value passes through unchanged",
+        expression={"$toDecimal": DECIMAL128_NEGATIVE_ONE_AND_HALF},
+        expected=DECIMAL128_NEGATIVE_ONE_AND_HALF,
+    ),
+    ExpressionTestCase(
+        "dec128_max",
+        msg="Decimal128 max value passes through unchanged",
+        expression={"$toDecimal": DECIMAL128_MAX},
+        expected=DECIMAL128_MAX,
+    ),
+    ExpressionTestCase(
+        "dec128_min",
+        msg="Decimal128 min value passes through unchanged",
+        expression={"$toDecimal": DECIMAL128_MIN},
+        expected=DECIMAL128_MIN,
+    ),
+    ExpressionTestCase(
+        "dec128_min_positive",
+        msg="Decimal128 min positive value (1E-6176) passes through unchanged",
+        expression={"$toDecimal": DECIMAL128_MIN_POSITIVE},
+        expected=DECIMAL128_MIN_POSITIVE,
+    ),
+    ExpressionTestCase(
+        "dec128_max_negative",
+        msg="Decimal128 max negative value (-1E-6176) passes through unchanged",
+        expression={"$toDecimal": DECIMAL128_MAX_NEGATIVE},
+        expected=DECIMAL128_MAX_NEGATIVE,
+    ),
+    ExpressionTestCase(
+        "dec128_nan",
+        msg="Decimal128 NaN passes through unchanged",
+        expression={"$toDecimal": DECIMAL128_NAN},
+        expected=DECIMAL128_NAN,
+    ),
+    ExpressionTestCase(
+        "dec128_negative_nan",
+        msg="Decimal128 -NaN passes through preserving sign bit",
+        expression={"$toDecimal": DECIMAL128_NEGATIVE_NAN},
+        expected=DECIMAL128_NEGATIVE_NAN,
+    ),
+    ExpressionTestCase(
+        "dec128_infinity",
+        msg="Decimal128 Infinity passes through unchanged",
+        expression={"$toDecimal": DECIMAL128_INFINITY},
+        expected=DECIMAL128_INFINITY,
+    ),
+    ExpressionTestCase(
+        "dec128_negative_infinity",
+        msg="Decimal128 -Infinity passes through unchanged",
+        expression={"$toDecimal": DECIMAL128_NEGATIVE_INFINITY},
+        expected=DECIMAL128_NEGATIVE_INFINITY,
+    ),
+    ExpressionTestCase(
+        "dec128_high_precision",
+        msg="Decimal128 maximum 34-digit coefficient passes through at full precision",
+        expression={"$toDecimal": DECIMAL128_MAX_COEFFICIENT},
+        expected=DECIMAL128_MAX_COEFFICIENT,
+    ),
+]
+
+
+@pytest.mark.parametrize("test", pytest_params(TODECIMAL_DECIMAL128_TESTS))
+def test_toDecimal_decimal128(collection, test: ExpressionTestCase):
+    """$toDecimal is the identity function for Decimal128 inputs."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_double.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_double.py
new file mode 100644
index 000000000..6705b327b
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_double.py
@@ -0,0 +1,147 @@
+"""$toDecimal double conversion tests: 15 significant digits, zero, NaN, and infinity."""
+
+import pytest
+from bson import Decimal128
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_INFINITY,
+    DECIMAL128_NAN,
+    DECIMAL128_NEGATIVE_INFINITY,
+    DECIMAL128_NEGATIVE_ZERO,
+    DECIMAL128_ZERO,
+    DOUBLE_MAX,
+    DOUBLE_MAX_SAFE_INTEGER,
+    DOUBLE_MIN,
+    DOUBLE_MIN_NEGATIVE_SUBNORMAL,
+    DOUBLE_MIN_SUBNORMAL,
+    DOUBLE_NEGATIVE_ZERO,
+    DOUBLE_TWO_AND_HALF,
+    DOUBLE_ZERO,
+    FLOAT_INFINITY,
+    FLOAT_NAN,
+    FLOAT_NEGATIVE_INFINITY,
+)
+
+# Property [Double Conversion]: non-zero finite doubles produce exactly 15 significant digits;
+# zero, negative zero, NaN, and infinity have special mappings.
+TODECIMAL_DOUBLE_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "double_two_point_five",
+        msg="2.5 converts with 15 significant digits",
+        expression={"$toDecimal": DOUBLE_TWO_AND_HALF},
+        expected=Decimal128("2.50000000000000"),
+    ),
+    ExpressionTestCase(
+        "double_negative",
+        msg="Negative double converts with 15 significant digits",
+        expression={"$toDecimal": -DOUBLE_TWO_AND_HALF},
+        expected=Decimal128("-2.50000000000000"),
+    ),
+    ExpressionTestCase(
+        "double_zero",
+        msg="0.0 converts to Decimal128('0') with no trailing zeros",
+        expression={"$toDecimal": DOUBLE_ZERO},
+        expected=DECIMAL128_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_negative_zero",
+        msg="Negative zero double preserves sign",
+        expression={"$toDecimal": DOUBLE_NEGATIVE_ZERO},
+        expected=DECIMAL128_NEGATIVE_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_nan",
+        msg="double NaN converts to Decimal128 NaN",
+        expression={"$toDecimal": FLOAT_NAN},
+        expected=DECIMAL128_NAN,
+    ),
+    ExpressionTestCase(
+        "double_pos_inf",
+        msg="double Infinity converts to Decimal128 Infinity",
+        expression={"$toDecimal": FLOAT_INFINITY},
+        expected=DECIMAL128_INFINITY,
+    ),
+    ExpressionTestCase(
+        "double_neg_inf",
+        msg="double -Infinity converts to Decimal128 -Infinity",
+        expression={"$toDecimal": FLOAT_NEGATIVE_INFINITY},
+        expected=DECIMAL128_NEGATIVE_INFINITY,
+    ),
+    ExpressionTestCase(
+        "double_round_up_power_of_10",
+        msg="Double rounds up to next power of 10 at 15th digit boundary",
+        expression={"$toDecimal": 9.999999999999998e15},
+        expected=Decimal128("1.00000000000000E+16"),
+    ),
+    ExpressionTestCase(
+        "double_round_up",
+        msg="Double rounds up at 15th significant digit",
+        expression={"$toDecimal": 1.234567890123456},
+        expected=Decimal128("1.23456789012346"),
+    ),
+    ExpressionTestCase(
+        "double_round_misleading_literal",
+        msg="Double rounds based on stored imprecise value, not source literal",
+        expression={"$toDecimal": 1.234567890123455},
+        expected=Decimal128("1.23456789012345"),
+    ),
+    ExpressionTestCase(
+        "double_round_down",
+        msg="Double rounds down at 15th significant digit",
+        expression={"$toDecimal": 1.234567890123451},
+        expected=Decimal128("1.23456789012345"),
+    ),
+    ExpressionTestCase(
+        "double_round_to_one",
+        msg="Double 0.9999999999999996 rounds to 1.00000000000000",
+        expression={"$toDecimal": 0.9999999999999996},
+        expected=Decimal128("1.00000000000000"),
+    ),
+    ExpressionTestCase(
+        "double_max_safe_int",
+        msg="Max safe integer (2^53) converts with 15 significant digits",
+        expression={"$toDecimal": float(DOUBLE_MAX_SAFE_INTEGER)},
+        expected=Decimal128("9.00719925474099E+15"),
+    ),
+    ExpressionTestCase(
+        "double_subnormal",
+        msg="Minimum positive subnormal double converts with 15 significant digits",
+        expression={"$toDecimal": DOUBLE_MIN_SUBNORMAL},
+        expected=Decimal128("4.94065645841247E-324"),
+    ),
+    ExpressionTestCase(
+        "double_negative_subnormal",
+        msg="Minimum negative subnormal double converts with 15 significant digits",
+        expression={"$toDecimal": DOUBLE_MIN_NEGATIVE_SUBNORMAL},
+        expected=Decimal128("-4.94065645841247E-324"),
+    ),
+    ExpressionTestCase(
+        "double_near_max",
+        msg="Near-max double converts with 15 significant digits",
+        expression={"$toDecimal": DOUBLE_MAX},
+        expected=Decimal128("1.79769313486232E+308"),
+    ),
+    ExpressionTestCase(
+        "double_near_min",
+        msg="Near-min double converts with 15 significant digits",
+        expression={"$toDecimal": DOUBLE_MIN},
+        expected=Decimal128("-1.79769313486232E+308"),
+    ),
+]
+
+
+@pytest.mark.parametrize("test", pytest_params(TODECIMAL_DOUBLE_TESTS))
+def test_toDecimal_double(collection, test: ExpressionTestCase):
+    """$toDecimal converts double inputs to Decimal128 with 15 significant digits."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_field_ref.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_field_ref.py
new file mode 100644
index 000000000..bd9e63e78
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_field_ref.py
@@ -0,0 +1,148 @@
+"""$toDecimal field reference and expression-as-input tests."""
+
+import pytest
+from bson import Decimal128, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+    execute_expression_with_insert,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_NEGATIVE_ZERO,
+    DECIMAL128_TWO_AND_HALF,
+    DECIMAL128_ZERO,
+    DOUBLE_NEGATIVE_ZERO,
+    DOUBLE_TWO_AND_HALF,
+    INT32_ZERO,
+)
+
+# Property [Field Reference]: $toDecimal resolves field paths and nested dot-notation paths;
+# missing fields and missing nested fields return null.
+TODECIMAL_FIELD_REF_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int_field",
+        msg="int32 field converts to Decimal128",
+        expression={"$toDecimal": "$v"},
+        doc={"v": 42},
+        expected=Decimal128("42"),
+    ),
+    ExpressionTestCase(
+        "int64_field",
+        msg="int64 field converts to Decimal128",
+        expression={"$toDecimal": "$v"},
+        doc={"v": Int64(86400000)},
+        expected=Decimal128("86400000"),
+    ),
+    ExpressionTestCase(
+        "decimal_field",
+        msg="Decimal128 field passes through unchanged",
+        expression={"$toDecimal": "$v"},
+        doc={"v": Decimal128("3.14")},
+        expected=Decimal128("3.14"),
+    ),
+    ExpressionTestCase(
+        "string_field",
+        msg="Numeric string field converts to Decimal128",
+        expression={"$toDecimal": "$v"},
+        doc={"v": "2.5"},
+        expected=DECIMAL128_TWO_AND_HALF,
+    ),
+    ExpressionTestCase(
+        "bool_field",
+        msg="Bool field converts to Decimal128",
+        expression={"$toDecimal": "$v"},
+        doc={"v": True},
+        expected=Decimal128("1"),
+    ),
+    ExpressionTestCase(
+        "double_field",
+        msg="Double field converts to Decimal128 with 15 significant digits",
+        expression={"$toDecimal": "$v"},
+        doc={"v": DOUBLE_TWO_AND_HALF},
+        expected=Decimal128("2.50000000000000"),
+    ),
+    ExpressionTestCase(
+        "nested_field",
+        msg="Nested field path converts to Decimal128",
+        expression={"$toDecimal": "$doc.v"},
+        doc={"doc": {"v": 100}},
+        expected=Decimal128("100"),
+    ),
+    ExpressionTestCase(
+        "missing_nested",
+        msg="Missing nested field returns null",
+        expression={"$toDecimal": "$doc.missing"},
+        doc={"doc": {"x": 1}},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "missing_field",
+        msg="Missing top-level field returns null",
+        expression={"$toDecimal": "$v"},
+        doc={},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "neg_zero_double_field",
+        msg="$toDecimal preserves -0.0 sign when reading double from a document field",
+        expression={"$toDecimal": "$v"},
+        doc={"v": DOUBLE_NEGATIVE_ZERO},
+        expected=DECIMAL128_NEGATIVE_ZERO,
+    ),
+    ExpressionTestCase(
+        "zero_field",
+        msg="$toDecimal converts zero from a document field",
+        expression={"$toDecimal": "$v"},
+        doc={"v": INT32_ZERO},
+        expected=DECIMAL128_ZERO,
+    ),
+    ExpressionTestCase(
+        "composite_array_path",
+        msg="$toDecimal fails when field path resolves to a composite array",
+        expression={"$toDecimal": "$a.b"},
+        doc={"a": [{"b": 1}, {"b": 2}]},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+# Property [Expression Input]: $toDecimal evaluates a nested expression before converting.
+TODECIMAL_EXPRESSION_INPUT_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "add",
+        msg="$toDecimal converts an arithmetic expression result",
+        expression={"$toDecimal": {"$add": [10, 20]}},
+        expected=Decimal128("30"),
+    ),
+    ExpressionTestCase(
+        "concat",
+        msg="$toDecimal converts a string concatenation expression result",
+        expression={"$toDecimal": {"$concat": ["3", ".", "14"]}},
+        expected=Decimal128("3.14"),
+    ),
+    ExpressionTestCase(
+        "nested_conversion",
+        msg="$toDecimal converts a nested type-conversion expression result",
+        expression={"$toDecimal": {"$toDouble": 42}},
+        expected=Decimal128("4.20000000000000E+1"),
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TODECIMAL_FIELD_REF_TESTS + TODECIMAL_EXPRESSION_INPUT_TESTS)
+)
+def test_toDecimal_field_ref(collection, test: ExpressionTestCase):
+    """$toDecimal resolves field paths and nested paths from inserted documents."""
+    if test.doc is not None:
+        result = execute_expression_with_insert(collection, test.expression, test.doc)
+    else:
+        result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_numeric.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_numeric.py
new file mode 100644
index 000000000..0a5624b30
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_numeric.py
@@ -0,0 +1,182 @@
+"""$toDecimal numeric type tests: null/missing, boolean, int32, and int64."""
+
+import pytest
+from bson import Decimal128, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_INT64_MAX,
+    DECIMAL128_ZERO,
+    INT32_MAX,
+    INT32_MAX_MINUS_1,
+    INT32_MIN,
+    INT32_MIN_PLUS_1,
+    INT32_OVERFLOW,
+    INT32_UNDERFLOW,
+    INT32_ZERO,
+    INT64_MAX,
+    INT64_MAX_MINUS_1,
+    INT64_MIN,
+    INT64_MIN_PLUS_1,
+    INT64_ZERO,
+    MISSING,
+)
+
+# Property [Null and Missing]: $toDecimal returns null for null and missing inputs.
+TODECIMAL_NULL_MISSING_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "null",
+        msg="Should return null for null",
+        expression={"$toDecimal": None},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "missing",
+        msg="Should return null for missing",
+        expression={"$toDecimal": MISSING},
+        expected=None,
+    ),
+]
+
+# Property [Boolean]: $toDecimal converts true to Decimal128("1") and false to Decimal128("0").
+TODECIMAL_BOOL_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "bool_true",
+        msg="True converts to Decimal128('1')",
+        expression={"$toDecimal": True},
+        expected=Decimal128("1"),
+    ),
+    ExpressionTestCase(
+        "bool_false",
+        msg="False converts to Decimal128('0')",
+        expression={"$toDecimal": False},
+        expected=DECIMAL128_ZERO,
+    ),
+]
+
+# Property [Int32]: $toDecimal converts int32 values to exact Decimal128 with no trailing zeros.
+TODECIMAL_INT32_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int32_zero",
+        msg="int32 zero converts to Decimal128('0')",
+        expression={"$toDecimal": INT32_ZERO},
+        expected=DECIMAL128_ZERO,
+    ),
+    ExpressionTestCase(
+        "int32_one",
+        msg="int32 1 converts to Decimal128('1')",
+        expression={"$toDecimal": 1},
+        expected=Decimal128("1"),
+    ),
+    ExpressionTestCase(
+        "int32_neg_one",
+        msg="int32 -1 converts to Decimal128('-1')",
+        expression={"$toDecimal": -1},
+        expected=Decimal128("-1"),
+    ),
+    ExpressionTestCase(
+        "int32_max",
+        msg="int32 max converts exactly",
+        expression={"$toDecimal": INT32_MAX},
+        expected=Decimal128(str(INT32_MAX)),
+    ),
+    ExpressionTestCase(
+        "int32_min",
+        msg="int32 min converts exactly",
+        expression={"$toDecimal": INT32_MIN},
+        expected=Decimal128(str(INT32_MIN)),
+    ),
+    ExpressionTestCase(
+        "int32_max_minus_1",
+        msg="int32 max-1 converts exactly",
+        expression={"$toDecimal": INT32_MAX_MINUS_1},
+        expected=Decimal128(str(INT32_MAX_MINUS_1)),
+    ),
+    ExpressionTestCase(
+        "int32_min_plus_1",
+        msg="int32 min+1 converts exactly",
+        expression={"$toDecimal": INT32_MIN_PLUS_1},
+        expected=Decimal128(str(INT32_MIN_PLUS_1)),
+    ),
+]
+
+# Property [Int64]: $toDecimal converts int64 values to exact Decimal128 with no trailing zeros.
+TODECIMAL_INT64_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int64_zero",
+        msg="int64 zero converts to Decimal128('0')",
+        expression={"$toDecimal": INT64_ZERO},
+        expected=DECIMAL128_ZERO,
+    ),
+    ExpressionTestCase(
+        "int64_one",
+        msg="int64 1 converts to Decimal128('1')",
+        expression={"$toDecimal": Int64(1)},
+        expected=Decimal128("1"),
+    ),
+    ExpressionTestCase(
+        "int64_neg_one",
+        msg="int64 -1 converts to Decimal128('-1')",
+        expression={"$toDecimal": Int64(-1)},
+        expected=Decimal128("-1"),
+    ),
+    ExpressionTestCase(
+        "int64_beyond_int32_pos",
+        msg="int64 just beyond int32 max converts exactly",
+        expression={"$toDecimal": INT32_OVERFLOW},
+        expected=Decimal128(str(INT32_OVERFLOW)),
+    ),
+    ExpressionTestCase(
+        "int64_beyond_int32_neg",
+        msg="int64 just beyond int32 min converts exactly",
+        expression={"$toDecimal": INT32_UNDERFLOW},
+        expected=Decimal128(str(INT32_UNDERFLOW)),
+    ),
+    ExpressionTestCase(
+        "int64_max",
+        msg="int64 max converts exactly to Decimal128",
+        expression={"$toDecimal": INT64_MAX},
+        expected=DECIMAL128_INT64_MAX,
+    ),
+    ExpressionTestCase(
+        "int64_min",
+        msg="int64 min converts exactly to Decimal128",
+        expression={"$toDecimal": INT64_MIN},
+        expected=Decimal128(str(INT64_MIN)),
+    ),
+    ExpressionTestCase(
+        "int64_max_minus_1",
+        msg="int64 max-1 converts exactly",
+        expression={"$toDecimal": INT64_MAX_MINUS_1},
+        expected=Decimal128(str(INT64_MAX_MINUS_1)),
+    ),
+    ExpressionTestCase(
+        "int64_min_plus_1",
+        msg="int64 min+1 converts exactly",
+        expression={"$toDecimal": INT64_MIN_PLUS_1},
+        expected=Decimal128(str(INT64_MIN_PLUS_1)),
+    ),
+]
+
+TODECIMAL_NUMERIC_TESTS = (
+    TODECIMAL_NULL_MISSING_TESTS
+    + TODECIMAL_BOOL_TESTS
+    + TODECIMAL_INT32_TESTS
+    + TODECIMAL_INT64_TESTS
+)
+
+
+@pytest.mark.parametrize("test", pytest_params(TODECIMAL_NUMERIC_TESTS))
+def test_toDecimal_numeric(collection, test: ExpressionTestCase):
+    """$toDecimal converts null, missing, bool, int32, and int64 inputs."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_return_type.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_return_type.py
new file mode 100644
index 000000000..83a60d359
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_return_type.py
@@ -0,0 +1,131 @@
+"""$toDecimal return-type invariant and idempotency tests."""
+
+import pytest
+from bson import Decimal128, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.bson_type_validator import (
+    BsonType,
+    BsonTypeTestCase,
+    generate_bson_acceptance_test_cases,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_HALF,
+    DECIMAL128_ZERO,
+    DOUBLE_TWO_AND_HALF,
+    MISSING,
+)
+
+# Property [Return Type]: $toDecimal always returns BSON type 'decimal' for successful
+# conversions and null for null or missing inputs.
+RETURN_TYPE_DECIMAL_SPEC = [
+    BsonTypeTestCase(
+        id="toDecimal_return_type",
+        msg="$toDecimal always returns BSON type decimal for a successful conversion",
+        valid_types=[
+            BsonType.BOOL,
+            BsonType.DOUBLE,
+            BsonType.INT,
+            BsonType.LONG,
+            BsonType.DECIMAL,
+            BsonType.STRING,
+            BsonType.DATE,
+        ],
+        valid_inputs={
+            BsonType.STRING: "7.5",
+        },
+    ),
+]
+
+RETURN_TYPE_DECIMAL_CASES = generate_bson_acceptance_test_cases(RETURN_TYPE_DECIMAL_SPEC)
+
+
+@pytest.mark.parametrize("bson_type,sample_value,spec", RETURN_TYPE_DECIMAL_CASES)
+def test_toDecimal_return_type_is_decimal(collection, bson_type, sample_value, spec):
+    """$toDecimal always returns BSON type 'decimal' for a successful conversion."""
+    result = execute_expression(collection, {"$type": {"$toDecimal": sample_value}})
+    assert_expression_result(
+        result, expected="decimal", msg=f"{spec.msg} ({bson_type.value} input)"
+    )
+
+
+# Property [Return Type — Null]: $toDecimal returns BSON type null for null or missing inputs.
+TODECIMAL_RETURN_TYPE_NULL_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "return_type_null",
+        msg="$toDecimal of null returns null type",
+        expression={"$type": {"$toDecimal": None}},
+        expected="null",
+    ),
+    ExpressionTestCase(
+        "return_type_missing",
+        msg="$toDecimal of missing returns null type",
+        expression={"$type": {"$toDecimal": MISSING}},
+        expected="null",
+    ),
+]
+
+
+# Property [Idempotency]: applying $toDecimal twice produces the same result as once.
+TODECIMAL_IDEMPOTENCY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "idempotent_bool",
+        msg="$toDecimal is idempotent for bool",
+        expression={"$toDecimal": {"$toDecimal": True}},
+        expected=Decimal128("1"),
+    ),
+    ExpressionTestCase(
+        "idempotent_int32",
+        msg="$toDecimal is idempotent for int32",
+        expression={"$toDecimal": {"$toDecimal": 42}},
+        expected=Decimal128("42"),
+    ),
+    ExpressionTestCase(
+        "idempotent_int64",
+        msg="$toDecimal is idempotent for int64",
+        expression={"$toDecimal": {"$toDecimal": Int64(99)}},
+        expected=Decimal128("99"),
+    ),
+    ExpressionTestCase(
+        "idempotent_decimal128",
+        msg="$toDecimal is idempotent for Decimal128",
+        expression={"$toDecimal": {"$toDecimal": DECIMAL128_HALF}},
+        expected=DECIMAL128_HALF,
+    ),
+    ExpressionTestCase(
+        "idempotent_zero",
+        msg="$toDecimal is idempotent for zero",
+        expression={"$toDecimal": {"$toDecimal": DECIMAL128_ZERO}},
+        expected=DECIMAL128_ZERO,
+    ),
+    ExpressionTestCase(
+        "idempotent_double",
+        msg="$toDecimal is idempotent for double",
+        expression={"$toDecimal": {"$toDecimal": DOUBLE_TWO_AND_HALF}},
+        expected=Decimal128("2.50000000000000"),
+    ),
+    ExpressionTestCase(
+        "idempotent_string",
+        msg="$toDecimal is idempotent for numeric string",
+        expression={"$toDecimal": {"$toDecimal": "7.5"}},
+        expected=Decimal128("7.5"),
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TODECIMAL_RETURN_TYPE_NULL_TESTS + TODECIMAL_IDEMPOTENCY_TESTS)
+)
+def test_toDecimal_return_type_null(collection, test: ExpressionTestCase):
+    """$toDecimal returns BSON type 'null' for null or missing input."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_string.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_string.py
new file mode 100644
index 000000000..2639dea6d
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_string.py
@@ -0,0 +1,225 @@
+"""$toDecimal valid string conversion tests: decimal, scientific notation, and special values."""
+
+import pytest
+from bson import Decimal128
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.lazy_payload import lazy
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_HALF,
+    DECIMAL128_INFINITY,
+    DECIMAL128_MIN_POSITIVE,
+    DECIMAL128_NAN,
+    DECIMAL128_NEGATIVE_INFINITY,
+    DECIMAL128_NEGATIVE_ZERO,
+    DECIMAL128_ZERO,
+    STRING_SIZE_LIMIT_BYTES,
+)
+
+# Property [String Conversion — Valid]: base-10 numeric strings, scientific notation, and
+# special value strings convert to the corresponding Decimal128.
+TODECIMAL_STRING_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "str_negative_decimal",
+        msg="$toDecimal should convert negative decimal string",
+        expression={"$toDecimal": "-5.5"},
+        expected=Decimal128("-5.5"),
+    ),
+    ExpressionTestCase(
+        "str_scientific_upper",
+        msg="$toDecimal should accept uppercase E in scientific notation",
+        expression={"$toDecimal": "1.5E+3"},
+        expected=Decimal128("1.5E+3"),
+    ),
+    ExpressionTestCase(
+        "str_scientific_lower",
+        msg="$toDecimal should accept lowercase e in scientific notation",
+        expression={"$toDecimal": "1.5e+3"},
+        expected=Decimal128("1.5E+3"),
+    ),
+    ExpressionTestCase(
+        "str_leading_plus",
+        msg="$toDecimal should strip leading plus sign",
+        expression={"$toDecimal": "+123"},
+        expected=Decimal128("123"),
+    ),
+    ExpressionTestCase(
+        "str_leading_zeros",
+        msg="$toDecimal should strip leading zeros",
+        expression={"$toDecimal": "007"},
+        expected=Decimal128("7"),
+    ),
+    ExpressionTestCase(
+        "str_leading_decimal",
+        msg="$toDecimal should accept leading decimal point",
+        expression={"$toDecimal": ".5"},
+        expected=DECIMAL128_HALF,
+    ),
+    ExpressionTestCase(
+        "str_trailing_decimal",
+        msg="$toDecimal should accept trailing decimal point",
+        expression={"$toDecimal": "5."},
+        expected=Decimal128("5"),
+    ),
+    ExpressionTestCase(
+        "str_trailing_zeros_preserved",
+        msg="$toDecimal should preserve trailing zeros in string decimal part",
+        expression={"$toDecimal": "1.00"},
+        expected=Decimal128("1.00"),
+    ),
+    ExpressionTestCase(
+        "str_nan_mixed_case",
+        msg="$toDecimal should accept 'NaN'",
+        expression={"$toDecimal": "NaN"},
+        expected=DECIMAL128_NAN,
+    ),
+    ExpressionTestCase(
+        "str_nan_lower",
+        msg="$toDecimal should accept 'nan' case-insensitively",
+        expression={"$toDecimal": "nan"},
+        expected=DECIMAL128_NAN,
+    ),
+    ExpressionTestCase(
+        "str_nan_upper",
+        msg="$toDecimal should accept 'NAN' case-insensitively",
+        expression={"$toDecimal": "NAN"},
+        expected=DECIMAL128_NAN,
+    ),
+    ExpressionTestCase(
+        "str_infinity",
+        msg="$toDecimal should accept 'Infinity'",
+        expression={"$toDecimal": "Infinity"},
+        expected=DECIMAL128_INFINITY,
+    ),
+    ExpressionTestCase(
+        "str_inf_short",
+        msg="$toDecimal should accept 'inf' short form",
+        expression={"$toDecimal": "inf"},
+        expected=DECIMAL128_INFINITY,
+    ),
+    ExpressionTestCase(
+        "str_inf_upper",
+        msg="$toDecimal should accept 'INF' case-insensitively",
+        expression={"$toDecimal": "INF"},
+        expected=DECIMAL128_INFINITY,
+    ),
+    ExpressionTestCase(
+        "str_neg_nan",
+        msg="$toDecimal should convert '-NaN' string preserving sign bit",
+        expression={"$toDecimal": "-NaN"},
+        expected=Decimal128("-NaN"),
+    ),
+    ExpressionTestCase(
+        "str_neg_infinity",
+        msg="$toDecimal should preserve sign on negative Infinity string",
+        expression={"$toDecimal": "-Infinity"},
+        expected=DECIMAL128_NEGATIVE_INFINITY,
+    ),
+    ExpressionTestCase(
+        "str_plus_infinity",
+        msg="$toDecimal should strip plus sign from Infinity string",
+        expression={"$toDecimal": "+Infinity"},
+        expected=DECIMAL128_INFINITY,
+    ),
+    ExpressionTestCase(
+        "str_max_exponent",
+        msg="$toDecimal should accept maximum exponent string",
+        expression={"$toDecimal": "1E+6144"},
+        expected=Decimal128("1.000000000000000000000000000000000E+6144"),
+    ),
+    ExpressionTestCase(
+        "str_min_exponent",
+        msg="$toDecimal should accept minimum exponent string",
+        expression={"$toDecimal": "1E-6176"},
+        expected=DECIMAL128_MIN_POSITIVE,
+    ),
+    ExpressionTestCase(
+        "str_exactly_34_digits",
+        msg="$toDecimal should convert 34-digit string without rounding",
+        expression={"$toDecimal": "1234567890123456789012345678901234"},
+        expected=Decimal128("1234567890123456789012345678901234"),
+    ),
+    ExpressionTestCase(
+        "str_exceeds_34_digits",
+        msg="$toDecimal should round strings exceeding 34 significant digits",
+        expression={"$toDecimal": "12345678901234567890123456789012345"},
+        expected=Decimal128("1.234567890123456789012345678901234E+34"),
+    ),
+    ExpressionTestCase(
+        "str_negative_zero",
+        msg="$toDecimal should preserve negative zero from string",
+        expression={"$toDecimal": "-0"},
+        expected=DECIMAL128_NEGATIVE_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_plus_zero",
+        msg="$toDecimal should convert '+0' to Decimal128 zero",
+        expression={"$toDecimal": "+0"},
+        expected=DECIMAL128_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_plus_dot_zero",
+        msg="$toDecimal should convert '+.0' to Decimal128 zero",
+        expression={"$toDecimal": "+.0"},
+        expected=Decimal128("0.0"),
+    ),
+    ExpressionTestCase(
+        "str_neg_zero_neg_exp",
+        msg="$toDecimal should convert '-0E-1' preserving negative zero",
+        expression={"$toDecimal": "-0E-1"},
+        expected=Decimal128("-0.0"),
+    ),
+    ExpressionTestCase(
+        "str_zero_pos_exp",
+        msg="$toDecimal should convert '0E+1' preserving exponent",
+        expression={"$toDecimal": "0E+1"},
+        expected=Decimal128("0E+1"),
+    ),
+    ExpressionTestCase(
+        "str_shifted_decimal_large",
+        msg="$toDecimal should convert shifted decimal form of large value",
+        expression={"$toDecimal": ".1797693134862315807E+309"},
+        expected=Decimal128("1.797693134862315807E+308"),
+    ),
+    ExpressionTestCase(
+        "str_plus_prefixed_max",
+        msg="$toDecimal should strip plus sign from max-range string",
+        expression={"$toDecimal": "+1.797693134862315807E+308"},
+        expected=Decimal128("1.797693134862315807E+308"),
+    ),
+    ExpressionTestCase(
+        "str_rounding_34_digits",
+        msg="$toDecimal rounds at digit 35; digit-35 is 0 so result rounds down",
+        expression={"$toDecimal": "1.00000000000000000000000000000000099999"},
+        expected=Decimal128("1.000000000000000000000000000000000"),
+    ),
+]
+
+
+# Property [String Size Limit — Valid]: a valid numeric string one byte under the limit converts.
+TODECIMAL_STRING_SIZE_LIMIT_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "size_one_under_valid",
+        msg="Valid numeric string one byte under limit converts successfully",
+        expression=lazy(lambda: {"$toDecimal": "0" * (STRING_SIZE_LIMIT_BYTES - 2) + "1"}),
+        expected=Decimal128("1"),
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TODECIMAL_STRING_TESTS + TODECIMAL_STRING_SIZE_LIMIT_TESTS)
+)
+def test_toDecimal_string(collection, test: ExpressionTestCase):
+    """$toDecimal parses valid numeric strings including scientific notation and special values."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_string_errors.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_string_errors.py
new file mode 100644
index 000000000..efe965418
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDecimal/test_toDecimal_string_errors.py
@@ -0,0 +1,228 @@
+"""$toDecimal string parsing error tests: invalid formats and size limit rejections."""
+
+import pytest
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR, STRING_SIZE_LIMIT_ERROR
+from documentdb_tests.framework.lazy_payload import lazy
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import STRING_SIZE_LIMIT_BYTES
+
+# Property [String Parsing Errors]: invalid string formats produce CONVERSION_FAILURE_ERROR.
+TODECIMAL_STRING_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "str_err_empty",
+        msg="$toDecimal should reject empty string",
+        expression={"$toDecimal": ""},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_non_numeric",
+        msg="$toDecimal should reject non-numeric string",
+        expression={"$toDecimal": "h"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_bare_plus",
+        msg="$toDecimal should reject bare plus sign",
+        expression={"$toDecimal": "+"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_bare_minus",
+        msg="$toDecimal should reject bare minus sign",
+        expression={"$toDecimal": "-"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_bare_dot",
+        msg="$toDecimal should reject bare dot",
+        expression={"$toDecimal": "."},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_hex",
+        msg="$toDecimal should reject hexadecimal string",
+        expression={"$toDecimal": "0x4301"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_leading_space",
+        msg="$toDecimal should reject string with leading space",
+        expression={"$toDecimal": " 1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_trailing_space",
+        msg="$toDecimal should reject string with trailing space",
+        expression={"$toDecimal": "1 "},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_embedded_space",
+        msg="$toDecimal should reject string with embedded space",
+        expression={"$toDecimal": "1 2"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_tab",
+        msg="$toDecimal should reject string with tab",
+        expression={"$toDecimal": "\t1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_newline",
+        msg="$toDecimal should reject string with newline",
+        expression={"$toDecimal": "\n1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_cr",
+        msg="$toDecimal should reject string with carriage return",
+        expression={"$toDecimal": "\r1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_nbsp",
+        msg="$toDecimal should reject string with non-breaking space (U+00A0)",
+        expression={"$toDecimal": "\u00a01"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_en_space",
+        msg="$toDecimal should reject string with en space (U+2002)",
+        expression={"$toDecimal": "\u20021"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_bom",
+        msg="$toDecimal should reject string with BOM (U+FEFF)",
+        expression={"$toDecimal": "\ufeff1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_zwsp",
+        msg="$toDecimal should reject string with zero-width space (U+200B)",
+        expression={"$toDecimal": "\u200b1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_zwj",
+        msg="$toDecimal should reject string with zero-width joiner (U+200D)",
+        expression={"$toDecimal": "\u200d1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_rtl_mark",
+        msg="$toDecimal should reject string with right-to-left mark (U+200F)",
+        expression={"$toDecimal": "\u200f1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_incomplete_exp",
+        msg="$toDecimal should reject incomplete exponent",
+        expression={"$toDecimal": "1E"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_incomplete_exp_plus",
+        msg="$toDecimal should reject incomplete exponent with plus",
+        expression={"$toDecimal": "1E+"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_incomplete_exp_minus",
+        msg="$toDecimal should reject incomplete exponent with minus",
+        expression={"$toDecimal": "1E-"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_multi_decimal",
+        msg="$toDecimal should reject multiple decimal points",
+        expression={"$toDecimal": "1.2.3"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_multi_exponent",
+        msg="$toDecimal should reject multiple exponents",
+        expression={"$toDecimal": "1E2E3"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_underscore",
+        msg="$toDecimal should reject underscore digit separators",
+        expression={"$toDecimal": "1_000"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_comma",
+        msg="$toDecimal should reject comma digit separators",
+        expression={"$toDecimal": "1,000"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_null_byte",
+        msg="$toDecimal should reject string with null byte",
+        expression={"$toDecimal": "\x001"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_non_ascii_digit",
+        msg="$toDecimal should reject non-ASCII digit characters (U+0661)",
+        expression={"$toDecimal": "\u0661"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_overflow",
+        msg="$toDecimal should reject exponent overflow",
+        expression={"$toDecimal": "1E+6145"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_underflow",
+        msg="$toDecimal should reject exponent underflow",
+        expression={"$toDecimal": "1E-6177"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+
+# Property [String Size Limit — Errors]: strings at or above the size limit are rejected with
+# STRING_SIZE_LIMIT_ERROR; non-numeric strings just under the limit fail with CONVERSION_FAILURE.
+TODECIMAL_STRING_SIZE_LIMIT_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "size_one_under_non_numeric",
+        msg="Non-numeric string one byte under limit passes size check but fails conversion",
+        expression=lazy(lambda: {"$toDecimal": "a" * (STRING_SIZE_LIMIT_BYTES - 1)}),
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "size_at_limit",
+        msg="String at STRING_SIZE_LIMIT_BYTES is rejected with STRING_SIZE_LIMIT_ERROR",
+        expression=lazy(lambda: {"$toDecimal": "0" * STRING_SIZE_LIMIT_BYTES}),
+        error_code=STRING_SIZE_LIMIT_ERROR,
+    ),
+    ExpressionTestCase(
+        "size_at_limit_four_byte",
+        msg="4-byte character string reaching STRING_SIZE_LIMIT_BYTES is rejected",
+        expression=lazy(lambda: {"$toDecimal": "\U0001f600" * (STRING_SIZE_LIMIT_BYTES // 4)}),
+        error_code=STRING_SIZE_LIMIT_ERROR,
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TODECIMAL_STRING_ERROR_TESTS + TODECIMAL_STRING_SIZE_LIMIT_ERROR_TESTS)
+)
+def test_toDecimal_string_errors(collection, test: ExpressionTestCase):
+    """$toDecimal rejects malformed and out-of-range string inputs."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/__init__.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_arity.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_arity.py
new file mode 100644
index 000000000..f076cc22b
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_arity.py
@@ -0,0 +1,85 @@
+"""$toDouble arity and field path syntax tests."""
+
+import pytest
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import (
+    FAILED_TO_PARSE_ERROR,
+    INVALID_DOLLAR_FIELD_PATH,
+    TO_TYPE_ARITY_ERROR,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+
+# Property [Arity]: $toDouble unwraps single-element literal arrays and rejects empty or
+# multi-element arrays. These cases are specific to $toDouble syntax (not $convert).
+TODOUBLE_ARITY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "single_element",
+        msg="Single-element literal array argument is unwrapped to a scalar",
+        expression={"$toDouble": [42]},
+        expected=42.0,
+    ),
+    ExpressionTestCase(
+        "empty_array",
+        msg="Empty literal array argument is an arity error",
+        expression={"$toDouble": []},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+    ExpressionTestCase(
+        "multi_element",
+        msg="Multi-element literal array argument is an arity error",
+        expression={"$toDouble": [1, 2]},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+    ExpressionTestCase(
+        "single_null",
+        msg="Single-element literal array wrapping null unwraps and returns null",
+        expression={"$toDouble": [None]},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "single_bool",
+        msg="Single-element literal array wrapping a bool unwraps and converts",
+        expression={"$toDouble": [True]},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "large_array",
+        msg="A large literal array argument is an arity error",
+        expression={"$toDouble": list(range(100))},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+]
+
+# Property [Invalid Field Path]: $toDouble rejects malformed field path syntax.
+TODOUBLE_INVALID_FIELD_PATH_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "bare_dollar",
+        msg="Bare '$' is an invalid field path",
+        expression={"$toDouble": "$"},
+        error_code=INVALID_DOLLAR_FIELD_PATH,
+    ),
+    ExpressionTestCase(
+        "double_dollar",
+        msg="'$$' is rejected as an empty variable name",
+        expression={"$toDouble": "$$"},
+        error_code=FAILED_TO_PARSE_ERROR,
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TODOUBLE_ARITY_TESTS + TODOUBLE_INVALID_FIELD_PATH_TESTS)
+)
+def test_toDouble_arity(collection, test: ExpressionTestCase):
+    """$toDouble literal array arguments are unwrapped or rejected based on arity."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_datetime_binary.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_datetime_binary.py
new file mode 100644
index 000000000..ef401a048
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_datetime_binary.py
@@ -0,0 +1,212 @@
+"""$toDouble datetime and binary conversion tests, and unsupported BSON type errors."""
+
+import struct
+from datetime import datetime, timezone
+
+import pytest
+from bson import Binary, Code, MaxKey, MinKey, ObjectId, Regex, Timestamp
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DATE_BEFORE_EPOCH,
+    DATE_EPOCH,
+    DOUBLE_ONE_AND_HALF,
+    DOUBLE_ZERO,
+)
+
+# Pre-computed binary values: 4-byte little-endian float32.
+_f32_zero = Binary(struct.pack("<f", DOUBLE_ZERO))
+_f32_one = Binary(struct.pack("<f", 1.0))
+_f32_neg_one = Binary(struct.pack("<f", -1.0))
+_f32_two = Binary(struct.pack("<f", 2.0))
+
+# Pre-computed binary values: 8-byte little-endian float64.
+_f64_zero = Binary(struct.pack("<d", DOUBLE_ZERO))
+_f64_one = Binary(struct.pack("<d", 1.0))
+_f64_neg_one = Binary(struct.pack("<d", -1.0))
+_f64_1_5 = Binary(struct.pack("<d", DOUBLE_ONE_AND_HALF))
+
+# Property [Datetime]: $toDouble converts datetime to milliseconds since Unix epoch as double.
+TODOUBLE_DATETIME_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "datetime_epoch",
+        msg="Epoch datetime converts to 0.0 ms",
+        expression={"$toDouble": DATE_EPOCH},
+        expected=DOUBLE_ZERO,
+    ),
+    ExpressionTestCase(
+        "datetime_one_day",
+        msg="One day after epoch converts to 86400000.0 ms",
+        expression={"$toDouble": datetime(1970, 1, 2, 0, 0, 0, tzinfo=timezone.utc)},
+        expected=86400000.0,
+    ),
+    ExpressionTestCase(
+        "datetime_before_epoch",
+        msg="1 ms before epoch converts to -1.0",
+        expression={"$toDouble": DATE_BEFORE_EPOCH},
+        expected=-1.0,
+    ),
+    ExpressionTestCase(
+        "datetime_2024",
+        msg="A modern date converts to its ms-since-epoch value",
+        expression={"$toDouble": datetime(2024, 1, 1, 0, 0, 0, tzinfo=timezone.utc)},
+        expected=1704067200000.0,
+    ),
+]
+
+# Property [Binary]: $toDouble interprets 4-byte binary as IEEE 754 float32 and 8-byte binary
+# as IEEE 754 float64; other lengths are conversion failures.
+TODOUBLE_BINARY_VALID_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "binary_f32_zero",
+        msg="4-byte float32 zero binary converts to 0.0",
+        expression={"$toDouble": _f32_zero},
+        expected=DOUBLE_ZERO,
+    ),
+    ExpressionTestCase(
+        "binary_f32_one",
+        msg="4-byte float32 1.0 binary converts to 1.0",
+        expression={"$toDouble": _f32_one},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "binary_f32_neg_one",
+        msg="4-byte float32 -1.0 binary converts to -1.0",
+        expression={"$toDouble": _f32_neg_one},
+        expected=-1.0,
+    ),
+    ExpressionTestCase(
+        "binary_f32_two",
+        msg="4-byte float32 2.0 binary converts to 2.0",
+        expression={"$toDouble": _f32_two},
+        expected=2.0,
+    ),
+    ExpressionTestCase(
+        "binary_f64_zero",
+        msg="8-byte float64 zero binary converts to 0.0",
+        expression={"$toDouble": _f64_zero},
+        expected=DOUBLE_ZERO,
+    ),
+    ExpressionTestCase(
+        "binary_f64_one",
+        msg="8-byte float64 1.0 binary converts to 1.0",
+        expression={"$toDouble": _f64_one},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "binary_f64_neg_one",
+        msg="8-byte float64 -1.0 binary converts to -1.0",
+        expression={"$toDouble": _f64_neg_one},
+        expected=-1.0,
+    ),
+    ExpressionTestCase(
+        "binary_f64_1_5",
+        msg="8-byte float64 1.5 binary converts to 1.5",
+        expression={"$toDouble": _f64_1_5},
+        expected=DOUBLE_ONE_AND_HALF,
+    ),
+]
+
+TODOUBLE_BINARY_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "binary_empty",
+        msg="0-byte binary is a conversion failure",
+        expression={"$toDouble": Binary(b"")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_one_byte",
+        msg="1-byte binary is a conversion failure",
+        expression={"$toDouble": Binary(b"\x00")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_three_bytes",
+        msg="3-byte binary is a conversion failure",
+        expression={"$toDouble": Binary(b"\x00\x00\x00")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_five_bytes",
+        msg="5-byte binary is a conversion failure",
+        expression={"$toDouble": Binary(b"\x00\x00\x00\x00\x00")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+# Property [Unsupported Types]: $toDouble fails with a conversion error for BSON types it
+# cannot convert (object, ObjectId, regex, timestamp, code, MinKey, MaxKey, array).
+TODOUBLE_UNSUPPORTED_TYPE_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "type_object",
+        msg="Object BSON type is a conversion failure",
+        expression={"$toDouble": {"$literal": {"a": 1}}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_objectid",
+        msg="ObjectId BSON type is a conversion failure",
+        expression={"$toDouble": ObjectId("000000000000000000000000")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_regex",
+        msg="Regex BSON type is a conversion failure",
+        expression={"$toDouble": Regex("abc")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_timestamp",
+        msg="Timestamp BSON type is a conversion failure",
+        expression={"$toDouble": Timestamp(0, 1)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_code",
+        msg="Code BSON type is a conversion failure",
+        expression={"$toDouble": Code("function(){}")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_minkey",
+        msg="MinKey BSON type is a conversion failure",
+        expression={"$toDouble": MinKey()},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_maxkey",
+        msg="MaxKey BSON type is a conversion failure",
+        expression={"$toDouble": MaxKey()},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_array",
+        msg="Array value (from $literal) is a conversion failure",
+        expression={"$toDouble": {"$literal": [1, 2]}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TODOUBLE_DATETIME_BINARY_TESTS = (
+    TODOUBLE_DATETIME_TESTS
+    + TODOUBLE_BINARY_VALID_TESTS
+    + TODOUBLE_BINARY_ERROR_TESTS
+    + TODOUBLE_UNSUPPORTED_TYPE_TESTS
+)
+
+
+@pytest.mark.parametrize("test", pytest_params(TODOUBLE_DATETIME_BINARY_TESTS))
+def test_toDouble_datetime_binary(collection, test: ExpressionTestCase):
+    """$toDouble converts datetime and binary inputs; rejects unsupported BSON types."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_decimal128.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_decimal128.py
new file mode 100644
index 000000000..498ee7c4d
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_decimal128.py
@@ -0,0 +1,104 @@
+"""$toDouble Decimal128 conversion tests: zeros, infinity, precision, and overflow."""
+
+import pytest
+from bson import Decimal128
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_INFINITY,
+    DECIMAL128_MANY_TRAILING_ZEROS,
+    DECIMAL128_MAX,
+    DECIMAL128_MIN,
+    DECIMAL128_NEGATIVE_INFINITY,
+    DECIMAL128_NEGATIVE_ONE_AND_HALF,
+    DECIMAL128_NEGATIVE_ZERO,
+    DECIMAL128_TRAILING_ZERO,
+    DECIMAL128_ZERO,
+    DOUBLE_NEGATIVE_ONE_AND_HALF,
+    DOUBLE_NEGATIVE_ZERO,
+    DOUBLE_ZERO,
+    FLOAT_INFINITY,
+    FLOAT_NEGATIVE_INFINITY,
+)
+
+# Property [Decimal128]: $toDouble converts Decimal128 values to double, mapping signed zeros
+# and infinities correctly, and rejecting values outside the double range.
+TODOUBLE_DECIMAL128_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "dec128_zero",
+        msg="Decimal128 zero converts to 0.0",
+        expression={"$toDouble": DECIMAL128_ZERO},
+        expected=DOUBLE_ZERO,
+    ),
+    ExpressionTestCase(
+        "dec128_neg_zero",
+        msg="Decimal128 -0 converts to -0.0 preserving sign",
+        expression={"$toDouble": DECIMAL128_NEGATIVE_ZERO},
+        expected=DOUBLE_NEGATIVE_ZERO,
+    ),
+    ExpressionTestCase(
+        "dec128_inf",
+        msg="Decimal128 Infinity converts to +Inf",
+        expression={"$toDouble": DECIMAL128_INFINITY},
+        expected=FLOAT_INFINITY,
+    ),
+    ExpressionTestCase(
+        "dec128_neg_inf",
+        msg="Decimal128 -Infinity converts to -Inf",
+        expression={"$toDouble": DECIMAL128_NEGATIVE_INFINITY},
+        expected=FLOAT_NEGATIVE_INFINITY,
+    ),
+    ExpressionTestCase(
+        "dec128_one",
+        msg="Decimal128 1 converts to 1.0",
+        expression={"$toDouble": Decimal128("1")},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "dec128_trailing_zero",
+        msg="Decimal128 trailing zero normalizes correctly",
+        expression={"$toDouble": DECIMAL128_TRAILING_ZERO},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "dec128_many_trailing_zeros",
+        msg="Decimal128 with many trailing zeros normalizes correctly",
+        expression={"$toDouble": DECIMAL128_MANY_TRAILING_ZEROS},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "dec128_neg",
+        msg="Decimal128 negative value converts correctly",
+        expression={"$toDouble": DECIMAL128_NEGATIVE_ONE_AND_HALF},
+        expected=DOUBLE_NEGATIVE_ONE_AND_HALF,
+    ),
+    ExpressionTestCase(
+        "dec128_overflow",
+        msg="Decimal128 value exceeding double max is a conversion failure",
+        expression={"$toDouble": DECIMAL128_MAX},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "dec128_neg_overflow",
+        msg="Decimal128 most-negative value exceeding double range is a conversion failure",
+        expression={"$toDouble": DECIMAL128_MIN},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+
+@pytest.mark.parametrize("test", pytest_params(TODOUBLE_DECIMAL128_TESTS))
+def test_toDouble_decimal128(collection, test: ExpressionTestCase):
+    """$toDouble converts Decimal128 values including infinity, signed zero, and overflow."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_field_ref.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_field_ref.py
new file mode 100644
index 000000000..ca013570a
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_field_ref.py
@@ -0,0 +1,130 @@
+"""$toDouble field reference and expression-as-input tests."""
+
+import pytest
+from bson import Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+    execute_expression_with_insert,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DOUBLE_NEGATIVE_ZERO,
+    DOUBLE_TWO_AND_HALF,
+)
+
+# Property [Field Reference]: $toDouble resolves field paths and nested dot-notation paths;
+# missing fields and missing nested fields return null.
+TODOUBLE_FIELD_REF_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int_field",
+        msg="int32 field converts to double",
+        expression={"$toDouble": "$v"},
+        doc={"v": 42},
+        expected=42.0,
+    ),
+    ExpressionTestCase(
+        "int64_field",
+        msg="int64 field converts to double",
+        expression={"$toDouble": "$v"},
+        doc={"v": Int64(86400000)},
+        expected=86400000.0,
+    ),
+    ExpressionTestCase(
+        "double_field",
+        msg="double field passes through unchanged",
+        expression={"$toDouble": "$v"},
+        doc={"v": 3.14},
+        expected=3.14,
+    ),
+    ExpressionTestCase(
+        "string_field",
+        msg="numeric string field converts to double",
+        expression={"$toDouble": "$v"},
+        doc={"v": "2.5"},
+        expected=DOUBLE_TWO_AND_HALF,
+    ),
+    ExpressionTestCase(
+        "bool_field",
+        msg="bool field converts to double",
+        expression={"$toDouble": "$v"},
+        doc={"v": True},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "nested_field",
+        msg="nested field path converts to double",
+        expression={"$toDouble": "$doc.v"},
+        doc={"doc": {"v": 100}},
+        expected=100.0,
+    ),
+    ExpressionTestCase(
+        "missing_nested",
+        msg="missing nested field returns null",
+        expression={"$toDouble": "$doc.missing"},
+        doc={"doc": {"x": 1}},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "missing_field",
+        msg="missing top-level field returns null",
+        expression={"$toDouble": "$v"},
+        doc={},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "neg_zero",
+        msg="$toDouble preserves -0.0 sign when reading from a document field",
+        expression={"$toDouble": "$v"},
+        doc={"v": DOUBLE_NEGATIVE_ZERO},
+        expected=DOUBLE_NEGATIVE_ZERO,
+    ),
+    ExpressionTestCase(
+        "composite_array_path",
+        msg="$toDouble fails when field path resolves to a composite array",
+        expression={"$toDouble": "$a.b"},
+        doc={"a": [{"b": 1.0}, {"b": 2.0}]},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+# Property [Expression Input]: $toDouble evaluates a nested expression before converting.
+TODOUBLE_EXPRESSION_INPUT_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "add",
+        msg="$toDouble converts an arithmetic expression result",
+        expression={"$toDouble": {"$add": [10, 20]}},
+        expected=30.0,
+    ),
+    ExpressionTestCase(
+        "concat",
+        msg="$toDouble converts a string concatenation expression result",
+        expression={"$toDouble": {"$concat": ["3", ".", "14"]}},
+        expected=3.14,
+    ),
+    ExpressionTestCase(
+        "nested_conversion",
+        msg="$toDouble converts a nested type-conversion expression result",
+        expression={"$toDouble": {"$toDecimal": 42}},
+        expected=42.0,
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TODOUBLE_FIELD_REF_TESTS + TODOUBLE_EXPRESSION_INPUT_TESTS)
+)
+def test_toDouble_field_ref(collection, test: ExpressionTestCase):
+    """$toDouble resolves field paths and nested paths from inserted documents."""
+    if test.doc is not None:
+        result = execute_expression_with_insert(collection, test.expression, test.doc)
+    else:
+        result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_numeric.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_numeric.py
new file mode 100644
index 000000000..3dd78cca3
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_numeric.py
@@ -0,0 +1,248 @@
+"""$toDouble numeric type tests: null/missing, boolean, int32, int64, double identity, and NaN."""
+
+import pytest
+from bson import Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_NAN,
+    DOUBLE_FROM_INT64_MAX,
+    DOUBLE_MAX,
+    DOUBLE_MAX_SAFE_INTEGER,
+    DOUBLE_MIN_NEGATIVE_SUBNORMAL,
+    DOUBLE_MIN_SUBNORMAL,
+    DOUBLE_NEGATIVE_ZERO,
+    DOUBLE_PRECISION_LOSS,
+    DOUBLE_ZERO,
+    FLOAT_INFINITY,
+    FLOAT_NAN,
+    FLOAT_NEGATIVE_INFINITY,
+    INT32_MAX,
+    INT32_MIN,
+    INT32_ZERO,
+    INT64_MAX,
+    INT64_MAX_MINUS_1,
+    INT64_MIN,
+    INT64_ZERO,
+    MISSING,
+)
+
+# Property [Null and Missing]: $toDouble returns null for null and missing inputs.
+TODOUBLE_NULL_MISSING_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "null", msg="Should return null for null", expression={"$toDouble": None}, expected=None
+    ),
+    ExpressionTestCase(
+        "missing",
+        msg="Should return null for missing",
+        expression={"$toDouble": MISSING},
+        expected=None,
+    ),
+]
+
+# Property [Boolean]: $toDouble converts true to 1.0 and false to +0.0.
+TODOUBLE_BOOL_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "bool_true", msg="True converts to 1.0", expression={"$toDouble": True}, expected=1.0
+    ),
+    ExpressionTestCase(
+        "bool_false",
+        msg="False converts to positive 0.0",
+        expression={"$toDouble": False},
+        expected=DOUBLE_ZERO,
+    ),
+]
+
+# Property [Int32]: $toDouble converts int32 values to their exact double equivalents.
+TODOUBLE_INT32_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int32_zero",
+        msg="int32 zero converts to 0.0",
+        expression={"$toDouble": INT32_ZERO},
+        expected=DOUBLE_ZERO,
+    ),
+    ExpressionTestCase(
+        "int32_one",
+        msg="int32 1 converts exactly to 1.0",
+        expression={"$toDouble": 1},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "int32_neg_one",
+        msg="int32 -1 converts exactly to -1.0",
+        expression={"$toDouble": -1},
+        expected=-1.0,
+    ),
+    ExpressionTestCase(
+        "int32_max",
+        msg="int32 max converts exactly",
+        expression={"$toDouble": INT32_MAX},
+        expected=2147483647.0,
+    ),
+    ExpressionTestCase(
+        "int32_min",
+        msg="int32 min converts exactly",
+        expression={"$toDouble": INT32_MIN},
+        expected=-2147483648.0,
+    ),
+]
+
+# Property [Int64]: $toDouble converts int64 values, with precision loss above 2^53.
+TODOUBLE_INT64_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int64_zero",
+        msg="int64 zero converts to 0.0",
+        expression={"$toDouble": INT64_ZERO},
+        expected=DOUBLE_ZERO,
+    ),
+    ExpressionTestCase(
+        "int64_one", msg="int64 1 converts to 1.0", expression={"$toDouble": Int64(1)}, expected=1.0
+    ),
+    ExpressionTestCase(
+        "int64_safe_max",
+        msg="int64 at 2^53 (max safe integer) converts exactly",
+        expression={"$toDouble": Int64(DOUBLE_MAX_SAFE_INTEGER)},
+        expected=9007199254740992.0,
+    ),
+    ExpressionTestCase(
+        "int64_above_safe",
+        msg="int64 above 2^53 loses the last bit of precision",
+        expression={"$toDouble": Int64(DOUBLE_PRECISION_LOSS)},
+        expected=9007199254740992.0,
+    ),
+    ExpressionTestCase(
+        "int64_neg_one",
+        msg="int64 -1 converts to -1.0",
+        expression={"$toDouble": Int64(-1)},
+        expected=-1.0,
+    ),
+    ExpressionTestCase(
+        "int64_max",
+        msg="int64 max converts with precision loss",
+        expression={"$toDouble": INT64_MAX},
+        expected=DOUBLE_FROM_INT64_MAX,
+    ),
+    ExpressionTestCase(
+        "int64_max_minus_one",
+        msg="int64 max-1 rounds to the same double as int64 max",
+        expression={"$toDouble": INT64_MAX_MINUS_1},
+        expected=DOUBLE_FROM_INT64_MAX,
+    ),
+    ExpressionTestCase(
+        "int64_min",
+        msg="int64 min converts to -2^63 representation",
+        expression={"$toDouble": INT64_MIN},
+        expected=-DOUBLE_FROM_INT64_MAX,
+    ),
+]
+
+# Property [Double Identity]: $toDouble is the identity function for double inputs.
+TODOUBLE_DOUBLE_IDENTITY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "double_zero",
+        msg="0.0 passes through unchanged",
+        expression={"$toDouble": DOUBLE_ZERO},
+        expected=DOUBLE_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_neg_zero",
+        msg="-0.0 passes through preserving sign",
+        expression={"$toDouble": DOUBLE_NEGATIVE_ZERO},
+        expected=DOUBLE_NEGATIVE_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_inf",
+        msg="+Inf passes through unchanged",
+        expression={"$toDouble": FLOAT_INFINITY},
+        expected=FLOAT_INFINITY,
+    ),
+    ExpressionTestCase(
+        "double_neg_inf",
+        msg="-Inf passes through unchanged",
+        expression={"$toDouble": FLOAT_NEGATIVE_INFINITY},
+        expected=FLOAT_NEGATIVE_INFINITY,
+    ),
+    ExpressionTestCase(
+        "double_one",
+        msg="1.0 passes through unchanged",
+        expression={"$toDouble": 1.0},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "double_pi",
+        msg="pi passes through unchanged",
+        expression={"$toDouble": 3.141592653589793},
+        expected=3.141592653589793,
+    ),
+    ExpressionTestCase(
+        "double_large",
+        msg="Large double passes through unchanged",
+        expression={"$toDouble": DOUBLE_MAX},
+        expected=DOUBLE_MAX,
+    ),
+    ExpressionTestCase(
+        "double_subnormal",
+        msg="Minimum positive subnormal double passes through unchanged",
+        expression={"$toDouble": DOUBLE_MIN_SUBNORMAL},
+        expected=DOUBLE_MIN_SUBNORMAL,
+    ),
+    ExpressionTestCase(
+        "double_neg_subnormal",
+        msg="Minimum negative subnormal double passes through unchanged",
+        expression={"$toDouble": DOUBLE_MIN_NEGATIVE_SUBNORMAL},
+        expected=DOUBLE_MIN_NEGATIVE_SUBNORMAL,
+    ),
+]
+
+# Property [NaN]: $toDouble preserves NaN inputs as double NaN.
+TODOUBLE_NAN_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "double_nan",
+        msg="double NaN passes through as NaN",
+        expression={"$toDouble": FLOAT_NAN},
+        expected=pytest.approx(FLOAT_NAN, nan_ok=True),
+    ),
+    ExpressionTestCase(
+        "dec128_nan",
+        msg="Decimal128 nan converts to double NaN",
+        expression={"$toDouble": DECIMAL128_NAN},
+        expected=pytest.approx(FLOAT_NAN, nan_ok=True),
+    ),
+    ExpressionTestCase(
+        "str_nan",
+        msg="'NaN' string converts to double NaN",
+        expression={"$toDouble": "NaN"},
+        expected=pytest.approx(FLOAT_NAN, nan_ok=True),
+    ),
+    ExpressionTestCase(
+        "str_nan_lower",
+        msg="'nan' string converts to double NaN",
+        expression={"$toDouble": "nan"},
+        expected=pytest.approx(FLOAT_NAN, nan_ok=True),
+    ),
+]
+
+TODOUBLE_NUMERIC_TESTS = (
+    TODOUBLE_NULL_MISSING_TESTS
+    + TODOUBLE_BOOL_TESTS
+    + TODOUBLE_INT32_TESTS
+    + TODOUBLE_INT64_TESTS
+    + TODOUBLE_DOUBLE_IDENTITY_TESTS
+    + TODOUBLE_NAN_TESTS
+)
+
+
+@pytest.mark.parametrize("test", pytest_params(TODOUBLE_NUMERIC_TESTS))
+def test_toDouble_numeric(collection, test: ExpressionTestCase):
+    """$toDouble converts null, bool, int32, int64, double, and NaN inputs."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_return_type.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_return_type.py
new file mode 100644
index 000000000..2b93ca534
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_return_type.py
@@ -0,0 +1,139 @@
+"""$toDouble return-type invariant and idempotency tests."""
+
+import struct
+from datetime import datetime, timezone
+
+import pytest
+from bson import Binary, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.bson_type_validator import (
+    BsonType,
+    BsonTypeTestCase,
+    generate_bson_acceptance_test_cases,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_TWO_AND_HALF,
+    DOUBLE_TWO_AND_HALF,
+    MISSING,
+)
+
+# Property [Return Type]: $toDouble always returns BSON type double for successful conversions
+# and null for null or missing inputs.
+RETURN_TYPE_DOUBLE_SPEC = [
+    BsonTypeTestCase(
+        id="toDouble_return_type",
+        msg="$toDouble always returns BSON type double for a successful conversion",
+        valid_types=[
+            BsonType.BOOL,
+            BsonType.DOUBLE,
+            BsonType.INT,
+            BsonType.LONG,
+            BsonType.DECIMAL,
+            BsonType.STRING,
+            BsonType.DATE,
+            BsonType.BIN_DATA,
+        ],
+        valid_inputs={
+            BsonType.STRING: "7.5",
+            BsonType.BIN_DATA: Binary(struct.pack("<d", 1.0)),
+        },
+    ),
+]
+
+RETURN_TYPE_DOUBLE_CASES = generate_bson_acceptance_test_cases(RETURN_TYPE_DOUBLE_SPEC)
+
+
+@pytest.mark.parametrize("bson_type,sample_value,spec", RETURN_TYPE_DOUBLE_CASES)
+def test_toDouble_return_type_is_double(collection, bson_type, sample_value, spec):
+    """$toDouble always returns BSON type 'double' for a successful conversion."""
+    result = execute_expression(collection, {"$type": {"$toDouble": sample_value}})
+    assert_expression_result(result, expected="double", msg=f"{spec.msg} ({bson_type.value} input)")
+
+
+# Property [Return Type — Null]: $toDouble returns BSON type null for null or missing inputs.
+TODOUBLE_RETURN_TYPE_NULL_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "null",
+        msg="$toDouble of null returns null type",
+        expression={"$type": {"$toDouble": None}},
+        expected="null",
+    ),
+    ExpressionTestCase(
+        "missing",
+        msg="$toDouble of missing returns null type",
+        expression={"$type": {"$toDouble": MISSING}},
+        expected="null",
+    ),
+]
+
+
+# Property [Idempotency]: applying $toDouble twice produces the same result as applying it once.
+TODOUBLE_IDEMPOTENCY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "idempotent_bool",
+        msg="$toDouble is idempotent for bool",
+        expression={"$toDouble": {"$toDouble": True}},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "idempotent_double",
+        msg="$toDouble is idempotent for double",
+        expression={"$toDouble": {"$toDouble": 3.14}},
+        expected=3.14,
+    ),
+    ExpressionTestCase(
+        "idempotent_int32",
+        msg="$toDouble is idempotent for int32",
+        expression={"$toDouble": {"$toDouble": 42}},
+        expected=42.0,
+    ),
+    ExpressionTestCase(
+        "idempotent_int64",
+        msg="$toDouble is idempotent for int64",
+        expression={"$toDouble": {"$toDouble": Int64(99)}},
+        expected=99.0,
+    ),
+    ExpressionTestCase(
+        "idempotent_decimal128",
+        msg="$toDouble is idempotent for Decimal128",
+        expression={"$toDouble": {"$toDouble": DECIMAL128_TWO_AND_HALF}},
+        expected=DOUBLE_TWO_AND_HALF,
+    ),
+    ExpressionTestCase(
+        "idempotent_string",
+        msg="$toDouble is idempotent for numeric string",
+        expression={"$toDouble": {"$toDouble": "7.5"}},
+        expected=7.5,
+    ),
+    ExpressionTestCase(
+        "idempotent_datetime",
+        msg="$toDouble is idempotent for datetime",
+        expression={"$toDouble": {"$toDouble": datetime(2024, 1, 1, tzinfo=timezone.utc)}},
+        expected=1_704_067_200_000.0,
+    ),
+    ExpressionTestCase(
+        "idempotent_binary_8byte",
+        msg="$toDouble is idempotent for 8-byte binary",
+        expression={"$toDouble": {"$toDouble": Binary(struct.pack("<d", 5.0))}},
+        expected=5.0,
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TODOUBLE_RETURN_TYPE_NULL_TESTS + TODOUBLE_IDEMPOTENCY_TESTS)
+)
+def test_toDouble_return_type_null(collection, test: ExpressionTestCase):
+    """$toDouble returns BSON type 'null' for null or missing input."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_string.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_string.py
new file mode 100644
index 000000000..ba1c69f3b
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toDouble/test_toDouble_string.py
@@ -0,0 +1,304 @@
+"""$toDouble string conversion tests: valid numeric, scientific notation, hex float, and errors."""
+
+import pytest
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR, STRING_SIZE_LIMIT_ERROR
+from documentdb_tests.framework.lazy_payload import lazy
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DOUBLE_HALF,
+    DOUBLE_NEGATIVE_ZERO,
+    DOUBLE_ONE_AND_HALF,
+    DOUBLE_ZERO,
+    FLOAT_INFINITY,
+    FLOAT_NEGATIVE_INFINITY,
+    STRING_SIZE_LIMIT_BYTES,
+)
+
+# Property [String Numeric]: $toDouble parses decimal, scientific-notation, and infinity strings.
+TODOUBLE_STRING_NUMERIC_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "str_zero", msg="'0' converts to 0.0", expression={"$toDouble": "0"}, expected=DOUBLE_ZERO
+    ),
+    ExpressionTestCase(
+        "str_one", msg="'1' converts to 1.0", expression={"$toDouble": "1"}, expected=1.0
+    ),
+    ExpressionTestCase(
+        "str_neg_one", msg="'-1' converts to -1.0", expression={"$toDouble": "-1"}, expected=-1.0
+    ),
+    ExpressionTestCase(
+        "str_plus_one", msg="'+1' converts to 1.0", expression={"$toDouble": "+1"}, expected=1.0
+    ),
+    ExpressionTestCase(
+        "str_decimal",
+        msg="'1.5' converts to 1.5",
+        expression={"$toDouble": "1.5"},
+        expected=DOUBLE_ONE_AND_HALF,
+    ),
+    ExpressionTestCase(
+        "str_dot_five",
+        msg="'.5' converts to 0.5",
+        expression={"$toDouble": ".5"},
+        expected=DOUBLE_HALF,
+    ),
+    ExpressionTestCase(
+        "str_neg_zero",
+        msg="'-0' converts to -0.0",
+        expression={"$toDouble": "-0"},
+        expected=DOUBLE_NEGATIVE_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_sci_pos",
+        msg="'1e10' (scientific) converts correctly",
+        expression={"$toDouble": "1e10"},
+        expected=1e10,
+    ),
+    ExpressionTestCase(
+        "str_sci_neg_exp",
+        msg="'1.5e-3' (scientific negative exponent) converts correctly",
+        expression={"$toDouble": "1.5e-3"},
+        expected=1.5e-3,
+    ),
+    ExpressionTestCase(
+        "str_sci_upper",
+        msg="'1E10' (uppercase E) converts correctly",
+        expression={"$toDouble": "1E10"},
+        expected=1e10,
+    ),
+    ExpressionTestCase(
+        "str_inf",
+        msg="'Infinity' converts to +Inf",
+        expression={"$toDouble": "Infinity"},
+        expected=FLOAT_INFINITY,
+    ),
+    ExpressionTestCase(
+        "str_neg_inf",
+        msg="'-Infinity' converts to -Inf",
+        expression={"$toDouble": "-Infinity"},
+        expected=FLOAT_NEGATIVE_INFINITY,
+    ),
+    ExpressionTestCase(
+        "str_plus_inf",
+        msg="'+Infinity' converts to +Inf",
+        expression={"$toDouble": "+Infinity"},
+        expected=FLOAT_INFINITY,
+    ),
+    ExpressionTestCase(
+        "str_inf_short",
+        msg="'inf' converts to +Inf",
+        expression={"$toDouble": "inf"},
+        expected=FLOAT_INFINITY,
+    ),
+    ExpressionTestCase(
+        "str_neg_inf_short",
+        msg="'-inf' converts to -Inf",
+        expression={"$toDouble": "-inf"},
+        expected=FLOAT_NEGATIVE_INFINITY,
+    ),
+]
+
+# Property [String Hex]: $toDouble parses hexadecimal float literals (requires a leading sign for
+# lowercase inputs).
+TODOUBLE_STRING_HEX_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "str_hex_zero",
+        msg="'+0x0p0' converts to 0.0",
+        expression={"$toDouble": "+0x0p0"},
+        expected=DOUBLE_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_hex_one",
+        msg="'+0x1p0' converts to 1.0",
+        expression={"$toDouble": "+0x1p0"},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "str_hex_two",
+        msg="'+0x1p1' converts to 2.0",
+        expression={"$toDouble": "+0x1p1"},
+        expected=2.0,
+    ),
+    ExpressionTestCase(
+        "str_hex_half",
+        msg="'+0x1p-1' converts to 0.5",
+        expression={"$toDouble": "+0x1p-1"},
+        expected=DOUBLE_HALF,
+    ),
+    ExpressionTestCase(
+        "str_hex_frac",
+        msg="'+0x1.8p1' converts to 3.0",
+        expression={"$toDouble": "+0x1.8p1"},
+        expected=3.0,
+    ),
+    ExpressionTestCase(
+        "str_hex_neg",
+        msg="'-0x1p0' converts to -1.0",
+        expression={"$toDouble": "-0x1p0"},
+        expected=-1.0,
+    ),
+    ExpressionTestCase(
+        "str_hex_plus",
+        msg="'+0x1p0' converts to 1.0",
+        expression={"$toDouble": "+0x1p0"},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "str_hex_upper",
+        msg="'0X1P0' (uppercase) converts to 1.0",
+        expression={"$toDouble": "0X1P0"},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "str_hex_ff",
+        msg="'+0xffp0' converts to 255.0",
+        expression={"$toDouble": "+0xffp0"},
+        expected=255.0,
+    ),
+    ExpressionTestCase(
+        "str_hex_bare_int",
+        msg="'+0x1' (bare hex integer) converts to 1.0",
+        expression={"$toDouble": "+0x1"},
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "str_hex_bare_ff",
+        msg="'+0xff' (bare hex integer) converts to 255.0",
+        expression={"$toDouble": "+0xff"},
+        expected=255.0,
+    ),
+    ExpressionTestCase(
+        "str_hex_err_no_digits",
+        msg="'0x' (prefix only) is a conversion failure",
+        expression={"$toDouble": "0x"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_hex_err_p_no_exp",
+        msg="'0x1p' (missing exponent digits) is a conversion failure",
+        expression={"$toDouble": "0x1p"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_hex_err_no_sig",
+        msg="'0xp0' (missing significand digits) is a conversion failure",
+        expression={"$toDouble": "0xp0"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_hex_err_dot_only",
+        msg="'0x.p0' (dot but no digits) is a conversion failure",
+        expression={"$toDouble": "0x.p0"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+# Property [String Errors]: $toDouble rejects malformed, whitespace-padded, and out-of-range
+# strings with a conversion failure.
+TODOUBLE_STRING_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "str_alpha",
+        msg="Alphabetic string is a conversion failure",
+        expression={"$toDouble": "abc"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_empty",
+        msg="Empty string is a conversion failure",
+        expression={"$toDouble": ""},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_leading_space",
+        msg="Leading whitespace is a conversion failure",
+        expression={"$toDouble": " 1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_trailing_space",
+        msg="Trailing whitespace is a conversion failure",
+        expression={"$toDouble": "1 "},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_embedded_space",
+        msg="Embedded whitespace is a conversion failure",
+        expression={"$toDouble": "1 2"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_overflow",
+        msg="Overflow string (> double max) is a conversion failure",
+        expression={"$toDouble": "1e309"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_underflow",
+        msg="Underflow string (< double min subnormal) is a conversion failure",
+        expression={"$toDouble": "1e-400"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_partial_sci",
+        msg="Incomplete scientific notation is a conversion failure",
+        expression={"$toDouble": "1.5e"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TODOUBLE_STRING_TESTS = (
+    TODOUBLE_STRING_NUMERIC_TESTS + TODOUBLE_STRING_HEX_TESTS + TODOUBLE_STRING_ERROR_TESTS
+)
+
+
+# Property [String Size Limit]: $toDouble checks the byte length of string inputs before
+# attempting conversion; strings at or above the limit are rejected unconditionally.
+TODOUBLE_STRING_SIZE_LIMIT_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "size_one_under_valid",
+        msg="Valid numeric string one byte under limit converts successfully",
+        expression=lazy(lambda: {"$toDouble": "0" * (STRING_SIZE_LIMIT_BYTES - 2) + "1"}),
+        expected=1.0,
+    ),
+    ExpressionTestCase(
+        "size_one_under_hex",
+        msg="Valid hex string one byte under limit converts successfully",
+        expression=lazy(lambda: {"$toDouble": "0X" + "0" * (STRING_SIZE_LIMIT_BYTES - 4) + "F"}),
+        expected=15.0,
+    ),
+    ExpressionTestCase(
+        "size_one_under_non_numeric",
+        msg="Non-numeric string one byte under limit passes size check but fails conversion",
+        expression=lazy(lambda: {"$toDouble": "a" * (STRING_SIZE_LIMIT_BYTES - 1)}),
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "size_at_limit",
+        msg="String at STRING_SIZE_LIMIT_BYTES is rejected with STRING_SIZE_LIMIT_ERROR",
+        expression=lazy(lambda: {"$toDouble": "a" * STRING_SIZE_LIMIT_BYTES}),
+        error_code=STRING_SIZE_LIMIT_ERROR,
+    ),
+    ExpressionTestCase(
+        "size_at_limit_four_byte",
+        msg="4-byte character string reaching STRING_SIZE_LIMIT_BYTES is rejected",
+        expression=lazy(lambda: {"$toDouble": "\U0001f600" * (STRING_SIZE_LIMIT_BYTES // 4)}),
+        error_code=STRING_SIZE_LIMIT_ERROR,
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TODOUBLE_STRING_TESTS + TODOUBLE_STRING_SIZE_LIMIT_TESTS)
+)
+def test_toDouble_string(collection, test: ExpressionTestCase):
+    """$toDouble parses valid numeric strings and rejects malformed ones."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/__init__.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_arity.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_arity.py
new file mode 100644
index 000000000..814917e0f
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_arity.py
@@ -0,0 +1,83 @@
+"""$toInt arity and field path syntax tests."""
+
+import pytest
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import (
+    FAILED_TO_PARSE_ERROR,
+    INVALID_DOLLAR_FIELD_PATH,
+    TO_TYPE_ARITY_ERROR,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+
+# Property [Arity]: $toInt unwraps single-element literal arrays and rejects empty or
+# multi-element arrays. These cases are specific to $toInt syntax (not $convert).
+TOINT_ARITY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "single_element",
+        msg="Single-element literal array argument is unwrapped to a scalar",
+        expression={"$toInt": [42]},
+        expected=42,
+    ),
+    ExpressionTestCase(
+        "empty_array",
+        msg="Empty literal array argument is an arity error",
+        expression={"$toInt": []},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+    ExpressionTestCase(
+        "multi_element",
+        msg="Multi-element literal array argument is an arity error",
+        expression={"$toInt": [1, 2]},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+    ExpressionTestCase(
+        "single_null",
+        msg="Single-element literal array wrapping null unwraps and returns null",
+        expression={"$toInt": [None]},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "single_bool",
+        msg="Single-element literal array wrapping a bool unwraps and converts",
+        expression={"$toInt": [True]},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "large_array",
+        msg="A large literal array argument is an arity error",
+        expression={"$toInt": list(range(100))},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+]
+
+# Property [Invalid Field Path]: $toInt rejects malformed field path syntax.
+TOINT_INVALID_FIELD_PATH_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "bare_dollar",
+        msg="Bare '$' is an invalid field path",
+        expression={"$toInt": "$"},
+        error_code=INVALID_DOLLAR_FIELD_PATH,
+    ),
+    ExpressionTestCase(
+        "double_dollar",
+        msg="'$$' is rejected as an empty variable name",
+        expression={"$toInt": "$$"},
+        error_code=FAILED_TO_PARSE_ERROR,
+    ),
+]
+
+
+@pytest.mark.parametrize("test", pytest_params(TOINT_ARITY_TESTS + TOINT_INVALID_FIELD_PATH_TESTS))
+def test_toInt_arity(collection, test: ExpressionTestCase):
+    """$toInt literal array arguments are unwrapped or rejected based on arity."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_binary.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_binary.py
new file mode 100644
index 000000000..dd05b2ec7
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_binary.py
@@ -0,0 +1,220 @@
+"""$toInt binary conversion tests and unsupported BSON type errors."""
+
+from datetime import datetime, timezone
+
+import pytest
+from bson import Binary, Code, MaxKey, MinKey, ObjectId, Regex, Timestamp
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import INT32_MAX, INT32_MIN, INT32_ZERO
+
+# Property [Binary Conversion]: Binary values of exactly 1, 2, or 4 bytes are
+# interpreted as signed little-endian integers, regardless of subtype (except subtype 2,
+# which prepends a 4-byte length header on the wire).
+TOINT_BINARY_VALID_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "binary_1byte_zero",
+        msg="1-byte Binary 0x00 converts to 0",
+        expression={"$toInt": Binary(b"\x00", 0)},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "binary_1byte_max",
+        msg="1-byte Binary 0x7F converts to 127",
+        expression={"$toInt": Binary(b"\x7f", 0)},
+        expected=127,
+    ),
+    ExpressionTestCase(
+        "binary_1byte_min",
+        msg="1-byte Binary 0x80 converts to -128",
+        expression={"$toInt": Binary(b"\x80", 0)},
+        expected=-128,
+    ),
+    ExpressionTestCase(
+        "binary_1byte_neg_one",
+        msg="1-byte Binary 0xFF converts to -1",
+        expression={"$toInt": Binary(b"\xff", 0)},
+        expected=-1,
+    ),
+    ExpressionTestCase(
+        "binary_2byte_int16_max",
+        msg="2-byte Binary little-endian 0xFF7F converts to int16 max (32767)",
+        expression={"$toInt": Binary(b"\xff\x7f", 0)},
+        expected=32_767,
+    ),
+    ExpressionTestCase(
+        "binary_2byte_int16_min",
+        msg="2-byte Binary little-endian 0x0080 converts to int16 min (-32768)",
+        expression={"$toInt": Binary(b"\x00\x80", 0)},
+        expected=-32_768,
+    ),
+    ExpressionTestCase(
+        "binary_4byte_int32_max",
+        msg="4-byte Binary little-endian converts to int32 max",
+        expression={"$toInt": Binary(b"\xff\xff\xff\x7f", 0)},
+        expected=INT32_MAX,
+    ),
+    ExpressionTestCase(
+        "binary_4byte_int32_min",
+        msg="4-byte Binary little-endian converts to int32 min",
+        expression={"$toInt": Binary(b"\x00\x00\x00\x80", 0)},
+        expected=INT32_MIN,
+    ),
+    ExpressionTestCase(
+        "binary_subtype_2_empty_payload",
+        msg="Subtype 2 empty payload (4-byte length header only on wire) converts to 0",
+        expression={"$toInt": Binary(b"", 2)},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "binary_subtype_3",
+        msg="Subtype 3 (old UUID) 1-byte binary converts; subtype is ignored",
+        expression={"$toInt": Binary(b"\x7f", 3)},
+        expected=127,
+    ),
+    ExpressionTestCase(
+        "binary_subtype_4",
+        msg="Subtype 4 (UUID) 1-byte binary converts; subtype is ignored",
+        expression={"$toInt": Binary(b"\x7f", 4)},
+        expected=127,
+    ),
+    ExpressionTestCase(
+        "binary_subtype_5",
+        msg="Subtype 5 (MD5) 1-byte binary converts; subtype is ignored",
+        expression={"$toInt": Binary(b"\x7f", 5)},
+        expected=127,
+    ),
+    ExpressionTestCase(
+        "binary_subtype_128",
+        msg="Subtype 128 (user-defined) 1-byte binary converts; subtype is ignored",
+        expression={"$toInt": Binary(b"\x7f", 128)},
+        expected=127,
+    ),
+]
+
+# Property [Binary Conversion Errors]: Binary values with lengths other than 1, 2, or 4
+# bytes produce a conversion failure.
+TOINT_BINARY_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "binary_0byte",
+        msg="0-byte binary is a conversion failure",
+        expression={"$toInt": Binary(b"", 0)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_3byte",
+        msg="3-byte binary is a conversion failure",
+        expression={"$toInt": Binary(b"\x00" * 3, 0)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_5byte",
+        msg="5-byte binary is a conversion failure",
+        expression={"$toInt": Binary(b"\x00" * 5, 0)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_8byte",
+        msg="8-byte binary is a conversion failure",
+        expression={"$toInt": Binary(b"\x00" * 8, 0)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_16byte",
+        msg="16-byte binary is a conversion failure",
+        expression={"$toInt": Binary(b"\x00" * 16, 0)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_uuid_16byte",
+        msg="UUID subtype 16-byte binary is a conversion failure",
+        expression={"$toInt": Binary(b"\x00" * 16, 4)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_subtype_2",
+        msg="Subtype 2 (old binary) 1-byte payload becomes 5 bytes on wire; conversion failure",
+        expression={"$toInt": Binary(b"\x7f", 2)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+# Property [Unsupported Types]: $toInt fails with a conversion error for BSON types it
+# cannot convert (datetime, ObjectId, regex, timestamp, code, MinKey, MaxKey, object, array).
+TOINT_UNSUPPORTED_TYPE_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "type_object",
+        msg="Object BSON type is a conversion failure",
+        expression={"$toInt": {"$literal": {"key": "val"}}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_objectid",
+        msg="ObjectId BSON type is a conversion failure",
+        expression={"$toInt": ObjectId("000000000000000000000000")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_datetime",
+        msg="Datetime BSON type is a conversion failure (unlike $toLong)",
+        expression={"$toInt": datetime(2024, 6, 15, tzinfo=timezone.utc)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_timestamp",
+        msg="Timestamp BSON type is a conversion failure",
+        expression={"$toInt": Timestamp(1, 1)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_regex",
+        msg="Regex BSON type is a conversion failure",
+        expression={"$toInt": Regex("abc")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_code",
+        msg="Code BSON type is a conversion failure",
+        expression={"$toInt": Code("x")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_minkey",
+        msg="MinKey BSON type is a conversion failure",
+        expression={"$toInt": MinKey()},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_maxkey",
+        msg="MaxKey BSON type is a conversion failure",
+        expression={"$toInt": MaxKey()},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_array",
+        msg="Nested array (unwrapped once; inner array hits type check) is a conversion failure",
+        expression={"$toInt": {"$literal": [["42"]]}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TOINT_BINARY_TESTS = (
+    TOINT_BINARY_VALID_TESTS + TOINT_BINARY_ERROR_TESTS + TOINT_UNSUPPORTED_TYPE_TESTS
+)
+
+
+@pytest.mark.parametrize("test", pytest_params(TOINT_BINARY_TESTS))
+def test_toInt_binary(collection, test: ExpressionTestCase):
+    """$toInt converts 1/2/4-byte binary; rejects other lengths and unsupported BSON types."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_decimal128.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_decimal128.py
new file mode 100644
index 000000000..7c68962c2
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_decimal128.py
@@ -0,0 +1,129 @@
+"""$toInt Decimal128 conversion tests: truncation, boundary values, and overflow."""
+
+import pytest
+from bson import Decimal128
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_INFINITY,
+    DECIMAL128_NAN,
+    DECIMAL128_NEGATIVE_INFINITY,
+    DECIMAL128_NEGATIVE_ZERO,
+    DECIMAL128_TRAILING_ZERO,
+    DECIMAL128_ZERO,
+    INT32_MAX,
+    INT32_MIN,
+    INT32_ZERO,
+)
+
+# Property [Decimal128 Truncation]: $toInt truncates Decimal128 toward zero.
+TOINT_DECIMAL128_TRUNCATION_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "dec128_zero",
+        msg="Decimal128 zero converts to 0",
+        expression={"$toInt": DECIMAL128_ZERO},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "dec128_neg_zero",
+        msg="Decimal128 -0 converts to 0",
+        expression={"$toInt": DECIMAL128_NEGATIVE_ZERO},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "dec128_one",
+        msg="Decimal128 1 converts to 1",
+        expression={"$toInt": Decimal128("1")},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "dec128_neg_one",
+        msg="Decimal128 -1 converts to -1",
+        expression={"$toInt": Decimal128("-1")},
+        expected=-1,
+    ),
+    ExpressionTestCase(
+        "dec128_truncate_positive",
+        msg="Decimal128 1.9 is truncated toward zero to 1",
+        expression={"$toInt": Decimal128("1.9")},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "dec128_truncate_negative",
+        msg="Decimal128 -1.9 is truncated toward zero to -1",
+        expression={"$toInt": Decimal128("-1.9")},
+        expected=-1,
+    ),
+    ExpressionTestCase(
+        "dec128_trailing_zero",
+        msg="Decimal128 1.0 (trailing zero) converts to 1",
+        expression={"$toInt": DECIMAL128_TRAILING_ZERO},
+        expected=1,
+    ),
+]
+
+# Property [Decimal128 Boundary]: $toInt accepts Decimal128 values in the int32 range;
+# rejects NaN, infinity, and out-of-range values.
+TOINT_DECIMAL128_BOUNDARY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "dec128_int32_max",
+        msg="Decimal128 equal to int32 max converts exactly",
+        expression={"$toInt": Decimal128(str(INT32_MAX))},
+        expected=INT32_MAX,
+    ),
+    ExpressionTestCase(
+        "dec128_int32_min",
+        msg="Decimal128 equal to int32 min converts exactly",
+        expression={"$toInt": Decimal128(str(INT32_MIN))},
+        expected=INT32_MIN,
+    ),
+    ExpressionTestCase(
+        "dec128_overflow",
+        msg="Decimal128 one above int32 max is a conversion failure",
+        expression={"$toInt": Decimal128(str(INT32_MAX + 1))},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "dec128_underflow",
+        msg="Decimal128 one below int32 min is a conversion failure",
+        expression={"$toInt": Decimal128(str(INT32_MIN - 1))},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "dec128_nan",
+        msg="Decimal128 NaN is a conversion failure",
+        expression={"$toInt": DECIMAL128_NAN},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "dec128_inf",
+        msg="Decimal128 Infinity is a conversion failure",
+        expression={"$toInt": DECIMAL128_INFINITY},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "dec128_neg_inf",
+        msg="Decimal128 -Infinity is a conversion failure",
+        expression={"$toInt": DECIMAL128_NEGATIVE_INFINITY},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TOINT_DECIMAL128_TESTS = TOINT_DECIMAL128_TRUNCATION_TESTS + TOINT_DECIMAL128_BOUNDARY_TESTS
+
+
+@pytest.mark.parametrize("test", pytest_params(TOINT_DECIMAL128_TESTS))
+def test_toInt_decimal128(collection, test: ExpressionTestCase):
+    """$toInt converts Decimal128 values within int32 range; rejects NaN, infinity, and overflow."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_double.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_double.py
new file mode 100644
index 000000000..4ff45c875
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_double.py
@@ -0,0 +1,147 @@
+"""$toInt double conversion tests: truncation, special values, and overflow."""
+
+import pytest
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DOUBLE_HALF,
+    DOUBLE_NEGATIVE_HALF,
+    DOUBLE_NEGATIVE_ZERO,
+    DOUBLE_ZERO,
+    FLOAT_INFINITY,
+    FLOAT_NAN,
+    FLOAT_NEGATIVE_INFINITY,
+    INT32_MAX,
+    INT32_MIN,
+    INT32_ZERO,
+)
+
+# Property [Double Truncation]: $toInt truncates the fractional part toward zero.
+TOINT_DOUBLE_TRUNCATION_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "double_zero",
+        msg="0.0 converts to 0",
+        expression={"$toInt": DOUBLE_ZERO},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_neg_zero",
+        msg="-0.0 converts to 0",
+        expression={"$toInt": DOUBLE_NEGATIVE_ZERO},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_one",
+        msg="1.0 converts to 1",
+        expression={"$toInt": 1.0},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "double_neg_one",
+        msg="-1.0 converts to -1",
+        expression={"$toInt": -1.0},
+        expected=-1,
+    ),
+    ExpressionTestCase(
+        "double_truncate_positive",
+        msg="1.9 is truncated toward zero to 1",
+        expression={"$toInt": 1.9},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "double_truncate_negative",
+        msg="-1.9 is truncated toward zero to -1",
+        expression={"$toInt": -1.9},
+        expected=-1,
+    ),
+    ExpressionTestCase(
+        "double_half",
+        msg="0.5 is truncated toward zero to 0",
+        expression={"$toInt": DOUBLE_HALF},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_neg_half",
+        msg="-0.5 is truncated toward zero to 0",
+        expression={"$toInt": DOUBLE_NEGATIVE_HALF},
+        expected=INT32_ZERO,
+    ),
+]
+
+# Property [Double Boundary]: $toInt accepts doubles in the int32 range;
+# rejects NaN, infinity, and out-of-range values.
+TOINT_DOUBLE_BOUNDARY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "double_int32_max",
+        msg="double equal to int32 max converts exactly",
+        expression={"$toInt": float(INT32_MAX)},
+        expected=INT32_MAX,
+    ),
+    ExpressionTestCase(
+        "double_int32_min",
+        msg="double equal to int32 min converts exactly",
+        expression={"$toInt": float(INT32_MIN)},
+        expected=INT32_MIN,
+    ),
+    ExpressionTestCase(
+        "double_just_above_max",
+        msg="double one above int32 max is a conversion failure",
+        expression={"$toInt": float(INT32_MAX) + 1.0},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_just_below_min",
+        msg="double one below int32 min is a conversion failure",
+        expression={"$toInt": float(INT32_MIN) - 1.0},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_large_positive",
+        msg="Large positive double is a conversion failure",
+        expression={"$toInt": 1e18},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_large_negative",
+        msg="Large negative double is a conversion failure",
+        expression={"$toInt": -1e18},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_nan",
+        msg="NaN is a conversion failure",
+        expression={"$toInt": FLOAT_NAN},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_inf",
+        msg="+Infinity is a conversion failure",
+        expression={"$toInt": FLOAT_INFINITY},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_neg_inf",
+        msg="-Infinity is a conversion failure",
+        expression={"$toInt": FLOAT_NEGATIVE_INFINITY},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TOINT_DOUBLE_TESTS = TOINT_DOUBLE_TRUNCATION_TESTS + TOINT_DOUBLE_BOUNDARY_TESTS
+
+
+@pytest.mark.parametrize("test", pytest_params(TOINT_DOUBLE_TESTS))
+def test_toInt_double(collection, test: ExpressionTestCase):
+    """$toInt truncates doubles toward zero; rejects NaN, infinity, and out-of-range values."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_field_ref.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_field_ref.py
new file mode 100644
index 000000000..427e9f12d
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_field_ref.py
@@ -0,0 +1,134 @@
+"""$toInt field reference and expression-as-input tests."""
+
+import pytest
+from bson import Binary, Decimal128, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+    execute_expression_with_insert,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+
+# Property [Field Reference]: $toInt resolves field paths and nested dot-notation paths;
+# missing fields and missing nested fields return null.
+TOINT_FIELD_REF_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int_field",
+        msg="int32 field passes through unchanged",
+        expression={"$toInt": "$v"},
+        doc={"v": 42},
+        expected=42,
+    ),
+    ExpressionTestCase(
+        "int64_field",
+        msg="int64 field (within int32 range) converts to int32",
+        expression={"$toInt": "$v"},
+        doc={"v": Int64(99)},
+        expected=99,
+    ),
+    ExpressionTestCase(
+        "double_field",
+        msg="double field is truncated toward zero",
+        expression={"$toInt": "$v"},
+        doc={"v": 3.7},
+        expected=3,
+    ),
+    ExpressionTestCase(
+        "string_field",
+        msg="numeric string field converts to int32",
+        expression={"$toInt": "$v"},
+        doc={"v": "42"},
+        expected=42,
+    ),
+    ExpressionTestCase(
+        "bool_field",
+        msg="bool field converts to int32",
+        expression={"$toInt": "$v"},
+        doc={"v": True},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "decimal128_field",
+        msg="Decimal128 field converts to int32 (truncated)",
+        expression={"$toInt": "$v"},
+        doc={"v": Decimal128("7.9")},
+        expected=7,
+    ),
+    ExpressionTestCase(
+        "binary_field",
+        msg="4-byte binary field converts to int32",
+        expression={"$toInt": "$v"},
+        doc={"v": Binary(b"\x2a\x00\x00\x00", 0)},
+        expected=42,
+    ),
+    ExpressionTestCase(
+        "nested_field",
+        msg="nested field path converts to int32",
+        expression={"$toInt": "$doc.v"},
+        doc={"doc": {"v": 100}},
+        expected=100,
+    ),
+    ExpressionTestCase(
+        "missing_nested",
+        msg="missing nested field returns null",
+        expression={"$toInt": "$doc.missing"},
+        doc={"doc": {"x": 1}},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "missing_field",
+        msg="missing top-level field returns null",
+        expression={"$toInt": "$v"},
+        doc={},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "composite_array_path",
+        msg="$toInt fails when field path resolves to a composite array",
+        expression={"$toInt": "$a.b"},
+        doc={"a": [{"b": 1}, {"b": 2}]},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+
+# Property [Expression Input]: $toInt evaluates a nested expression before converting.
+TOINT_EXPRESSION_INPUT_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "add",
+        msg="$toInt converts an arithmetic expression result",
+        expression={"$toInt": {"$add": [10, 20]}},
+        expected=30,
+    ),
+    ExpressionTestCase(
+        "concat",
+        msg="$toInt converts a string concatenation expression result",
+        expression={"$toInt": {"$concat": ["3", "0"]}},
+        expected=30,
+    ),
+    ExpressionTestCase(
+        "nested_conversion",
+        msg="$toInt converts a nested type-conversion expression result",
+        expression={"$toInt": {"$toDecimal": 42}},
+        expected=42,
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TOINT_FIELD_REF_TESTS + TOINT_EXPRESSION_INPUT_TESTS)
+)
+def test_toInt_field_ref(collection, test: ExpressionTestCase):
+    """$toInt resolves field paths and nested paths from inserted documents."""
+    if test.doc is not None:
+        result = execute_expression_with_insert(collection, test.expression, test.doc)
+    else:
+        result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_numeric.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_numeric.py
new file mode 100644
index 000000000..ebb8aee4c
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_numeric.py
@@ -0,0 +1,151 @@
+"""$toInt numeric type tests: null/missing, boolean, int32 identity, and int64 conversion."""
+
+import pytest
+from bson import Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    INT32_MAX,
+    INT32_MIN,
+    INT32_ZERO,
+    INT64_MAX,
+    INT64_MIN,
+    INT64_ZERO,
+    MISSING,
+)
+
+# Property [Null and Missing]: $toInt returns null for null and missing inputs.
+TOINT_NULL_MISSING_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "null", msg="Should return null for null", expression={"$toInt": None}, expected=None
+    ),
+    ExpressionTestCase(
+        "missing",
+        msg="Should return null for missing",
+        expression={"$toInt": MISSING},
+        expected=None,
+    ),
+]
+
+# Property [Boolean]: $toInt converts true to 1 and false to 0.
+TOINT_BOOL_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "bool_true", msg="True converts to 1", expression={"$toInt": True}, expected=1
+    ),
+    ExpressionTestCase(
+        "bool_false", msg="False converts to 0", expression={"$toInt": False}, expected=INT32_ZERO
+    ),
+]
+
+# Property [Int32 Identity]: $toInt is the identity function for int32 inputs.
+TOINT_INT32_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int32_zero",
+        msg="int32 zero passes through unchanged",
+        expression={"$toInt": INT32_ZERO},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "int32_one",
+        msg="int32 1 passes through unchanged",
+        expression={"$toInt": 1},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "int32_neg_one",
+        msg="int32 -1 passes through unchanged",
+        expression={"$toInt": -1},
+        expected=-1,
+    ),
+    ExpressionTestCase(
+        "int32_max",
+        msg="int32 max passes through unchanged",
+        expression={"$toInt": INT32_MAX},
+        expected=INT32_MAX,
+    ),
+    ExpressionTestCase(
+        "int32_min",
+        msg="int32 min passes through unchanged",
+        expression={"$toInt": INT32_MIN},
+        expected=INT32_MIN,
+    ),
+]
+
+# Property [Int64]: $toInt converts int64 values within int32 range; rejects out-of-range values.
+TOINT_INT64_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int64_zero",
+        msg="int64 zero converts to int32 0",
+        expression={"$toInt": INT64_ZERO},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "int64_one",
+        msg="int64 1 converts to int32 1",
+        expression={"$toInt": Int64(1)},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "int64_neg_one",
+        msg="int64 -1 converts to int32 -1",
+        expression={"$toInt": Int64(-1)},
+        expected=-1,
+    ),
+    ExpressionTestCase(
+        "int64_int32_max",
+        msg="int64 equal to int32 max converts exactly",
+        expression={"$toInt": Int64(INT32_MAX)},
+        expected=INT32_MAX,
+    ),
+    ExpressionTestCase(
+        "int64_int32_min",
+        msg="int64 equal to int32 min converts exactly",
+        expression={"$toInt": Int64(INT32_MIN)},
+        expected=INT32_MIN,
+    ),
+    ExpressionTestCase(
+        "int64_overflow",
+        msg="int64 one above int32 max is a conversion failure",
+        expression={"$toInt": Int64(INT32_MAX + 1)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "int64_underflow",
+        msg="int64 one below int32 min is a conversion failure",
+        expression={"$toInt": Int64(INT32_MIN - 1)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "int64_max",
+        msg="int64 max is a conversion failure",
+        expression={"$toInt": INT64_MAX},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "int64_min",
+        msg="int64 min is a conversion failure",
+        expression={"$toInt": INT64_MIN},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TOINT_NUMERIC_TESTS = (
+    TOINT_NULL_MISSING_TESTS + TOINT_BOOL_TESTS + TOINT_INT32_TESTS + TOINT_INT64_TESTS
+)
+
+
+@pytest.mark.parametrize("test", pytest_params(TOINT_NUMERIC_TESTS))
+def test_toInt_numeric(collection, test: ExpressionTestCase):
+    """$toInt converts null, bool, int32, and int64 inputs."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_return_type.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_return_type.py
new file mode 100644
index 000000000..398c2e946
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_return_type.py
@@ -0,0 +1,126 @@
+"""$toInt return-type invariant and idempotency tests."""
+
+import pytest
+from bson import Binary, Decimal128, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.bson_type_validator import (
+    BsonType,
+    BsonTypeTestCase,
+    generate_bson_acceptance_test_cases,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import MISSING
+
+# Property [Return Type]: $toInt always returns BSON type int for successful conversions
+# and null for null or missing inputs.
+RETURN_TYPE_INT_SPEC = [
+    BsonTypeTestCase(
+        id="toInt_return_type",
+        msg="$toInt always returns BSON type int for a successful conversion",
+        valid_types=[
+            BsonType.BOOL,
+            BsonType.INT,
+            BsonType.LONG,
+            BsonType.DOUBLE,
+            BsonType.DECIMAL,
+            BsonType.STRING,
+            BsonType.BIN_DATA,
+        ],
+        valid_inputs={
+            BsonType.LONG: Int64(42),
+            BsonType.STRING: "42",
+            BsonType.BIN_DATA: Binary(b"\x2a\x00\x00\x00", 0),
+        },
+    ),
+]
+
+RETURN_TYPE_INT_CASES = generate_bson_acceptance_test_cases(RETURN_TYPE_INT_SPEC)
+
+
+@pytest.mark.parametrize("bson_type,sample_value,spec", RETURN_TYPE_INT_CASES)
+def test_toInt_return_type_is_int(collection, bson_type, sample_value, spec):
+    """$toInt always returns BSON type 'int' for a successful conversion."""
+    result = execute_expression(collection, {"$type": {"$toInt": sample_value}})
+    assert_expression_result(result, expected="int", msg=f"{spec.msg} ({bson_type.value} input)")
+
+
+# Property [Return Type — Null]: $toInt returns BSON type null for null or missing inputs.
+TOINT_RETURN_TYPE_NULL_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "null",
+        msg="$toInt of null returns null type",
+        expression={"$type": {"$toInt": None}},
+        expected="null",
+    ),
+    ExpressionTestCase(
+        "missing",
+        msg="$toInt of missing returns null type",
+        expression={"$type": {"$toInt": MISSING}},
+        expected="null",
+    ),
+]
+
+
+# Property [Idempotency]: applying $toInt twice produces the same result as applying it once.
+TOINT_IDEMPOTENCY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "idempotent_bool",
+        msg="$toInt is idempotent for bool",
+        expression={"$toInt": {"$toInt": True}},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "idempotent_int32",
+        msg="$toInt is idempotent for int32",
+        expression={"$toInt": {"$toInt": 42}},
+        expected=42,
+    ),
+    ExpressionTestCase(
+        "idempotent_int64",
+        msg="$toInt is idempotent for int64 (within int32 range)",
+        expression={"$toInt": {"$toInt": Int64(99)}},
+        expected=99,
+    ),
+    ExpressionTestCase(
+        "idempotent_double",
+        msg="$toInt is idempotent for double (truncated first pass)",
+        expression={"$toInt": {"$toInt": 3.14}},
+        expected=3,
+    ),
+    ExpressionTestCase(
+        "idempotent_decimal128",
+        msg="$toInt is idempotent for Decimal128",
+        expression={"$toInt": {"$toInt": Decimal128("7")}},
+        expected=7,
+    ),
+    ExpressionTestCase(
+        "idempotent_string",
+        msg="$toInt is idempotent for numeric string",
+        expression={"$toInt": {"$toInt": "123"}},
+        expected=123,
+    ),
+    ExpressionTestCase(
+        "idempotent_binary",
+        msg="$toInt is idempotent for 4-byte binary",
+        expression={"$toInt": {"$toInt": Binary(b"\x2a\x00\x00\x00", 0)}},
+        expected=42,
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TOINT_RETURN_TYPE_NULL_TESTS + TOINT_IDEMPOTENCY_TESTS)
+)
+def test_toInt_return_type_null(collection, test: ExpressionTestCase):
+    """$toInt returns BSON type 'null' for null or missing input."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_string.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_string.py
new file mode 100644
index 000000000..ef7bc888b
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toInt/test_toInt_string.py
@@ -0,0 +1,473 @@
+"""$toInt string conversion tests: valid base-10 integers and rejection of invalid strings."""
+
+import pytest
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR, STRING_SIZE_LIMIT_ERROR
+from documentdb_tests.framework.lazy_payload import lazy
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    INT32_MAX,
+    INT32_MIN,
+    INT32_ZERO,
+    STRING_SIZE_LIMIT_BYTES,
+)
+
+# Property [String Conversion]: a base-10 integer string within int32 range converts to the
+# corresponding int32 value; leading zeros, a leading '+', and a leading '-' are accepted.
+TOINT_STRING_VALID_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "str_zero",
+        msg="'0' converts to 0",
+        expression={"$toInt": "0"},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_positive",
+        msg="'42' converts to 42",
+        expression={"$toInt": "42"},
+        expected=42,
+    ),
+    ExpressionTestCase(
+        "str_negative",
+        msg="'-2' converts to -2",
+        expression={"$toInt": "-2"},
+        expected=-2,
+    ),
+    ExpressionTestCase(
+        "str_plus_sign",
+        msg="'+1' accepts leading + sign",
+        expression={"$toInt": "+1"},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "str_leading_zeros",
+        msg="'007' strips leading zeros",
+        expression={"$toInt": "007"},
+        expected=7,
+    ),
+    ExpressionTestCase(
+        "str_plus_leading_zeros",
+        msg="'+0042' accepts + sign with leading zeros",
+        expression={"$toInt": "+0042"},
+        expected=42,
+    ),
+    ExpressionTestCase(
+        "str_minus_leading_zeros",
+        msg="'-0042' accepts - sign with leading zeros",
+        expression={"$toInt": "-0042"},
+        expected=-42,
+    ),
+    ExpressionTestCase(
+        "str_thousands_leading_zeros",
+        msg="Thousands of leading zeros with trailing '1' converts to 1",
+        expression={"$toInt": "0" * 10_000 + "1"},
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "str_minus_zero",
+        msg="'-0' converts to 0",
+        expression={"$toInt": "-0"},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_plus_zero",
+        msg="'+0' converts to 0",
+        expression={"$toInt": "+0"},
+        expected=INT32_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_int32_max",
+        msg="'2147483647' (int32 max as string) converts exactly",
+        expression={"$toInt": "2147483647"},
+        expected=INT32_MAX,
+    ),
+    ExpressionTestCase(
+        "str_int32_min",
+        msg="'-2147483648' (int32 min as string) converts exactly",
+        expression={"$toInt": "-2147483648"},
+        expected=INT32_MIN,
+    ),
+]
+
+# Property [String Errors]: strings that are not valid base-10 integers within int32 range
+# produce a conversion failure.
+TOINT_STRING_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "str_err_empty",
+        msg="Empty string is a conversion failure",
+        expression={"$toInt": ""},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_alpha",
+        msg="Alphabetic string is a conversion failure",
+        expression={"$toInt": "a"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_decimal_point",
+        msg="'3.14' (decimal point) is a conversion failure",
+        expression={"$toInt": "3.14"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_decimal_zero_fraction",
+        msg="'1.0' (fractional part is zero) is still a conversion failure",
+        expression={"$toInt": "1.0"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_trailing_dot",
+        msg="'1.' (trailing dot) is a conversion failure",
+        expression={"$toInt": "1."},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_leading_dot",
+        msg="'.1' (leading dot) is a conversion failure",
+        expression={"$toInt": ".1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_sci_lower",
+        msg="'1e2' (scientific notation lowercase) is a conversion failure",
+        expression={"$toInt": "1e2"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_sci_upper",
+        msg="'1E2' (scientific notation uppercase) is a conversion failure",
+        expression={"$toInt": "1E2"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_hex_lower",
+        msg="'0x0' (lowercase hex prefix) is a conversion failure",
+        expression={"$toInt": "0x0"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_hex_upper",
+        msg="'0X0' (uppercase hex prefix) is a conversion failure",
+        expression={"$toInt": "0X0"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_nan",
+        msg="'NaN' is a conversion failure",
+        expression={"$toInt": "NaN"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_infinity",
+        msg="'Infinity' is a conversion failure",
+        expression={"$toInt": "Infinity"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_inf",
+        msg="'inf' is a conversion failure",
+        expression={"$toInt": "inf"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_true",
+        msg="'true' is a conversion failure",
+        expression={"$toInt": "true"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_false",
+        msg="'false' is a conversion failure",
+        expression={"$toInt": "false"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_null_word",
+        msg="'null' is a conversion failure",
+        expression={"$toInt": "null"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_leading_space",
+        msg="Leading whitespace is a conversion failure",
+        expression={"$toInt": " 1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_trailing_space",
+        msg="Trailing whitespace is a conversion failure",
+        expression={"$toInt": "1 "},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_embedded_space",
+        msg="Embedded whitespace is a conversion failure",
+        expression={"$toInt": "1 2"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_tab",
+        msg="Tab character is a conversion failure",
+        expression={"$toInt": "\t1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_newline",
+        msg="Newline character is a conversion failure",
+        expression={"$toInt": "1\n"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_carriage_return",
+        msg="Carriage return character is a conversion failure",
+        expression={"$toInt": "1\r"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_nbsp",
+        msg="U+00A0 NBSP character is a conversion failure",
+        expression={"$toInt": "\u00a01"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_en_space",
+        msg="U+2000 EN SPACE character is a conversion failure",
+        expression={"$toInt": "\u20001"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_em_space",
+        msg="U+2003 EM SPACE character is a conversion failure",
+        expression={"$toInt": "\u20031"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_bom",
+        msg="U+FEFF BOM character is a conversion failure",
+        expression={"$toInt": "\ufeff1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_zwsp",
+        msg="U+200B ZWSP character is a conversion failure",
+        expression={"$toInt": "\u200b1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_zwj",
+        msg="U+200D ZWJ character is a conversion failure",
+        expression={"$toInt": "\u200d1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_ltr_mark",
+        msg="U+200E LTR mark character is a conversion failure",
+        expression={"$toInt": "\u200e1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_rtl_mark",
+        msg="U+200F RTL mark character is a conversion failure",
+        expression={"$toInt": "\u200f1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_fullwidth_digit",
+        msg="U+FF11 fullwidth digit one is a conversion failure",
+        expression={"$toInt": "\uff11"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_arabic_indic_digit",
+        msg="U+0661 Arabic-Indic digit one is a conversion failure",
+        expression={"$toInt": "\u0661"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_superscript_digit",
+        msg="U+00B2 superscript two is a conversion failure",
+        expression={"$toInt": "\u00b2"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_null_byte",
+        msg="String with null byte is a conversion failure",
+        expression={"$toInt": "\x001"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_control_char",
+        msg="String with control character is a conversion failure",
+        expression={"$toInt": "\x011"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_special_chars",
+        msg="String with special characters is a conversion failure",
+        expression={"$toInt": "!@#$%^&*()"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_backslash",
+        msg="String with backslash is a conversion failure",
+        expression={"$toInt": "\\1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_braces",
+        msg="String with braces is a conversion failure",
+        expression={"$toInt": "{1}"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_brackets",
+        msg="String with brackets is a conversion failure",
+        expression={"$toInt": "[1]"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_quotes",
+        msg="String with quotes ('\"') is a conversion failure",
+        expression={"$toInt": '"1"'},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_sign_only_plus",
+        msg="Sign-only string '+' is a conversion failure",
+        expression={"$toInt": "+"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_sign_only_minus",
+        msg="Sign-only string '-' is a conversion failure",
+        expression={"$toInt": "-"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_double_minus",
+        msg="Double-sign string '--1' is a conversion failure",
+        expression={"$toInt": "--1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_double_plus",
+        msg="Double-sign string '++1' is a conversion failure",
+        expression={"$toInt": "++1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_mixed_signs",
+        msg="Mixed-sign string '+-1' is a conversion failure",
+        expression={"$toInt": "+-1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_comma_separator",
+        msg="String with comma separator '1,000' is a conversion failure",
+        expression={"$toInt": "1,000"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_underscore_separator",
+        msg="String with underscore separator '1_000' is a conversion failure",
+        expression={"$toInt": "1_000"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_overflow_above_max",
+        msg="'2147483648' (one above int32 max) is a conversion failure",
+        expression={"$toInt": "2147483648"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_overflow_below_min",
+        msg="'-2147483649' (one below int32 min) is a conversion failure",
+        expression={"$toInt": "-2147483649"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_overflow_very_large",
+        msg="Very large numeric string is a conversion failure",
+        expression={"$toInt": "9" * 100},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_zwj_emoji",
+        msg="ZWJ emoji sequence is a conversion failure",
+        expression={"$toInt": "\U0001f468\u200d\U0001f469\u200d\U0001f467"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_literal_dollar_number",
+        msg="'$42' passed via $literal is a conversion failure",
+        expression={"$toInt": {"$literal": "$42"}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_literal_double_dollar_number",
+        msg="'$$42' passed via $literal is a conversion failure",
+        expression={"$toInt": {"$literal": "$$42"}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_literal_dollar_only",
+        msg="'$' passed via $literal is a conversion failure",
+        expression={"$toInt": {"$literal": "$"}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_literal_double_dollar_only",
+        msg="'$$' passed via $literal is a conversion failure",
+        expression={"$toInt": {"$literal": "$$"}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TOINT_STRING_TESTS = TOINT_STRING_VALID_TESTS + TOINT_STRING_ERROR_TESTS
+
+
+# Property [String Size Limit]: $toInt checks the byte length of string inputs before
+# attempting conversion; strings at or above the limit are rejected unconditionally.
+TOINT_STRING_SIZE_LIMIT_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "size_one_under_valid",
+        msg="Valid integer string one byte under limit converts successfully",
+        expression=lazy(lambda: {"$toInt": "0" * (STRING_SIZE_LIMIT_BYTES - 2) + "1"}),
+        expected=1,
+    ),
+    ExpressionTestCase(
+        "size_one_under_non_numeric",
+        msg="Non-numeric string one byte under limit passes size check but fails conversion",
+        expression=lazy(lambda: {"$toInt": "a" * (STRING_SIZE_LIMIT_BYTES - 1)}),
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "size_at_limit",
+        msg="String at STRING_SIZE_LIMIT_BYTES is rejected with STRING_SIZE_LIMIT_ERROR",
+        expression=lazy(lambda: {"$toInt": "a" * STRING_SIZE_LIMIT_BYTES}),
+        error_code=STRING_SIZE_LIMIT_ERROR,
+    ),
+    ExpressionTestCase(
+        "size_at_limit_four_byte",
+        msg="4-byte character string reaching STRING_SIZE_LIMIT_BYTES is rejected",
+        expression=lazy(lambda: {"$toInt": "\U0001f600" * (STRING_SIZE_LIMIT_BYTES // 4)}),
+        error_code=STRING_SIZE_LIMIT_ERROR,
+    ),
+]
+
+
+@pytest.mark.parametrize("test", pytest_params(TOINT_STRING_TESTS + TOINT_STRING_SIZE_LIMIT_TESTS))
+def test_toInt_string(collection, test: ExpressionTestCase):
+    """$toInt parses valid base-10 integer strings and rejects malformed or out-of-range ones."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/__init__.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_arity.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_arity.py
new file mode 100644
index 000000000..88f42b789
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_arity.py
@@ -0,0 +1,80 @@
+"""$toLong arity and field path syntax tests."""
+
+import pytest
+from bson import Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import (
+    FAILED_TO_PARSE_ERROR,
+    INVALID_DOLLAR_FIELD_PATH,
+    TO_TYPE_ARITY_ERROR,
+)
+from documentdb_tests.framework.parametrize import pytest_params
+
+# Property [Arity]: $toLong unwraps single-element literal arrays and rejects empty or
+# multi-element arrays. These cases are specific to $toLong syntax (not $convert).
+TOLONG_ARITY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "single_element",
+        msg="Single-element literal array argument is unwrapped to a scalar",
+        expression={"$toLong": [42]},
+        expected=Int64(42),
+    ),
+    ExpressionTestCase(
+        "empty_array",
+        msg="Empty literal array argument is an arity error",
+        expression={"$toLong": []},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+    ExpressionTestCase(
+        "multi_element",
+        msg="Multi-element literal array argument is an arity error",
+        expression={"$toLong": [1, 2]},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+    ExpressionTestCase(
+        "single_null",
+        msg="Single-element literal array wrapping null unwraps and returns null",
+        expression={"$toLong": [None]},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "large_array",
+        msg="A large literal array argument is an arity error",
+        expression={"$toLong": list(range(100))},
+        error_code=TO_TYPE_ARITY_ERROR,
+    ),
+]
+
+# Property [Invalid Field Path]: $toLong rejects malformed field path syntax.
+TOLONG_INVALID_FIELD_PATH_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "bare_dollar",
+        msg="Bare '$' is an invalid field path",
+        expression={"$toLong": "$"},
+        error_code=INVALID_DOLLAR_FIELD_PATH,
+    ),
+    ExpressionTestCase(
+        "double_dollar",
+        msg="'$$' is rejected as an empty variable name",
+        expression={"$toLong": "$$"},
+        error_code=FAILED_TO_PARSE_ERROR,
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TOLONG_ARITY_TESTS + TOLONG_INVALID_FIELD_PATH_TESTS)
+)
+def test_toLong_arity(collection, test: ExpressionTestCase):
+    """$toLong literal array arguments are unwrapped or rejected based on arity."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_datetime_binary.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_datetime_binary.py
new file mode 100644
index 000000000..92335059e
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_datetime_binary.py
@@ -0,0 +1,237 @@
+"""$toLong datetime and binary conversion tests, and unsupported BSON type errors."""
+
+from datetime import datetime, timezone
+
+import pytest
+from bson import Binary, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    INT32_MAX,
+    INT32_MIN,
+    INT64_MAX,
+    INT64_MIN,
+    INT64_ZERO,
+)
+
+# Property [Datetime]: $toLong converts datetime to milliseconds since Unix epoch as Int64.
+TOLONG_DATETIME_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "datetime_epoch",
+        msg="Epoch datetime converts to Int64(0)",
+        expression={"$toLong": datetime(1970, 1, 1, tzinfo=timezone.utc)},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "datetime_1ms_after_epoch",
+        msg="1ms after epoch converts to Int64(1)",
+        expression={"$toLong": datetime(1970, 1, 1, 0, 0, 0, 1000, tzinfo=timezone.utc)},
+        expected=Int64(1),
+    ),
+    ExpressionTestCase(
+        "datetime_1ms_before_epoch",
+        msg="1ms before epoch converts to Int64(-1)",
+        expression={"$toLong": datetime(1969, 12, 31, 23, 59, 59, 999000, tzinfo=timezone.utc)},
+        expected=Int64(-1),
+    ),
+    ExpressionTestCase(
+        "datetime_pre_epoch",
+        msg="Pre-epoch datetime produces negative milliseconds",
+        expression={"$toLong": datetime(1969, 12, 31, 23, 59, 59, tzinfo=timezone.utc)},
+        expected=Int64(-1000),
+    ),
+    ExpressionTestCase(
+        "datetime_with_ms",
+        msg="Modern datetime preserves millisecond precision",
+        expression={"$toLong": datetime(2024, 6, 15, 12, 30, 45, 123000, tzinfo=timezone.utc)},
+        expected=Int64(1_718_454_645_123),
+    ),
+    ExpressionTestCase(
+        "datetime_far_future",
+        msg="Far-future datetime converts correctly",
+        expression={"$toLong": datetime(9999, 12, 31, 23, 59, 59, 999000, tzinfo=timezone.utc)},
+        expected=Int64(253_402_300_799_999),
+    ),
+    ExpressionTestCase(
+        "datetime_far_past",
+        msg="Far-past datetime converts correctly",
+        expression={"$toLong": datetime(1, 1, 1, 0, 0, 0, tzinfo=timezone.utc)},
+        expected=Int64(-62_135_596_800_000),
+    ),
+]
+
+# Property [Binary Conversion]: Binary values of exactly 1, 2, 4, or 8 bytes are
+# interpreted as signed little-endian integers.
+TOLONG_BINARY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "binary_1byte_zero",
+        msg="1-byte Binary 0x00 converts to Int64(0)",
+        expression={"$toLong": Binary(b"\x00")},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "binary_1byte_max",
+        msg="1-byte Binary 0x7F converts to Int64(127)",
+        expression={"$toLong": Binary(b"\x7f")},
+        expected=Int64(127),
+    ),
+    ExpressionTestCase(
+        "binary_1byte_min",
+        msg="1-byte Binary 0x80 converts to Int64(-128)",
+        expression={"$toLong": Binary(b"\x80")},
+        expected=Int64(-128),
+    ),
+    ExpressionTestCase(
+        "binary_1byte_neg_one",
+        msg="1-byte Binary 0xFF converts to Int64(-1)",
+        expression={"$toLong": Binary(b"\xff")},
+        expected=Int64(-1),
+    ),
+    ExpressionTestCase(
+        "binary_2byte_max",
+        msg="2-byte Binary converts to int16 max (Int64(32767))",
+        expression={"$toLong": Binary(b"\xff\x7f")},
+        expected=Int64(32767),
+    ),
+    ExpressionTestCase(
+        "binary_2byte_min",
+        msg="2-byte Binary converts to int16 min (Int64(-32768))",
+        expression={"$toLong": Binary(b"\x00\x80")},
+        expected=Int64(-32768),
+    ),
+    ExpressionTestCase(
+        "binary_4byte_max",
+        msg="4-byte Binary converts to int32 max",
+        expression={"$toLong": Binary(b"\xff\xff\xff\x7f")},
+        expected=Int64(INT32_MAX),
+    ),
+    ExpressionTestCase(
+        "binary_4byte_min",
+        msg="4-byte Binary converts to int32 min",
+        expression={"$toLong": Binary(b"\x00\x00\x00\x80")},
+        expected=Int64(INT32_MIN),
+    ),
+    ExpressionTestCase(
+        "binary_8byte_max",
+        msg="8-byte Binary converts to int64 max",
+        expression={"$toLong": Binary(b"\xff\xff\xff\xff\xff\xff\xff\x7f")},
+        expected=INT64_MAX,
+    ),
+    ExpressionTestCase(
+        "binary_8byte_min",
+        msg="8-byte Binary converts to int64 min",
+        expression={"$toLong": Binary(b"\x00\x00\x00\x00\x00\x00\x00\x80")},
+        expected=INT64_MIN,
+    ),
+    ExpressionTestCase(
+        "binary_8byte_zero",
+        msg="8-byte all-zeros Binary converts to Int64(0)",
+        expression={"$toLong": Binary(b"\x00\x00\x00\x00\x00\x00\x00\x00")},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "binary_subtype_2_empty_payload",
+        msg="Subtype 2 empty payload (4-byte header only) converts to Int64(0)",
+        expression={"$toLong": Binary(b"", 2)},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "binary_subtype_3",
+        msg="Binary subtype 3 converts by payload length (1 byte)",
+        expression={"$toLong": Binary(b"\x7f", 3)},
+        expected=Int64(127),
+    ),
+]
+
+# Property [Binary Conversion Errors]: Binary values of sizes other than 1, 2, 4, or 8 bytes
+# produce a conversion error.
+TOLONG_BINARY_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "binary_err_0byte",
+        msg="0-byte Binary is a conversion failure",
+        expression={"$toLong": Binary(b"", 0)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_err_3byte",
+        msg="3-byte Binary is a conversion failure",
+        expression={"$toLong": Binary(b"\x01\x02\x03")},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_err_5byte",
+        msg="5-byte Binary is a conversion failure",
+        expression={"$toLong": Binary(b"\x01" * 5)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_err_9byte",
+        msg="9-byte Binary is a conversion failure",
+        expression={"$toLong": Binary(b"\x01" * 9)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_err_uuid_subtype",
+        msg="UUID subtype Binary (16 bytes) is a conversion failure",
+        expression={"$toLong": Binary(b"\x01" * 16, 4)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "binary_err_subtype_2",
+        msg="Binary subtype 2 (old binary) with 1-byte payload is a conversion failure (5-byte wire length)",  # noqa: E501
+        expression={"$toLong": Binary(b"\x7f", 2)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+# Property [Unsupported Types — literal-wrapped]: OBJECT and ARRAY must be wrapped in
+# $literal to prevent MongoDB from interpreting them as expression syntax. The remaining
+# unsupported BSON types (ObjectId, Regex, Timestamp, Code, MinKey, MaxKey) are covered
+# by generate_bson_rejection_test_cases() in test_toLong_return_type.py.
+#
+# The nested-array case wraps its value in $literal so the outer single-element array
+# can be unwrapped by the arity rule, leaving the inner array as the actual argument.
+TOLONG_UNSUPPORTED_TYPE_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "type_object",
+        msg="Object BSON type is a conversion failure",
+        expression={"$toLong": {"$literal": {"key": "val"}}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_array",
+        msg="Array value (from $literal) is a conversion failure",
+        expression={"$toLong": {"$literal": [1, 2]}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "type_nested_array",
+        msg="Outer single-element array unwraps at parse time; inner array arg is a conversion failure",  # noqa: E501
+        expression={"$toLong": [["42"]]},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TOLONG_DATETIME_BINARY_TESTS = (
+    TOLONG_DATETIME_TESTS
+    + TOLONG_BINARY_TESTS
+    + TOLONG_BINARY_ERROR_TESTS
+    + TOLONG_UNSUPPORTED_TYPE_TESTS
+)
+
+
+@pytest.mark.parametrize("test", pytest_params(TOLONG_DATETIME_BINARY_TESTS))
+def test_toLong_datetime_binary(collection, test: ExpressionTestCase):
+    """$toLong converts datetime and binary inputs; rejects unsupported BSON types."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_decimal128.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_decimal128.py
new file mode 100644
index 000000000..f47954c84
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_decimal128.py
@@ -0,0 +1,174 @@
+"""$toLong Decimal128 conversion tests: zeros, truncation, boundary values, and overflow."""
+
+import pytest
+from bson import Decimal128, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DECIMAL128_INFINITY,
+    DECIMAL128_INT64_MAX,
+    DECIMAL128_INT64_OVERFLOW,
+    DECIMAL128_INT64_UNDERFLOW,
+    DECIMAL128_LARGE_EXPONENT,
+    DECIMAL128_MAX,
+    DECIMAL128_MAX_NEGATIVE,
+    DECIMAL128_MIN,
+    DECIMAL128_MIN_POSITIVE,
+    DECIMAL128_NAN,
+    DECIMAL128_NEGATIVE_INFINITY,
+    DECIMAL128_NEGATIVE_ZERO,
+    DECIMAL128_SMALL_EXPONENT,
+    INT64_MAX,
+    INT64_MIN,
+    INT64_ZERO,
+)
+
+# Property [Decimal128 Conversion]: whole-number Decimal128 values convert exactly,
+# fractional values are truncated toward zero, and boundary values at the edges of
+# int64 range are accepted.
+TOLONG_DECIMAL128_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "decimal_whole",
+        msg="Whole-number Decimal128 converts to Int64",
+        expression={"$toLong": Decimal128("7")},
+        expected=Int64(7),
+    ),
+    ExpressionTestCase(
+        "decimal_truncate_positive",
+        msg="Positive fractional Decimal128 is truncated toward zero",
+        expression={"$toLong": Decimal128("5.5000")},
+        expected=Int64(5),
+    ),
+    ExpressionTestCase(
+        "decimal_truncate_negative",
+        msg="Negative fractional Decimal128 is truncated toward zero",
+        expression={"$toLong": Decimal128("-3.9")},
+        expected=Int64(-3),
+    ),
+    ExpressionTestCase(
+        "decimal_negative_zero",
+        msg="Decimal128 negative zero converts to Int64(0)",
+        expression={"$toLong": DECIMAL128_NEGATIVE_ZERO},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "decimal_trailing_zeros",
+        msg="Decimal128 trailing zeros are ignored",
+        expression={"$toLong": Decimal128("1.000000000")},
+        expected=Int64(1),
+    ),
+    ExpressionTestCase(
+        "decimal_tiny_small_exponent",
+        msg="Tiny Decimal128 (1E-6143) is truncated to Int64(0)",
+        expression={"$toLong": DECIMAL128_SMALL_EXPONENT},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "decimal_tiny_min_positive",
+        msg="Tiny Decimal128 (1E-6176) is truncated to Int64(0)",
+        expression={"$toLong": DECIMAL128_MIN_POSITIVE},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "decimal_tiny_max_negative",
+        msg="Tiny negative Decimal128 (-1E-6176) is truncated to Int64(0)",
+        expression={"$toLong": DECIMAL128_MAX_NEGATIVE},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "decimal_int64_max",
+        msg="Exact int64 max as Decimal128 converts to Int64 max",
+        expression={"$toLong": DECIMAL128_INT64_MAX},
+        expected=INT64_MAX,
+    ),
+    ExpressionTestCase(
+        "decimal_int64_min",
+        msg="Exact int64 min as Decimal128 converts to Int64 min",
+        expression={"$toLong": Decimal128("-9223372036854775808")},
+        expected=INT64_MIN,
+    ),
+    ExpressionTestCase(
+        "decimal_just_below_max_plus_one",
+        msg="Decimal128 just below int64 max + 1 truncates to Int64 max",
+        expression={"$toLong": Decimal128("9223372036854775807.999")},
+        expected=INT64_MAX,
+    ),
+    ExpressionTestCase(
+        "decimal_just_below_min",
+        msg="Decimal128 just below int64 min truncates to Int64 min",
+        expression={"$toLong": Decimal128("-9223372036854775808.999")},
+        expected=INT64_MIN,
+    ),
+]
+
+# Property [Decimal128 Conversion Errors]: Decimal128 NaN, infinities, and values outside
+# int64 range produce a conversion error.
+TOLONG_DECIMAL128_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "decimal_err_nan",
+        msg="Decimal128 NaN is a conversion failure",
+        expression={"$toLong": DECIMAL128_NAN},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "decimal_err_pos_infinity",
+        msg="Decimal128 Infinity is a conversion failure",
+        expression={"$toLong": DECIMAL128_INFINITY},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "decimal_err_neg_infinity",
+        msg="Decimal128 -Infinity is a conversion failure",
+        expression={"$toLong": DECIMAL128_NEGATIVE_INFINITY},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "decimal_err_overflow_above_max",
+        msg="Decimal128 one above int64 max is a conversion failure",
+        expression={"$toLong": DECIMAL128_INT64_OVERFLOW},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "decimal_err_overflow_below_min",
+        msg="Decimal128 one below int64 min is a conversion failure",
+        expression={"$toLong": DECIMAL128_INT64_UNDERFLOW},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "decimal_err_large_exponent",
+        msg="Decimal128 with large exponent is a conversion failure",
+        expression={"$toLong": DECIMAL128_LARGE_EXPONENT},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "decimal_err_max_value",
+        msg="Decimal128 max value is a conversion failure",
+        expression={"$toLong": DECIMAL128_MAX},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "decimal_err_min_value",
+        msg="Decimal128 min value (negative max) is a conversion failure",
+        expression={"$toLong": DECIMAL128_MIN},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TOLONG_DECIMAL128_TESTS = TOLONG_DECIMAL128_TESTS + TOLONG_DECIMAL128_ERROR_TESTS
+
+
+@pytest.mark.parametrize("test", pytest_params(TOLONG_DECIMAL128_TESTS))
+def test_toLong_decimal128(collection, test: ExpressionTestCase):
+    """$toLong converts Decimal128 values including truncation, boundary values, and overflow."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_field_ref.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_field_ref.py
new file mode 100644
index 000000000..95a96cdbf
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_field_ref.py
@@ -0,0 +1,143 @@
+"""$toLong field reference and expression-as-input tests."""
+
+import pytest
+from bson import Binary, Decimal128, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+    execute_expression_with_insert,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    INT64_MAX,
+)
+
+# Property [Field Reference]: $toLong resolves field paths and nested dot-notation paths;
+# missing fields and missing nested fields return null.
+TOLONG_FIELD_REF_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int32_field",
+        msg="int32 field widens to Int64",
+        expression={"$toLong": "$v"},
+        doc={"v": 42},
+        expected=Int64(42),
+    ),
+    ExpressionTestCase(
+        "int64_field",
+        msg="int64 field passes through unchanged",
+        expression={"$toLong": "$v"},
+        doc={"v": Int64(100)},
+        expected=Int64(100),
+    ),
+    ExpressionTestCase(
+        "double_field",
+        msg="double field is truncated to Int64",
+        expression={"$toLong": "$v"},
+        doc={"v": 7.9},
+        expected=Int64(7),
+    ),
+    ExpressionTestCase(
+        "string_field",
+        msg="numeric string field converts to Int64",
+        expression={"$toLong": "$v"},
+        doc={"v": "99"},
+        expected=Int64(99),
+    ),
+    ExpressionTestCase(
+        "bool_field",
+        msg="bool field converts to Int64",
+        expression={"$toLong": "$v"},
+        doc={"v": True},
+        expected=Int64(1),
+    ),
+    ExpressionTestCase(
+        "decimal_field",
+        msg="Decimal128 field is truncated to Int64",
+        expression={"$toLong": "$v"},
+        doc={"v": Decimal128("5.9")},
+        expected=Int64(5),
+    ),
+    ExpressionTestCase(
+        "binary_field",
+        msg="1-byte binary field converts to Int64",
+        expression={"$toLong": "$v"},
+        doc={"v": Binary(b"\x0a")},
+        expected=Int64(10),
+    ),
+    ExpressionTestCase(
+        "nested_field",
+        msg="nested field path converts to Int64",
+        expression={"$toLong": "$doc.v"},
+        doc={"doc": {"v": 200}},
+        expected=Int64(200),
+    ),
+    ExpressionTestCase(
+        "missing_nested",
+        msg="missing nested field returns null",
+        expression={"$toLong": "$doc.missing"},
+        doc={"doc": {"x": 1}},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "missing_field",
+        msg="missing top-level field returns null",
+        expression={"$toLong": "$v"},
+        doc={},
+        expected=None,
+    ),
+    ExpressionTestCase(
+        "int64_max_field",
+        msg="int64 max field passes through unchanged",
+        expression={"$toLong": "$v"},
+        doc={"v": INT64_MAX},
+        expected=INT64_MAX,
+    ),
+    ExpressionTestCase(
+        "composite_array_path",
+        msg="$toLong fails when field path resolves to a composite array",
+        expression={"$toLong": "$a.b"},
+        doc={"a": [{"b": 1}, {"b": 2}]},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+# Property [Expression Input]: $toLong evaluates a nested expression before converting.
+TOLONG_EXPRESSION_INPUT_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "add",
+        msg="$toLong converts an arithmetic expression result",
+        expression={"$toLong": {"$add": [10, 20]}},
+        expected=Int64(30),
+    ),
+    ExpressionTestCase(
+        "concat",
+        msg="$toLong converts a string concatenation expression result",
+        expression={"$toLong": {"$concat": ["1", "23"]}},
+        expected=Int64(123),
+    ),
+    ExpressionTestCase(
+        "nested_conversion",
+        msg="$toLong converts a nested type-conversion expression result",
+        expression={"$toLong": {"$toDecimal": 42}},
+        expected=Int64(42),
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TOLONG_FIELD_REF_TESTS + TOLONG_EXPRESSION_INPUT_TESTS)
+)
+def test_toLong_field_ref(collection, test: ExpressionTestCase):
+    """$toLong resolves field paths and nested paths from inserted documents."""
+    if test.doc is not None:
+        result = execute_expression_with_insert(collection, test.expression, test.doc)
+    else:
+        result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_numeric.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_numeric.py
new file mode 100644
index 000000000..7f75408db
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_numeric.py
@@ -0,0 +1,272 @@
+"""$toLong numeric type tests: null/missing, boolean, int32, int64 identity, and double."""
+
+import math
+
+import pytest
+from bson import Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    DOUBLE_FROM_INT64_MAX,
+    DOUBLE_HALF,
+    DOUBLE_MAX_FITTING_INT64,
+    DOUBLE_MIN_SUBNORMAL,
+    DOUBLE_NEAR_MAX,
+    DOUBLE_NEAR_MIN,
+    DOUBLE_NEGATIVE_HALF,
+    DOUBLE_NEGATIVE_ZERO,
+    FLOAT_INFINITY,
+    FLOAT_NAN,
+    FLOAT_NEGATIVE_INFINITY,
+    INT32_MAX,
+    INT32_MIN,
+    INT32_ZERO,
+    INT64_FROM_DOUBLE_MAX_FITTING,
+    INT64_MAX,
+    INT64_MAX_MINUS_1,
+    INT64_MIN,
+    INT64_MIN_PLUS_1,
+    INT64_ZERO,
+    MISSING,
+)
+
+# Property [Null and Missing]: $toLong returns null for null and missing inputs.
+TOLONG_NULL_MISSING_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "null", msg="Should return null for null", expression={"$toLong": None}, expected=None
+    ),
+    ExpressionTestCase(
+        "missing",
+        msg="Should return null for missing",
+        expression={"$toLong": MISSING},
+        expected=None,
+    ),
+]
+
+# Property [Boolean]: $toLong converts false to Int64(0) and true to Int64(1).
+TOLONG_BOOL_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "bool_false",
+        msg="False converts to Int64(0)",
+        expression={"$toLong": False},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "bool_true",
+        msg="True converts to Int64(1)",
+        expression={"$toLong": True},
+        expected=Int64(1),
+    ),
+]
+
+# Property [Int32]: $toLong widens int32 values to their exact Int64 equivalents.
+TOLONG_INT32_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int32_zero",
+        msg="int32 zero widens to Int64(0)",
+        expression={"$toLong": INT32_ZERO},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "int32_one",
+        msg="int32 1 widens to Int64(1)",
+        expression={"$toLong": 1},
+        expected=Int64(1),
+    ),
+    ExpressionTestCase(
+        "int32_neg_one",
+        msg="int32 -1 widens to Int64(-1)",
+        expression={"$toLong": -1},
+        expected=Int64(-1),
+    ),
+    ExpressionTestCase(
+        "int32_max",
+        msg="int32 max widens exactly to Int64",
+        expression={"$toLong": INT32_MAX},
+        expected=Int64(INT32_MAX),
+    ),
+    ExpressionTestCase(
+        "int32_min",
+        msg="int32 min widens exactly to Int64",
+        expression={"$toLong": INT32_MIN},
+        expected=Int64(INT32_MIN),
+    ),
+]
+
+# Property [Int64 Identity]: $toLong passes Int64 values through unchanged.
+TOLONG_INT64_IDENTITY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "int64_zero",
+        msg="Int64(0) passes through unchanged",
+        expression={"$toLong": INT64_ZERO},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "int64_max",
+        msg="Int64 max passes through unchanged",
+        expression={"$toLong": INT64_MAX},
+        expected=INT64_MAX,
+    ),
+    ExpressionTestCase(
+        "int64_min",
+        msg="Int64 min passes through unchanged",
+        expression={"$toLong": INT64_MIN},
+        expected=INT64_MIN,
+    ),
+    ExpressionTestCase(
+        "int64_max_minus_1",
+        msg="Int64 max minus 1 passes through unchanged",
+        expression={"$toLong": INT64_MAX_MINUS_1},
+        expected=INT64_MAX_MINUS_1,
+    ),
+    ExpressionTestCase(
+        "int64_min_plus_1",
+        msg="Int64 min plus 1 passes through unchanged",
+        expression={"$toLong": INT64_MIN_PLUS_1},
+        expected=INT64_MIN_PLUS_1,
+    ),
+]
+
+# Property [Double Conversion]: $toLong truncates doubles toward zero; whole-number doubles
+# convert exactly, and boundary values at the edges of int64 range are accepted.
+TOLONG_DOUBLE_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "double_whole",
+        msg="Whole-number double converts to Int64",
+        expression={"$toLong": 3.0},
+        expected=Int64(3),
+    ),
+    ExpressionTestCase(
+        "double_negative_whole",
+        msg="Negative whole-number double converts to Int64",
+        expression={"$toLong": -5.0},
+        expected=Int64(-5),
+    ),
+    ExpressionTestCase(
+        "double_truncate_positive",
+        msg="Positive fractional double is truncated toward zero",
+        expression={"$toLong": 1.99999},
+        expected=Int64(1),
+    ),
+    ExpressionTestCase(
+        "double_truncate_negative",
+        msg="Negative fractional double is truncated toward zero",
+        expression={"$toLong": -3.14},
+        expected=Int64(-3),
+    ),
+    ExpressionTestCase(
+        "double_negative_zero",
+        msg="-0.0 converts to Int64(0)",
+        expression={"$toLong": DOUBLE_NEGATIVE_ZERO},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_half_positive",
+        msg="0.5 is truncated toward zero to Int64(0)",
+        expression={"$toLong": DOUBLE_HALF},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_half_negative",
+        msg="-0.5 is truncated toward zero to Int64(0)",
+        expression={"$toLong": DOUBLE_NEGATIVE_HALF},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_subnormal",
+        msg="Subnormal double is truncated to Int64(0)",
+        expression={"$toLong": DOUBLE_MIN_SUBNORMAL},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_small_positive",
+        msg="Small positive double near min is truncated to Int64(0)",
+        expression={"$toLong": DOUBLE_NEAR_MIN},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "double_max_fitting",
+        msg="Largest double fitting in int64 range converts to its truncated Int64 value",
+        expression={"$toLong": DOUBLE_MAX_FITTING_INT64},
+        expected=INT64_FROM_DOUBLE_MAX_FITTING,
+    ),
+    ExpressionTestCase(
+        "double_int64_min_exact",
+        msg="int64 min as an exact double converts to Int64 min",
+        expression={"$toLong": -DOUBLE_FROM_INT64_MAX},
+        expected=INT64_MIN,
+    ),
+]
+
+# Property [Double Conversion Errors]: NaN, infinities, and doubles outside int64 range
+# produce a conversion error.
+TOLONG_DOUBLE_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "double_err_nan",
+        msg="NaN is a conversion failure",
+        expression={"$toLong": FLOAT_NAN},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_err_pos_infinity",
+        msg="+Infinity is a conversion failure",
+        expression={"$toLong": FLOAT_INFINITY},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_err_neg_infinity",
+        msg="-Infinity is a conversion failure",
+        expression={"$toLong": FLOAT_NEGATIVE_INFINITY},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_err_overflow_2_63",
+        msg="Double at 2**63 (first above int64 max) is a conversion failure",
+        expression={"$toLong": float(2**63)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_err_overflow_large",
+        msg="Very large double is a conversion failure",
+        expression={"$toLong": DOUBLE_NEAR_MAX},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_err_underflow_below_int64_min",
+        msg="First double below int64 min is a conversion failure",
+        expression={"$toLong": math.nextafter(-float(2**63), FLOAT_NEGATIVE_INFINITY)},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "double_err_underflow_large_negative",
+        msg="Very large negative double is a conversion failure",
+        expression={"$toLong": -DOUBLE_NEAR_MAX},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+TOLONG_NUMERIC_TESTS = (
+    TOLONG_NULL_MISSING_TESTS
+    + TOLONG_BOOL_TESTS
+    + TOLONG_INT32_TESTS
+    + TOLONG_INT64_IDENTITY_TESTS
+    + TOLONG_DOUBLE_TESTS
+    + TOLONG_DOUBLE_ERROR_TESTS
+)
+
+
+@pytest.mark.parametrize("test", pytest_params(TOLONG_NUMERIC_TESTS))
+def test_toLong_numeric(collection, test: ExpressionTestCase):
+    """$toLong converts null, bool, int32, int64, and double inputs."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_return_type.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_return_type.py
new file mode 100644
index 000000000..4a5071d96
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_return_type.py
@@ -0,0 +1,159 @@
+"""$toLong return-type invariant and idempotency tests."""
+
+from datetime import datetime, timezone
+
+import pytest
+from bson import Binary, Decimal128, Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.bson_type_validator import (
+    BsonType,
+    BsonTypeTestCase,
+    generate_bson_acceptance_test_cases,
+    generate_bson_rejection_test_cases,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    MISSING,
+)
+
+# Property [Return Type]: $toLong always returns BSON type long for successful conversions
+# and null for null or missing inputs.
+# NULL is skipped from rejection because $toLong(null) returns null (not an error).
+# OBJECT and ARRAY are skipped because they need $literal wrapping to avoid being parsed
+# as MongoDB expressions — their rejection is verified in test_toLong_datetime_binary.py.
+RETURN_TYPE_LONG_SPEC = [
+    BsonTypeTestCase(
+        id="toLong_return_type",
+        msg="$toLong always returns BSON type long for a successful conversion",
+        valid_types=[
+            BsonType.BOOL,
+            BsonType.INT,
+            BsonType.LONG,
+            BsonType.DOUBLE,
+            BsonType.DECIMAL,
+            BsonType.STRING,
+            BsonType.DATE,
+            BsonType.BIN_DATA,
+        ],
+        skip_rejection_types=[
+            BsonType.NULL,
+            BsonType.OBJECT,
+            BsonType.ARRAY,
+        ],
+        default_error_code=CONVERSION_FAILURE_ERROR,
+        valid_inputs={
+            BsonType.STRING: "42",
+            BsonType.BIN_DATA: Binary(b"\x05"),
+        },
+    ),
+]
+
+RETURN_TYPE_LONG_CASES = generate_bson_acceptance_test_cases(RETURN_TYPE_LONG_SPEC)
+REJECTION_LONG_CASES = generate_bson_rejection_test_cases(RETURN_TYPE_LONG_SPEC)
+
+
+@pytest.mark.parametrize("bson_type,sample_value,spec", RETURN_TYPE_LONG_CASES)
+def test_toLong_return_type_is_long(collection, bson_type, sample_value, spec):
+    """$toLong always returns BSON type 'long' for a successful conversion."""
+    result = execute_expression(collection, {"$type": {"$toLong": sample_value}})
+    assert_expression_result(result, expected="long", msg=f"{spec.msg} ({bson_type.value} input)")
+
+
+@pytest.mark.parametrize("bson_type,sample_value,spec", REJECTION_LONG_CASES)
+def test_toLong_rejects_unsupported_type(collection, bson_type, sample_value, spec):
+    """$toLong rejects BSON types it cannot convert with a conversion failure."""
+    result = execute_expression(collection, {"$toLong": sample_value})
+    assert_expression_result(
+        result,
+        error_code=spec.expected_code(bson_type),
+        msg=f"$toLong should reject {bson_type.value} input",
+    )
+
+
+# Property [Return Type — Null]: $toLong returns BSON type null for null or missing inputs.
+TOLONG_RETURN_TYPE_NULL_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "null",
+        msg="$toLong of null returns null type",
+        expression={"$type": {"$toLong": None}},
+        expected="null",
+    ),
+    ExpressionTestCase(
+        "missing",
+        msg="$toLong of missing returns null type",
+        expression={"$type": {"$toLong": MISSING}},
+        expected="null",
+    ),
+]
+
+
+# Property [Idempotency]: applying $toLong twice produces the same result as applying it once.
+TOLONG_IDEMPOTENCY_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "idempotent_bool",
+        msg="$toLong is idempotent for bool",
+        expression={"$toLong": {"$toLong": True}},
+        expected=Int64(1),
+    ),
+    ExpressionTestCase(
+        "idempotent_int32",
+        msg="$toLong is idempotent for int32",
+        expression={"$toLong": {"$toLong": 42}},
+        expected=Int64(42),
+    ),
+    ExpressionTestCase(
+        "idempotent_int64",
+        msg="$toLong is idempotent for int64",
+        expression={"$toLong": {"$toLong": Int64(99)}},
+        expected=Int64(99),
+    ),
+    ExpressionTestCase(
+        "idempotent_double",
+        msg="$toLong is idempotent for double",
+        expression={"$toLong": {"$toLong": 3.7}},
+        expected=Int64(3),
+    ),
+    ExpressionTestCase(
+        "idempotent_decimal128",
+        msg="$toLong is idempotent for Decimal128",
+        expression={"$toLong": {"$toLong": Decimal128("8.9")}},
+        expected=Int64(8),
+    ),
+    ExpressionTestCase(
+        "idempotent_string",
+        msg="$toLong is idempotent for numeric string",
+        expression={"$toLong": {"$toLong": "55"}},
+        expected=Int64(55),
+    ),
+    ExpressionTestCase(
+        "idempotent_datetime",
+        msg="$toLong is idempotent for datetime",
+        expression={"$toLong": {"$toLong": datetime(2024, 1, 1, tzinfo=timezone.utc)}},
+        expected=Int64(1_704_067_200_000),
+    ),
+    ExpressionTestCase(
+        "idempotent_binary",
+        msg="$toLong is idempotent for 1-byte binary",
+        expression={"$toLong": {"$toLong": Binary(b"\x05")}},
+        expected=Int64(5),
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TOLONG_RETURN_TYPE_NULL_TESTS + TOLONG_IDEMPOTENCY_TESTS)
+)
+def test_toLong_return_type_null(collection, test: ExpressionTestCase):
+    """$toLong returns BSON type 'null' for null or missing input."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_string.py b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_string.py
new file mode 100644
index 000000000..dbfbc27f9
--- /dev/null
+++ b/documentdb_tests/compatibility/tests/core/operator/expressions/type/toLong/test_toLong_string.py
@@ -0,0 +1,338 @@
+"""$toLong string conversion tests: valid integer strings, invalid formats, and size limit."""
+
+import pytest
+from bson import Int64
+
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.expression_test_case import (  # noqa: E501
+    ExpressionTestCase,
+)
+from documentdb_tests.compatibility.tests.core.operator.expressions.utils.utils import (
+    assert_expression_result,
+    execute_expression,
+)
+from documentdb_tests.framework.error_codes import CONVERSION_FAILURE_ERROR, STRING_SIZE_LIMIT_ERROR
+from documentdb_tests.framework.lazy_payload import lazy
+from documentdb_tests.framework.parametrize import pytest_params
+from documentdb_tests.framework.test_constants import (
+    INT64_MAX,
+    INT64_MIN,
+    INT64_ZERO,
+    STRING_SIZE_LIMIT_BYTES,
+)
+
+# Property [String Conversion]: base-10 integer strings with optional leading sign and leading
+# zeros convert to the corresponding Int64 value.
+TOLONG_STRING_NUMERIC_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "str_positive",
+        msg="Positive integer string converts to Int64",
+        expression={"$toLong": "42"},
+        expected=Int64(42),
+    ),
+    ExpressionTestCase(
+        "str_negative",
+        msg="Negative integer string converts to Int64",
+        expression={"$toLong": "-2"},
+        expected=Int64(-2),
+    ),
+    ExpressionTestCase(
+        "str_zero",
+        msg="'0' converts to Int64(0)",
+        expression={"$toLong": "0"},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_leading_plus",
+        msg="Leading '+' sign is accepted",
+        expression={"$toLong": "+5"},
+        expected=Int64(5),
+    ),
+    ExpressionTestCase(
+        "str_leading_zeros",
+        msg="Leading zeros are accepted",
+        expression={"$toLong": "007"},
+        expected=Int64(7),
+    ),
+    ExpressionTestCase(
+        "str_plus_leading_zeros",
+        msg="'+' sign with leading zeros is accepted",
+        expression={"$toLong": "+0042"},
+        expected=Int64(42),
+    ),
+    ExpressionTestCase(
+        "str_minus_leading_zeros",
+        msg="'-' sign with leading zeros is accepted",
+        expression={"$toLong": "-0042"},
+        expected=Int64(-42),
+    ),
+    ExpressionTestCase(
+        "str_negative_zero",
+        msg="'-0' converts to Int64(0)",
+        expression={"$toLong": "-0"},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_plus_zero",
+        msg="'+0' converts to Int64(0)",
+        expression={"$toLong": "+0"},
+        expected=INT64_ZERO,
+    ),
+    ExpressionTestCase(
+        "str_int64_max",
+        msg="int64 max string converts to Int64 max",
+        expression={"$toLong": "9223372036854775807"},
+        expected=INT64_MAX,
+    ),
+    ExpressionTestCase(
+        "str_int64_min",
+        msg="int64 min string converts to Int64 min",
+        expression={"$toLong": "-9223372036854775808"},
+        expected=INT64_MIN,
+    ),
+]
+
+# Property [String Conversion Errors]: non-integer string formats, decimal points, scientific
+# notation, hex, whitespace, Unicode non-ASCII digits, control characters, special characters,
+# sign-only strings, separator characters, and overflow strings produce a conversion error.
+TOLONG_STRING_ERROR_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "str_err_empty",
+        msg="Empty string is a conversion failure",
+        expression={"$toLong": ""},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_alpha",
+        msg="Alphabetic string is a conversion failure",
+        expression={"$toLong": "a"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_decimal_point",
+        msg="String with decimal point is a conversion failure",
+        expression={"$toLong": "3.0"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_trailing_dot",
+        msg="String with trailing decimal point is a conversion failure",
+        expression={"$toLong": "1."},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_leading_dot",
+        msg="String with leading decimal point is a conversion failure",
+        expression={"$toLong": ".1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_sci_lower",
+        msg="Lowercase scientific notation string is a conversion failure",
+        expression={"$toLong": "1e2"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_sci_upper",
+        msg="Uppercase scientific notation string is a conversion failure",
+        expression={"$toLong": "1E2"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_hex_lower",
+        msg="Lowercase hex prefix string is a conversion failure",
+        expression={"$toLong": "0x1A"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_hex_upper",
+        msg="Uppercase hex prefix string is a conversion failure",
+        expression={"$toLong": "0X1A"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_nan",
+        msg="'NaN' string is a conversion failure",
+        expression={"$toLong": "NaN"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_infinity",
+        msg="'Infinity' string is a conversion failure",
+        expression={"$toLong": "Infinity"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_inf",
+        msg="'inf' string is a conversion failure",
+        expression={"$toLong": "inf"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_true",
+        msg="'true' string is a conversion failure",
+        expression={"$toLong": "true"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_false",
+        msg="'false' string is a conversion failure",
+        expression={"$toLong": "false"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_null",
+        msg="'null' string is a conversion failure",
+        expression={"$toLong": "null"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_leading_space",
+        msg="String with leading space is a conversion failure",
+        expression={"$toLong": " 1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_trailing_space",
+        msg="String with trailing space is a conversion failure",
+        expression={"$toLong": "1 "},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_embedded_space",
+        msg="String with embedded space is a conversion failure",
+        expression={"$toLong": "1 2"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_tab",
+        msg="String with tab character is a conversion failure",
+        expression={"$toLong": "\t1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_newline",
+        msg="String with newline is a conversion failure",
+        expression={"$toLong": "1\n"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_nbsp",
+        msg="String with NBSP (U+00A0) is a conversion failure",
+        expression={"$toLong": "1\u00a0"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_fullwidth_digit",
+        msg="Fullwidth digit (U+FF11) is a conversion failure",
+        expression={"$toLong": "\uff11"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_arabic_indic_digit",
+        msg="Arabic-Indic digit (U+0661) is a conversion failure",
+        expression={"$toLong": "\u0661"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_null_byte",
+        msg="String with null byte is a conversion failure",
+        expression={"$toLong": "\x001"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_plus_only",
+        msg="Sign-only string '+' is a conversion failure",
+        expression={"$toLong": "+"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_minus_only",
+        msg="Sign-only string '-' is a conversion failure",
+        expression={"$toLong": "-"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_double_minus",
+        msg="Double-sign string '--1' is a conversion failure",
+        expression={"$toLong": "--1"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_comma_separator",
+        msg="String with comma separator is a conversion failure",
+        expression={"$toLong": "1,000"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_underscore_separator",
+        msg="String with underscore separator is a conversion failure",
+        expression={"$toLong": "1_000"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_overflow_above_max",
+        msg="String exceeding int64 max is a conversion failure",
+        expression={"$toLong": "9223372036854775808"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_overflow_below_min",
+        msg="String below int64 min is a conversion failure",
+        expression={"$toLong": "-9223372036854775809"},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_literal_dollar_number",
+        msg="'$42' passed via $literal is a conversion failure",
+        expression={"$toLong": {"$literal": "$42"}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "str_err_literal_dollar_only",
+        msg="'$' passed via $literal is a conversion failure",
+        expression={"$toLong": {"$literal": "$"}},
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+]
+
+# Property [String Size Limit]: $toLong checks the byte length of string inputs before
+# attempting conversion; strings at or above the limit are rejected unconditionally.
+TOLONG_STRING_SIZE_LIMIT_TESTS: list[ExpressionTestCase] = [
+    ExpressionTestCase(
+        "size_one_under_valid",
+        msg="Valid numeric string one byte under limit converts successfully",
+        expression=lazy(lambda: {"$toLong": "0" * (STRING_SIZE_LIMIT_BYTES - 2) + "1"}),
+        expected=Int64(1),
+    ),
+    ExpressionTestCase(
+        "size_one_under_non_numeric",
+        msg="Non-numeric string one byte under limit passes size check but fails conversion",
+        expression=lazy(lambda: {"$toLong": "a" * (STRING_SIZE_LIMIT_BYTES - 1)}),
+        error_code=CONVERSION_FAILURE_ERROR,
+    ),
+    ExpressionTestCase(
+        "size_at_limit",
+        msg="String at STRING_SIZE_LIMIT_BYTES is rejected with STRING_SIZE_LIMIT_ERROR",
+        expression=lazy(lambda: {"$toLong": "a" * STRING_SIZE_LIMIT_BYTES}),
+        error_code=STRING_SIZE_LIMIT_ERROR,
+    ),
+    ExpressionTestCase(
+        "size_at_limit_four_byte",
+        msg="4-byte character string reaching STRING_SIZE_LIMIT_BYTES is rejected",
+        expression=lazy(lambda: {"$toLong": "\U0001f600" * (STRING_SIZE_LIMIT_BYTES // 4)}),
+        error_code=STRING_SIZE_LIMIT_ERROR,
+    ),
+]
+
+TOLONG_STRING_TESTS = TOLONG_STRING_NUMERIC_TESTS + TOLONG_STRING_ERROR_TESTS
+
+
+@pytest.mark.parametrize(
+    "test", pytest_params(TOLONG_STRING_TESTS + TOLONG_STRING_SIZE_LIMIT_TESTS)
+)
+def test_toLong_string(collection, test: ExpressionTestCase):
+    """$toLong parses valid integer strings and rejects non-integer or malformed ones."""
+    result = execute_expression(collection, test.expression)
+    assert_expression_result(
+        result, expected=test.expected, error_code=test.error_code, msg=test.msg
+    )
diff --git a/documentdb_tests/framework/test_constants.py b/documentdb_tests/framework/test_constants.py
index 02002c2aa..b3bda419e 100644
--- a/documentdb_tests/framework/test_constants.py
+++ b/documentdb_tests/framework/test_constants.py
@@ -19,6 +19,7 @@
 INT64_ZERO = Int64(0)
 INT64_MAX = Int64(9223372036854775807)
 INT64_MAX_MINUS_1 = Int64(9223372036854775806)
+INT64_FROM_DOUBLE_MAX_FITTING = Int64(9223372036854774784)
 
 # Double boundary values
 DOUBLE_MIN = -1.7976931348623157e308