import uuid

# imports
import pytest
from src.datadog_api_client.v2.api.on_call_paging_api import OnCallPagingApi

# function to test (as defined above)
# ... [The full function/class definitions from above are assumed present here] ...

# Helper: Minimal stub for a UUID class for testing (since datadog_api_client.model_utils.UUID is imported above)
class UUID(str):
    pass

# Helper: Dummy Endpoint and ApiClient to avoid actual HTTP calls
class DummyEndpoint:
    def __init__(self):
        self.last_kwargs = None

    def call_with_http_info(self, **kwargs):
        self.last_kwargs = kwargs
        # Simulate correct behavior: only accept a UUID-like string as 'page_id'
        page_id = kwargs.get("page_id")
        if page_id is None:
            raise ValueError("Missing required parameter 'page_id'")
        # Accept UUID instance or valid uuid string
        if isinstance(page_id, UUID):
            # Accept any UUID instance
            return None
        elif isinstance(page_id, str):
            try:
                uuid.UUID(page_id)
                return None
            except Exception:
                raise ValueError("Invalid UUID format")
        else:
            raise TypeError("Invalid type for 'page_id'")

class DummyOnCallPagingApi(OnCallPagingApi):
    def __init__(self):
        # Patch the endpoint to our dummy
        self._acknowledge_on_call_page_endpoint = DummyEndpoint()

# TESTS

# ----------- BASIC TEST CASES -----------

def test_acknowledge_valid_uuid_instance():
    """Test with a valid UUID instance."""
    api = DummyOnCallPagingApi()
    page_id = UUID(str(uuid.uuid4()))
    codeflash_output = api.acknowledge_on_call_page(page_id); result = codeflash_output # 2.74μs -> 1.53μs (78.8% faster)

def test_acknowledge_valid_uuid_string():
    """Test with a valid UUID string."""
    api = DummyOnCallPagingApi()
    page_id = str(uuid.uuid4())
    codeflash_output = api.acknowledge_on_call_page(page_id); result = codeflash_output # 7.43μs -> 6.09μs (21.8% faster)

def test_acknowledge_multiple_calls_unique_ids():
    """Test calling with multiple different valid UUIDs."""
    api = DummyOnCallPagingApi()
    ids = [UUID(str(uuid.uuid4())) for _ in range(3)]
    for pid in ids:
        codeflash_output = api.acknowledge_on_call_page(pid); result = codeflash_output # 4.68μs -> 2.61μs (79.5% faster)

# ----------- EDGE TEST CASES -----------

def test_acknowledge_missing_page_id():
    """Test calling without page_id (should raise)."""
    api = DummyOnCallPagingApi()
    with pytest.raises(TypeError):
        # Missing required positional argument
        api.acknowledge_on_call_page() # 5.04μs -> 4.72μs (6.65% faster)

def test_acknowledge_invalid_uuid_string():
    """Test with an invalid UUID string."""
    api = DummyOnCallPagingApi()
    invalid_id = "not-a-uuid"
    with pytest.raises(ValueError):
        api.acknowledge_on_call_page(invalid_id) # 7.90μs -> 6.73μs (17.3% faster)

def test_acknowledge_empty_string():
    """Test with empty string as page_id."""
    api = DummyOnCallPagingApi()
    with pytest.raises(ValueError):
        api.acknowledge_on_call_page("") # 7.35μs -> 6.01μs (22.3% faster)


def test_acknowledge_integer_page_id():
    """Test with integer as page_id."""
    api = DummyOnCallPagingApi()
    with pytest.raises(TypeError):
        api.acknowledge_on_call_page(123456) # 3.89μs -> 2.81μs (38.4% faster)

def test_acknowledge_list_page_id():
    """Test with list as page_id."""
    api = DummyOnCallPagingApi()
    with pytest.raises(TypeError):
        api.acknowledge_on_call_page([str(uuid.uuid4())]) # 4.22μs -> 3.35μs (26.3% faster)

def test_acknowledge_dict_page_id():
    """Test with dict as page_id."""
    api = DummyOnCallPagingApi()
    with pytest.raises(TypeError):
        api.acknowledge_on_call_page({"id": str(uuid.uuid4())}) # 4.12μs -> 3.34μs (23.3% faster)

def test_acknowledge_uuid_with_extra_spaces():
    """Test with UUID string with leading/trailing spaces."""
    api = DummyOnCallPagingApi()
    page_id = "  " + str(uuid.uuid4()) + "  "
    with pytest.raises(ValueError):
        api.acknowledge_on_call_page(page_id) # 7.61μs -> 6.36μs (19.6% faster)

