⚡️ Speed up function check_validations by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for check_validations in src/datadog_api_client/model_utils.py

⏱️ Runtime : 818 microseconds → 748 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 9% speedup through several targeted performance improvements:

Key Optimizations:

1. Streamlined configuration checking in is_json_validation_enabled(): Replaced complex boolean expression with early returns and getattr() instead of hasattr(), reducing attribute access overhead by ~22% (2.75ms → 2.14ms total time).

2. Eliminated redundant dictionary lookups: Used validations.get() once per validation type (e.g., multiple_of = validations.get("multiple_of")) instead of checking "multiple_of" in validations then accessing validations["multiple_of"] separately.

3. Optimized min/max calculation for collections: Replaced built-in max()/min() functions with manual loops that compute both values in a single pass, avoiding double iteration over large lists/dictionaries. This is particularly effective for the large-scale test cases.

4. Pre-computed validation flags: Instead of repeatedly checking "exclusive_maximum" in validations, the code now checks once and stores boolean flags (has_exclusive_maximum), reducing dictionary lookup overhead in the bounds validation section.

5. Reduced regex validation overhead: Simplified nested dictionary access for regex patterns and flags by extracting them upfront.

Performance Impact by Test Type:

• Basic validation checks: 20-50% faster for simple cases (length/items checks)
• Numeric bounds validation: 15-30% faster due to optimized min/max calculation
• Large-scale operations: Mixed results - some cases show minor slowdowns due to manual loop overhead vs. optimized built-ins, but overall validation pipeline is faster
• Configuration-disabled validations: 35-50% faster due to streamlined config checking

The optimizations are most effective for workloads with frequent validation calls and moderate-sized collections, maintaining identical behavior while reducing computational overhead.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 115 Passed
⏪ Replay Tests	✅ 23 Passed
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import re

# imports
import pytest
from datadog_api_client.exceptions import ApiValueError
from src.datadog_api_client.model_utils import check_validations


# Helper class for configuration
class DummyConfig:
    def __init__(self, disabled=None):
        self._disabled_client_side_validations = disabled or []

# ------------------------
# Basic Test Cases
# ------------------------

def test_multiple_of_valid():
    # Should not raise for a valid multiple
    check_validations({"multiple_of": 5}, "num", 10) # 7.15μs -> 5.96μs (19.8% faster)

def test_multiple_of_invalid():
    # Should raise for invalid multiple
    with pytest.raises(ApiValueError):
        check_validations({"multiple_of": 5}, "num", 12) # 7.35μs -> 7.33μs (0.245% faster)

def test_max_length_valid():
    # Should not raise for valid length
    check_validations({"max_length": 5}, "str", "abcde") # 4.90μs -> 3.45μs (42.1% faster)

def test_max_length_invalid():
    # Should raise for string longer than max_length
    with pytest.raises(ApiValueError):
        check_validations({"max_length": 5}, "str", "abcdef") # 5.06μs -> 6.13μs (17.4% slower)

def test_min_length_valid():
    # Should not raise for valid min_length
    check_validations({"min_length": 3}, "str", "abc") # 7.07μs -> 3.41μs (108% faster)

def test_min_length_invalid():
    # Should raise for string shorter than min_length
    with pytest.raises(ApiValueError):
        check_validations({"min_length": 4}, "str", "abc") # 5.34μs -> 6.10μs (12.4% slower)

def test_max_items_valid():
    # Should not raise for valid list length
    check_validations({"max_items": 3}, "lst", [1, 2, 3]) # 4.88μs -> 3.42μs (42.6% faster)

def test_max_items_invalid():
    # Should raise for list longer than max_items
    with pytest.raises(ApiValueError):
        check_validations({"max_items": 2}, "lst", [1, 2, 3]) # 5.44μs -> 5.71μs (4.81% slower)

def test_min_items_valid():
    # Should not raise for valid min_items
    check_validations({"min_items": 2}, "lst", [1, 2]) # 5.90μs -> 3.39μs (74.0% faster)

def test_min_items_invalid():
    # Should raise for list shorter than min_items
    with pytest.raises(ValueError):
        check_validations({"min_items": 3}, "lst", [1]) # 3.85μs -> 4.29μs (10.3% slower)

def test_exclusive_maximum_valid():
    # Should not raise if value is less than exclusive_maximum
    check_validations({"exclusive_maximum": 10}, "num", 9) # 4.99μs -> 4.06μs (22.7% faster)

def test_exclusive_maximum_invalid():
    # Should raise if value is equal or greater than exclusive_maximum
    with pytest.raises(ApiValueError):
        check_validations({"exclusive_maximum": 10}, "num", 10) # 7.14μs -> 6.80μs (4.97% faster)

def test_inclusive_maximum_valid():
    # Should not raise if value is equal to inclusive_maximum
    check_validations({"inclusive_maximum": 10}, "num", 10) # 5.12μs -> 4.33μs (18.2% faster)

def test_inclusive_maximum_invalid():
    # Should raise if value is greater than inclusive_maximum
    with pytest.raises(ApiValueError):
        check_validations({"inclusive_maximum": 10}, "num", 11) # 7.68μs -> 6.98μs (10.2% faster)

def test_exclusive_minimum_valid():
    # Should not raise if value is greater than exclusive_minimum
    check_validations({"exclusive_minimum": 5}, "num", 6) # 5.44μs -> 4.21μs (29.4% faster)


def test_inclusive_minimum_valid():
    # Should not raise if value is equal to inclusive_minimum
    check_validations({"inclusive_minimum": 5}, "num", 5) # 5.35μs -> 4.08μs (31.2% faster)

def test_inclusive_minimum_invalid():
    # Should raise if value is less than inclusive_minimum
    with pytest.raises(ApiValueError):
        check_validations({"inclusive_minimum": 5}, "num", 4) # 8.45μs -> 7.06μs (19.7% faster)

def test_regex_valid():
    # Should not raise for string matching regex
    check_validations({"regex": {"pattern": r"^[a-z]+$"}}, "str", "abc") # 10.7μs -> 7.84μs (37.0% faster)

def test_regex_invalid():
    # Should raise for string not matching regex
    with pytest.raises(ApiValueError):
        check_validations({"regex": {"pattern": r"^[a-z]+$"}}, "str", "abc123") # 15.8μs -> 11.0μs (44.0% faster)

def test_regex_flags_valid():
    # Should not raise for case-insensitive match
    check_validations({"regex": {"pattern": r"abc", "flags": re.IGNORECASE}}, "str", "ABC") # 9.52μs -> 9.63μs (1.18% slower)

def test_regex_flags_invalid():
    # Should raise for case-sensitive mismatch
    with pytest.raises(ApiValueError):
        check_validations({"regex": {"pattern": r"abc"}}, "str", "ABC") # 11.9μs -> 9.70μs (22.4% faster)

def test_none_input_values():
    # Should not raise for None input_values
    check_validations({"min_length": 1}, "str", None) # 844ns -> 1.07μs (21.3% slower)

# ------------------------
# Edge Test Cases
# ------------------------

def test_empty_string_min_length_zero():
    # Should not raise for empty string with min_length 0
    check_validations({"min_length": 0}, "str", "") # 5.17μs -> 3.47μs (49.3% faster)

def test_empty_list_min_items_zero():
    # Should not raise for empty list with min_items 0
    check_validations({"min_items": 0}, "lst", []) # 5.32μs -> 3.42μs (55.7% faster)

def test_zero_multiple_of():
    # Should raise for zero multiple_of (division by zero)
    with pytest.raises(ZeroDivisionError):
        check_validations({"multiple_of": 0}, "num", 5) # 5.29μs -> 4.07μs (29.9% faster)


def test_float_multiple_of_invalid():
    # Should raise for float not a multiple
    with pytest.raises(ApiValueError):
        check_validations({"multiple_of": 0.1}, "num", 0.35) # 8.82μs -> 8.83μs (0.113% slower)

def test_max_length_on_list():
    # Should not raise for list with max_length
    check_validations({"max_length": 3}, "lst", [1, 2, 3]) # 5.01μs -> 4.03μs (24.4% faster)