def test_acknowledge_uuid_uppercase():
    """Test with UUID string in uppercase (should be valid)."""
    api = DummyOnCallPagingApi()
    page_id = str(uuid.uuid4()).upper()
    codeflash_output = api.acknowledge_on_call_page(page_id); result = codeflash_output # 7.29μs -> 5.98μs (21.9% faster)

def test_acknowledge_uuid_with_hyphens_removed():
    """Test with UUID string without hyphens (should be valid)."""
    api = DummyOnCallPagingApi()
    page_id = str(uuid.uuid4()).replace("-", "")
    codeflash_output = api.acknowledge_on_call_page(page_id); result = codeflash_output # 6.61μs -> 5.29μs (25.0% faster)

# ----------- LARGE SCALE TEST CASES -----------

def test_acknowledge_large_number_of_calls():
    """Test performance with many valid UUIDs."""
    api = DummyOnCallPagingApi()
    ids = [UUID(str(uuid.uuid4())) for _ in range(500)]
    for pid in ids:
        codeflash_output = api.acknowledge_on_call_page(pid); result = codeflash_output # 376μs -> 212μs (77.0% faster)

def test_acknowledge_large_batch_of_uuid_strings():
    """Test with a large batch of UUID strings."""
    api = DummyOnCallPagingApi()
    ids = [str(uuid.uuid4()) for _ in range(500)]
    for pid in ids:
        codeflash_output = api.acknowledge_on_call_page(pid); result = codeflash_output # 1.19ms -> 1.03ms (15.5% faster)

def test_acknowledge_large_batch_of_invalid_strings():
    """Test with a large batch of invalid strings (should all raise)."""
    api = DummyOnCallPagingApi()
    invalid_ids = [f"invalid-{i}" for i in range(100)]
    for pid in invalid_ids:
        with pytest.raises(ValueError):
            api.acknowledge_on_call_page(pid)


def test_acknowledge_uuid_subclass():
    """Test with a subclass of UUID."""
    class MyUUID(UUID):
        pass
    api = DummyOnCallPagingApi()
    pid = MyUUID(str(uuid.uuid4()))
    codeflash_output = api.acknowledge_on_call_page(pid); result = codeflash_output # 3.00μs -> 1.58μs (90.2% faster)

def test_acknowledge_uuid_object():
    """Test with a uuid.UUID object (should be valid)."""
    api = DummyOnCallPagingApi()
    pid = uuid.uuid4()
    codeflash_output = api.acknowledge_on_call_page(str(pid)); result = codeflash_output # 7.34μs -> 6.08μs (20.8% faster)

def test_acknowledge_uuid_str_with_newline():
    """Test with UUID string containing a newline (should raise)."""
    api = DummyOnCallPagingApi()
    pid = str(uuid.uuid4()) + "\n"
    with pytest.raises(ValueError):
        api.acknowledge_on_call_page(pid) # 7.51μs -> 6.18μs (21.5% faster)

def test_acknowledge_uuid_str_with_tab():
    """Test with UUID string containing a tab (should raise)."""
    api = DummyOnCallPagingApi()
    pid = str(uuid.uuid4()) + "\t"
    with pytest.raises(ValueError):
        api.acknowledge_on_call_page(pid) # 7.47μs -> 6.38μs (17.3% faster)

def test_acknowledge_uuid_str_with_special_char():
    """Test with UUID string containing a special character (should raise)."""
    api = DummyOnCallPagingApi()
    pid = str(uuid.uuid4()) + "#"
    with pytest.raises(ValueError):
        api.acknowledge_on_call_page(pid) # 7.86μs -> 6.79μs (15.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import uuid

# imports
import pytest
from src.datadog_api_client.v2.api.on_call_paging_api import OnCallPagingApi

# 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.

# Minimal stub for UUID to avoid import errors
class UUID(str):
    pass

# Minimal stub for ApiValueError and ApiTypeError
class ApiValueError(ValueError):
    pass

class ApiTypeError(TypeError):
    pass

# Main function to test, with correct external behavior
def acknowledge_on_call_page(page_id: UUID) -> None:
    endpoint = Endpoint(UUID)
    return endpoint.call_with_http_info(page_id=page_id)

# unit tests

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





#------------------------------------------------
from src.datadog_api_client.v2.api.on_call_paging_api import OnCallPagingApi