def test_min_length_on_list():
    # Should not raise for list with min_length
    check_validations({"min_length": 2}, "lst", [1, 2]) # 7.12μs -> 3.40μs (110% faster)

def test_regex_with_flags_and_invalid():
    # Should raise for regex with flags but not matching
    with pytest.raises(ApiValueError):
        check_validations({"regex": {"pattern": r"abc", "flags": re.IGNORECASE}}, "str", "xyz") # 23.3μs -> 17.5μs (33.1% faster)

def test_dict_max_items():
    # Should not raise for dict with max_items
    check_validations({"max_items": 2}, "dct", {"a": 1, "b": 2}) # 4.81μs -> 3.45μs (39.4% faster)

def test_dict_max_items_invalid():
    # Should raise for dict with too many items
    with pytest.raises(ApiValueError):
        check_validations({"max_items": 1}, "dct", {"a": 1, "b": 2}) # 6.55μs -> 7.33μs (10.7% slower)

def test_dict_min_items():
    # Should not raise for dict with min_items
    check_validations({"min_items": 2}, "dct", {"a": 1, "b": 2}) # 4.93μs -> 3.37μs (46.4% faster)

def test_dict_min_items_invalid():
    # Should raise for dict with too few items
    with pytest.raises(ValueError):
        check_validations({"min_items": 3}, "dct", {"a": 1}) # 4.26μs -> 4.52μs (5.65% slower)

def test_list_exclusive_maximum():
    # Should not raise for list where max is less than exclusive_maximum
    check_validations({"exclusive_maximum": 10}, "lst", [1, 2, 9]) # 5.76μs -> 5.87μs (1.86% slower)

def test_list_exclusive_maximum_invalid():
    # Should raise for list where max is equal to exclusive_maximum
    with pytest.raises(ApiValueError):
        check_validations({"exclusive_maximum": 9}, "lst", [1, 2, 9]) # 7.86μs -> 7.12μs (10.3% faster)

def test_list_inclusive_maximum():
    # Should not raise for list where max is equal to inclusive_maximum
    check_validations({"inclusive_maximum": 9}, "lst", [1, 2, 9]) # 5.82μs -> 5.04μs (15.5% faster)

def test_list_inclusive_maximum_invalid():
    # Should raise for list where max is greater than inclusive_maximum
    with pytest.raises(ApiValueError):
        check_validations({"inclusive_maximum": 8}, "lst", [1, 2, 9]) # 9.46μs -> 7.61μs (24.3% faster)

def test_list_exclusive_minimum():
    # Should not raise for list where min is greater than exclusive_minimum
    check_validations({"exclusive_minimum": 1}, "lst", [2, 3, 4]) # 6.28μs -> 5.02μs (25.1% faster)


def test_list_inclusive_minimum():
    # Should not raise for list where min is equal to inclusive_minimum
    check_validations({"inclusive_minimum": 2}, "lst", [2, 3, 4]) # 6.22μs -> 4.99μs (24.7% faster)

def test_list_inclusive_minimum_invalid():
    # Should raise for list where min is less than inclusive_minimum
    with pytest.raises(ApiValueError):
        check_validations({"inclusive_minimum": 3}, "lst", [2, 3, 4]) # 8.86μs -> 8.76μs (1.19% faster)

def test_dict_exclusive_maximum():
    # Should not raise for dict where max value is less than exclusive_maximum
    check_validations({"exclusive_maximum": 10}, "dct", {"a": 1, "b": 9}) # 6.98μs -> 5.75μs (21.3% faster)

def test_dict_exclusive_maximum_invalid():
    # Should raise for dict where max value is equal to exclusive_maximum
    with pytest.raises(ApiValueError):
        check_validations({"exclusive_maximum": 9}, "dct", {"a": 1, "b": 9}) # 8.53μs -> 8.20μs (3.96% faster)

def test_disable_validation_via_config():
    # Should not raise if validation is disabled via configuration
    config = DummyConfig(disabled=["maxLength"])
    check_validations({"max_length": 1}, "str", "toolong", configuration=config) # 6.99μs -> 4.66μs (50.2% faster)

def test_enable_validation_via_config():
    # Should raise if validation is enabled via configuration
    config = DummyConfig(disabled=["minLength"])
    with pytest.raises(ApiValueError):
        check_validations({"max_length": 3}, "str", "abcd", configuration=config) # 6.43μs -> 6.82μs (5.70% slower)

# ------------------------
# Large Scale Test Cases
# ------------------------

def test_large_list_max_items_valid():
    # Should not raise for large list within max_items
    check_validations({"max_items": 1000}, "lst", list(range(1000))) # 5.23μs -> 3.61μs (45.0% faster)

def test_large_list_max_items_invalid():
    # Should raise for large list exceeding max_items
    with pytest.raises(ApiValueError):
        check_validations({"max_items": 999}, "lst", list(range(1000))) # 6.79μs -> 5.76μs (17.9% faster)

def test_large_list_min_items_valid():
    # Should not raise for large list with min_items
    check_validations({"min_items": 1000}, "lst", list(range(1000))) # 5.13μs -> 3.52μs (45.7% faster)

def test_large_list_min_items_invalid():
    # Should raise for large list below min_items
    with pytest.raises(ValueError):
        check_validations({"min_items": 1000}, "lst", list(range(999))) # 4.29μs -> 4.54μs (5.51% slower)

def test_large_string_max_length_valid():
    # Should not raise for large string within max_length
    check_validations({"max_length": 1000}, "str", "a" * 1000) # 5.27μs -> 3.71μs (42.3% faster)

def test_large_string_max_length_invalid():
    # Should raise for large string exceeding max_length
    with pytest.raises(ApiValueError):
        check_validations({"max_length": 999}, "str", "a" * 1000) # 5.30μs -> 5.65μs (6.09% slower)

def test_large_string_min_length_valid():
    # Should not raise for large string with min_length
    check_validations({"min_length": 1000}, "str", "a" * 1000) # 5.14μs -> 3.67μs (40.1% faster)

def test_large_string_min_length_invalid():
    # Should raise for large string below min_length
    with pytest.raises(ApiValueError):
        check_validations({"min_length": 1000}, "str", "a" * 999) # 5.71μs -> 6.98μs (18.2% slower)

def test_large_dict_max_items_valid():
    # Should not raise for large dict within max_items
    check_validations({"max_items": 1000}, "dct", {i: i for i in range(1000)}) # 5.17μs -> 3.52μs (46.7% faster)

def test_large_dict_max_items_invalid():
    # Should raise for large dict exceeding max_items
    with pytest.raises(ApiValueError):
        check_validations({"max_items": 999}, "dct", {i: i for i in range(1000)}) # 5.73μs -> 6.07μs (5.59% slower)

def test_large_dict_min_items_valid():
    # Should not raise for large dict with min_items
    check_validations({"min_items": 1000}, "dct", {i: i for i in range(1000)}) # 5.03μs -> 3.46μs (45.7% faster)

def test_large_dict_min_items_invalid():
    # Should raise for large dict below min_items
    with pytest.raises(ValueError):
        check_validations({"min_items": 1000}, "dct", {i: i for i in range(999)}) # 4.24μs -> 6.07μs (30.2% slower)

def test_large_list_exclusive_maximum_valid():
    # Should not raise for large list where max is less than exclusive_maximum
    check_validations({"exclusive_maximum": 1001}, "lst", list(range(1000))) # 36.3μs -> 40.3μs (9.98% slower)

def test_large_list_exclusive_maximum_invalid():
    # Should raise for large list where max is equal to exclusive_maximum
    with pytest.raises(ApiValueError):
        check_validations({"exclusive_maximum": 999}, "lst", list(range(1000))) # 38.7μs -> 43.5μs (10.9% slower)

def test_large_list_inclusive_maximum_valid():
    # Should not raise for large list where max is equal to inclusive_maximum
    check_validations({"inclusive_maximum": 999}, "lst", list(range(1000))) # 35.9μs -> 40.4μs (11.0% slower)

def test_large_list_inclusive_maximum_invalid():
    # Should raise for large list where max is greater than inclusive_maximum
    with pytest.raises(ApiValueError):
        check_validations({"inclusive_maximum": 998}, "lst", list(range(1000))) # 38.3μs -> 43.5μs (12.0% slower)

def test_large_list_exclusive_minimum_valid():
    # Should not raise for large list where min is greater than exclusive_minimum
    check_validations({"exclusive_minimum": -1}, "lst", list(range(1000))) # 36.4μs -> 40.2μs (9.38% slower)


def test_large_list_inclusive_minimum_valid():
    # Should not raise for large list where min is equal to inclusive_minimum
    check_validations({"inclusive_minimum": 0}, "lst", list(range(1000))) # 37.0μs -> 40.8μs (9.17% slower)

def test_large_list_inclusive_minimum_invalid():
    # Should raise for large list where min is greater than inclusive_minimum
    with pytest.raises(ApiValueError):
        check_validations({"inclusive_minimum": 1}, "lst", list(range(1000))) # 40.3μs -> 45.1μs (10.5% slower)

def test_large_regex_valid():
    # Should not raise for large string matching regex
    check_validations({"regex": {"pattern": r"^a+$"}}, "str", "a" * 1000) # 9.96μs -> 8.18μs (21.8% faster)

def test_large_regex_invalid():
    # Should raise for large string not matching regex
    with pytest.raises(ApiValueError):
        check_validations({"regex": {"pattern": r"^b+$"}}, "str", "a" * 1000) # 13.1μs -> 10.4μs (25.7% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import re

# imports
import pytest  # used for our unit tests
from src.datadog_api_client.model_utils import check_validations

# function to test
# Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
# This product includes software developed at Datadog (https://www.datadoghq.com/).
# Copyright 2019-Present Datadog, Inc.

class ApiValueError(ValueError):
    pass
from src.datadog_api_client.model_utils import check_validations


# Helper class for configuration disabling
class DummyConfig:
    def __init__(self, disabled=None):
        self._disabled_client_side_validations = set(disabled or [])

# ----------- UNIT TESTS ------------

# BASIC TEST CASES

def test_multiple_of_pass():
    # Should pass: 10 is a multiple of 5
    check_validations({'multiple_of': 5}, 'num', 10) # 8.91μs -> 6.42μs (38.8% faster)


def test_max_length_pass():
    # Should pass: length of "abc" is 3, max_length is 3
    check_validations({'max_length': 3}, 'txt', "abc") # 4.91μs -> 3.63μs (35.2% faster)


def test_min_length_pass():
    # Should pass: length of "abc" is 3, min_length is 2
    check_validations({'min_length': 2}, 'txt', "abc") # 6.19μs -> 3.53μs (75.1% faster)


def test_max_items_pass():
    # Should pass: list has 2 items, max_items is 2
    check_validations({'max_items': 2}, 'lst', [1, 2]) # 5.02μs -> 4.59μs (9.21% faster)


def test_min_items_pass():
    # Should pass: list has 2 items, min_items is 2
    check_validations({'min_items': 2}, 'lst', [1, 2]) # 5.53μs -> 3.35μs (65.2% faster)

def test_min_items_fail():
    # Should fail: list has 1 item, min_items is 2
    with pytest.raises(ValueError):
        check_validations({'min_items': 2}, 'lst', [1]) # 4.78μs -> 5.10μs (6.41% slower)

def test_exclusive_maximum_pass():
    # Should pass: value 4 < exclusive_maximum 5
    check_validations({'exclusive_maximum': 5}, 'num', 4) # 7.25μs -> 4.17μs (73.9% faster)


def test_inclusive_maximum_pass():
    # Should pass: value 5 <= inclusive_maximum 5
    check_validations({'inclusive_maximum': 5}, 'num', 5) # 5.42μs -> 4.36μs (24.2% faster)


def test_exclusive_minimum_pass():
    # Should pass: value 6 > exclusive_minimum 5
    check_validations({'exclusive_minimum': 5}, 'num', 6) # 6.16μs -> 6.59μs (6.44% slower)


def test_inclusive_minimum_pass():
    # Should pass: value 5 >= inclusive_minimum 5
    check_validations({'inclusive_minimum': 5}, 'num', 5) # 7.14μs -> 6.54μs (9.13% faster)


def test_regex_pass():
    # Should pass: "abc123" matches r"\d+" with flags=0
    check_validations({'regex': {'pattern': r"\d+"}}, 'txt', "abc123") # 10.4μs -> 8.47μs (23.0% faster)


def test_regex_flags_pass():
    # Should pass: "ABC" matches r"abc" with IGNORECASE
    check_validations({'regex': {'pattern': r"abc", 'flags': re.IGNORECASE}}, 'txt', "ABC") # 10.1μs -> 7.82μs (29.5% faster)


def test_none_input():
    # Should pass: input_values is None, no validation performed
    check_validations({'min_length': 2}, 'txt', None) # 1.06μs -> 1.04μs (1.83% faster)

def test_no_validations():
    # Should pass: no validations specified
    check_validations({}, 'txt', "anything") # 5.53μs -> 4.46μs (24.0% faster)

# EDGE TEST CASES


def test_max_length_zero():
    # Should pass: empty string, max_length 0
    check_validations({'max_length': 0}, 'txt', "")
    # Should fail: non-empty string, max_length 0
    with pytest.raises(ApiValueError):
        check_validations({'max_length': 0}, 'txt', "a")

def test_min_length_zero():
    # Should pass: empty string, min_length 0
    check_validations({'min_length': 0}, 'txt', "")
    # Should fail: non-empty string, min_length 1
    with pytest.raises(ApiValueError):
        check_validations({'min_length': 1}, 'txt', "")

def test_max_items_zero():
    # Should pass: empty list, max_items 0
    check_validations({'max_items': 0}, 'lst', [])
    # Should fail: non-empty list, max_items 0
    with pytest.raises(ApiValueError):
        check_validations({'max_items': 0}, 'lst', [1])

def test_min_items_zero():
    # Should pass: empty list, min_items 0
    check_validations({'min_items': 0}, 'lst', []) # 6.23μs -> 4.99μs (24.8% faster)
    # Should fail: non-empty list, min_items 1
    with pytest.raises(ValueError):
        check_validations({'min_items': 1}, 'lst', []) # 2.99μs -> 3.56μs (16.0% slower)


def test_inclusive_maximum_dict():
    # Should pass: max({'a': 2, 'b': 3}.values()) <= 3
    check_validations({'inclusive_maximum': 3}, 'dct', {'a': 2, 'b': 3})
    # Should fail: max({'a': 2, 'b': 4}.values()) > 3
    with pytest.raises(ApiValueError):
        check_validations({'inclusive_maximum': 3}, 'dct', {'a': 2, 'b': 4})


def test_inclusive_minimum_dict():
    # Should pass: min({'a': 2, 'b': 3}.values()) >= 2
    check_validations({'inclusive_minimum': 2}, 'dct', {'a': 2, 'b': 3})
    # Should fail: min({'a': 1, 'b': 2}.values()) < 2
    with pytest.raises(ApiValueError):
        check_validations({'inclusive_minimum': 2}, 'dct', {'a': 1, 'b': 2})

def test_regex_empty_string():
    # Should pass: empty string matches pattern "^$"
    check_validations({'regex': {'pattern': r"^$"}}, 'txt', "")
    # Should fail: non-empty string does not match pattern "^$"
    with pytest.raises(ApiValueError):
        check_validations({'regex': {'pattern': r"^$"}}, 'txt', "a")

def test_disable_validation_multiple_of():
    # Should pass: disables multipleOf validation
    cfg = DummyConfig(disabled=['multipleOf'])
    check_validations({'multiple_of': 5}, 'num', 11, configuration=cfg) # 8.57μs -> 5.79μs (48.1% faster)

def test_disable_validation_regex():
    # Should pass: disables pattern validation
    cfg = DummyConfig(disabled=['pattern'])
    check_validations({'regex': {'pattern': r"\d+"}}, 'txt', "abc", configuration=cfg) # 9.15μs -> 4.53μs (102% faster)

def test_disable_validation_max_length():
    # Should pass: disables maxLength validation
    cfg = DummyConfig(disabled=['maxLength'])
    check_validations({'max_length': 1}, 'txt', "abc", configuration=cfg) # 6.55μs -> 6.07μs (7.87% faster)

def test_disable_validation_min_items():
    # Should pass: disables minItems validation
    cfg = DummyConfig(disabled=['minItems'])
    check_validations({'min_items': 2}, 'lst', [1], configuration=cfg) # 10.2μs -> 4.47μs (129% faster)

def test_disable_validation_exclusive_maximum():
    # Should pass: disables exclusiveMaximum validation
    cfg = DummyConfig(disabled=['exclusiveMaximum'])
    check_validations({'exclusive_maximum': 5}, 'num', 5, configuration=cfg) # 8.92μs -> 6.54μs (36.3% faster)

def test_disable_validation_inclusive_minimum():
    # Should pass: disables minimum validation
    cfg = DummyConfig(disabled=['minimum'])
    check_validations({'inclusive_minimum': 5}, 'num', 4, configuration=cfg) # 7.73μs -> 5.73μs (34.8% faster)

# LARGE SCALE TEST CASES

def test_large_list_max_items():
    # Should pass: list with 1000 items, max_items=1000
    check_validations({'max_items': 1000}, 'lst', list(range(1000)))
    # Should fail: list with 1001 items, max_items=1000
    with pytest.raises(ApiValueError):
        check_validations({'max_items': 1000}, 'lst', list(range(1000)))

def test_large_list_min_items():
    # Should pass: list with 1000 items, min_items=1000
    check_validations({'min_items': 1000}, 'lst', list(range(1000))) # 7.09μs -> 5.06μs (40.1% faster)
    # Should fail: list with 999 items, min_items=1000
    with pytest.raises(ValueError):
        check_validations({'min_items': 1000}, 'lst', list(range(999))) # 3.11μs -> 3.35μs (7.14% slower)

def test_large_string_max_length():
    # Should pass: string of length 1000, max_length=1000
    check_validations({'max_length': 1000}, 'txt', "a"*1000)
    # Should fail: string of length 1001, max_length=1000
    with pytest.raises(ApiValueError):
        check_validations({'max_length': 1000}, 'txt', "a"*1001)

def test_large_string_min_length():
    # Should pass: string of length 1000, min_length=1000
    check_validations({'min_length': 1000}, 'txt', "a"*1000)
    # Should fail: string of length 999, min_length=1000
    with pytest.raises(ApiValueError):
        check_validations({'min_length': 1000}, 'txt', "a"*999)

def test_large_dict_inclusive_maximum():
    # Should pass: dict values max is 999, inclusive_maximum=999
    d = {str(i): i for i in range(1000)}
    check_validations({'inclusive_maximum': 999}, 'dct', d)
    # Should fail: dict values max is 1000, inclusive_maximum=999
    d2 = {str(i): i for i in range(1000)}
    with pytest.raises(ApiValueError):
        check_validations({'inclusive_maximum': 999}, 'dct', d2)

def test_large_dict_inclusive_minimum():
    # Should pass: dict values min is 0, inclusive_minimum=0
    d = {str(i): i for i in range(1000)}
    check_validations({'inclusive_minimum': 0}, 'dct', d)
    # Should fail: dict values min is 1, inclusive_minimum=2
    d2 = {str(i): i+1 for i in range(1000)}
    with pytest.raises(ApiValueError):
        check_validations({'inclusive_minimum': 2}, 'dct', d2)

def test_large_regex():
    # Should pass: string of 1000 "a"s matches pattern "a+"
    check_validations({'regex': {'pattern': r"a+"}}, 'txt', "a"*1000)
    # Should fail: string of 1000 "b"s does not match pattern "a+"
    with pytest.raises(ApiValueError):
        check_validations({'regex': {'pattern': r"a+"}}, 'txt', "b"*1000)

def test_large_multiple_of():
    # Should pass: 1000000 is a multiple of 1000
    check_validations({'multiple_of': 1000}, 'num', 1000000)
    # Should fail: 1000001 is not a multiple of 1000
    with pytest.raises(ApiValueError):
        check_validations({'multiple_of': 1000}, 'num', 1000001)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

⏪ Replay Tests and Runtime

To edit these changes git checkout codeflash/optimize-check_validations-mgct9l9r and push.