test_comparator.py

import array  # Add import for array
import ast
import copy
import dataclasses
import datetime
import decimal
import re
import sys
import uuid
import weakref
from collections import ChainMap, Counter, OrderedDict, UserDict, UserList, UserString, defaultdict, deque, namedtuple
from enum import Enum, Flag, IntFlag, auto
from pathlib import Path

import pydantic
import pytest

from codeflash.either import Failure, Success
from codeflash.models.models import FunctionTestInvocation, InvocationId, TestDiffScope, TestResults, TestType
from codeflash.verification.comparator import (
    PYTEST_TEMP_PATH_PATTERN,
    PYTHON_TEMPFILE_PATTERN,
    _extract_exception_from_message,
    _get_wrapped_exception,
    _is_temp_path,
    _normalize_temp_path,
    comparator,
)
from codeflash.verification.equivalence import compare_test_results


def test_basic_python_objects() -> None:
    a = 5
    b = 5
    c = 6
    d = None
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    a = 5.0
    b = 5.0
    c = 6.0
    d = None
    e = None
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)
    assert not comparator(d, a)
    assert comparator(d, e)

    a = "Hello"
    b = "Hello"
    c = "World"
    assert comparator(a, b)
    assert not comparator(a, c)

    a = [1, 2, 3]
    b = [1, 2, 3]
    c = [1, 2, 4]
    assert comparator(a, b)
    assert not comparator(a, c)

    a = {"a": 1, "b": 2}
    b = {"a": 1, "b": 2}
    c = {"a": 1, "b": 3}
    d = {"c": 1, "b": 2}
    e = {"a": 1, "b": 2, "c": 3}
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)
    assert not comparator(a, e)

    a = (1, 2, "str")
    b = (1, 2, "str")
    c = (1, 2, "str2")
    d = [1, 2, "str"]
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    a = {1, 2, 3}
    b = {2, 3, 1}
    c = {1, 2, 4}
    d = {1, 2, 3, 4}
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    a = (65).to_bytes(1, byteorder="big")
    b = (65).to_bytes(1, byteorder="big")
    c = (66).to_bytes(1, byteorder="big")
    assert comparator(a, b)
    assert not comparator(a, c)
    a = (65).to_bytes(2, byteorder="little")
    b = (65).to_bytes(2, byteorder="big")
    assert not comparator(a, b)

    a = bytearray([65, 64, 63])
    b = bytearray([65, 64, 63])
    c = bytearray([65, 64, 62])
    assert comparator(a, b)
    assert not comparator(a, c)

    memoryview_a = memoryview(bytearray([65, 64, 63]))
    memoryview_b = memoryview(bytearray([65, 64, 63]))
    memoryview_c = memoryview(bytearray([65, 64, 62]))
    assert comparator(memoryview_a, memoryview_b)
    assert not comparator(memoryview_a, memoryview_c)

    a = frozenset([1, 2, 3])
    b = frozenset([2, 3, 1])
    c = frozenset([1, 2, 4])
    d = frozenset([1, 2, 3, 4])
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    a = map
    b = pow
    c = pow
    d = abs
    assert comparator(b, c)
    assert not comparator(a, b)
    assert not comparator(c, d)

    a = object()
    b = object()
    c = abs
    assert comparator(a, b)
    assert not comparator(a, c)

    a = type([])
    b = type([])
    c = type({})
    assert comparator(a, b)
    assert not comparator(a, c)


def test_weakref() -> None:
    """Test comparator for weakref.ref objects."""

    # Helper class that supports weak references and has comparable __dict__
    class Holder:
        def __init__(self, value):
            self.value = value

    # Test weak references to the same object
    obj = Holder([1, 2, 3])
    ref1 = weakref.ref(obj)
    ref2 = weakref.ref(obj)
    assert comparator(ref1, ref2)

    # Test weak references to equivalent but different objects
    obj1 = Holder({"key": "value"})
    obj2 = Holder({"key": "value"})
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    assert comparator(ref1, ref2)

    # Test weak references to different objects
    obj1 = Holder([1, 2, 3])
    obj2 = Holder([1, 2, 4])
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    assert not comparator(ref1, ref2)

    # Test weak references with different data
    obj1 = Holder([1, 2, 3])
    obj2 = Holder([1, 2, 3, 4])
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    assert not comparator(ref1, ref2)

    # Test dead weak references (both dead)
    obj1 = Holder([1, 2, 3])
    obj2 = Holder([1, 2, 3])
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    del obj1
    del obj2
    # Both refs are now dead, should be equal
    assert comparator(ref1, ref2)

    # Test one dead, one alive weak reference
    obj1 = Holder([1, 2, 3])
    obj2 = Holder([1, 2, 3])
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    del obj1
    # ref1 is dead, ref2 is alive, should not be equal
    assert not comparator(ref1, ref2)
    assert not comparator(ref2, ref1)

    # Test weak references to nested structures
    obj1 = Holder({"nested": [1, 2, {"inner": "value"}]})
    obj2 = Holder({"nested": [1, 2, {"inner": "value"}]})
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    assert comparator(ref1, ref2)

    # Test weak references to nested structures with differences
    obj1 = Holder({"nested": [1, 2, {"inner": "value1"}]})
    obj2 = Holder({"nested": [1, 2, {"inner": "value2"}]})
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    assert not comparator(ref1, ref2)

    # Test weak references in a dictionary (simulating __dict__ with weakrefs)
    obj1 = Holder([1, 2, 3])
    obj2 = Holder([1, 2, 3])
    dict1 = {"data": 42, "ref": weakref.ref(obj1)}
    dict2 = {"data": 42, "ref": weakref.ref(obj2)}
    assert comparator(dict1, dict2)

    # Test weak references in a dictionary with different referents
    obj1 = Holder([1, 2, 3])
    obj2 = Holder([4, 5, 6])
    dict1 = {"data": 42, "ref": weakref.ref(obj1)}
    dict2 = {"data": 42, "ref": weakref.ref(obj2)}
    assert not comparator(dict1, dict2)

    # Test weak references in a list
    obj1 = Holder({"a": 1})
    obj2 = Holder({"a": 1})
    list1 = [weakref.ref(obj1), "other"]
    list2 = [weakref.ref(obj2), "other"]
    assert comparator(list1, list2)


def test_weakref_to_custom_objects() -> None:
    """Test comparator for weakref.ref to custom class instances."""

    class MyClass:
        def __init__(self, value):
            self.value = value

    # Test weak references to equivalent custom objects
    obj1 = MyClass(42)
    obj2 = MyClass(42)
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    assert comparator(ref1, ref2)

    # Test weak references to different custom objects
    obj1 = MyClass(42)
    obj2 = MyClass(99)
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    assert not comparator(ref1, ref2)

    # Test weak references to custom objects with nested data
    class Container:
        def __init__(self, items):
            self.items = items

    obj1 = Container([1, 2, 3])
    obj2 = Container([1, 2, 3])
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    assert comparator(ref1, ref2)

    obj1 = Container([1, 2, 3])
    obj2 = Container([1, 2, 4])
    ref1 = weakref.ref(obj1)
    ref2 = weakref.ref(obj2)
    assert not comparator(ref1, ref2)


def test_weakref_with_callbacks() -> None:
    """Test that weakrefs with callbacks are compared correctly."""

    class Holder:
        def __init__(self, value):
            self.value = value

    callback_called = []

    def callback(ref):
        callback_called.append(ref)

    obj1 = Holder([1, 2, 3])
    obj2 = Holder([1, 2, 3])
    # Weakrefs with callbacks should still compare based on referents
    ref1 = weakref.ref(obj1, callback)
    ref2 = weakref.ref(obj2, callback)
    assert comparator(ref1, ref2)

    obj1 = Holder([1, 2, 3])
    obj2 = Holder([4, 5, 6])
    ref1 = weakref.ref(obj1, callback)
    ref2 = weakref.ref(obj2, callback)
    assert not comparator(ref1, ref2)


@pytest.mark.parametrize(
    "r1, r2, expected",
    [
        (range(1, 10), range(1, 10), True),  # equal
        (range(10), range(1, 10), False),  # different start
        (range(2, 10), range(1, 10), False),
        (range(1, 5), range(1, 10), False),  # different stop
        (range(1, 20), range(1, 10), False),
        (range(1, 10, 1), range(1, 10, 2), False),  # different step
        (range(1, 10, 3), range(1, 10, 2), False),
        (range(-5, 0), range(-5, 0), True),  # negative ranges
        (range(-10, 0), range(-5, 0), False),
        (range(5, 1), range(10, 5), True),  # empty ranges
        (range(5, 1), range(5, 1), True),
        (range(7), range(7), True),
        (range(7), range(0, 7, 1), True),
        (range(7), range(0, 7, 1), True),
    ],
)
def test_ranges(r1, r2, expected):
    assert comparator(r1, r2) == expected


def test_standard_python_library_objects() -> None:
    a = datetime.datetime(2020, 2, 2, 2, 2, 2)  # type: ignore
    b = datetime.datetime(2020, 2, 2, 2, 2, 2)  # type: ignore
    c = datetime.datetime(2020, 2, 2, 2, 2, 3)  # type: ignore
    assert comparator(a, b)
    assert not comparator(a, c)

    a = datetime.date(2020, 2, 2)  # type: ignore
    b = datetime.date(2020, 2, 2)  # type: ignore
    c = datetime.date(2020, 2, 3)  # type: ignore
    assert comparator(a, b)
    assert not comparator(a, c)

    a = datetime.timedelta(days=1)  # type: ignore
    b = datetime.timedelta(days=1)  # type: ignore
    c = datetime.timedelta(days=2)  # type: ignore
    assert comparator(a, b)
    assert not comparator(a, c)

    a = datetime.time(2, 2, 2)  # type: ignore
    b = datetime.time(2, 2, 2)  # type: ignore
    c = datetime.time(2, 2, 3)  # type: ignore
    assert comparator(a, b)
    assert not comparator(a, c)

    a = datetime.timezone.utc  # type: ignore
    b = datetime.timezone.utc  # type: ignore
    c = datetime.timezone(datetime.timedelta(hours=1))  # type: ignore
    assert comparator(a, b)
    assert not comparator(a, c)

    a = decimal.Decimal(3.14)  # type: ignore
    b = decimal.Decimal(3.14)  # type: ignore
    c = decimal.Decimal(3.15)  # type: ignore
    assert comparator(a, b)
    assert not comparator(a, c)

    class Color(Flag):
        RED = auto()
        GREEN = auto()
        BLUE = auto()

    class Color2(Enum):
        RED = auto()
        GREEN = auto()
        BLUE = auto()

    a = Color.RED  # type: ignore
    b = Color.RED  # type: ignore
    c = Color.GREEN  # type: ignore
    assert comparator(a, b)
    assert not comparator(a, c)

    a = Color2.RED  # type: ignore
    b = Color2.RED  # type: ignore
    c = Color2.GREEN  # type: ignore
    assert comparator(a, b)
    assert not comparator(a, c)

    class Color4(IntFlag):
        RED = auto()
        GREEN = auto()
        BLUE = auto()

    a = Color4.RED  # type: ignore
    b = Color4.RED  # type: ignore
    c = Color4.GREEN  # type: ignore
    assert comparator(a, b)
    assert not comparator(a, c)

    a: re.Pattern = re.compile("a")
    b: re.Pattern = re.compile("a")
    c: re.Pattern = re.compile("b")
    d: re.Pattern = re.compile("a", re.IGNORECASE)
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    arr1 = array.array("i", [1, 2, 3])
    arr2 = array.array("i", [1, 2, 3])
    arr3 = array.array("i", [4, 5, 6])
    arr4 = array.array("f", [1.0, 2.0, 3.0])

    assert comparator(arr1, arr2)
    assert not comparator(arr1, arr3)
    assert not comparator(arr1, arr4)
    assert not comparator(arr1, [1, 2, 3])

    empty_arr_i1 = array.array("i")
    empty_arr_i2 = array.array("i")
    empty_arr_f = array.array("f")
    assert comparator(empty_arr_i1, empty_arr_i2)
    assert not comparator(empty_arr_i1, empty_arr_f)
    assert not comparator(empty_arr_i1, arr1)

    id1 = uuid.uuid4()
    id3 = uuid.uuid4()
    assert comparator(id1, id1)
    assert not comparator(id1, id3)


def test_itertools_count() -> None:
    import itertools

    # Equal: same start and step (default step=1)
    assert comparator(itertools.count(0), itertools.count(0))
    assert comparator(itertools.count(5), itertools.count(5))
    assert comparator(itertools.count(0, 1), itertools.count(0, 1))
    assert comparator(itertools.count(10, 3), itertools.count(10, 3))

    # Equal: negative start and step
    assert comparator(itertools.count(-5, -2), itertools.count(-5, -2))

    # Equal: float start and step
    assert comparator(itertools.count(0.5, 0.1), itertools.count(0.5, 0.1))

    # Not equal: different start
    assert not comparator(itertools.count(0), itertools.count(1))
    assert not comparator(itertools.count(5), itertools.count(10))

    # Not equal: different step
    assert not comparator(itertools.count(0, 1), itertools.count(0, 2))
    assert not comparator(itertools.count(0, 1), itertools.count(0, -1))

    # Not equal: different type
    assert not comparator(itertools.count(0), 0)
    assert not comparator(itertools.count(0), [0, 1, 2])

    # Equal after partial consumption (both advanced to the same state)
    a = itertools.count(0)
    b = itertools.count(0)
    next(a)
    next(b)
    assert comparator(a, b)

    # Not equal after different consumption
    a = itertools.count(0)
    b = itertools.count(0)
    next(a)
    assert not comparator(a, b)

    # Works inside containers
    assert comparator([itertools.count(0)], [itertools.count(0)])
    assert comparator({"key": itertools.count(5, 2)}, {"key": itertools.count(5, 2)})
    assert not comparator([itertools.count(0)], [itertools.count(1)])


def test_itertools_repeat() -> None:
    import itertools

    # Equal: infinite repeat
    assert comparator(itertools.repeat(5), itertools.repeat(5))
    assert comparator(itertools.repeat("hello"), itertools.repeat("hello"))

    # Equal: bounded repeat
    assert comparator(itertools.repeat(5, 3), itertools.repeat(5, 3))
    assert comparator(itertools.repeat(None, 10), itertools.repeat(None, 10))

    # Not equal: different value
    assert not comparator(itertools.repeat(5), itertools.repeat(6))
    assert not comparator(itertools.repeat(5, 3), itertools.repeat(6, 3))

    # Not equal: different count
    assert not comparator(itertools.repeat(5, 3), itertools.repeat(5, 4))

    # Not equal: bounded vs infinite
    assert not comparator(itertools.repeat(5), itertools.repeat(5, 3))

    # Not equal: different type
    assert not comparator(itertools.repeat(5), 5)
    assert not comparator(itertools.repeat(5), [5])

    # Equal after partial consumption
    a = itertools.repeat(5, 5)
    b = itertools.repeat(5, 5)
    next(a)
    next(b)
    assert comparator(a, b)

    # Not equal after different consumption
    a = itertools.repeat(5, 5)
    b = itertools.repeat(5, 5)
    next(a)
    assert not comparator(a, b)

    # Works inside containers
    assert comparator([itertools.repeat(5, 3)], [itertools.repeat(5, 3)])
    assert not comparator([itertools.repeat(5, 3)], [itertools.repeat(5, 4)])


def test_itertools_cycle() -> None:
    import itertools

    # Equal: same sequence
    assert comparator(itertools.cycle([1, 2, 3]), itertools.cycle([1, 2, 3]))
    assert comparator(itertools.cycle("abc"), itertools.cycle("abc"))

    # Not equal: different sequence
    assert not comparator(itertools.cycle([1, 2, 3]), itertools.cycle([1, 2, 4]))
    assert not comparator(itertools.cycle([1, 2, 3]), itertools.cycle([1, 2]))

    # Not equal: different type
    assert not comparator(itertools.cycle([1, 2, 3]), [1, 2, 3])

    # Equal after same partial consumption
    a = itertools.cycle([1, 2, 3])
    b = itertools.cycle([1, 2, 3])
    next(a)
    next(b)
    assert comparator(a, b)

    # Not equal after different consumption
    a = itertools.cycle([1, 2, 3])
    b = itertools.cycle([1, 2, 3])
    next(a)
    assert not comparator(a, b)

    # Equal after consuming a full cycle
    a = itertools.cycle([1, 2, 3])
    b = itertools.cycle([1, 2, 3])
    for _ in range(3):
        next(a)
        next(b)
    assert comparator(a, b)

    # Equal at same position across different full-cycle counts
    a = itertools.cycle([1, 2, 3])
    b = itertools.cycle([1, 2, 3])
    for _ in range(4):
        next(a)
    for _ in range(7):
        next(b)
    # Both at position 1 within the cycle (4%3 == 7%3 == 1)
    assert comparator(a, b)

    # Works inside containers
    assert comparator([itertools.cycle([1, 2])], [itertools.cycle([1, 2])])
    assert not comparator([itertools.cycle([1, 2])], [itertools.cycle([1, 3])])


def test_itertools_chain() -> None:
    import itertools

    assert comparator(itertools.chain([1, 2], [3, 4]), itertools.chain([1, 2], [3, 4]))
    assert not comparator(itertools.chain([1, 2], [3, 4]), itertools.chain([1, 2], [3, 5]))
    assert comparator(itertools.chain.from_iterable([[1, 2], [3]]), itertools.chain.from_iterable([[1, 2], [3]]))
    assert comparator(itertools.chain(), itertools.chain())
    assert not comparator(itertools.chain([1]), itertools.chain([1, 2]))


def test_itertools_islice() -> None:
    import itertools

    assert comparator(itertools.islice(range(10), 5), itertools.islice(range(10), 5))
    assert not comparator(itertools.islice(range(10), 5), itertools.islice(range(10), 6))
    assert comparator(itertools.islice(range(10), 2, 5), itertools.islice(range(10), 2, 5))
    assert not comparator(itertools.islice(range(10), 2, 5), itertools.islice(range(10), 2, 6))


def test_itertools_product() -> None:
    import itertools

    assert comparator(itertools.product("AB", repeat=2), itertools.product("AB", repeat=2))
    assert not comparator(itertools.product("AB", repeat=2), itertools.product("AC", repeat=2))
    assert comparator(itertools.product([1, 2], [3, 4]), itertools.product([1, 2], [3, 4]))
    assert not comparator(itertools.product([1, 2], [3, 4]), itertools.product([1, 2], [3, 5]))


def test_itertools_permutations_combinations() -> None:
    import itertools

    assert comparator(itertools.permutations("ABC", 2), itertools.permutations("ABC", 2))
    assert not comparator(itertools.permutations("ABC", 2), itertools.permutations("ABD", 2))
    assert comparator(itertools.combinations("ABCD", 2), itertools.combinations("ABCD", 2))
    assert not comparator(itertools.combinations("ABCD", 2), itertools.combinations("ABCD", 3))
    assert comparator(
        itertools.combinations_with_replacement("ABC", 2), itertools.combinations_with_replacement("ABC", 2)
    )
    assert not comparator(
        itertools.combinations_with_replacement("ABC", 2), itertools.combinations_with_replacement("ABD", 2)
    )


def test_itertools_accumulate() -> None:
    import itertools

    assert comparator(itertools.accumulate([1, 2, 3, 4]), itertools.accumulate([1, 2, 3, 4]))
    assert not comparator(itertools.accumulate([1, 2, 3, 4]), itertools.accumulate([1, 2, 3, 5]))
    assert comparator(itertools.accumulate([1, 2, 3], initial=10), itertools.accumulate([1, 2, 3], initial=10))
    assert not comparator(itertools.accumulate([1, 2, 3], initial=10), itertools.accumulate([1, 2, 3], initial=0))


def test_itertools_filtering() -> None:
    import itertools

    # compress
    assert comparator(
        itertools.compress("ABCDEF", [1, 0, 1, 0, 1, 1]), itertools.compress("ABCDEF", [1, 0, 1, 0, 1, 1])
    )
    assert not comparator(
        itertools.compress("ABCDEF", [1, 0, 1, 0, 1, 1]), itertools.compress("ABCDEF", [1, 1, 1, 0, 1, 1])
    )

    # dropwhile
    assert comparator(
        itertools.dropwhile(lambda x: x < 5, [1, 4, 6, 4, 1]), itertools.dropwhile(lambda x: x < 5, [1, 4, 6, 4, 1])
    )
    assert not comparator(
        itertools.dropwhile(lambda x: x < 5, [1, 4, 6, 4, 1]), itertools.dropwhile(lambda x: x < 5, [1, 4, 7, 4, 1])
    )

    # takewhile
    assert comparator(
        itertools.takewhile(lambda x: x < 5, [1, 4, 6, 4, 1]), itertools.takewhile(lambda x: x < 5, [1, 4, 6, 4, 1])
    )
    assert not comparator(
        itertools.takewhile(lambda x: x < 5, [1, 4, 6, 4, 1]), itertools.takewhile(lambda x: x < 5, [1, 3, 6, 4, 1])
    )

    # filterfalse
    assert comparator(
        itertools.filterfalse(lambda x: x % 2, range(10)), itertools.filterfalse(lambda x: x % 2, range(10))
    )


def test_itertools_starmap() -> None:
    import itertools

    assert comparator(
        itertools.starmap(pow, [(2, 3), (3, 2), (10, 0)]), itertools.starmap(pow, [(2, 3), (3, 2), (10, 0)])
    )
    assert not comparator(itertools.starmap(pow, [(2, 3), (3, 2)]), itertools.starmap(pow, [(2, 3), (3, 3)]))


def test_itertools_zip_longest() -> None:
    import itertools

    assert comparator(
        itertools.zip_longest("AB", "xyz", fillvalue="-"), itertools.zip_longest("AB", "xyz", fillvalue="-")
    )
    assert not comparator(
        itertools.zip_longest("AB", "xyz", fillvalue="-"), itertools.zip_longest("AB", "xyz", fillvalue="*")
    )


def test_itertools_groupby() -> None:
    import itertools

    assert comparator(itertools.groupby("AAABBBCC"), itertools.groupby("AAABBBCC"))
    assert not comparator(itertools.groupby("AAABBBCC"), itertools.groupby("AAABBCC"))
    assert comparator(itertools.groupby([]), itertools.groupby([]))

    # With key function
    assert comparator(
        itertools.groupby([1, 1, 2, 2, 3], key=lambda x: x), itertools.groupby([1, 1, 2, 2, 3], key=lambda x: x)
    )


@pytest.mark.skipif(sys.version_info < (3, 10), reason="itertools.pairwise requires Python 3.10+")
def test_itertools_pairwise() -> None:
    import itertools

    assert comparator(itertools.pairwise([1, 2, 3, 4]), itertools.pairwise([1, 2, 3, 4]))
    assert not comparator(itertools.pairwise([1, 2, 3, 4]), itertools.pairwise([1, 2, 3, 5]))


@pytest.mark.skipif(sys.version_info < (3, 12), reason="itertools.batched requires Python 3.12+")
def test_itertools_batched() -> None:
    import itertools

    assert comparator(itertools.batched("ABCDEFG", 3), itertools.batched("ABCDEFG", 3))
    assert not comparator(itertools.batched("ABCDEFG", 3), itertools.batched("ABCDEFG", 2))


def test_itertools_in_containers() -> None:
    import itertools

    # Itertools objects nested in dicts/lists
    assert comparator(
        {"a": itertools.chain([1], [2]), "b": itertools.islice(range(5), 3)},
        {"a": itertools.chain([1], [2]), "b": itertools.islice(range(5), 3)},
    )
    assert not comparator([itertools.product("AB", repeat=2)], [itertools.product("AC", repeat=2)])

    # Different itertools types should not match
    assert not comparator(itertools.chain([1, 2]), itertools.islice([1, 2], 2))


def test_numpy():
    try:
        import numpy as np
    except ImportError:
        pytest.skip()
    a = np.array([1, 2, 3])
    b = np.array([1, 2, 3])
    c = np.array([1, 2, 4])
    assert comparator(a, b)
    assert not comparator(a, c)

    d = np.array([[1, 2], [3, 4]])
    e = np.array([[1, 2], [3, 4]])
    f = np.array([[1, 2], [3, 5]])
    assert comparator(d, e)
    assert not comparator(d, f)
    assert not comparator(a, d)

    g = np.array([1.0, 2.0, 3.0])
    assert not comparator(a, g)

    h = np.float32(1.0)
    i = np.float32(1.0)
    assert comparator(h, i)

    j = np.float64(1.0)
    k = np.float64(1.0)
    assert not comparator(h, j)
    assert comparator(j, k)

    l = np.int32(1)
    m = np.int32(1)
    assert comparator(l, m)
    assert not comparator(l, h)
    assert not comparator(l, j)

    n = np.int64(1)
    o = np.int64(1)
    assert not comparator(n, l)
    assert comparator(n, o)

    p = np.uint32(1)
    q = np.uint32(1)
    assert comparator(p, q)
    assert not comparator(p, l)

    r = np.uint64(1)
    s = np.uint64(1)
    assert not comparator(r, p)
    assert comparator(r, s)

    t = np.bool_(True)
    u = np.bool_(True)
    assert comparator(t, u)
    assert not comparator(t, r)

    v = np.complex64(1.0 + 1.0j)
    w = np.complex64(1.0 + 1.0j)
    assert comparator(v, w)
    assert not comparator(v, t)

    x = np.complex128(1.0 + 1.0j)
    y = np.complex128(1.0 + 1.0j)
    assert not comparator(x, v)
    assert comparator(x, y)

    # Create numpy array with mixed type object
    z = np.array([1, 2, "str"], dtype=np.object_)
    aa = np.array([1, 2, "str"], dtype=np.object_)
    ab = np.array([1, 2, "str2"], dtype=np.object_)
    assert comparator(z, aa)
    assert not comparator(z, ab)

    ac = np.array([1, 2, "str2"])
    ad = np.array([1, 2, "str2"])
    assert comparator(ac, ad)

    # Test for numpy array with nan and inf
    ae = np.array([1, 2, np.nan])
    af = np.array([1, 2, np.nan])
    ag = np.array([1, 2, np.inf])
    ah = np.array([1, 2, np.inf])
    ai = np.inf
    aj = np.inf
    ak = np.nan
    al = np.nan
    assert comparator(ae, af)
    assert comparator(ag, ah)
    assert not comparator(ae, ag)
    assert not comparator(af, ah)
    assert comparator(ai, aj)
    assert comparator(ak, al)
    assert not comparator(ai, ak)

    dt = np.dtype([("name", "S10"), ("age", np.int32)])
    a_struct = np.array([("Alice", 25)], dtype=dt)
    b_struct = np.array([("Alice", 25)], dtype=dt)
    c_struct = np.array([("Bob", 30)], dtype=dt)

    a_void = a_struct[0]
    b_void = b_struct[0]
    c_void = c_struct[0]

    assert isinstance(a_void, np.void)
    assert comparator(a_void, b_void)
    assert not comparator(a_void, c_void)


def test_numpy_random_generator():
    try:
        import numpy as np
    except ImportError:
        pytest.skip()

    # Test numpy.random.Generator (modern API)
    # Same seed should produce equal generators
    rng1 = np.random.default_rng(seed=42)
    rng2 = np.random.default_rng(seed=42)
    assert comparator(rng1, rng2)

    # Different seeds should produce non-equal generators
    rng3 = np.random.default_rng(seed=123)
    assert not comparator(rng1, rng3)

    # After generating numbers, state changes
    rng4 = np.random.default_rng(seed=42)
    rng5 = np.random.default_rng(seed=42)
    rng4.random()  # Advance state
    assert not comparator(rng4, rng5)

    # Both advanced by same amount should be equal
    rng5.random()
    assert comparator(rng4, rng5)

    # Test with different bit generators
    from numpy.random import MT19937, PCG64

    rng_pcg1 = np.random.Generator(PCG64(seed=42))
    rng_pcg2 = np.random.Generator(PCG64(seed=42))
    assert comparator(rng_pcg1, rng_pcg2)

    rng_mt1 = np.random.Generator(MT19937(seed=42))
    rng_mt2 = np.random.Generator(MT19937(seed=42))
    assert comparator(rng_mt1, rng_mt2)

    # Different bit generator types should not be equal
    assert not comparator(rng_pcg1, rng_mt1)


def test_numpy_random_state():
    try:
        import numpy as np
    except ImportError:
        pytest.skip()

    # Test numpy.random.RandomState (legacy API)
    # Same seed should produce equal states
    rs1 = np.random.RandomState(seed=42)
    rs2 = np.random.RandomState(seed=42)
    assert comparator(rs1, rs2)

    # Different seeds should produce non-equal states
    rs3 = np.random.RandomState(seed=123)
    assert not comparator(rs1, rs3)

    # After generating numbers, state changes
    rs4 = np.random.RandomState(seed=42)
    rs5 = np.random.RandomState(seed=42)
    rs4.random()  # Advance state
    assert not comparator(rs4, rs5)

    # Both advanced by same amount should be equal
    rs5.random()
    assert comparator(rs4, rs5)

    # Test state restoration
    rs6 = np.random.RandomState(seed=42)
    state = rs6.get_state()
    rs6.random()  # Advance state
    rs7 = np.random.RandomState(seed=42)
    rs7.set_state(state)
    # rs6 advanced, rs7 restored to original state
    assert not comparator(rs6, rs7)


def test_scipy():
    try:
        import scipy as sp  # type: ignore
    except ImportError:
        pytest.skip()
    a = sp.sparse.csr_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    b = sp.sparse.csr_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    c = sp.sparse.csr_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 6]])
    ca = sp.sparse.csr_matrix([[1, 0, 0, 0], [0, 0, 3, 0], [4, 0, 6, 0]])
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(c, ca)

    d = sp.sparse.csc_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    e = sp.sparse.csc_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    f = sp.sparse.csc_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 6]])
    fa = sp.sparse.csc_matrix([[1, 0, 0, 0], [0, 0, 3, 0], [4, 0, 6, 0]])
    assert comparator(d, e)
    assert not comparator(d, f)
    assert not comparator(a, d)
    assert not comparator(c, f)
    assert not comparator(f, fa)

    g = sp.sparse.lil_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    h = sp.sparse.lil_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    i = sp.sparse.lil_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 6]])
    assert comparator(g, h)
    assert not comparator(g, i)
    assert not comparator(a, g)

    j = sp.sparse.dok_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    k = sp.sparse.dok_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    l = sp.sparse.dok_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 6]])
    assert comparator(j, k)
    assert not comparator(j, l)
    assert not comparator(a, j)

    m = sp.sparse.dia_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    n = sp.sparse.dia_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    o = sp.sparse.dia_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 6]])
    assert comparator(m, n)
    assert not comparator(m, o)
    assert not comparator(a, m)

    p = sp.sparse.coo_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    q = sp.sparse.coo_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    r = sp.sparse.coo_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 6]])
    assert comparator(p, q)
    assert not comparator(p, r)
    assert not comparator(a, p)

    s = sp.sparse.bsr_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    t = sp.sparse.bsr_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 5]])
    u = sp.sparse.bsr_matrix([[1, 0, 0], [0, 0, 3], [4, 0, 6]])
    assert comparator(s, t)
    assert not comparator(s, u)
    assert not comparator(a, s)

    try:
        import numpy as np

        row = np.array([0, 3, 1, 0])
        col = np.array([0, 3, 1, 2])
        data = np.array([4, 5, 7, 9])
        v = sp.sparse.coo_array((data, (row, col)), shape=(4, 4)).toarray()
        w = sp.sparse.coo_array((data, (row, col)), shape=(4, 4)).toarray()
        assert comparator(v, w)
    except ImportError:
        print("Should run tests with numpy installed to test more thoroughly")


def test_pandas():
    try:
        import pandas as pd
    except ImportError:
        pytest.skip()
    a = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
    b = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
    c = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 7]})
    ca = pd.DataFrame({"a": [1, 2, 3, 4], "b": [4, 5, 6, 7]})
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(c, ca)

    ak = pd.DataFrame(
        {"a": [datetime.datetime(2020, 2, 2, 2, 2, 2), datetime.datetime(2020, 2, 2, 2, 2, 2)], "b": [4, 5]}
    )
    al = pd.DataFrame(
        {"a": [datetime.datetime(2020, 2, 2, 2, 2, 2), datetime.datetime(2020, 2, 2, 2, 2, 2)], "b": [4, 5]}
    )
    am = pd.DataFrame(
        {"a": [datetime.datetime(2020, 2, 2, 2, 2, 2), datetime.datetime(2020, 2, 2, 2, 2, 3)], "b": [4, 5]}
    )
    assert comparator(ak, al)
    assert not comparator(ak, am)

    d = pd.Series([1, 2, 3])
    e = pd.Series([1, 2, 3])
    f = pd.Series([1, 2, 4])
    assert comparator(d, e)
    assert not comparator(d, f)

    g = pd.Index([1, 2, 3])
    h = pd.Index([1, 2, 3])
    i = pd.Index([1, 2, 4])
    assert comparator(g, h)
    assert not comparator(g, i)

    j = pd.MultiIndex.from_tuples([(1, 2), (3, 4)])
    k = pd.MultiIndex.from_tuples([(1, 2), (3, 4)])
    l = pd.MultiIndex.from_tuples([(1, 2), (3, 5)])
    assert comparator(j, k)
    assert not comparator(j, l)

    m = pd.Categorical([1, 2, 3])
    n = pd.Categorical([1, 2, 3])
    o = pd.Categorical([1, 2, 4])
    assert comparator(m, n)
    assert not comparator(m, o)

    p = pd.Interval(1, 2)
    q = pd.Interval(1, 2)
    r = pd.Interval(1, 3)
    assert comparator(p, q)
    assert not comparator(p, r)

    s = pd.IntervalIndex.from_tuples([(1, 2), (3, 4)])
    t = pd.IntervalIndex.from_tuples([(1, 2), (3, 4)])
    u = pd.IntervalIndex.from_tuples([(1, 2), (3, 5)])
    assert comparator(s, t)
    assert not comparator(s, u)

    v = pd.Period("2021-01")
    w = pd.Period("2021-01")
    x = pd.Period("2021-02")
    assert comparator(v, w)
    assert not comparator(v, x)

    y = pd.period_range(start="2021-01", periods=3, freq="M")
    z = pd.period_range(start="2021-01", periods=3, freq="M")
    aa = pd.period_range(start="2021-01", periods=4, freq="M")
    assert comparator(y, z)
    assert not comparator(y, aa)

    ab = pd.Timedelta("1 days")
    ac = pd.Timedelta("1 days")
    ad = pd.Timedelta("2 days")
    assert comparator(ab, ac)
    assert not comparator(ab, ad)

    ae = pd.TimedeltaIndex(["1 days", "2 days"])
    af = pd.TimedeltaIndex(["1 days", "2 days"])
    ag = pd.TimedeltaIndex(["1 days", "3 days"])
    assert comparator(ae, af)
    assert not comparator(ae, ag)

    ah = pd.Timestamp("2021-01-01")
    ai = pd.Timestamp("2021-01-01")
    aj = pd.Timestamp("2021-01-02")
    assert comparator(ah, ai)
    assert not comparator(ah, aj)

    # test cases for sparse pandas arrays
    an = pd.arrays.SparseArray([1, 2, 3])
    ao = pd.arrays.SparseArray([1, 2, 3])
    ap = pd.arrays.SparseArray([1, 2, 4])
    assert comparator(an, ao)
    assert not comparator(an, ap)

    assert comparator(pd.NA, pd.NA)
    assert not comparator(pd.NA, None)
    assert not comparator(None, pd.NA)

    s1 = pd.Series([1, 2, pd.NA, 4])
    s2 = pd.Series([1, 2, pd.NA, 4])
    s3 = pd.Series([1, 2, None, 4])

    assert comparator(s1, s2)
    assert not comparator(s1, s3)

    df1 = pd.DataFrame({"a": [1, 2, pd.NA], "b": [4, pd.NA, 6]})
    df2 = pd.DataFrame({"a": [1, 2, pd.NA], "b": [4, pd.NA, 6]})
    df3 = pd.DataFrame({"a": [1, 2, None], "b": [4, None, 6]})
    assert comparator(df1, df2)
    assert not comparator(df1, df3)

    d1 = {"a": pd.NA, "b": [1, pd.NA, 3]}
    d2 = {"a": pd.NA, "b": [1, pd.NA, 3]}
    d3 = {"a": None, "b": [1, None, 3]}
    assert comparator(d1, d2)
    assert not comparator(d1, d3)

    s1 = pd.Series([1, 2, pd.NA, 4])
    s2 = pd.Series([1, 2, pd.NA, 4])

    filtered1 = s1[s1 > 1]
    filtered2 = s2[s2 > 1]
    assert comparator(filtered1, filtered2)


def test_pyarrow():
    try:
        import pyarrow as pa
    except ImportError:
        pytest.skip()

    # Test PyArrow Table
    table1 = pa.table({"a": [1, 2, 3], "b": [4, 5, 6]})
    table2 = pa.table({"a": [1, 2, 3], "b": [4, 5, 6]})
    table3 = pa.table({"a": [1, 2, 3], "b": [4, 5, 7]})
    table4 = pa.table({"a": [1, 2, 3, 4], "b": [4, 5, 6, 7]})
    table5 = pa.table({"a": [1, 2, 3], "c": [4, 5, 6]})  # different column name

    assert comparator(table1, table2)
    assert not comparator(table1, table3)
    assert not comparator(table1, table4)
    assert not comparator(table1, table5)

    # Test PyArrow RecordBatch
    batch1 = pa.RecordBatch.from_pydict({"x": [1, 2], "y": [3.0, 4.0]})
    batch2 = pa.RecordBatch.from_pydict({"x": [1, 2], "y": [3.0, 4.0]})
    batch3 = pa.RecordBatch.from_pydict({"x": [1, 2], "y": [3.0, 5.0]})
    batch4 = pa.RecordBatch.from_pydict({"x": [1, 2, 3], "y": [3.0, 4.0, 5.0]})

    assert comparator(batch1, batch2)
    assert not comparator(batch1, batch3)
    assert not comparator(batch1, batch4)

    # Test PyArrow Array
    arr1 = pa.array([1, 2, 3])
    arr2 = pa.array([1, 2, 3])
    arr3 = pa.array([1, 2, 4])
    arr4 = pa.array([1, 2, 3, 4])
    arr5 = pa.array([1.0, 2.0, 3.0])  # different type

    assert comparator(arr1, arr2)
    assert not comparator(arr1, arr3)
    assert not comparator(arr1, arr4)
    assert not comparator(arr1, arr5)

    # Test PyArrow Array with nulls
    arr_null1 = pa.array([1, None, 3])
    arr_null2 = pa.array([1, None, 3])
    arr_null3 = pa.array([1, 2, 3])

    assert comparator(arr_null1, arr_null2)
    assert not comparator(arr_null1, arr_null3)

    # Test PyArrow ChunkedArray
    chunked1 = pa.chunked_array([[1, 2], [3, 4]])
    chunked2 = pa.chunked_array([[1, 2], [3, 4]])
    chunked3 = pa.chunked_array([[1, 2], [3, 5]])
    chunked4 = pa.chunked_array([[1, 2, 3], [4, 5]])

    assert comparator(chunked1, chunked2)
    assert not comparator(chunked1, chunked3)
    assert not comparator(chunked1, chunked4)

    # Test PyArrow Scalar
    scalar1 = pa.scalar(42)
    scalar2 = pa.scalar(42)
    scalar3 = pa.scalar(43)
    scalar4 = pa.scalar(42.0)  # different type

    assert comparator(scalar1, scalar2)
    assert not comparator(scalar1, scalar3)
    assert not comparator(scalar1, scalar4)

    # Test null scalars
    null_scalar1 = pa.scalar(None, type=pa.int64())
    null_scalar2 = pa.scalar(None, type=pa.int64())
    null_scalar3 = pa.scalar(None, type=pa.float64())

    assert comparator(null_scalar1, null_scalar2)
    assert not comparator(null_scalar1, null_scalar3)

    # Test PyArrow Schema
    schema1 = pa.schema([("a", pa.int64()), ("b", pa.float64())])
    schema2 = pa.schema([("a", pa.int64()), ("b", pa.float64())])
    schema3 = pa.schema([("a", pa.int64()), ("c", pa.float64())])
    schema4 = pa.schema([("a", pa.int32()), ("b", pa.float64())])

    assert comparator(schema1, schema2)
    assert not comparator(schema1, schema3)
    assert not comparator(schema1, schema4)

    # Test PyArrow Field
    field1 = pa.field("name", pa.int64())
    field2 = pa.field("name", pa.int64())
    field3 = pa.field("other", pa.int64())
    field4 = pa.field("name", pa.float64())

    assert comparator(field1, field2)
    assert not comparator(field1, field3)
    assert not comparator(field1, field4)

    # Test PyArrow DataType
    type1 = pa.int64()
    type2 = pa.int64()
    type3 = pa.int32()
    type4 = pa.float64()

    assert comparator(type1, type2)
    assert not comparator(type1, type3)
    assert not comparator(type1, type4)

    # Test string arrays
    str_arr1 = pa.array(["hello", "world"])
    str_arr2 = pa.array(["hello", "world"])
    str_arr3 = pa.array(["hello", "there"])

    assert comparator(str_arr1, str_arr2)
    assert not comparator(str_arr1, str_arr3)

    # Test nested types (struct)
    struct_arr1 = pa.array([{"x": 1, "y": 2}, {"x": 3, "y": 4}])
    struct_arr2 = pa.array([{"x": 1, "y": 2}, {"x": 3, "y": 4}])
    struct_arr3 = pa.array([{"x": 1, "y": 2}, {"x": 3, "y": 5}])

    assert comparator(struct_arr1, struct_arr2)
    assert not comparator(struct_arr1, struct_arr3)

    # Test list arrays
    list_arr1 = pa.array([[1, 2], [3, 4, 5]])
    list_arr2 = pa.array([[1, 2], [3, 4, 5]])
    list_arr3 = pa.array([[1, 2], [3, 4, 6]])

    assert comparator(list_arr1, list_arr2)
    assert not comparator(list_arr1, list_arr3)


def test_pyrsistent():
    try:
        from pyrsistent import PBag, PClass, PRecord, field, pdeque, pmap, pset, pvector  # type: ignore
    except ImportError:
        pytest.skip()

    a = pmap({"a": 1, "b": 2})
    b = pmap({"a": 1, "b": 2})
    c = pmap({"a": 1, "b": 3})
    assert comparator(a, b)
    assert not comparator(a, c)

    d = pvector([1, 2, 3])
    e = pvector([1, 2, 3])
    f = pvector([1, 2, 4])
    assert comparator(d, e)
    assert not comparator(d, f)

    g = pset([1, 2, 3])
    h = pset([2, 3, 1])
    i = pset([1, 2, 4])
    assert comparator(g, h)
    assert not comparator(g, i)

    class TestRecord(PRecord):
        a = field()
        b = field()

    j = TestRecord()
    k = TestRecord()
    l = TestRecord(a=2, b=3)
    assert comparator(j, k)
    assert not comparator(j, l)

    class TestClass(PClass):
        a = field()
        b = field()

    m = TestClass()
    n = TestClass()
    o = TestClass(a=1, b=3)
    assert comparator(m, n)
    assert not comparator(m, o)

    p = pdeque([1, 2, 3], 3)
    q = pdeque([1, 2, 3], 3)
    r = pdeque([1, 2, 4], 3)
    assert comparator(p, q)
    assert not comparator(p, r)

    s = PBag([1, 2, 3])
    t = PBag([1, 2, 3])
    u = PBag([1, 2, 4])
    assert comparator(s, t)
    assert not comparator(s, u)

    v = pvector([1, 2, 3])
    w = pvector([1, 2, 3])
    x = pvector([1, 2, 4])
    assert comparator(v, w)
    assert not comparator(v, x)


def test_torch_dtype():
    try:
        import torch  # type: ignore
    except ImportError:
        pytest.skip()

    # Test torch.dtype comparisons
    a = torch.float32
    b = torch.float32
    c = torch.float64
    d = torch.int32
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    # Test different dtype categories
    e = torch.int64
    f = torch.int64
    g = torch.int32
    assert comparator(e, f)
    assert not comparator(e, g)

    # Test complex dtypes
    h = torch.complex64
    i = torch.complex64
    j = torch.complex128
    assert comparator(h, i)
    assert not comparator(h, j)

    # Test bool dtype
    k = torch.bool
    l = torch.bool
    m = torch.int8
    assert comparator(k, l)
    assert not comparator(k, m)


def test_torch():
    try:
        import torch  # type: ignore
    except ImportError:
        pytest.skip()

    a = torch.tensor([1, 2, 3])
    b = torch.tensor([1, 2, 3])
    c = torch.tensor([1, 2, 4])
    assert comparator(a, b)
    assert not comparator(a, c)

    d = torch.tensor([[1, 2, 3], [4, 5, 6]])
    e = torch.tensor([[1, 2, 3], [4, 5, 6]])
    f = torch.tensor([[1, 2, 3], [4, 5, 7]])
    assert comparator(d, e)
    assert not comparator(d, f)

    # Test tensors with different data types
    g = torch.tensor([1, 2, 3], dtype=torch.float32)
    h = torch.tensor([1, 2, 3], dtype=torch.float32)
    i = torch.tensor([1, 2, 3], dtype=torch.int64)
    assert comparator(g, h)
    assert not comparator(g, i)

    # Test 3D tensors
    j = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
    k = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
    l = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 9]]])
    assert comparator(j, k)
    assert not comparator(j, l)

    # Test tensors with different shapes
    m = torch.tensor([1, 2, 3])
    n = torch.tensor([[1, 2, 3]])
    assert not comparator(m, n)

    # Test empty tensors
    o = torch.tensor([])
    p = torch.tensor([])
    q = torch.tensor([1])
    assert comparator(o, p)
    assert not comparator(o, q)

    # Test tensors with NaN values
    r = torch.tensor([1.0, float("nan"), 3.0])
    s = torch.tensor([1.0, float("nan"), 3.0])
    t = torch.tensor([1.0, 2.0, 3.0])
    assert comparator(r, s)  # NaN == NaN
    assert not comparator(r, t)

    # Test tensors with infinity values
    u = torch.tensor([1.0, float("inf"), 3.0])
    v = torch.tensor([1.0, float("inf"), 3.0])
    w = torch.tensor([1.0, float("-inf"), 3.0])
    assert comparator(u, v)
    assert not comparator(u, w)

    # Test tensors with different devices (if CUDA is available)
    if torch.cuda.is_available():
        x = torch.tensor([1, 2, 3]).cuda()
        y = torch.tensor([1, 2, 3]).cuda()
        z = torch.tensor([1, 2, 3])
        assert comparator(x, y)
        assert not comparator(x, z)

    # Test tensors with requires_grad
    aa = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
    bb = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
    cc = torch.tensor([1.0, 2.0, 3.0], requires_grad=False)
    assert comparator(aa, bb)
    assert not comparator(aa, cc)

    # Test complex tensors
    dd = torch.tensor([1 + 2j, 3 + 4j])
    ee = torch.tensor([1 + 2j, 3 + 4j])
    ff = torch.tensor([1 + 2j, 3 + 5j])
    assert comparator(dd, ee)
    assert not comparator(dd, ff)

    # Test boolean tensors
    gg = torch.tensor([True, False, True])
    hh = torch.tensor([True, False, True])
    ii = torch.tensor([True, True, True])
    assert comparator(gg, hh)
    assert not comparator(gg, ii)


def test_torch_device():
    try:
        import torch  # type: ignore
    except ImportError:
        pytest.skip()

    # Test torch.device comparisons - same device type
    a = torch.device("cpu")
    b = torch.device("cpu")
    assert comparator(a, b)

    # Test different device types
    c = torch.device("cpu")
    d = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
    if torch.cuda.is_available():
        assert not comparator(c, d)

    # Test device with index
    e = torch.device("cpu")
    f = torch.device("cpu")
    assert comparator(e, f)

    # Test cuda devices with different indices (if multiple GPUs available)
    if torch.cuda.is_available() and torch.cuda.device_count() > 1:
        g = torch.device("cuda:0")
        h = torch.device("cuda:0")
        i = torch.device("cuda:1")
        assert comparator(g, h)
        assert not comparator(g, i)

    # Test cuda device with and without explicit index
    if torch.cuda.is_available():
        j = torch.device("cuda:0")
        k = torch.device("cuda", 0)
        assert comparator(j, k)

    # Test meta device
    l = torch.device("meta")
    m = torch.device("meta")
    n = torch.device("cpu")
    assert comparator(l, m)
    assert not comparator(l, n)


def test_torch_nn_linear():
    """Test comparator for torch.nn.Linear modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical Linear layers
    torch.manual_seed(42)
    a = nn.Linear(10, 5)
    torch.manual_seed(42)
    b = nn.Linear(10, 5)
    assert comparator(a, b)

    # Test Linear layers with different weights (different seeds)
    torch.manual_seed(42)
    c = nn.Linear(10, 5)
    torch.manual_seed(123)
    d = nn.Linear(10, 5)
    assert not comparator(c, d)

    # Test Linear layers with different in_features
    torch.manual_seed(42)
    e = nn.Linear(10, 5)
    torch.manual_seed(42)
    f = nn.Linear(20, 5)
    assert not comparator(e, f)

    # Test Linear layers with different out_features
    torch.manual_seed(42)
    g = nn.Linear(10, 5)
    torch.manual_seed(42)
    h = nn.Linear(10, 10)
    assert not comparator(g, h)

    # Test Linear with and without bias
    torch.manual_seed(42)
    i = nn.Linear(10, 5, bias=True)
    torch.manual_seed(42)
    j = nn.Linear(10, 5, bias=False)
    assert not comparator(i, j)

    # Test Linear layers in train vs eval mode
    torch.manual_seed(42)
    k = nn.Linear(10, 5)
    k.train()
    torch.manual_seed(42)
    l = nn.Linear(10, 5)
    l.eval()
    assert not comparator(k, l)


def test_torch_nn_conv2d():
    """Test comparator for torch.nn.Conv2d modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical Conv2d layers
    torch.manual_seed(42)
    a = nn.Conv2d(3, 16, kernel_size=3)
    torch.manual_seed(42)
    b = nn.Conv2d(3, 16, kernel_size=3)
    assert comparator(a, b)

    # Test Conv2d with different weights
    torch.manual_seed(42)
    c = nn.Conv2d(3, 16, kernel_size=3)
    torch.manual_seed(123)
    d = nn.Conv2d(3, 16, kernel_size=3)
    assert not comparator(c, d)

    # Test Conv2d with different in_channels
    torch.manual_seed(42)
    e = nn.Conv2d(3, 16, kernel_size=3)
    torch.manual_seed(42)
    f = nn.Conv2d(1, 16, kernel_size=3)
    assert not comparator(e, f)

    # Test Conv2d with different out_channels
    torch.manual_seed(42)
    g = nn.Conv2d(3, 16, kernel_size=3)
    torch.manual_seed(42)
    h = nn.Conv2d(3, 32, kernel_size=3)
    assert not comparator(g, h)

    # Test Conv2d with different kernel_size
    torch.manual_seed(42)
    i = nn.Conv2d(3, 16, kernel_size=3)
    torch.manual_seed(42)
    j = nn.Conv2d(3, 16, kernel_size=5)
    assert not comparator(i, j)

    # Test Conv2d with different stride
    torch.manual_seed(42)
    k = nn.Conv2d(3, 16, kernel_size=3, stride=1)
    torch.manual_seed(42)
    l = nn.Conv2d(3, 16, kernel_size=3, stride=2)
    assert not comparator(k, l)

    # Test Conv2d with different padding
    torch.manual_seed(42)
    m = nn.Conv2d(3, 16, kernel_size=3, padding=0)
    torch.manual_seed(42)
    n = nn.Conv2d(3, 16, kernel_size=3, padding=1)
    assert not comparator(m, n)


def test_torch_nn_batchnorm():
    """Test comparator for torch.nn.BatchNorm modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical BatchNorm2d layers
    torch.manual_seed(42)
    a = nn.BatchNorm2d(16)
    torch.manual_seed(42)
    b = nn.BatchNorm2d(16)
    assert comparator(a, b)

    # Test BatchNorm2d with different num_features
    torch.manual_seed(42)
    c = nn.BatchNorm2d(16)
    torch.manual_seed(42)
    d = nn.BatchNorm2d(32)
    assert not comparator(c, d)

    # Test BatchNorm2d with different eps
    torch.manual_seed(42)
    e = nn.BatchNorm2d(16, eps=1e-5)
    torch.manual_seed(42)
    f = nn.BatchNorm2d(16, eps=1e-3)
    assert not comparator(e, f)

    # Test BatchNorm2d with different momentum
    torch.manual_seed(42)
    g = nn.BatchNorm2d(16, momentum=0.1)
    torch.manual_seed(42)
    h = nn.BatchNorm2d(16, momentum=0.01)
    assert not comparator(g, h)

    # Test BatchNorm2d with and without affine
    torch.manual_seed(42)
    i = nn.BatchNorm2d(16, affine=True)
    torch.manual_seed(42)
    j = nn.BatchNorm2d(16, affine=False)
    assert not comparator(i, j)

    # Test BatchNorm2d running stats after forward passes
    torch.manual_seed(42)
    k = nn.BatchNorm2d(16)
    k.train()
    input_k = torch.randn(4, 16, 8, 8)
    _ = k(input_k)
    torch.manual_seed(42)
    l = nn.BatchNorm2d(16)
    l.train()
    input_l = torch.randn(4, 16, 8, 8)
    _ = l(input_l)
    # Same seed means same running stats
    assert comparator(k, l)

    # Test BatchNorm2d with different running stats
    torch.manual_seed(42)
    m = nn.BatchNorm2d(16)
    m.train()
    torch.manual_seed(42)
    _ = m(torch.randn(4, 16, 8, 8))
    torch.manual_seed(42)
    n = nn.BatchNorm2d(16)
    n.train()
    torch.manual_seed(123)
    _ = n(torch.randn(4, 16, 8, 8))
    assert not comparator(m, n)

    # Test BatchNorm1d
    torch.manual_seed(42)
    o = nn.BatchNorm1d(16)
    torch.manual_seed(42)
    p = nn.BatchNorm1d(16)
    assert comparator(o, p)


def test_torch_nn_dropout():
    """Test comparator for torch.nn.Dropout modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical Dropout layers
    a = nn.Dropout(p=0.5)
    b = nn.Dropout(p=0.5)
    assert comparator(a, b)

    # Test Dropout with different p values
    c = nn.Dropout(p=0.5)
    d = nn.Dropout(p=0.3)
    assert not comparator(c, d)

    # Test Dropout with different inplace values
    e = nn.Dropout(p=0.5, inplace=False)
    f = nn.Dropout(p=0.5, inplace=True)
    assert not comparator(e, f)

    # Test Dropout2d
    g = nn.Dropout2d(p=0.5)
    h = nn.Dropout2d(p=0.5)
    assert comparator(g, h)

    # Test Dropout vs Dropout2d (different types)
    i = nn.Dropout(p=0.5)
    j = nn.Dropout2d(p=0.5)
    assert not comparator(i, j)


def test_torch_nn_activation():
    """Test comparator for torch.nn activation modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test ReLU
    a = nn.ReLU()
    b = nn.ReLU()
    assert comparator(a, b)

    # Test ReLU with different inplace
    c = nn.ReLU(inplace=False)
    d = nn.ReLU(inplace=True)
    assert not comparator(c, d)

    # Test LeakyReLU
    e = nn.LeakyReLU(negative_slope=0.01)
    f = nn.LeakyReLU(negative_slope=0.01)
    assert comparator(e, f)

    # Test LeakyReLU with different negative_slope
    g = nn.LeakyReLU(negative_slope=0.01)
    h = nn.LeakyReLU(negative_slope=0.1)
    assert not comparator(g, h)

    # Test Sigmoid vs ReLU (different types)
    i = nn.Sigmoid()
    j = nn.ReLU()
    assert not comparator(i, j)

    # Test GELU
    k = nn.GELU()
    l = nn.GELU()
    assert comparator(k, l)

    # Test Softmax
    m = nn.Softmax(dim=1)
    n = nn.Softmax(dim=1)
    assert comparator(m, n)

    # Test Softmax with different dim
    o = nn.Softmax(dim=1)
    p = nn.Softmax(dim=0)
    assert not comparator(o, p)


def test_torch_nn_pooling():
    """Test comparator for torch.nn pooling modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test MaxPool2d
    a = nn.MaxPool2d(kernel_size=2)
    b = nn.MaxPool2d(kernel_size=2)
    assert comparator(a, b)

    # Test MaxPool2d with different kernel_size
    c = nn.MaxPool2d(kernel_size=2)
    d = nn.MaxPool2d(kernel_size=3)
    assert not comparator(c, d)

    # Test MaxPool2d with different stride
    e = nn.MaxPool2d(kernel_size=2, stride=2)
    f = nn.MaxPool2d(kernel_size=2, stride=1)
    assert not comparator(e, f)

    # Test AvgPool2d
    g = nn.AvgPool2d(kernel_size=2)
    h = nn.AvgPool2d(kernel_size=2)
    assert comparator(g, h)

    # Test MaxPool2d vs AvgPool2d (different types)
    i = nn.MaxPool2d(kernel_size=2)
    j = nn.AvgPool2d(kernel_size=2)
    assert not comparator(i, j)

    # Test AdaptiveAvgPool2d
    k = nn.AdaptiveAvgPool2d(output_size=(1, 1))
    l = nn.AdaptiveAvgPool2d(output_size=(1, 1))
    assert comparator(k, l)

    # Test AdaptiveAvgPool2d with different output_size
    m = nn.AdaptiveAvgPool2d(output_size=(1, 1))
    n = nn.AdaptiveAvgPool2d(output_size=(2, 2))
    assert not comparator(m, n)


def test_torch_nn_embedding():
    """Test comparator for torch.nn.Embedding modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical Embedding layers
    torch.manual_seed(42)
    a = nn.Embedding(1000, 128)
    torch.manual_seed(42)
    b = nn.Embedding(1000, 128)
    assert comparator(a, b)

    # Test Embedding with different weights
    torch.manual_seed(42)
    c = nn.Embedding(1000, 128)
    torch.manual_seed(123)
    d = nn.Embedding(1000, 128)
    assert not comparator(c, d)

    # Test Embedding with different num_embeddings
    torch.manual_seed(42)
    e = nn.Embedding(1000, 128)
    torch.manual_seed(42)
    f = nn.Embedding(2000, 128)
    assert not comparator(e, f)

    # Test Embedding with different embedding_dim
    torch.manual_seed(42)
    g = nn.Embedding(1000, 128)
    torch.manual_seed(42)
    h = nn.Embedding(1000, 256)
    assert not comparator(g, h)

    # Test Embedding with different padding_idx
    torch.manual_seed(42)
    i = nn.Embedding(1000, 128, padding_idx=0)
    torch.manual_seed(42)
    j = nn.Embedding(1000, 128, padding_idx=1)
    assert not comparator(i, j)

    # Test Embedding with and without padding_idx
    torch.manual_seed(42)
    k = nn.Embedding(1000, 128)
    torch.manual_seed(42)
    l = nn.Embedding(1000, 128, padding_idx=0)
    assert not comparator(k, l)


def test_torch_nn_lstm():
    """Test comparator for torch.nn.LSTM modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical LSTM layers
    torch.manual_seed(42)
    a = nn.LSTM(input_size=10, hidden_size=20, num_layers=2)
    torch.manual_seed(42)
    b = nn.LSTM(input_size=10, hidden_size=20, num_layers=2)
    assert comparator(a, b)

    # Test LSTM with different weights
    torch.manual_seed(42)
    c = nn.LSTM(input_size=10, hidden_size=20, num_layers=2)
    torch.manual_seed(123)
    d = nn.LSTM(input_size=10, hidden_size=20, num_layers=2)
    assert not comparator(c, d)

    # Test LSTM with different input_size
    torch.manual_seed(42)
    e = nn.LSTM(input_size=10, hidden_size=20)
    torch.manual_seed(42)
    f = nn.LSTM(input_size=20, hidden_size=20)
    assert not comparator(e, f)

    # Test LSTM with different hidden_size
    torch.manual_seed(42)
    g = nn.LSTM(input_size=10, hidden_size=20)
    torch.manual_seed(42)
    h = nn.LSTM(input_size=10, hidden_size=40)
    assert not comparator(g, h)

    # Test LSTM with different num_layers
    torch.manual_seed(42)
    i = nn.LSTM(input_size=10, hidden_size=20, num_layers=1)
    torch.manual_seed(42)
    j = nn.LSTM(input_size=10, hidden_size=20, num_layers=2)
    assert not comparator(i, j)

    # Test LSTM with different bidirectional
    torch.manual_seed(42)
    k = nn.LSTM(input_size=10, hidden_size=20, bidirectional=False)
    torch.manual_seed(42)
    l = nn.LSTM(input_size=10, hidden_size=20, bidirectional=True)
    assert not comparator(k, l)

    # Test LSTM with different batch_first
    torch.manual_seed(42)
    m = nn.LSTM(input_size=10, hidden_size=20, batch_first=False)
    torch.manual_seed(42)
    n = nn.LSTM(input_size=10, hidden_size=20, batch_first=True)
    assert not comparator(m, n)


def test_torch_nn_gru():
    """Test comparator for torch.nn.GRU modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical GRU layers
    torch.manual_seed(42)
    a = nn.GRU(input_size=10, hidden_size=20, num_layers=2)
    torch.manual_seed(42)
    b = nn.GRU(input_size=10, hidden_size=20, num_layers=2)
    assert comparator(a, b)

    # Test GRU with different hidden_size
    torch.manual_seed(42)
    c = nn.GRU(input_size=10, hidden_size=20)
    torch.manual_seed(42)
    d = nn.GRU(input_size=10, hidden_size=40)
    assert not comparator(c, d)

    # Test GRU vs LSTM (different types)
    torch.manual_seed(42)
    e = nn.GRU(input_size=10, hidden_size=20)
    torch.manual_seed(42)
    f = nn.LSTM(input_size=10, hidden_size=20)
    assert not comparator(e, f)


def test_torch_nn_layernorm():
    """Test comparator for torch.nn.LayerNorm modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical LayerNorm layers
    torch.manual_seed(42)
    a = nn.LayerNorm(normalized_shape=[10])
    torch.manual_seed(42)
    b = nn.LayerNorm(normalized_shape=[10])
    assert comparator(a, b)

    # Test LayerNorm with different normalized_shape
    torch.manual_seed(42)
    c = nn.LayerNorm(normalized_shape=[10])
    torch.manual_seed(42)
    d = nn.LayerNorm(normalized_shape=[20])
    assert not comparator(c, d)

    # Test LayerNorm with different eps
    torch.manual_seed(42)
    e = nn.LayerNorm(normalized_shape=[10], eps=1e-5)
    torch.manual_seed(42)
    f = nn.LayerNorm(normalized_shape=[10], eps=1e-3)
    assert not comparator(e, f)

    # Test LayerNorm with and without elementwise_affine
    torch.manual_seed(42)
    g = nn.LayerNorm(normalized_shape=[10], elementwise_affine=True)
    torch.manual_seed(42)
    h = nn.LayerNorm(normalized_shape=[10], elementwise_affine=False)
    assert not comparator(g, h)


def test_torch_nn_multihead_attention():
    """Test comparator for torch.nn.MultiheadAttention modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical MultiheadAttention layers
    torch.manual_seed(42)
    a = nn.MultiheadAttention(embed_dim=64, num_heads=8)
    torch.manual_seed(42)
    b = nn.MultiheadAttention(embed_dim=64, num_heads=8)
    assert comparator(a, b)

    # Test MultiheadAttention with different weights
    torch.manual_seed(42)
    c = nn.MultiheadAttention(embed_dim=64, num_heads=8)
    torch.manual_seed(123)
    d = nn.MultiheadAttention(embed_dim=64, num_heads=8)
    assert not comparator(c, d)

    # Test MultiheadAttention with different embed_dim
    torch.manual_seed(42)
    e = nn.MultiheadAttention(embed_dim=64, num_heads=8)
    torch.manual_seed(42)
    f = nn.MultiheadAttention(embed_dim=128, num_heads=8)
    assert not comparator(e, f)

    # Test MultiheadAttention with different num_heads
    torch.manual_seed(42)
    g = nn.MultiheadAttention(embed_dim=64, num_heads=8)
    torch.manual_seed(42)
    h = nn.MultiheadAttention(embed_dim=64, num_heads=4)
    assert not comparator(g, h)

    # Test MultiheadAttention with different dropout
    torch.manual_seed(42)
    i = nn.MultiheadAttention(embed_dim=64, num_heads=8, dropout=0.0)
    torch.manual_seed(42)
    j = nn.MultiheadAttention(embed_dim=64, num_heads=8, dropout=0.1)
    assert not comparator(i, j)


def test_torch_nn_sequential():
    """Test comparator for torch.nn.Sequential modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical Sequential modules
    torch.manual_seed(42)
    a = nn.Sequential(nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 5))
    torch.manual_seed(42)
    b = nn.Sequential(nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 5))
    assert comparator(a, b)

    # Test Sequential with different weights
    torch.manual_seed(42)
    c = nn.Sequential(nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 5))
    torch.manual_seed(123)
    d = nn.Sequential(nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 5))
    assert not comparator(c, d)

    # Test Sequential with different number of layers
    torch.manual_seed(42)
    e = nn.Sequential(nn.Linear(10, 20), nn.ReLU())
    torch.manual_seed(42)
    f = nn.Sequential(nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 5))
    assert not comparator(e, f)

    # Test Sequential with different layer types
    torch.manual_seed(42)
    g = nn.Sequential(nn.Linear(10, 20), nn.ReLU())
    torch.manual_seed(42)
    h = nn.Sequential(nn.Linear(10, 20), nn.Sigmoid())
    assert not comparator(g, h)


def test_torch_nn_modulelist():
    """Test comparator for torch.nn.ModuleList modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical ModuleList
    torch.manual_seed(42)
    a = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
    torch.manual_seed(42)
    b = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
    assert comparator(a, b)

    # Test ModuleList with different number of modules
    torch.manual_seed(42)
    c = nn.ModuleList([nn.Linear(10, 10) for _ in range(3)])
    torch.manual_seed(42)
    d = nn.ModuleList([nn.Linear(10, 10) for _ in range(4)])
    assert not comparator(c, d)


def test_torch_nn_moduledict():
    """Test comparator for torch.nn.ModuleDict modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical ModuleDict
    torch.manual_seed(42)
    a = nn.ModuleDict({"fc1": nn.Linear(10, 20), "fc2": nn.Linear(20, 5)})
    torch.manual_seed(42)
    b = nn.ModuleDict({"fc1": nn.Linear(10, 20), "fc2": nn.Linear(20, 5)})
    assert comparator(a, b)

    # Test ModuleDict with different keys
    torch.manual_seed(42)
    c = nn.ModuleDict({"fc1": nn.Linear(10, 20), "fc2": nn.Linear(20, 5)})
    torch.manual_seed(42)
    d = nn.ModuleDict({"layer1": nn.Linear(10, 20), "layer2": nn.Linear(20, 5)})
    assert not comparator(c, d)


def test_torch_nn_custom_module():
    """Test comparator for custom torch.nn.Module subclasses."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    class SimpleNet(nn.Module):
        def __init__(self, hidden_size):
            super().__init__()
            self.fc1 = nn.Linear(10, hidden_size)
            self.relu = nn.ReLU()
            self.fc2 = nn.Linear(hidden_size, 5)

        def forward(self, x):
            x = self.fc1(x)
            x = self.relu(x)
            x = self.fc2(x)
            return x

    # Test identical custom modules
    torch.manual_seed(42)
    a = SimpleNet(hidden_size=20)
    torch.manual_seed(42)
    b = SimpleNet(hidden_size=20)
    assert comparator(a, b)

    # Test custom modules with different weights
    torch.manual_seed(42)
    c = SimpleNet(hidden_size=20)
    torch.manual_seed(123)
    d = SimpleNet(hidden_size=20)
    assert not comparator(c, d)

    # Test custom modules with different architecture
    torch.manual_seed(42)
    e = SimpleNet(hidden_size=20)
    torch.manual_seed(42)
    f = SimpleNet(hidden_size=40)
    assert not comparator(e, f)


def test_torch_nn_nested_modules():
    """Test comparator for nested torch.nn.Module structures."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    class EncoderBlock(nn.Module):
        def __init__(self, in_channels, out_channels):
            super().__init__()
            self.conv = nn.Conv2d(in_channels, out_channels, 3, padding=1)
            self.bn = nn.BatchNorm2d(out_channels)
            self.relu = nn.ReLU()

        def forward(self, x):
            return self.relu(self.bn(self.conv(x)))

    class Encoder(nn.Module):
        def __init__(self):
            super().__init__()
            self.block1 = EncoderBlock(3, 16)
            self.block2 = EncoderBlock(16, 32)
            self.pool = nn.MaxPool2d(2)

        def forward(self, x):
            x = self.block1(x)
            x = self.pool(x)
            x = self.block2(x)
            x = self.pool(x)
            return x

    # Test identical nested modules
    torch.manual_seed(42)
    a = Encoder()
    torch.manual_seed(42)
    b = Encoder()
    assert comparator(a, b)

    # Test nested modules with different weights
    torch.manual_seed(42)
    c = Encoder()
    torch.manual_seed(123)
    d = Encoder()
    assert not comparator(c, d)


def test_torch_nn_transformer():
    """Test comparator for torch.nn.Transformer modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test identical Transformer
    torch.manual_seed(42)
    a = nn.Transformer(d_model=64, nhead=4, num_encoder_layers=2, num_decoder_layers=2)
    torch.manual_seed(42)
    b = nn.Transformer(d_model=64, nhead=4, num_encoder_layers=2, num_decoder_layers=2)
    assert comparator(a, b)

    # Test Transformer with different d_model
    torch.manual_seed(42)
    c = nn.Transformer(d_model=64, nhead=4)
    torch.manual_seed(42)
    d = nn.Transformer(d_model=128, nhead=4)
    assert not comparator(c, d)

    # Test Transformer with different nhead
    torch.manual_seed(42)
    e = nn.Transformer(d_model=64, nhead=4)
    torch.manual_seed(42)
    f = nn.Transformer(d_model=64, nhead=8)
    assert not comparator(e, f)

    # Test TransformerEncoder
    torch.manual_seed(42)
    encoder_layer_a = nn.TransformerEncoderLayer(d_model=64, nhead=4)
    g = nn.TransformerEncoder(encoder_layer_a, num_layers=2)
    torch.manual_seed(42)
    encoder_layer_b = nn.TransformerEncoderLayer(d_model=64, nhead=4)
    h = nn.TransformerEncoder(encoder_layer_b, num_layers=2)
    assert comparator(g, h)


def test_torch_nn_parameter_buffer_modification():
    """Test comparator detects parameter and buffer modifications."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test that modifying a parameter is detected
    torch.manual_seed(42)
    a = nn.Linear(10, 5)
    torch.manual_seed(42)
    b = nn.Linear(10, 5)
    assert comparator(a, b)

    # Modify a parameter
    with torch.no_grad():
        b.weight[0, 0] = 999.0
    assert not comparator(a, b)

    # Test that modifying a buffer is detected (BatchNorm running_mean)
    torch.manual_seed(42)
    c = nn.BatchNorm2d(16)
    torch.manual_seed(42)
    d = nn.BatchNorm2d(16)
    assert comparator(c, d)

    # Modify a buffer
    d.running_mean[0] = 999.0
    assert not comparator(c, d)


def test_torch_nn_device_placement():
    """Test comparator handles modules on different devices."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Create modules on CPU
    torch.manual_seed(42)
    cpu_module = nn.Linear(10, 5)
    torch.manual_seed(42)
    cpu_module2 = nn.Linear(10, 5)
    assert comparator(cpu_module, cpu_module2)

    # If CUDA is available, test device mismatch
    if torch.cuda.is_available():
        torch.manual_seed(42)
        cpu_mod = nn.Linear(10, 5)
        torch.manual_seed(42)
        cuda_mod = nn.Linear(10, 5).cuda()
        assert not comparator(cpu_mod, cuda_mod)


def test_torch_nn_conv1d_conv3d():
    """Test comparator for Conv1d and Conv3d modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test Conv1d
    torch.manual_seed(42)
    a = nn.Conv1d(3, 16, kernel_size=3)
    torch.manual_seed(42)
    b = nn.Conv1d(3, 16, kernel_size=3)
    assert comparator(a, b)

    # Test Conv1d with different out_channels
    torch.manual_seed(42)
    c = nn.Conv1d(3, 16, kernel_size=3)
    torch.manual_seed(42)
    d = nn.Conv1d(3, 32, kernel_size=3)
    assert not comparator(c, d)

    # Test Conv3d
    torch.manual_seed(42)
    e = nn.Conv3d(3, 16, kernel_size=3)
    torch.manual_seed(42)
    f = nn.Conv3d(3, 16, kernel_size=3)
    assert comparator(e, f)

    # Test Conv1d vs Conv2d (different types)
    torch.manual_seed(42)
    g = nn.Conv1d(3, 16, kernel_size=3)
    torch.manual_seed(42)
    h = nn.Conv2d(3, 16, kernel_size=3)
    assert not comparator(g, h)


def test_torch_nn_flatten_unflatten():
    """Test comparator for Flatten and Unflatten modules."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test Flatten
    a = nn.Flatten()
    b = nn.Flatten()
    assert comparator(a, b)

    # Test Flatten with different start_dim
    c = nn.Flatten(start_dim=1)
    d = nn.Flatten(start_dim=0)
    assert not comparator(c, d)

    # Test Unflatten
    e = nn.Unflatten(dim=1, unflattened_size=(2, 5))
    f = nn.Unflatten(dim=1, unflattened_size=(2, 5))
    assert comparator(e, f)


def test_torch_nn_identity():
    """Test comparator for Identity module."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # Test Identity
    a = nn.Identity()
    b = nn.Identity()
    assert comparator(a, b)

    # Test Identity vs Linear (different types)
    torch.manual_seed(42)
    c = nn.Identity()
    d = nn.Linear(10, 10)
    assert not comparator(c, d)


def test_torch_nn_with_superset():
    """Test comparator superset_obj mode with nn.Module."""
    try:
        import torch
        from torch import nn
    except ImportError:
        pytest.skip()

    # For nn.Module, superset_obj should still work
    torch.manual_seed(42)
    a = nn.Linear(10, 5)
    torch.manual_seed(42)
    b = nn.Linear(10, 5)

    # superset_obj=True should pass for identical modules
    assert comparator(a, b, superset_obj=True)

    # Different modules should still fail
    torch.manual_seed(42)
    c = nn.Linear(10, 5)
    torch.manual_seed(123)
    d = nn.Linear(10, 5)
    assert not comparator(c, d, superset_obj=True)


def test_jax():
    try:
        import jax.numpy as jnp
    except ImportError:
        pytest.skip()

    # Test basic arrays
    a = jnp.array([1, 2, 3])
    b = jnp.array([1, 2, 3])
    c = jnp.array([1, 2, 4])
    assert comparator(a, b)
    assert not comparator(a, c)

    # Test 2D arrays
    d = jnp.array([[1, 2, 3], [4, 5, 6]])
    e = jnp.array([[1, 2, 3], [4, 5, 6]])
    f = jnp.array([[1, 2, 3], [4, 5, 7]])
    assert comparator(d, e)
    assert not comparator(d, f)

    # Test arrays with different data types
    g = jnp.array([1, 2, 3], dtype=jnp.float32)
    h = jnp.array([1, 2, 3], dtype=jnp.float32)
    i = jnp.array([1, 2, 3], dtype=jnp.int32)
    assert comparator(g, h)
    assert not comparator(g, i)

    # Test 3D arrays
    j = jnp.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
    k = jnp.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
    l = jnp.array([[[1, 2], [3, 4]], [[5, 6], [7, 9]]])
    assert comparator(j, k)
    assert not comparator(j, l)

    # Test arrays with different shapes
    m = jnp.array([1, 2, 3])
    n = jnp.array([[1, 2, 3]])
    assert not comparator(m, n)

    # Test empty arrays
    o = jnp.array([])
    p = jnp.array([])
    q = jnp.array([1])
    assert comparator(o, p)
    assert not comparator(o, q)

    # Test arrays with NaN values
    r = jnp.array([1.0, jnp.nan, 3.0])
    s = jnp.array([1.0, jnp.nan, 3.0])
    t = jnp.array([1.0, 2.0, 3.0])
    assert comparator(r, s)  # NaN == NaN
    assert not comparator(r, t)

    # Test arrays with infinity values
    u = jnp.array([1.0, jnp.inf, 3.0])
    v = jnp.array([1.0, jnp.inf, 3.0])
    w = jnp.array([1.0, -jnp.inf, 3.0])
    assert comparator(u, v)
    assert not comparator(u, w)

    # Test complex arrays
    x = jnp.array([1 + 2j, 3 + 4j])
    y = jnp.array([1 + 2j, 3 + 4j])
    z = jnp.array([1 + 2j, 3 + 5j])
    assert comparator(x, y)
    assert not comparator(x, z)

    # Test boolean arrays
    aa = jnp.array([True, False, True])
    bb = jnp.array([True, False, True])
    cc = jnp.array([True, True, True])
    assert comparator(aa, bb)
    assert not comparator(aa, cc)


def test_xarray():
    try:
        import numpy as np
        import xarray as xr
    except ImportError:
        pytest.skip()

    # Test basic DataArray
    a = xr.DataArray([1, 2, 3], dims=["x"])
    b = xr.DataArray([1, 2, 3], dims=["x"])
    c = xr.DataArray([1, 2, 4], dims=["x"])
    assert comparator(a, b)
    assert not comparator(a, c)

    # Test DataArray with coordinates
    d = xr.DataArray([1, 2, 3], coords={"x": [0, 1, 2]}, dims=["x"])
    e = xr.DataArray([1, 2, 3], coords={"x": [0, 1, 2]}, dims=["x"])
    f = xr.DataArray([1, 2, 3], coords={"x": [0, 1, 3]}, dims=["x"])
    assert comparator(d, e)
    assert not comparator(d, f)

    # Test DataArray with attributes
    g = xr.DataArray([1, 2, 3], dims=["x"], attrs={"units": "meters"})
    h = xr.DataArray([1, 2, 3], dims=["x"], attrs={"units": "meters"})
    i = xr.DataArray([1, 2, 3], dims=["x"], attrs={"units": "feet"})
    assert comparator(g, h)
    assert not comparator(g, i)

    # Test 2D DataArray
    j = xr.DataArray([[1, 2, 3], [4, 5, 6]], dims=["x", "y"])
    k = xr.DataArray([[1, 2, 3], [4, 5, 6]], dims=["x", "y"])
    l = xr.DataArray([[1, 2, 3], [4, 5, 7]], dims=["x", "y"])
    assert comparator(j, k)
    assert not comparator(j, l)

    # Test DataArray with different dimensions
    m = xr.DataArray([1, 2, 3], dims=["x"])
    n = xr.DataArray([1, 2, 3], dims=["y"])
    assert not comparator(m, n)

    # Test DataArray with NaN values
    o = xr.DataArray([1.0, np.nan, 3.0], dims=["x"])
    p = xr.DataArray([1.0, np.nan, 3.0], dims=["x"])
    q = xr.DataArray([1.0, 2.0, 3.0], dims=["x"])
    assert comparator(o, p)
    assert not comparator(o, q)

    # Test Dataset
    r = xr.Dataset({"temp": (["x", "y"], [[1, 2], [3, 4]]), "pressure": (["x", "y"], [[5, 6], [7, 8]])})
    s = xr.Dataset({"temp": (["x", "y"], [[1, 2], [3, 4]]), "pressure": (["x", "y"], [[5, 6], [7, 8]])})
    t = xr.Dataset({"temp": (["x", "y"], [[1, 2], [3, 4]]), "pressure": (["x", "y"], [[5, 6], [7, 9]])})
    assert comparator(r, s)
    assert not comparator(r, t)

    # Test Dataset with coordinates
    u = xr.Dataset({"temp": (["x", "y"], [[1, 2], [3, 4]])}, coords={"x": [0, 1], "y": [0, 1]})
    v = xr.Dataset({"temp": (["x", "y"], [[1, 2], [3, 4]])}, coords={"x": [0, 1], "y": [0, 1]})
    w = xr.Dataset({"temp": (["x", "y"], [[1, 2], [3, 4]])}, coords={"x": [0, 2], "y": [0, 1]})
    assert comparator(u, v)
    assert not comparator(u, w)

    # Test Dataset with attributes
    x = xr.Dataset({"temp": (["x"], [1, 2, 3])}, attrs={"source": "sensor"})
    y = xr.Dataset({"temp": (["x"], [1, 2, 3])}, attrs={"source": "sensor"})
    z = xr.Dataset({"temp": (["x"], [1, 2, 3])}, attrs={"source": "model"})
    assert comparator(x, y)
    assert not comparator(x, z)

    # Test Dataset with different variables
    aa = xr.Dataset({"temp": (["x"], [1, 2, 3])})
    bb = xr.Dataset({"temp": (["x"], [1, 2, 3])})
    cc = xr.Dataset({"pressure": (["x"], [1, 2, 3])})
    assert comparator(aa, bb)
    assert not comparator(aa, cc)

    # Test empty Dataset
    dd = xr.Dataset()
    ee = xr.Dataset()
    assert comparator(dd, ee)

    # Test DataArray with different shapes
    ff = xr.DataArray([1, 2, 3], dims=["x"])
    gg = xr.DataArray([[1, 2, 3]], dims=["x", "y"])
    assert not comparator(ff, gg)

    # Test DataArray with different data types
    # Note: xarray.identical() considers int and float arrays with same values as identical
    hh = xr.DataArray(np.array([1, 2, 3], dtype="int32"), dims=["x"])
    ii = xr.DataArray(np.array([1, 2, 3], dtype="int64"), dims=["x"])
    # xarray is permissive with dtype comparisons, treats these as identical
    assert comparator(hh, ii)

    # Test DataArray with infinity
    jj = xr.DataArray([1.0, np.inf, 3.0], dims=["x"])
    kk = xr.DataArray([1.0, np.inf, 3.0], dims=["x"])
    ll = xr.DataArray([1.0, -np.inf, 3.0], dims=["x"])
    assert comparator(jj, kk)
    assert not comparator(jj, ll)

    # Test Dataset vs DataArray (different types)
    mm = xr.DataArray([1, 2, 3], dims=["x"])
    nn = xr.Dataset({"data": (["x"], [1, 2, 3])})
    assert not comparator(mm, nn)


def test_returns():
    a = Success(5)
    b = Success(5)
    c = Success(6)
    d = Failure(5)
    e = Success((5, 5))
    f = Success((5, 6))
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)
    assert not comparator(a, e)
    assert not comparator(e, f)

    g = Success((5, 5))
    h = Success((5, 5))
    i = Success((5, 6))
    assert comparator(g, h)
    assert not comparator(g, i)


def test_custom_object():
    class TestClass:
        def __init__(self, value):
            self.value = value

        def __eq__(self, other):
            return self.value == other.value

    a = TestClass(5)
    b = TestClass(5)
    c = TestClass(6)
    assert comparator(a, b)
    assert not comparator(a, c)

    class TestClass2:
        def __init__(self, value1, value2=6):
            self.value1 = value1
            self.value2 = value2

    a = TestClass(5)
    b = TestClass2(5, 6)
    c = TestClass2(5, 7)
    d = TestClass2(5, 6)
    assert not comparator(a, b)
    assert not comparator(b, c)
    assert comparator(b, d)

    class TestClass3(TestClass):
        def print(self):
            print(self.value)

    a = TestClass2(5)
    b = TestClass3(5)
    c = TestClass3(5)
    assert not comparator(a, b)
    assert comparator(b, c)

    @dataclasses.dataclass
    class InventoryItem:
        """Class for keeping track of an item in inventory."""

        name: str
        unit_price: float
        quantity_on_hand: int = 0

        def total_cost(self) -> float:
            return self.unit_price * self.quantity_on_hand

    a = InventoryItem(name="widget", unit_price=3.0, quantity_on_hand=10)
    b = InventoryItem(name="widget", unit_price=3.0, quantity_on_hand=10)
    c = InventoryItem(name="widget", unit_price=3.0, quantity_on_hand=11)

    assert comparator(a, b)
    assert not comparator(a, c)

    @pydantic.dataclasses.dataclass
    class InventoryItemPydantic:
        """Class for keeping track of an item in inventory."""

        name: str
        unit_price: float
        quantity_on_hand: int = 0

        def total_cost(self) -> float:
            return self.unit_price * self.quantity_on_hand

    a = InventoryItemPydantic(name="widget", unit_price=3.0, quantity_on_hand=10)
    b = InventoryItemPydantic(name="widget", unit_price=3.0, quantity_on_hand=10)
    c = InventoryItemPydantic(name="widget", unit_price=3.0, quantity_on_hand=11)
    assert comparator(a, b)
    assert not comparator(a, c)

    class InventoryItemBasePydantic(pydantic.BaseModel):
        name: str
        unit_price: float
        quantity_on_hand: int = 0

        def total_cost(self) -> float:
            return self.unit_price * self.quantity_on_hand

    a = InventoryItemBasePydantic(name="widget", unit_price=3.0, quantity_on_hand=10)
    b = InventoryItemBasePydantic(name="widget", unit_price=3.0, quantity_on_hand=10)
    c = InventoryItemBasePydantic(name="widget", unit_price=3.0, quantity_on_hand=11)
    assert comparator(a, b)
    assert not comparator(a, c)

    class A:
        items = [1, 2, 3]
        val = 5

    class B:
        items = [1, 2, 4]
        val = 5

    assert comparator(A, A)
    assert not comparator(A, B)

    class C:
        items = [1, 2, 3]
        val = 5

        def __init__(self):
            self.itemm2 = [1, 2, 3]
            self.val2 = 5

    class D:
        items = [1, 2, 3]
        val = 5

        def __init__(self):
            self.itemm2 = [1, 2, 4]
            self.val2 = 5

    assert comparator(C, C)
    assert not comparator(C, D)

    E = C
    assert comparator(C, E)


def test_custom_object_2():
    fto_path = (Path(__file__).parent.resolve() / "../code_to_optimize/bubble_sort_method.py").resolve()
    original_code = fto_path.read_text("utf-8")
    from code_to_optimize.bubble_sort_method import BubbleSorter

    a = BubbleSorter()
    assert a.x == 0
    try:
        # Remove the module from sys.modules, to get the updated class
        sys.modules.pop("code_to_optimize.bubble_sort_method", None)
        from code_to_optimize.bubble_sort_method import BubbleSorter

        b = BubbleSorter()
        assert comparator(
            a, b
        )  # Note that type(a) != type(b) as the class type objects are different, even if the code is the same.

        optimized_code_mutated_attr = """
class BubbleSorter:
    z = 0

    def __init__(self, x=1):
        self.x = x

    def sorter(self, arr):
        for i in range(len(arr)):
            for j in range(len(arr) - 1):
                if arr[j] > arr[j + 1]:
                    temp = arr[j]
                    arr[j] = arr[j + 1]
                    arr[j + 1] = temp
        return arr
                                    """
        fto_path.write_text(optimized_code_mutated_attr, "utf-8")
        sys.modules.pop("code_to_optimize.bubble_sort_method", None)
        from code_to_optimize.bubble_sort_method import BubbleSorter

        c = BubbleSorter()
        assert c.x == 1
        assert not comparator(a, c)

        optimized_code_new_attr = """
class BubbleSorter:
    z = 5

    def __init__(self, x=0):
        self.x = x

    def sorter(self, arr):
        for i in range(len(arr)):
            for j in range(len(arr) - 1):
                if arr[j] > arr[j + 1]:
                    temp = arr[j]
                    arr[j] = arr[j + 1]
                    arr[j + 1] = temp
        return arr
                                            """
        fto_path.write_text(optimized_code_new_attr, "utf-8")
        sys.modules.pop("code_to_optimize.bubble_sort_method", None)
        from code_to_optimize.bubble_sort_method import BubbleSorter

        d = BubbleSorter()
        assert d.x == 0
        # Currently, we do not check if class variables are different, since the code replacer does not allow this.
        # In the future, if this functionality is allowed, this assert should be false.
        assert comparator(a, d)
    finally:
        fto_path.write_text(original_code, "utf-8")


def test_superset():
    class A:
        def __init__(self):
            self.a = 1

    obj = A()
    obj.x = 3

    assert comparator(A(), obj, superset_obj=True)
    assert not comparator(obj, A(), superset_obj=True)
    assert not comparator(A(), obj)
    assert not comparator(obj, A())
    assert comparator(obj, obj, superset_obj=True)
    assert comparator(obj, obj)


def test_compare_results_fn():
    original_results = TestResults()
    original_results.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=True,
            runtime=5,
            test_framework="unittest",
            test_type=TestType.EXISTING_UNIT_TEST,
            return_value=5,
            timed_out=False,
            loop_index=1,
        )
    )

    new_results_1 = TestResults()
    new_results_1.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=True,
            runtime=10,
            test_framework="unittest",
            test_type=TestType.EXISTING_UNIT_TEST,
            return_value=5,
            timed_out=False,
            loop_index=1,
        )
    )

    match, _ = compare_test_results(original_results, new_results_1)
    assert match

    new_results_2 = TestResults()
    new_results_2.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=True,
            runtime=10,
            test_framework="unittest",
            test_type=TestType.EXISTING_UNIT_TEST,
            return_value=[5],
            timed_out=False,
            loop_index=1,
        )
    )

    match, _ = compare_test_results(original_results, new_results_2)
    assert not match

    new_results_3 = TestResults()
    new_results_3.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=True,
            runtime=10,
            test_framework="unittest",
            test_type=TestType.EXISTING_UNIT_TEST,
            return_value=5,
            timed_out=False,
            loop_index=1,
        )
    )
    new_results_3.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="2",
            ),
            file_name=Path("file_name"),
            did_pass=True,
            runtime=10,
            test_framework="unittest",
            test_type=TestType.EXISTING_UNIT_TEST,
            return_value=5,
            timed_out=False,
            loop_index=1,
        )
    )

    match, _ = compare_test_results(original_results, new_results_3)
    assert match

    new_results_4 = TestResults()
    new_results_4.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=False,
            runtime=5,
            test_framework="unittest",
            test_type=TestType.EXISTING_UNIT_TEST,
            return_value=5,
            timed_out=False,
            loop_index=1,
        )
    )

    match, _ = compare_test_results(original_results, new_results_4)
    assert not match

    new_results_5_baseline = TestResults()
    new_results_5_baseline.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=True,
            runtime=5,
            test_framework="unittest",
            test_type=TestType.GENERATED_REGRESSION,
            return_value=5,
            timed_out=False,
            loop_index=1,
        )
    )

    new_results_5_opt = TestResults()
    new_results_5_opt.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=False,
            runtime=5,
            test_framework="unittest",
            test_type=TestType.GENERATED_REGRESSION,
            return_value=5,
            timed_out=False,
            loop_index=1,
        )
    )

    match, _ = compare_test_results(new_results_5_baseline, new_results_5_opt)
    assert not match

    new_results_6_baseline = TestResults()
    new_results_6_baseline.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=True,
            runtime=5,
            test_framework="unittest",
            test_type=TestType.REPLAY_TEST,
            return_value=5,
            timed_out=False,
            loop_index=1,
        )
    )

    new_results_6_opt = TestResults()
    new_results_6_opt.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=False,
            runtime=5,
            test_framework="unittest",
            test_type=TestType.REPLAY_TEST,
            return_value=5,
            timed_out=False,
            loop_index=1,
        )
    )

    match, _ = compare_test_results(new_results_6_baseline, new_results_6_opt)
    assert not match

    match, _ = compare_test_results(TestResults(), TestResults())
    assert not match


def test_compare_results_detects_stdout_mismatch_when_candidate_stdout_is_empty() -> None:
    original_results = TestResults()
    original_results.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=True,
            runtime=5,
            test_framework="pytest",
            test_type=TestType.EXISTING_UNIT_TEST,
            return_value=[0, 1, 2],
            timed_out=False,
            loop_index=1,
            stdout="codeflash stdout: Sorting list\nresult: [0, 1, 2]\n",
        )
    )

    candidate_results = TestResults()
    candidate_results.add(
        FunctionTestInvocation(
            id=InvocationId(
                test_module_path="test_module_path",
                test_class_name="test_class_name",
                test_function_name="test_function_name",
                function_getting_tested="function_getting_tested",
                iteration_id="0",
            ),
            file_name=Path("file_name"),
            did_pass=True,
            runtime=5,
            test_framework="pytest",
            test_type=TestType.EXISTING_UNIT_TEST,
            return_value=[0, 1, 2],
            timed_out=False,
            loop_index=1,
            stdout="",
        )
    )

    match, diffs = compare_test_results(original_results, candidate_results)

    assert not match
    assert len(diffs) == 1
    assert diffs[0].scope == TestDiffScope.STDOUT
    assert diffs[0].original_value == "codeflash stdout: Sorting list\nresult: [0, 1, 2]\n"
    assert diffs[0].candidate_value == ""


def test_exceptions():
    type_error = TypeError("This is a type error")

    type_error_2 = TypeError("This is a type error")

    assert comparator(type_error, type_error_2)


def raise_exception():
    raise Exception("This is an exception")


def test_exceptions_comparator():
    # Currently we are only comparing the exception types and the attributes that don't start with "_"
    # there are complications with comparing the exception messages
    try:
        raise_exception()
    except Exception as e:
        exception = e

    try:
        raise_exception()
    except Exception as b:
        exception_2 = b

    assert comparator(exception, exception_2)

    exc1 = ValueError("same message")
    exc2 = ValueError("same message")
    assert comparator(exc1, exc2)

    exc_msg1 = ValueError("message one")
    exc_msg2 = ValueError("message two")
    # Different messages but same types
    assert comparator(exc_msg1, exc_msg2)

    exc1 = ValueError("common message")
    exc2 = TypeError("common message")
    assert not comparator(exc1, exc2)

    exc_file_1 = FileNotFoundError(2, "No such file or directory")

    exc_file2 = FileNotFoundError(2, "No such file or directory")

    exc_file4 = FileNotFoundError(2, "File not found")

    exc_file3 = FileNotFoundError(3, "No such file or directory")

    assert not comparator(exc1, exc2)

    assert comparator(exc_file_1, exc_file2)

    assert comparator(exc_file_1, exc_file3)

    assert comparator(exc_file_1, exc_file4)

    assert comparator(exception, exception)

    assert not comparator(exception, None)
    assert not comparator(None, exception)
    assert comparator(None, None)

    # Different exception types
    exc_type1 = TypeError("Type error")
    exc_type2 = TypeError("Another type error")
    assert comparator(exc_type1, exc_type2)

    exc_type3 = KeyError("Missing key")
    exc_type4 = KeyError("Missing key")
    assert comparator(exc_type3, exc_type4)
    assert not comparator(exc_type1, exc_type3)

    # compare the attributes of the exception as well
    class CustomError(Exception):
        def __init__(self, message, code):
            super().__init__(message)
            self.code = code

    custom_exc1 = CustomError("Something went wrong", 101)
    custom_exc2 = CustomError("Something went wrong", 101)
    assert comparator(custom_exc1, custom_exc2)

    custom_exc4 = CustomError("Something went wrong", 102)

    assert not comparator(custom_exc1, custom_exc4)

    class CustomErrorNoArgs(Exception):
        pass

    custom_no_args1 = CustomErrorNoArgs()
    custom_no_args2 = CustomErrorNoArgs()
    assert comparator(custom_no_args1, custom_no_args2)

    exc_empty1 = ValueError("")
    exc_empty2 = ValueError("")
    assert comparator(exc_empty1, exc_empty2)

    exc_not_empty = ValueError("Not empty")
    assert comparator(exc_empty1, exc_not_empty)

    class CustomValueError(ValueError):
        pass

    custom_value_error1 = CustomValueError("A custom value error")
    value_error1 = ValueError("A custom value error")
    assert not comparator(custom_value_error1, value_error1)

    custom_value_error2 = CustomValueError("Another custom value error")
    assert comparator(custom_value_error1, custom_value_error2)

    class CustomExceptionWithArgs(Exception):
        def __init__(self, arg1, arg2):
            self.args = (arg1, arg2)

    custom_args_exc1 = CustomExceptionWithArgs(1, "test")
    custom_args_exc2 = CustomExceptionWithArgs(1, "test")
    assert comparator(custom_args_exc1, custom_args_exc2)

    custom_args_exc3 = CustomExceptionWithArgs(1, "different")
    assert comparator(custom_args_exc1, custom_args_exc3)

    def raise_specific_exception():
        raise ZeroDivisionError("Cannot divide by zero")

    try:
        raise_specific_exception()
    except ZeroDivisionError as z1:
        zero_division_exc1 = z1

    try:
        raise_specific_exception()
    except ZeroDivisionError as z2:
        zero_division_exc2 = z2

    assert comparator(zero_division_exc1, zero_division_exc2)

    zero_division_exc3 = ZeroDivisionError("Different message")
    assert comparator(zero_division_exc1, zero_division_exc3)

    assert comparator(..., ...)
    assert comparator(Ellipsis, Ellipsis)

    assert not comparator(..., None)

    assert not comparator(Ellipsis, None)

    code7 = "a = 1 + 2"
    module7 = ast.parse(code7)
    for node in ast.walk(module7):
        for child in ast.iter_child_nodes(node):
            child.parent = node  # type: ignore
    module8 = copy.deepcopy(module7)
    assert comparator(module7, module8)

    code2 = "a = 1 + 3"

    module2 = ast.parse(code2)

    assert not comparator(module7, module2)


def test_torch_runtime_error_wrapping():
    """Test that TorchRuntimeError wrapping is handled correctly.

    When torch.compile is used, exceptions are wrapped in TorchRuntimeError.
    The comparator should consider an IndexError equivalent to a TorchRuntimeError
    that wraps an IndexError.
    """

    # Create a mock TorchRuntimeError class that mimics torch._dynamo.exc.TorchRuntimeError
    class TorchRuntimeError(Exception):
        """Mock TorchRuntimeError for testing."""

    # Monkey-patch the __module__ to match torch._dynamo.exc
    TorchRuntimeError.__module__ = "torch._dynamo.exc"

    # Test 1: TorchRuntimeError with __cause__ set to the same exception type
    index_error = IndexError("index 0 is out of bounds for dimension 0 with size 0")
    torch_error = TorchRuntimeError(
        "Dynamo failed to run FX node with fake tensors: got IndexError('index 0 is out of bounds')"
    )
    torch_error.__cause__ = IndexError("index 0 is out of bounds for dimension 0 with size 0")

    # These should be considered equivalent since TorchRuntimeError wraps IndexError
    assert comparator(index_error, torch_error)
    assert comparator(torch_error, index_error)

    # Test 2: TorchRuntimeError without __cause__ but with matching error type in message
    torch_error_no_cause = TorchRuntimeError(
        "Dynamo failed to run FX node with fake tensors: got IndexError('index 0 is out of bounds')"
    )
    assert comparator(index_error, torch_error_no_cause)
    assert comparator(torch_error_no_cause, index_error)

    # Test 3: Different exception types should not be equivalent
    value_error = ValueError("some value error")
    torch_error_index = TorchRuntimeError("got IndexError('some error')")
    torch_error_index.__cause__ = IndexError("some error")
    assert not comparator(value_error, torch_error_index)
    assert not comparator(torch_error_index, value_error)

    # Test 4: TorchRuntimeError wrapping a different type should not match
    type_error = TypeError("some type error")
    torch_error_with_index = TorchRuntimeError("got IndexError('index error')")
    torch_error_with_index.__cause__ = IndexError("index error")
    assert not comparator(type_error, torch_error_with_index)

    # Test 5: Two TorchRuntimeErrors wrapping the same exception type
    torch_error1 = TorchRuntimeError("got IndexError('error 1')")
    torch_error1.__cause__ = IndexError("error 1")
    torch_error2 = TorchRuntimeError("got IndexError('error 2')")
    torch_error2.__cause__ = IndexError("error 2")
    assert comparator(torch_error1, torch_error2)

    # Test 6: Regular exception comparison still works
    error1 = IndexError("same error")
    error2 = IndexError("same error")
    assert comparator(error1, error2)

    # Test 7: Exception wrapped in tuple (return value scenario from debug output)
    orig_return = (("tensor1", "tensor2"), {}, IndexError("index 0 is out of bounds for dimension 0 with size 0"))
    torch_wrapped_return = (
        ("tensor1", "tensor2"),
        {},
        TorchRuntimeError("Dynamo failed: got IndexError('index 0 is out of bounds for dimension 0 with size 0')"),
    )
    torch_wrapped_return[2].__cause__ = IndexError("index 0 is out of bounds for dimension 0 with size 0")
    assert comparator(orig_return, torch_wrapped_return)


def test_extract_exception_from_message():
    """Test the _extract_exception_from_message helper function."""
    # Test with single-quoted message
    result = _extract_exception_from_message("got IndexError('some error message')")
    assert result is not None
    assert isinstance(result, IndexError)

    # Test with double-quoted message
    result = _extract_exception_from_message('got ValueError("another error")')
    assert result is not None
    assert isinstance(result, ValueError)

    # Test with various builtin exception types
    for exc_name, exc_class in [
        ("TypeError", TypeError),
        ("KeyError", KeyError),
        ("RuntimeError", RuntimeError),
        ("AttributeError", AttributeError),
        ("ZeroDivisionError", ZeroDivisionError),
    ]:
        result = _extract_exception_from_message(f"got {exc_name}('test')")
        assert result is not None
        assert isinstance(result, exc_class)

    # Test with no matching pattern
    result = _extract_exception_from_message("This is a normal error message")
    assert result is None

    # Test with non-exception class name
    result = _extract_exception_from_message("got SomeRandomClass('not an exception')")
    assert result is None

    # Test with partial match (no opening quote)
    result = _extract_exception_from_message("got IndexError without quotes")
    assert result is None

    # Test with empty string
    result = _extract_exception_from_message("")
    assert result is None

    # Test with torch-like error message format
    result = _extract_exception_from_message(
        "Dynamo failed to run FX node with fake tensors: got IndexError('index 0 is out of bounds for dimension 0 with size 0')"
    )
    assert result is not None
    assert isinstance(result, IndexError)


def test_get_wrapped_exception():
    """Test the _get_wrapped_exception helper function."""
    # Test with __cause__ (explicit chaining)
    inner_error = ValueError("inner error")
    outer_error = RuntimeError("outer error")
    outer_error.__cause__ = inner_error
    result = _get_wrapped_exception(outer_error)
    assert result is inner_error

    # Test with no wrapping
    plain_error = ValueError("plain error")
    result = _get_wrapped_exception(plain_error)
    assert result is None

    # Test with message pattern
    error_with_pattern = RuntimeError("got TypeError('some type error')")
    result = _get_wrapped_exception(error_with_pattern)
    assert result is not None
    assert isinstance(result, TypeError)

    # Test that __cause__ takes precedence over message pattern
    actual_cause = IndexError("actual cause")
    error_with_both = RuntimeError("got TypeError('different error in message')")
    error_with_both.__cause__ = actual_cause
    result = _get_wrapped_exception(error_with_both)
    assert result is actual_cause
    assert isinstance(result, IndexError)


@pytest.mark.skipif(sys.version_info < (3, 11), reason="ExceptionGroup requires Python 3.11+")
def test_get_wrapped_exception_exception_group():
    """Test _get_wrapped_exception with ExceptionGroup (Python 3.11+)."""
    # ExceptionGroup with single exception
    inner_error = ValueError("single inner error")
    group = ExceptionGroup("group", [inner_error])
    result = _get_wrapped_exception(group)
    assert result is inner_error

    # ExceptionGroup with multiple exceptions - should return None
    error1 = ValueError("error 1")
    error2 = TypeError("error 2")
    multi_group = ExceptionGroup("multi group", [error1, error2])
    result = _get_wrapped_exception(multi_group)
    assert result is None


@pytest.mark.skipif(sys.version_info < (3, 11), reason="ExceptionGroup requires Python 3.11+")
def test_comparator_with_exception_group():
    """Test comparator with ExceptionGroup wrapping (Python 3.11+)."""
    # ExceptionGroup wrapping a single ValueError should match a plain ValueError
    inner_value_error = ValueError("some value error")
    group = ExceptionGroup("group", [inner_value_error])

    plain_value_error = ValueError("different message but same type")
    assert comparator(group, plain_value_error)
    assert comparator(plain_value_error, group)

    # ExceptionGroup with different exception type should not match
    inner_type_error = TypeError("type error")
    type_group = ExceptionGroup("group", [inner_type_error])
    assert not comparator(type_group, plain_value_error)

    # Two ExceptionGroups with same wrapped type should match
    group1 = ExceptionGroup("group1", [ValueError("error 1")])
    group2 = ExceptionGroup("group2", [ValueError("error 2")])
    assert comparator(group1, group2)


def test_comparator_with_cause_chaining():
    """Test comparator with __cause__ exception chaining."""
    # Create an exception chain using 'raise from'
    inner = IndexError("inner index error")
    outer = RuntimeError("outer runtime error")
    outer.__cause__ = inner

    # Outer exception should match the inner exception type
    plain_index_error = IndexError("different index error")
    assert comparator(outer, plain_index_error)
    assert comparator(plain_index_error, outer)

    # Should not match a different type
    plain_type_error = TypeError("type error")
    assert not comparator(outer, plain_type_error)

    # Two chained exceptions with same wrapper type match (regardless of inner type)
    # because same-type exceptions compare non-private attributes only (__cause__ is ignored)
    outer1 = RuntimeError("outer 1")
    outer1.__cause__ = ValueError("inner 1")
    outer2 = RuntimeError("outer 2")
    outer2.__cause__ = ValueError("inner 2")
    assert comparator(outer1, outer2)

    # Different wrapper types with same inner type - unwrapping makes them match
    class WrapperA(Exception):
        pass

    class WrapperB(Exception):
        pass

    wrapper_a = WrapperA("wrapper a")
    wrapper_a.__cause__ = KeyError("same inner type")
    wrapper_b = WrapperB("wrapper b")
    wrapper_b.__cause__ = KeyError("same inner type")
    # Both unwrap to KeyError, so they should match
    assert comparator(wrapper_a, wrapper_b)

    # Different wrapper types with different inner types should not match
    wrapper_c = WrapperA("wrapper c")
    wrapper_c.__cause__ = ValueError("value error")
    wrapper_d = WrapperB("wrapper d")
    wrapper_d.__cause__ = TypeError("type error")
    assert not comparator(wrapper_c, wrapper_d)


def test_comparator_with_message_pattern():
    """Test comparator with exception type extracted from message pattern."""
    # Exception with wrapped type in message (no __cause__)
    wrapper = RuntimeError("Operation failed: got IndexError('list index out of range')")

    plain_index = IndexError("some index error")
    assert comparator(wrapper, plain_index)
    assert comparator(plain_index, wrapper)

    # Should not match different types
    plain_key = KeyError("some key error")
    assert not comparator(wrapper, plain_key)


def test_comparator_wrapped_exceptions_bidirectional():
    """Test that wrapped exception comparison works in both directions."""

    class CustomWrapper(Exception):
        pass

    # Create wrapper with __cause__
    inner = AttributeError("attr error")
    wrapper = CustomWrapper("wrapper message")
    wrapper.__cause__ = inner

    plain_attr = AttributeError("plain attr error")

    # Test both directions
    assert comparator(wrapper, plain_attr)
    assert comparator(plain_attr, wrapper)

    # Test with superset_obj flag
    assert comparator(wrapper, plain_attr, superset_obj=True)
    assert comparator(plain_attr, wrapper, superset_obj=True)


def test_comparator_same_type_exceptions_still_work():
    """Ensure that same-type exception comparison still works correctly."""
    exc1 = ValueError("message 1")
    exc2 = ValueError("message 2")
    assert comparator(exc1, exc2)

    # With custom attributes
    class CustomError(Exception):
        def __init__(self, msg, code):
            super().__init__(msg)
            self.code = code

    custom1 = CustomError("msg1", 100)
    custom2 = CustomError("msg2", 100)
    assert comparator(custom1, custom2)

    custom3 = CustomError("msg3", 200)
    assert not comparator(custom1, custom3)


def test_comparator_no_false_positives_for_wrapped_exceptions():
    """Test that unrelated exception types don't match due to wrapping logic."""
    # Two completely different exception types should never match
    val_err = ValueError("value error")
    type_err = TypeError("type error")
    assert not comparator(val_err, type_err)

    # Wrapper with different inner type should not match
    wrapper = RuntimeError("some error")
    wrapper.__cause__ = KeyError("key error")
    assert not comparator(wrapper, val_err)
    assert not comparator(val_err, wrapper)


def test_collections() -> None:
    # Deque
    a = deque([1, 2, 3])
    b = deque([1, 2, 3])
    c = deque([1, 2, 4])
    d = deque([1, 2])
    e = [1, 2, 3]
    f = deque([1, 2, 3], maxlen=5)
    assert comparator(a, b)
    assert comparator(a, f)  # same elements, different maxlen is ok
    assert not comparator(a, c)
    assert not comparator(a, d)
    assert not comparator(a, e)

    g = deque([{"a": 1}, {"b": 2}])
    h = deque([{"a": 1}, {"b": 2}])
    i = deque([{"a": 1}, {"b": 3}])
    assert comparator(g, h)
    assert not comparator(g, i)

    empty_deque1 = deque()
    empty_deque2 = deque()
    assert comparator(empty_deque1, empty_deque2)
    assert not comparator(empty_deque1, a)

    # namedtuple
    Point = namedtuple("Point", ["x", "y"])
    a = Point(x=1, y=2)
    b = Point(x=1, y=2)
    c = Point(x=1, y=3)
    assert comparator(a, b)
    assert not comparator(a, c)

    Point2 = namedtuple("Point2", ["x", "y"])
    d = Point2(x=1, y=2)
    assert not comparator(a, d)

    e = (1, 2)
    assert not comparator(a, e)

    # ChainMap
    map1 = {"a": 1, "b": 2}
    map2 = {"c": 3, "d": 4}
    a = ChainMap(map1, map2)
    b = ChainMap(map1, map2)
    c = ChainMap(map2, map1)
    d = {"a": 1, "b": 2, "c": 3, "d": 4}
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    # Counter
    a = Counter(["a", "b", "a", "c", "b", "a"])
    b = Counter({"a": 3, "b": 2, "c": 1})
    c = Counter({"a": 3, "b": 2, "c": 2})
    d = {"a": 3, "b": 2, "c": 1}
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    # OrderedDict
    a = OrderedDict([("a", 1), ("b", 2)])
    b = OrderedDict([("a", 1), ("b", 2)])
    c = OrderedDict([("b", 2), ("a", 1)])
    d = {"a": 1, "b": 2}
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    # defaultdict
    a = defaultdict(int, {"a": 1, "b": 2})
    b = defaultdict(int, {"a": 1, "b": 2})
    c = defaultdict(list, {"a": 1, "b": 2})
    d = {"a": 1, "b": 2}
    e = defaultdict(int, {"a": 1, "b": 3})
    assert comparator(a, b)
    assert comparator(a, c)
    assert not comparator(a, d)
    assert not comparator(a, e)

    # UserDict
    a = UserDict({"a": 1, "b": 2})
    b = UserDict({"a": 1, "b": 2})
    c = UserDict({"a": 1, "b": 3})
    d = {"a": 1, "b": 2}
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    # UserList
    a = UserList([1, 2, 3])
    b = UserList([1, 2, 3])
    c = UserList([1, 2, 4])
    d = [1, 2, 3]
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    # UserString
    a = UserString("hello")
    b = UserString("hello")
    c = UserString("world")
    d = "hello"
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)


def test_attrs():
    try:
        import attrs  # type: ignore
    except ImportError:
        pytest.skip()

    @attrs.define
    class Person:
        name: str
        age: int = 10

    a = Person("Alice", 25)
    b = Person("Alice", 25)
    c = Person("Bob", 25)
    d = Person("Alice", 30)
    assert comparator(a, b)
    assert not comparator(a, c)
    assert not comparator(a, d)

    @attrs.frozen
    class Point:
        x: int
        y: int

    p1 = Point(1, 2)
    p2 = Point(1, 2)
    p3 = Point(2, 3)
    assert comparator(p1, p2)
    assert not comparator(p1, p3)

    @attrs.define(slots=True)
    class Vehicle:
        brand: str
        model: str
        year: int = 2020

    v1 = Vehicle("Toyota", "Camry", 2021)
    v2 = Vehicle("Toyota", "Camry", 2021)
    v3 = Vehicle("Honda", "Civic", 2021)
    assert comparator(v1, v2)
    assert not comparator(v1, v3)

    @attrs.define
    class ComplexClass:
        public_field: str
        private_field: str = attrs.field(repr=False)
        non_eq_field: int = attrs.field(eq=False, default=0)
        computed: str = attrs.field(init=False, eq=True)

        def __attrs_post_init__(self):
            self.computed = f"{self.public_field}_{self.private_field}"

    c1 = ComplexClass("test", "secret")
    c2 = ComplexClass("test", "secret")
    c3 = ComplexClass("different", "secret")

    c1.non_eq_field = 100
    c2.non_eq_field = 200

    assert comparator(c1, c2)
    assert not comparator(c1, c3)

    @attrs.define
    class Address:
        street: str
        city: str

    @attrs.define
    class PersonWithAddress:
        name: str
        address: Address

    addr1 = Address("123 Main St", "Anytown")
    addr2 = Address("123 Main St", "Anytown")
    addr3 = Address("456 Oak Ave", "Anytown")

    person1 = PersonWithAddress("John", addr1)
    person2 = PersonWithAddress("John", addr2)
    person3 = PersonWithAddress("John", addr3)

    assert comparator(person1, person2)
    assert not comparator(person1, person3)

    @attrs.define
    class Container:
        items: list
        metadata: dict

    cont1 = Container([1, 2, 3], {"type": "numbers"})
    cont2 = Container([1, 2, 3], {"type": "numbers"})
    cont3 = Container([1, 2, 4], {"type": "numbers"})

    assert comparator(cont1, cont2)
    assert not comparator(cont1, cont3)

    @attrs.define
    class BaseClass:
        name: str
        value: int

    @attrs.define
    class ExtendedClass:
        name: str
        value: int
        extra_field: str = "default"

    base = BaseClass("test", 42)
    extended = ExtendedClass("test", 42, "extra")

    assert not comparator(base, extended)

    @attrs.define
    class WithNonEqFields:
        name: str
        timestamp: float = attrs.field(eq=False)  # Should be ignored
        debug_info: str = attrs.field(eq=False, default="debug")

    obj1 = WithNonEqFields("test", 1000.0, "info1")
    obj2 = WithNonEqFields("test", 9999.0, "info2")  # Different non-eq fields
    obj3 = WithNonEqFields("different", 1000.0, "info1")

    assert comparator(obj1, obj2)  # Should be equal despite different timestamp/debug_info
    assert not comparator(obj1, obj3)  # Should be different due to name

    @attrs.define
    class MinimalClass:
        name: str
        value: int

    @attrs.define
    class ExtendedClass:
        name: str
        value: int
        extra_field: str = "default"
        metadata: dict = attrs.field(factory=dict)
        timestamp: float = attrs.field(eq=False, default=0.0)  # This should be ignored

    minimal = MinimalClass("test", 42)
    extended = ExtendedClass("test", 42, "extra", {"key": "value"}, 1000.0)

    assert not comparator(minimal, extended)


def test_dict_views() -> None:
    """Test comparator support for dict_keys, dict_values, and dict_items."""
    # Test dict_keys
    d1 = {"a": 1, "b": 2, "c": 3}
    d2 = {"a": 1, "b": 2, "c": 3}
    d3 = {"a": 1, "b": 2, "d": 3}
    d4 = {"a": 1, "b": 2}

    # dict_keys - same keys
    assert comparator(d1.keys(), d2.keys())
    # dict_keys - different keys
    assert not comparator(d1.keys(), d3.keys())
    # dict_keys - different length
    assert not comparator(d1.keys(), d4.keys())

    # Test dict_values
    v1 = {"a": 1, "b": 2, "c": 3}
    v2 = {"x": 1, "y": 2, "z": 3}  # same values, different keys
    v3 = {"a": 1, "b": 2, "c": 4}  # different value
    v4 = {"a": 1, "b": 2}  # different length

    # dict_values - same values (order matters for values since they're iterable)
    assert comparator(v1.values(), v2.values())
    # dict_values - different values
    assert not comparator(v1.values(), v3.values())
    # dict_values - different length
    assert not comparator(v1.values(), v4.values())

    # Test dict_items
    i1 = {"a": 1, "b": 2, "c": 3}
    i2 = {"a": 1, "b": 2, "c": 3}
    i3 = {"a": 1, "b": 2, "c": 4}  # different value
    i4 = {"a": 1, "b": 2, "d": 3}  # different key
    i5 = {"a": 1, "b": 2}  # different length
    i6 = {"b": 2, "c": 3, "a": 1}  # different order

    # dict_items - same items
    assert comparator(i1.items(), i2.items())
    # dict_items - different value
    assert not comparator(i1.items(), i3.items())
    # dict_items - different key
    assert not comparator(i1.items(), i4.items())
    # dict_items - different length
    assert not comparator(i1.items(), i5.items())

    assert comparator(i1.items(), i6.items())

    # Test empty dicts
    empty1 = {}
    empty2 = {}
    assert comparator(empty1.keys(), empty2.keys())
    assert comparator(empty1.values(), empty2.values())
    assert comparator(empty1.items(), empty2.items())

    # Test with nested values
    nested1 = {"a": [1, 2, 3], "b": {"x": 1}}
    nested2 = {"a": [1, 2, 3], "b": {"x": 1}}
    nested3 = {"a": [1, 2, 4], "b": {"x": 1}}

    assert comparator(nested1.values(), nested2.values())
    assert not comparator(nested1.values(), nested3.values())
    assert comparator(nested1.items(), nested2.items())
    assert not comparator(nested1.items(), nested3.items())

    # Test that dict views are not equal to lists/sets
    d = {"a": 1, "b": 2}
    assert not comparator(d.keys(), ["a", "b"])
    assert not comparator(d.keys(), {"a", "b"})
    assert not comparator(d.values(), [1, 2])
    assert not comparator(d.items(), [("a", 1), ("b", 2)])


def test_mappingproxy() -> None:
    """Test comparator support for types.MappingProxyType (read-only dict view)."""
    import types

    # Basic equality
    mp1 = types.MappingProxyType({"a": 1, "b": 2, "c": 3})
    mp2 = types.MappingProxyType({"a": 1, "b": 2, "c": 3})
    assert comparator(mp1, mp2)

    # Different values
    mp3 = types.MappingProxyType({"a": 1, "b": 2, "c": 4})
    assert not comparator(mp1, mp3)

    # Different keys
    mp4 = types.MappingProxyType({"a": 1, "b": 2, "d": 3})
    assert not comparator(mp1, mp4)

    # Different length
    mp5 = types.MappingProxyType({"a": 1, "b": 2})
    assert not comparator(mp1, mp5)

    # Order doesn't matter (like dict)
    mp6 = types.MappingProxyType({"c": 3, "a": 1, "b": 2})
    assert comparator(mp1, mp6)

    # Empty mappingproxy
    empty1 = types.MappingProxyType({})
    empty2 = types.MappingProxyType({})
    assert comparator(empty1, empty2)

    # Nested values
    nested1 = types.MappingProxyType({"a": [1, 2, 3], "b": {"x": 1}})
    nested2 = types.MappingProxyType({"a": [1, 2, 3], "b": {"x": 1}})
    nested3 = types.MappingProxyType({"a": [1, 2, 4], "b": {"x": 1}})
    assert comparator(nested1, nested2)
    assert not comparator(nested1, nested3)

    # mappingproxy is not equal to dict (different types)
    d = {"a": 1, "b": 2}
    mp = types.MappingProxyType({"a": 1, "b": 2})
    assert not comparator(mp, d)
    assert not comparator(d, mp)

    # Verify class __dict__ is indeed a mappingproxy
    class MyClass:
        x = 1
        y = 2

    assert isinstance(MyClass.__dict__, types.MappingProxyType)


def test_mappingproxy_superset() -> None:
    """Test comparator superset_obj support for mappingproxy."""
    import types

    mp1 = types.MappingProxyType({"a": 1, "b": 2})
    mp2 = types.MappingProxyType({"a": 1, "b": 2, "c": 3})

    # mp2 is a superset of mp1
    assert comparator(mp1, mp2, superset_obj=True)
    # mp1 is not a superset of mp2
    assert not comparator(mp2, mp1, superset_obj=True)

    # Same mappingproxy with superset_obj=True
    assert comparator(mp1, mp1, superset_obj=True)

    # Different values even with superset
    mp3 = types.MappingProxyType({"a": 1, "b": 99, "c": 3})
    assert not comparator(mp1, mp3, superset_obj=True)


def test_tensorflow_tensor() -> None:
    """Test comparator support for TensorFlow Tensor objects."""
    try:
        import tensorflow as tf
    except ImportError:
        pytest.skip("tensorflow required for this test")

    # Test basic 1D tensors
    a = tf.constant([1, 2, 3])
    b = tf.constant([1, 2, 3])
    c = tf.constant([1, 2, 4])

    assert comparator(a, b)
    assert not comparator(a, c)

    # Test 2D tensors
    d = tf.constant([[1, 2, 3], [4, 5, 6]])
    e = tf.constant([[1, 2, 3], [4, 5, 6]])
    f = tf.constant([[1, 2, 3], [4, 5, 7]])

    assert comparator(d, e)
    assert not comparator(d, f)

    # Test tensors with different shapes
    g = tf.constant([1, 2, 3])
    h = tf.constant([[1, 2, 3]])

    assert not comparator(g, h)

    # Test tensors with different dtypes
    i = tf.constant([1, 2, 3], dtype=tf.float32)
    j = tf.constant([1, 2, 3], dtype=tf.float32)
    k = tf.constant([1, 2, 3], dtype=tf.int32)

    assert comparator(i, j)
    assert not comparator(i, k)

    # Test 3D tensors
    l = tf.constant([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
    m = tf.constant([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
    n = tf.constant([[[1, 2], [3, 4]], [[5, 6], [7, 9]]])

    assert comparator(l, m)
    assert not comparator(l, n)

    # Test empty tensors
    o = tf.constant([])
    p = tf.constant([])
    q = tf.constant([1.0])

    assert comparator(o, p)
    assert not comparator(o, q)

    # Test tensors with NaN values
    r = tf.constant([1.0, float("nan"), 3.0])
    s = tf.constant([1.0, float("nan"), 3.0])
    t = tf.constant([1.0, 2.0, 3.0])

    assert comparator(r, s)  # NaN == NaN should be True
    assert not comparator(r, t)

    # Test tensors with infinity values
    u = tf.constant([1.0, float("inf"), 3.0])
    v = tf.constant([1.0, float("inf"), 3.0])
    w = tf.constant([1.0, float("-inf"), 3.0])

    assert comparator(u, v)
    assert not comparator(u, w)

    # Test complex tensors
    x = tf.constant([1 + 2j, 3 + 4j])
    y = tf.constant([1 + 2j, 3 + 4j])
    z = tf.constant([1 + 2j, 3 + 5j])

    assert comparator(x, y)
    assert not comparator(x, z)

    # Test boolean tensors
    aa = tf.constant([True, False, True])
    bb = tf.constant([True, False, True])
    cc = tf.constant([True, True, True])

    assert comparator(aa, bb)
    assert not comparator(aa, cc)

    # Test string tensors
    dd = tf.constant(["hello", "world"])
    ee = tf.constant(["hello", "world"])
    ff = tf.constant(["hello", "there"])

    assert comparator(dd, ee)
    assert not comparator(dd, ff)


def test_tensorflow_dtype() -> None:
    """Test comparator support for TensorFlow DType objects."""
    try:
        import tensorflow as tf
    except ImportError:
        pytest.skip("tensorflow required for this test")

    # Test float dtypes
    a = tf.float32
    b = tf.float32
    c = tf.float64

    assert comparator(a, b)
    assert not comparator(a, c)

    # Test integer dtypes
    d = tf.int32
    e = tf.int32
    f = tf.int64

    assert comparator(d, e)
    assert not comparator(d, f)

    # Test unsigned integer dtypes
    g = tf.uint8
    h = tf.uint8
    i = tf.uint16

    assert comparator(g, h)
    assert not comparator(g, i)

    # Test complex dtypes
    j = tf.complex64
    k = tf.complex64
    l = tf.complex128

    assert comparator(j, k)
    assert not comparator(j, l)

    # Test bool dtype
    m = tf.bool
    n = tf.bool
    o = tf.int8

    assert comparator(m, n)
    assert not comparator(m, o)

    # Test string dtype
    p = tf.string
    q = tf.string
    r = tf.int32

    assert comparator(p, q)
    assert not comparator(p, r)


def test_tensorflow_variable() -> None:
    """Test comparator support for TensorFlow Variable objects."""
    try:
        import tensorflow as tf
    except ImportError:
        pytest.skip("tensorflow required for this test")

    # Test basic variables
    a = tf.Variable([1, 2, 3], dtype=tf.float32)
    b = tf.Variable([1, 2, 3], dtype=tf.float32)
    c = tf.Variable([1, 2, 4], dtype=tf.float32)

    assert comparator(a, b)
    assert not comparator(a, c)

    # Test variables with different dtypes
    d = tf.Variable([1, 2, 3], dtype=tf.float32)
    e = tf.Variable([1, 2, 3], dtype=tf.float64)

    assert not comparator(d, e)

    # Test 2D variables
    f = tf.Variable([[1, 2], [3, 4]], dtype=tf.float32)
    g = tf.Variable([[1, 2], [3, 4]], dtype=tf.float32)
    h = tf.Variable([[1, 2], [3, 5]], dtype=tf.float32)

    assert comparator(f, g)
    assert not comparator(f, h)

    # Test variables with different shapes
    i = tf.Variable([1, 2, 3], dtype=tf.float32)
    j = tf.Variable([[1, 2, 3]], dtype=tf.float32)

    assert not comparator(i, j)


def test_tensorflow_tensor_shape() -> None:
    """Test comparator support for TensorFlow TensorShape objects."""
    try:
        import tensorflow as tf
    except ImportError:
        pytest.skip("tensorflow required for this test")

    # Test equal shapes
    a = tf.TensorShape([2, 3, 4])
    b = tf.TensorShape([2, 3, 4])
    c = tf.TensorShape([2, 3, 5])

    assert comparator(a, b)
    assert not comparator(a, c)

    # Test different ranks
    d = tf.TensorShape([2, 3])
    e = tf.TensorShape([2, 3, 4])

    assert not comparator(d, e)

    # Test scalar shapes
    f = tf.TensorShape([])
    g = tf.TensorShape([])
    h = tf.TensorShape([1])

    assert comparator(f, g)
    assert not comparator(f, h)

    # Test shapes with None dimensions (unknown dimensions)
    i = tf.TensorShape([None, 3, 4])
    j = tf.TensorShape([None, 3, 4])
    k = tf.TensorShape([2, 3, 4])

    assert comparator(i, j)
    assert not comparator(i, k)

    # Test fully unknown shapes
    l = tf.TensorShape(None)
    m = tf.TensorShape(None)
    n = tf.TensorShape([1, 2])

    assert comparator(l, m)
    assert not comparator(l, n)


def test_tensorflow_sparse_tensor() -> None:
    """Test comparator support for TensorFlow SparseTensor objects."""
    try:
        import tensorflow as tf
    except ImportError:
        pytest.skip("tensorflow required for this test")

    # Test equal sparse tensors
    a = tf.SparseTensor(indices=[[0, 0], [1, 2]], values=[1.0, 2.0], dense_shape=[3, 4])
    b = tf.SparseTensor(indices=[[0, 0], [1, 2]], values=[1.0, 2.0], dense_shape=[3, 4])
    c = tf.SparseTensor(
        indices=[[0, 0], [1, 2]],
        values=[1.0, 3.0],  # Different value
        dense_shape=[3, 4],
    )

    assert comparator(a, b)
    assert not comparator(a, c)

    # Test sparse tensors with different indices
    d = tf.SparseTensor(
        indices=[[0, 0], [1, 3]],  # Different index
        values=[1.0, 2.0],
        dense_shape=[3, 4],
    )

    assert not comparator(a, d)

    # Test sparse tensors with different shapes
    e = tf.SparseTensor(
        indices=[[0, 0], [1, 2]],
        values=[1.0, 2.0],
        dense_shape=[4, 5],  # Different shape
    )

    assert not comparator(a, e)

    # Test empty sparse tensors
    f = tf.SparseTensor(indices=tf.zeros([0, 2], dtype=tf.int64), values=[], dense_shape=[3, 4])
    g = tf.SparseTensor(indices=tf.zeros([0, 2], dtype=tf.int64), values=[], dense_shape=[3, 4])

    assert comparator(f, g)


def test_tensorflow_ragged_tensor() -> None:
    """Test comparator support for TensorFlow RaggedTensor objects."""
    try:
        import tensorflow as tf
    except ImportError:
        pytest.skip("tensorflow required for this test")

    # Test equal ragged tensors
    a = tf.ragged.constant([[1, 2], [3, 4, 5], [6]])
    b = tf.ragged.constant([[1, 2], [3, 4, 5], [6]])
    c = tf.ragged.constant([[1, 2], [3, 4, 6], [6]])  # Different value

    assert comparator(a, b)
    assert not comparator(a, c)

    # Test ragged tensors with different row lengths
    d = tf.ragged.constant([[1, 2, 3], [4, 5], [6]])  # Different structure

    assert not comparator(a, d)

    # Test ragged tensors with different dtypes
    e = tf.ragged.constant([[1.0, 2.0], [3.0, 4.0, 5.0], [6.0]])
    f = tf.ragged.constant([[1.0, 2.0], [3.0, 4.0, 5.0], [6.0]])

    assert comparator(e, f)
    assert not comparator(a, e)  # int vs float

    # Test nested ragged tensors
    g = tf.ragged.constant([[[1, 2], [3]], [[4, 5, 6]]])
    h = tf.ragged.constant([[[1, 2], [3]], [[4, 5, 6]]])
    i = tf.ragged.constant([[[1, 2], [3]], [[4, 5, 7]]])

    assert comparator(g, h)
    assert not comparator(g, i)

    # Test empty ragged tensors
    j = tf.ragged.constant([[], [], []])
    k = tf.ragged.constant([[], [], []])

    assert comparator(j, k)


def test_slice() -> None:
    """Test comparator support for slice objects."""
    # Test equal slices
    a = slice(1, 10, 2)
    b = slice(1, 10, 2)
    assert comparator(a, b)

    # Test slices with different start
    c = slice(2, 10, 2)
    assert not comparator(a, c)

    # Test slices with different stop
    d = slice(1, 11, 2)
    assert not comparator(a, d)

    # Test slices with different step
    e = slice(1, 10, 3)
    assert not comparator(a, e)

    # Test slices with None values
    f = slice(None, 10, 2)
    g = slice(None, 10, 2)
    h = slice(1, 10, 2)
    assert comparator(f, g)
    assert not comparator(f, h)

    # Test slices with all None (equivalent to [:])
    i = slice(None, None, None)
    j = slice(None, None, None)
    k = slice(None, None, 1)
    assert comparator(i, j)
    assert not comparator(i, k)

    # Test slices with only stop
    l = slice(5)
    m = slice(5)
    n = slice(6)
    assert comparator(l, m)
    assert not comparator(l, n)

    # Test slices with negative values
    o = slice(-5, -1, 1)
    p = slice(-5, -1, 1)
    q = slice(-5, -2, 1)
    assert comparator(o, p)
    assert not comparator(o, q)

    # Test slice is not equal to other types
    r = slice(1, 10)
    s = (1, 10)
    assert not comparator(r, s)


def test_numpy_datetime64() -> None:
    """Test comparator support for numpy datetime64 and timedelta64 types."""
    try:
        import numpy as np
    except ImportError:
        pytest.skip("numpy required for this test")

    # Test datetime64 equality
    a = np.datetime64("2021-01-01")
    b = np.datetime64("2021-01-01")
    c = np.datetime64("2021-01-02")

    assert comparator(a, b)
    assert not comparator(a, c)

    # Test datetime64 with different units
    d = np.datetime64("2021-01-01", "D")
    e = np.datetime64("2021-01-01", "D")
    f = np.datetime64("2021-01-01", "s")  # Different unit (seconds)

    assert comparator(d, e)
    # Note: datetime64 with different units but same moment may or may not be equal
    # depending on numpy version behavior

    # Test datetime64 with time
    g = np.datetime64("2021-01-01T12:00:00")
    h = np.datetime64("2021-01-01T12:00:00")
    i = np.datetime64("2021-01-01T12:00:01")

    assert comparator(g, h)
    assert not comparator(g, i)

    # Test timedelta64 equality
    j = np.timedelta64(1, "D")
    k = np.timedelta64(1, "D")
    l = np.timedelta64(2, "D")

    assert comparator(j, k)
    assert not comparator(j, l)

    # Test timedelta64 with different units
    m = np.timedelta64(1, "h")
    n = np.timedelta64(1, "h")
    o = np.timedelta64(60, "m")  # Same duration, different unit

    assert comparator(m, n)
    # 1 hour == 60 minutes, but they have different units
    # numpy may treat them as equal or not depending on comparison

    # Test NaT (Not a Time) - numpy's equivalent of NaN for datetime
    p = np.datetime64("NaT")
    q = np.datetime64("NaT")
    r = np.datetime64("2021-01-01")

    assert comparator(p, q)  # NaT == NaT should be True
    assert not comparator(p, r)

    # Test timedelta64 NaT
    s = np.timedelta64("NaT")
    t = np.timedelta64("NaT")
    u = np.timedelta64(1, "D")

    assert comparator(s, t)  # NaT == NaT should be True
    assert not comparator(s, u)

    # Test datetime64 is not equal to other types
    v = np.datetime64("2021-01-01")
    w = "2021-01-01"
    assert not comparator(v, w)

    # Test arrays of datetime64
    x = np.array(["2021-01-01", "2021-01-02"], dtype="datetime64")
    y = np.array(["2021-01-01", "2021-01-02"], dtype="datetime64")
    z = np.array(["2021-01-01", "2021-01-03"], dtype="datetime64")

    assert comparator(x, y)
    assert not comparator(x, z)


def test_numpy_0d_array() -> None:
    """Test comparator handles 0-d numpy arrays without 'iteration over 0-d array' error."""
    try:
        import numpy as np
    except ImportError:
        pytest.skip("numpy required for this test")

    # Test 0-d integer array
    a = np.array(5)
    b = np.array(5)
    c = np.array(6)

    assert comparator(a, b)
    assert not comparator(a, c)

    # Test 0-d float array
    d = np.array(3.14)
    e = np.array(3.14)
    f = np.array(2.71)

    assert comparator(d, e)
    assert not comparator(d, f)

    # Test 0-d complex array
    g = np.array(1 + 2j)
    h = np.array(1 + 2j)
    i = np.array(1 + 3j)

    assert comparator(g, h)
    assert not comparator(g, i)

    # Test 0-d string array
    j = np.array("hello")
    k = np.array("hello")
    l = np.array("world")

    assert comparator(j, k)
    assert not comparator(j, l)

    # Test 0-d boolean array
    m = np.array(True)
    n = np.array(True)
    o = np.array(False)

    assert comparator(m, n)
    assert not comparator(m, o)

    # Test 0-d array with NaN
    p = np.array(np.nan)
    q = np.array(np.nan)
    r = np.array(1.0)

    assert comparator(p, q)  # NaN == NaN should be True
    assert not comparator(p, r)

    # Test 0-d datetime64 array
    s = np.array(np.datetime64("2021-01-01"))
    t = np.array(np.datetime64("2021-01-01"))
    u = np.array(np.datetime64("2021-01-02"))

    assert comparator(s, t)
    assert not comparator(s, u)

    # Test 0-d array vs scalar
    v = np.array(5)
    w = 5
    # 0-d array and scalar are different types
    assert not comparator(v, w)

    # Test 0-d array vs 1-d array with one element
    x = np.array(5)
    y = np.array([5])
    # Different shapes
    assert not comparator(x, y)


def test_numpy_dtypes() -> None:
    """Test comparator for numpy.dtypes types like Float64DType, Int64DType, etc."""
    try:
        import numpy as np
        from numpy import dtypes
    except ImportError:
        pytest.skip("numpy not available")

    # Test Float64DType
    a = dtypes.Float64DType()
    b = dtypes.Float64DType()
    assert comparator(a, b)

    # Test Int64DType
    c = dtypes.Int64DType()
    d = dtypes.Int64DType()
    assert comparator(c, d)

    # Test different DType classes should not be equal
    assert not comparator(a, c)  # Float64DType vs Int64DType

    # Test various numeric DType classes
    assert comparator(dtypes.Int8DType(), dtypes.Int8DType())
    assert comparator(dtypes.Int16DType(), dtypes.Int16DType())
    assert comparator(dtypes.Int32DType(), dtypes.Int32DType())
    assert comparator(dtypes.UInt8DType(), dtypes.UInt8DType())
    assert comparator(dtypes.UInt16DType(), dtypes.UInt16DType())
    assert comparator(dtypes.UInt32DType(), dtypes.UInt32DType())
    assert comparator(dtypes.UInt64DType(), dtypes.UInt64DType())
    assert comparator(dtypes.Float32DType(), dtypes.Float32DType())
    assert comparator(dtypes.Complex64DType(), dtypes.Complex64DType())
    assert comparator(dtypes.Complex128DType(), dtypes.Complex128DType())
    assert comparator(dtypes.BoolDType(), dtypes.BoolDType())

    # Test cross-type comparisons should be False
    assert not comparator(dtypes.Int32DType(), dtypes.Int64DType())
    assert not comparator(dtypes.Float32DType(), dtypes.Float64DType())
    assert not comparator(dtypes.UInt32DType(), dtypes.Int32DType())

    # Test regular np.dtype instances
    e = np.dtype("float64")
    f = np.dtype("float64")
    assert comparator(e, f)

    g = np.dtype("int64")
    h = np.dtype("int64")
    assert comparator(g, h)

    assert not comparator(e, g)  # float64 vs int64

    # Test DType class instances vs regular np.dtype (they should be equal if same underlying type)
    assert comparator(dtypes.Float64DType(), np.dtype("float64"))
    assert comparator(dtypes.Int64DType(), np.dtype("int64"))
    assert comparator(dtypes.Int32DType(), np.dtype("int32"))
    assert comparator(dtypes.BoolDType(), np.dtype("bool"))

    # Test that DType and np.dtype of different types are not equal
    assert not comparator(dtypes.Float64DType(), np.dtype("int64"))
    assert not comparator(dtypes.Int32DType(), np.dtype("float32"))


def test_numpy_extended_precision_types() -> None:
    """Test comparator for numpy extended precision types like clongdouble."""
    try:
        import numpy as np
    except ImportError:
        pytest.skip("numpy not available")

    # Test np.clongdouble (extended precision complex)
    c1 = np.clongdouble(1 + 2j)
    c2 = np.clongdouble(1 + 2j)
    c3 = np.clongdouble(1 + 3j)
    assert comparator(c1, c2)
    assert not comparator(c1, c3)

    # Test np.longdouble (extended precision float)
    l1 = np.longdouble(1.5)
    l2 = np.longdouble(1.5)
    l3 = np.longdouble(2.5)
    assert comparator(l1, l2)
    assert not comparator(l1, l3)

    # Test NaN handling for extended precision complex
    nan_c1 = np.clongdouble(complex(np.nan, 2))
    nan_c2 = np.clongdouble(complex(np.nan, 2))
    assert comparator(nan_c1, nan_c2)

    # Test NaN handling for extended precision float
    nan_l1 = np.longdouble(np.nan)
    nan_l2 = np.longdouble(np.nan)
    assert comparator(nan_l1, nan_l2)


def test_numpy_typing_types() -> None:
    """Test comparator for numpy.typing types like NDArray type aliases."""
    try:
        import numpy as np
        import numpy.typing as npt
    except ImportError:
        pytest.skip("numpy or numpy.typing not available")

    # Test NDArray type alias comparisons
    arr_type1 = npt.NDArray[np.float64]
    arr_type2 = npt.NDArray[np.float64]
    arr_type3 = npt.NDArray[np.int64]
    assert comparator(arr_type1, arr_type2)
    assert not comparator(arr_type1, arr_type3)

    # Test NBitBase (if it can be instantiated)
    try:
        nbit1 = npt.NBitBase()
        nbit2 = npt.NBitBase()
        # NBitBase instances with empty __dict__ should compare as equal
        assert comparator(nbit1, nbit2)
        # Also test with superset_obj=True
        assert comparator(nbit1, nbit2, superset_obj=True)
    except TypeError:
        # NBitBase may not be instantiable in all numpy versions
        pass


def test_numpy_typing_superset_obj() -> None:
    """Test comparator with superset_obj=True for numpy types."""
    try:
        import numpy as np
        import numpy.typing as npt
    except ImportError:
        pytest.skip("numpy or numpy.typing not available")

    # Test numpy arrays with object dtype containing dicts (superset scenario)
    a1 = np.array([{"a": 1}], dtype=object)
    a2 = np.array([{"a": 1, "b": 2}], dtype=object)  # superset
    assert comparator(a1, a2, superset_obj=True)
    assert not comparator(a1, a2, superset_obj=False)

    # Test extended precision types with superset_obj=True
    c1 = np.clongdouble(1 + 2j)
    c2 = np.clongdouble(1 + 2j)
    assert comparator(c1, c2, superset_obj=True)

    l1 = np.longdouble(1.5)
    l2 = np.longdouble(1.5)
    assert comparator(l1, l2, superset_obj=True)

    # Test NDArray type alias with superset_obj=True
    arr_type1 = npt.NDArray[np.float64]
    arr_type2 = npt.NDArray[np.float64]
    assert comparator(arr_type1, arr_type2, superset_obj=True)

    # Test numpy structured arrays (np.void) with superset_obj=True
    dt = np.dtype([("name", "S10"), ("age", np.int32)])
    a_struct = np.array([("Alice", 25)], dtype=dt)
    b_struct = np.array([("Alice", 25)], dtype=dt)
    assert comparator(a_struct[0], b_struct[0], superset_obj=True)

    # Test numpy random generators with superset_obj=True
    rng1 = np.random.default_rng(seed=42)
    rng2 = np.random.default_rng(seed=42)
    assert comparator(rng1, rng2, superset_obj=True)

    rs1 = np.random.RandomState(seed=42)
    rs2 = np.random.RandomState(seed=42)
    assert comparator(rs1, rs2, superset_obj=True)


def test_numba_typed_list() -> None:
    """Test comparator for numba.typed.List."""
    try:
        import numba
        from numba.typed import List as NumbaList
    except ImportError:
        pytest.skip("numba not available")

    # Test equal lists
    a = NumbaList([1, 2, 3])
    b = NumbaList([1, 2, 3])
    assert comparator(a, b)

    # Test different values
    c = NumbaList([1, 2, 4])
    assert not comparator(a, c)

    # Test different lengths
    d = NumbaList([1, 2, 3, 4])
    assert not comparator(a, d)

    # Test empty lists
    e = NumbaList.empty_list(item_type=numba.int64)
    f = NumbaList.empty_list(item_type=numba.int64)
    assert comparator(e, f)

    # Test nested values (floats)
    g = NumbaList([1.0, 2.0, 3.0])
    h = NumbaList([1.0, 2.0, 3.0])
    assert comparator(g, h)

    i = NumbaList([1.0, 2.0, 4.0])
    assert not comparator(g, i)


def test_numba_typed_dict() -> None:
    """Test comparator for numba.typed.Dict."""
    try:
        import numba
        from numba.typed import Dict as NumbaDict
    except ImportError:
        pytest.skip("numba not available")

    # Test equal dicts
    a = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    a["x"] = 1
    a["y"] = 2

    b = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    b["x"] = 1
    b["y"] = 2
    assert comparator(a, b)

    # Test different values
    c = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    c["x"] = 1
    c["y"] = 3
    assert not comparator(a, c)

    # Test different keys
    d = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    d["x"] = 1
    d["z"] = 2
    assert not comparator(a, d)

    # Test different lengths
    e = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    e["x"] = 1
    assert not comparator(a, e)

    # Test empty dicts
    f = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    g = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    assert comparator(f, g)


def test_numba_types() -> None:
    """Test comparator for numba type objects."""
    try:
        import numba
        from numba import types
    except ImportError:
        pytest.skip("numba not available")

    # Test basic numeric types from numba module
    assert comparator(numba.int64, numba.int64)
    assert comparator(numba.float64, numba.float64)
    assert comparator(numba.int32, numba.int32)
    assert comparator(numba.float32, numba.float32)

    # Test basic numeric types from numba.types module
    assert comparator(types.int64, types.int64)
    assert comparator(types.float64, types.float64)
    assert comparator(types.int8, types.int8)
    assert comparator(types.int16, types.int16)
    assert comparator(types.uint8, types.uint8)
    assert comparator(types.uint16, types.uint16)
    assert comparator(types.uint32, types.uint32)
    assert comparator(types.uint64, types.uint64)
    assert comparator(types.complex64, types.complex64)
    assert comparator(types.complex128, types.complex128)

    # Test different types
    assert not comparator(numba.int64, numba.float64)
    assert not comparator(numba.int32, numba.int64)
    assert not comparator(numba.float32, numba.float64)
    assert not comparator(types.int8, types.int16)
    assert not comparator(types.uint32, types.int32)
    assert not comparator(types.complex64, types.complex128)

    # Test boolean type
    assert comparator(numba.boolean, numba.boolean)
    assert comparator(types.boolean, types.boolean)
    assert not comparator(numba.boolean, numba.int64)

    # Test special types
    assert comparator(types.none, types.none)
    assert comparator(types.void, types.void)
    assert comparator(types.pyobject, types.pyobject)
    assert comparator(types.unicode_type, types.unicode_type)
    # Note: types.none and types.void are the same object in numba
    assert comparator(types.none, types.void)
    assert not comparator(types.unicode_type, types.pyobject)
    assert not comparator(types.none, types.int64)

    # Test array types
    arr_type1 = types.Array(numba.float64, 1, "C")
    arr_type2 = types.Array(numba.float64, 1, "C")
    arr_type3 = types.Array(numba.float64, 2, "C")
    arr_type4 = types.Array(numba.int64, 1, "C")
    arr_type5 = types.Array(numba.float64, 1, "F")  # Fortran order

    assert comparator(arr_type1, arr_type2)
    assert not comparator(arr_type1, arr_type3)  # different ndim
    assert not comparator(arr_type1, arr_type4)  # different dtype
    assert not comparator(arr_type1, arr_type5)  # different layout

    # Test tuple types
    tuple_type1 = types.UniTuple(types.int64, 3)
    tuple_type2 = types.UniTuple(types.int64, 3)
    tuple_type3 = types.UniTuple(types.int64, 4)
    tuple_type4 = types.UniTuple(types.float64, 3)

    assert comparator(tuple_type1, tuple_type2)
    assert not comparator(tuple_type1, tuple_type3)  # different count
    assert not comparator(tuple_type1, tuple_type4)  # different dtype

    # Test heterogeneous tuple types
    hetero_tuple1 = types.Tuple([types.int64, types.float64])
    hetero_tuple2 = types.Tuple([types.int64, types.float64])
    hetero_tuple3 = types.Tuple([types.int64, types.int64])

    assert comparator(hetero_tuple1, hetero_tuple2)
    assert not comparator(hetero_tuple1, hetero_tuple3)

    # Test ListType and DictType
    list_type1 = types.ListType(types.int64)
    list_type2 = types.ListType(types.int64)
    list_type3 = types.ListType(types.float64)

    assert comparator(list_type1, list_type2)
    assert not comparator(list_type1, list_type3)

    dict_type1 = types.DictType(types.unicode_type, types.int64)
    dict_type2 = types.DictType(types.unicode_type, types.int64)
    dict_type3 = types.DictType(types.unicode_type, types.float64)
    dict_type4 = types.DictType(types.int64, types.int64)

    assert comparator(dict_type1, dict_type2)
    assert not comparator(dict_type1, dict_type3)  # different value type
    assert not comparator(dict_type1, dict_type4)  # different key type


def test_numba_jit_functions() -> None:
    """Test comparator for numba JIT-compiled functions."""
    try:
        from numba import jit
    except ImportError:
        pytest.skip("numba not available")

    @jit(nopython=True)
    def add(x, y):
        return x + y

    @jit(nopython=True)
    def add2(x, y):
        return x + y

    @jit(nopython=True)
    def multiply(x, y):
        return x * y

    # Compile the functions by calling them
    add(1, 2)
    add2(1, 2)
    multiply(1, 2)

    # Same function should compare equal to itself
    assert comparator(add, add)

    # Different functions (even with same code) should not compare equal
    # since they are distinct function objects
    assert not comparator(add, add2)

    # Different functions with different code should not compare equal
    assert not comparator(add, multiply)


def test_numba_superset_obj() -> None:
    """Test comparator for numba types with superset_obj=True."""
    try:
        import numba
        from numba.typed import Dict as NumbaDict
        from numba.typed import List as NumbaList
    except ImportError:
        pytest.skip("numba not available")

    # Test NumbaDict with superset_obj=True
    orig_dict = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    orig_dict["x"] = 1
    orig_dict["y"] = 2

    # New dict with same keys - should pass
    new_dict_same = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    new_dict_same["x"] = 1
    new_dict_same["y"] = 2
    assert comparator(orig_dict, new_dict_same, superset_obj=True)

    # New dict with extra keys - should pass with superset_obj=True
    new_dict_superset = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    new_dict_superset["x"] = 1
    new_dict_superset["y"] = 2
    new_dict_superset["z"] = 3
    assert comparator(orig_dict, new_dict_superset, superset_obj=True)
    # But should fail with superset_obj=False
    assert not comparator(orig_dict, new_dict_superset, superset_obj=False)

    # New dict missing keys - should fail even with superset_obj=True
    new_dict_subset = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    new_dict_subset["x"] = 1
    assert not comparator(orig_dict, new_dict_subset, superset_obj=True)

    # New dict with different values - should fail
    new_dict_diff = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    new_dict_diff["x"] = 1
    new_dict_diff["y"] = 99
    assert not comparator(orig_dict, new_dict_diff, superset_obj=True)

    # Test NumbaList with superset_obj=True (lists don't support superset semantics)
    orig_list = NumbaList([1, 2, 3])
    new_list_same = NumbaList([1, 2, 3])
    new_list_longer = NumbaList([1, 2, 3, 4])

    assert comparator(orig_list, new_list_same, superset_obj=True)
    # Lists must have same length regardless of superset_obj
    assert not comparator(orig_list, new_list_longer, superset_obj=True)

    # Test empty dict with superset_obj=True
    empty_orig = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    non_empty_new = NumbaDict.empty(key_type=numba.types.unicode_type, value_type=numba.int64)
    non_empty_new["a"] = 1
    # Empty orig should match any superset
    assert comparator(empty_orig, non_empty_new, superset_obj=True)
    assert not comparator(empty_orig, non_empty_new, superset_obj=False)


# =============================================================================
# Tests for pytest temp path normalization (lines 28-69 in comparator.py)
# =============================================================================


class TestIsTempPath:
    """Tests for the _is_temp_path() function."""

    def test_standard_pytest_temp_path(self):
        """Test detection of standard pytest temp paths."""
        assert _is_temp_path("/tmp/pytest-of-user/pytest-0/test_something")
        assert _is_temp_path("/tmp/pytest-of-user/pytest-123/")
        assert _is_temp_path("/tmp/pytest-of-admin/pytest-999/subdir/file.txt")

    def test_different_usernames(self):
        """Test temp paths with various usernames."""
        assert _is_temp_path("/tmp/pytest-of-root/pytest-1/")
        assert _is_temp_path("/tmp/pytest-of-john_doe/pytest-42/")
        assert _is_temp_path("/tmp/pytest-of-user123/pytest-0/test")
        assert _is_temp_path("/tmp/pytest-of-test-user/pytest-5/data")

    def test_different_session_numbers(self):
        """Test temp paths with various session numbers."""
        assert _is_temp_path("/tmp/pytest-of-user/pytest-0/")
        assert _is_temp_path("/tmp/pytest-of-user/pytest-1/")
        assert _is_temp_path("/tmp/pytest-of-user/pytest-99/")
        assert _is_temp_path("/tmp/pytest-of-user/pytest-12345/")

    def test_paths_with_subdirectories(self):
        """Test temp paths with nested subdirectories."""
        assert _is_temp_path("/tmp/pytest-of-user/pytest-0/test_func/subdir")
        assert _is_temp_path("/tmp/pytest-of-user/pytest-0/a/b/c/d/file.txt")
        assert _is_temp_path("/tmp/pytest-of-user/pytest-0/test_module0/test_file.py")

    def test_paths_with_filenames(self):
        """Test temp paths ending with filenames."""
        assert _is_temp_path("/tmp/pytest-of-user/pytest-0/output.json")
        assert _is_temp_path("/tmp/pytest-of-user/pytest-0/test.log")
        assert _is_temp_path("/tmp/pytest-of-user/pytest-0/data.csv")

    def test_non_temp_paths(self):
        """Test that non-temp paths are correctly identified."""
        assert not _is_temp_path("/home/user/project/test.py")
        assert not _is_temp_path("/tmp/other/directory")
        assert not _is_temp_path("/var/log/test.log")
        assert not _is_temp_path("./relative/path")
        assert not _is_temp_path("test_file.py")

    def test_similar_but_not_temp_paths(self):
        """Test paths that look similar but don't match the pattern."""
        assert not _is_temp_path("/tmp/pytest-user/pytest-0/")  # missing "of-"
        assert not _is_temp_path("/tmp/pytest-of-user/pytest-/")  # no number
        assert not _is_temp_path("/tmp/pytest-of-/pytest-0/")  # empty username
        assert not _is_temp_path("/tmp/pytest-of-user/pytest-abc/")  # non-numeric session

    def test_edge_cases(self):
        """Test edge cases for _is_temp_path."""
        assert not _is_temp_path("")
        assert not _is_temp_path("/")
        assert not _is_temp_path("/tmp/")
        assert not _is_temp_path("/tmp/pytest-of-")

    def test_path_embedded_in_string(self):
        """Test that temp paths are detected when embedded in longer strings."""
        assert _is_temp_path("Error in /tmp/pytest-of-user/pytest-0/test.py: failed")
        assert _is_temp_path("File: /tmp/pytest-of-user/pytest-123/output.txt")

    def test_windows_style_paths(self):
        """Test that Windows-style paths are not detected as temp paths."""
        assert not _is_temp_path("C:\\Users\\test\\pytest")
        assert not _is_temp_path("D:\\tmp\\pytest-of-user\\pytest-0\\")


class TestNormalizeTempPath:
    """Tests for the _normalize_temp_path() function."""

    def test_basic_normalization(self):
        """Test basic temp path normalization."""
        assert _normalize_temp_path("/tmp/pytest-of-user/pytest-0/test") == "/tmp/pytest-temp/test"
        assert _normalize_temp_path("/tmp/pytest-of-user/pytest-123/test") == "/tmp/pytest-temp/test"

    def test_different_session_numbers_normalize_same(self):
        """Test that different session numbers normalize to the same result."""
        path1 = _normalize_temp_path("/tmp/pytest-of-user/pytest-0/file.txt")
        path2 = _normalize_temp_path("/tmp/pytest-of-user/pytest-99/file.txt")
        path3 = _normalize_temp_path("/tmp/pytest-of-user/pytest-12345/file.txt")
        assert path1 == path2 == path3 == "/tmp/pytest-temp/file.txt"

    def test_different_usernames_normalize_same(self):
        """Test that different usernames normalize to the same result."""
        path1 = _normalize_temp_path("/tmp/pytest-of-alice/pytest-0/file.txt")
        path2 = _normalize_temp_path("/tmp/pytest-of-bob/pytest-0/file.txt")
        path3 = _normalize_temp_path("/tmp/pytest-of-root/pytest-0/file.txt")
        assert path1 == path2 == path3 == "/tmp/pytest-temp/file.txt"

    def test_complex_subdirectories(self):
        """Test normalization with complex subdirectory structures."""
        result = _normalize_temp_path("/tmp/pytest-of-user/pytest-42/test_module/subdir/file.py")
        assert result == "/tmp/pytest-temp/test_module/subdir/file.py"

    def test_non_temp_path_unchanged(self):
        """Test that non-temp paths are returned unchanged."""
        path = "/home/user/project/test.py"
        assert _normalize_temp_path(path) == path

    def test_empty_string(self):
        """Test normalization of empty string."""
        assert _normalize_temp_path("") == ""

    def test_path_with_multiple_occurrences(self):
        """Test paths with multiple temp path patterns (unusual but possible in error messages)."""
        path = "/tmp/pytest-of-user/pytest-0/ref to /tmp/pytest-of-user/pytest-1/other"
        result = _normalize_temp_path(path)
        assert result == "/tmp/pytest-temp/ref to /tmp/pytest-temp/other"

    def test_trailing_slash_handling(self):
        """Test normalization preserves or removes trailing slashes correctly."""
        result1 = _normalize_temp_path("/tmp/pytest-of-user/pytest-0/")
        result2 = _normalize_temp_path("/tmp/pytest-of-user/pytest-0/subdir/")
        assert result1 == "/tmp/pytest-temp/"
        assert result2 == "/tmp/pytest-temp/subdir/"


class TestComparatorTempPaths:
    """Tests for comparator() with temp path strings."""

    def test_identical_temp_paths(self):
        """Test that identical temp paths compare as equal."""
        path = "/tmp/pytest-of-user/pytest-0/test.txt"
        assert comparator(path, path)

    def test_different_session_numbers(self):
        """Test that paths differing only in session number are equal."""
        path1 = "/tmp/pytest-of-user/pytest-0/output.txt"
        path2 = "/tmp/pytest-of-user/pytest-99/output.txt"
        assert comparator(path1, path2)

    def test_different_usernames(self):
        """Test that paths differing in username are equal."""
        path1 = "/tmp/pytest-of-alice/pytest-0/result.json"
        path2 = "/tmp/pytest-of-bob/pytest-0/result.json"
        assert comparator(path1, path2)

    def test_different_usernames_and_sessions(self):
        """Test that paths differing in both username and session are equal."""
        path1 = "/tmp/pytest-of-alice/pytest-10/data/file.csv"
        path2 = "/tmp/pytest-of-bob/pytest-999/data/file.csv"
        assert comparator(path1, path2)

    def test_different_subdirectories_not_equal(self):
        """Test that paths with different subdirectories are not equal."""
        path1 = "/tmp/pytest-of-user/pytest-0/subdir1/file.txt"
        path2 = "/tmp/pytest-of-user/pytest-0/subdir2/file.txt"
        assert not comparator(path1, path2)

    def test_different_filenames_not_equal(self):
        """Test that paths with different filenames are not equal."""
        path1 = "/tmp/pytest-of-user/pytest-0/file1.txt"
        path2 = "/tmp/pytest-of-user/pytest-0/file2.txt"
        assert not comparator(path1, path2)

    def test_temp_path_vs_non_temp_path(self):
        """Test that temp paths don't match non-temp paths."""
        temp_path = "/tmp/pytest-of-user/pytest-0/file.txt"
        non_temp_path = "/home/user/file.txt"
        assert not comparator(temp_path, non_temp_path)

    def test_regular_strings_still_work(self):
        """Test that regular string comparison still works."""
        assert comparator("hello", "hello")
        assert not comparator("hello", "world")
        assert comparator("", "")
        assert not comparator("test", "")

    def test_non_temp_paths_must_be_exact(self):
        """Test that non-temp paths require exact equality."""
        path1 = "/home/user/project/file.txt"
        path2 = "/home/user/project/file.txt"
        path3 = "/home/user/project/other.txt"
        assert comparator(path1, path2)
        assert not comparator(path1, path3)


class TestComparatorTempPathsInNestedStructures:
    """Tests for comparator() with temp paths in nested data structures."""

    def test_temp_paths_in_list(self):
        """Test temp paths inside lists."""
        list1 = ["/tmp/pytest-of-alice/pytest-0/file.txt", "other"]
        list2 = ["/tmp/pytest-of-bob/pytest-99/file.txt", "other"]
        assert comparator(list1, list2)

    def test_temp_paths_in_tuple(self):
        """Test temp paths inside tuples."""
        tuple1 = ("/tmp/pytest-of-user/pytest-0/a.txt", "/tmp/pytest-of-user/pytest-0/b.txt")
        tuple2 = ("/tmp/pytest-of-user/pytest-123/a.txt", "/tmp/pytest-of-user/pytest-123/b.txt")
        assert comparator(tuple1, tuple2)

    def test_temp_paths_in_dict_values(self):
        """Test temp paths as dictionary values."""
        dict1 = {"path": "/tmp/pytest-of-user/pytest-0/output.json", "name": "test"}
        dict2 = {"path": "/tmp/pytest-of-user/pytest-999/output.json", "name": "test"}
        assert comparator(dict1, dict2)

    def test_temp_paths_in_dict_keys_not_supported(self):
        """Test that temp paths as dictionary keys must match exactly (keys are not normalized)."""
        # Dict keys use direct comparison, so temp paths as keys won't be normalized
        # This tests the expected behavior
        dict1 = {"/tmp/pytest-of-user/pytest-0/key": "value"}
        dict2 = {"/tmp/pytest-of-user/pytest-0/key": "value"}
        assert comparator(dict1, dict2)

    def test_temp_paths_in_nested_dict(self):
        """Test temp paths in nested dictionaries."""
        nested1 = {
            "config": {
                "output_path": "/tmp/pytest-of-alice/pytest-5/results",
                "log_path": "/tmp/pytest-of-alice/pytest-5/logs",
            }
        }
        nested2 = {
            "config": {
                "output_path": "/tmp/pytest-of-bob/pytest-10/results",
                "log_path": "/tmp/pytest-of-bob/pytest-10/logs",
            }
        }
        assert comparator(nested1, nested2)

    def test_temp_paths_in_deeply_nested_structure(self):
        """Test temp paths in deeply nested structures."""
        deep1 = {"a": {"b": {"c": ["/tmp/pytest-of-user/pytest-0/file.txt"]}}}
        deep2 = {"a": {"b": {"c": ["/tmp/pytest-of-other/pytest-99/file.txt"]}}}
        assert comparator(deep1, deep2)

    def test_mixed_temp_and_regular_paths(self):
        """Test structures with both temp and regular paths."""
        data1 = {"temp": "/tmp/pytest-of-user/pytest-0/temp.txt", "regular": "/home/user/file.txt"}
        data2 = {"temp": "/tmp/pytest-of-user/pytest-99/temp.txt", "regular": "/home/user/file.txt"}
        assert comparator(data1, data2)

        data3 = {"temp": "/tmp/pytest-of-user/pytest-99/temp.txt", "regular": "/home/user/different.txt"}
        assert not comparator(data1, data3)

    def test_temp_paths_in_deque(self):
        """Test temp paths inside deque."""
        from collections import deque

        d1 = deque(["/tmp/pytest-of-user/pytest-0/file.txt"])
        d2 = deque(["/tmp/pytest-of-user/pytest-123/file.txt"])
        assert comparator(d1, d2)

    def test_temp_paths_in_chainmap(self):
        """Test temp paths inside ChainMap."""
        from collections import ChainMap

        cm1 = ChainMap({"path": "/tmp/pytest-of-user/pytest-0/file.txt"})
        cm2 = ChainMap({"path": "/tmp/pytest-of-user/pytest-99/file.txt"})
        assert comparator(cm1, cm2)


class TestComparatorTempPathsEdgeCases:
    """Edge case tests for temp path handling in comparator."""

    def test_empty_string_vs_temp_path(self):
        """Test empty string comparison with temp path."""
        assert not comparator("", "/tmp/pytest-of-user/pytest-0/file.txt")
        assert not comparator("/tmp/pytest-of-user/pytest-0/file.txt", "")

    def test_path_with_special_characters(self):
        """Test temp paths containing special characters in filenames."""
        path1 = "/tmp/pytest-of-user/pytest-0/file with spaces.txt"
        path2 = "/tmp/pytest-of-user/pytest-99/file with spaces.txt"
        assert comparator(path1, path2)

        path3 = "/tmp/pytest-of-user/pytest-0/file-with-dashes.txt"
        path4 = "/tmp/pytest-of-user/pytest-99/file-with-dashes.txt"
        assert comparator(path3, path4)

    def test_path_with_unicode_characters(self):
        """Test temp paths with unicode characters."""
        path1 = "/tmp/pytest-of-user/pytest-0/файл.txt"
        path2 = "/tmp/pytest-of-user/pytest-99/файл.txt"
        assert comparator(path1, path2)

    def test_very_long_session_number(self):
        """Test temp paths with very long session numbers."""
        path1 = "/tmp/pytest-of-user/pytest-9999999999/file.txt"
        path2 = "/tmp/pytest-of-user/pytest-0/file.txt"
        assert comparator(path1, path2)

    def test_username_with_special_characters(self):
        """Test temp paths with special characters in username."""
        path1 = "/tmp/pytest-of-user-name/pytest-0/file.txt"
        path2 = "/tmp/pytest-of-other-user/pytest-99/file.txt"
        assert comparator(path1, path2)

    def test_path_only_differs_in_temp_portion(self):
        """Test that only the temp portion is normalized, rest must match."""
        path1 = "/tmp/pytest-of-user/pytest-0/subdir/nested/file.txt"
        path2 = "/tmp/pytest-of-user/pytest-99/subdir/nested/file.txt"
        assert comparator(path1, path2)

        path3 = "/tmp/pytest-of-user/pytest-0/subdir/nested/other.txt"
        assert not comparator(path1, path3)

    def test_multiple_slashes(self):
        """Test temp paths with multiple consecutive slashes (should still work)."""
        # Note: The regex handles the standard format, extra slashes may not be normalized
        path1 = "/tmp/pytest-of-user/pytest-0/file.txt"
        path2 = "/tmp/pytest-of-user/pytest-99/file.txt"
        assert comparator(path1, path2)

    def test_temp_path_at_start_middle_end(self):
        """Test that temp paths are detected regardless of position in string."""
        # Path at start
        assert _is_temp_path("/tmp/pytest-of-user/pytest-0/test")
        # Path in middle (embedded in error message)
        assert _is_temp_path("Error: /tmp/pytest-of-user/pytest-0/test failed")
        # Path at end
        assert _is_temp_path("Output saved to /tmp/pytest-of-user/pytest-0/")

    def test_partial_temp_path_patterns(self):
        """Test strings that partially match temp path pattern."""
        # Missing components
        assert not _is_temp_path("/tmp/pytest-of-user/")
        assert not _is_temp_path("/tmp/pytest-0/")
        assert not _is_temp_path("pytest-of-user/pytest-0/")


class TestPytestTempPathPatternRegex:
    """Tests for the PYTEST_TEMP_PATH_PATTERN regex directly."""

    def test_pattern_matches_standard_format(self):
        """Test regex matches standard pytest temp path format."""
        assert PYTEST_TEMP_PATH_PATTERN.search("/tmp/pytest-of-user/pytest-0/")
        assert PYTEST_TEMP_PATH_PATTERN.search("/tmp/pytest-of-user/pytest-123/file")

    def test_pattern_captures_correctly(self):
        """Test that the pattern substitution works correctly."""
        result = PYTEST_TEMP_PATH_PATTERN.sub("REPLACED", "/tmp/pytest-of-user/pytest-0/file.txt")
        assert result == "REPLACEDfile.txt"

    def test_pattern_handles_multiple_matches(self):
        """Test pattern with multiple temp paths in same string."""
        text = "/tmp/pytest-of-a/pytest-1/ and /tmp/pytest-of-b/pytest-2/"
        result = PYTEST_TEMP_PATH_PATTERN.sub("X", text)
        assert result == "X and X"

    def test_pattern_greedy_behavior(self):
        """Test that the pattern doesn't over-match."""
        # The pattern should stop at the trailing slash of the session number
        path = "/tmp/pytest-of-user/pytest-0/subdir/pytest-1/file.txt"
        result = PYTEST_TEMP_PATH_PATTERN.sub("X", path)
        # The first temp path should be replaced, but "pytest-1" in subdir shouldn't trigger
        assert "subdir" in result


class TestComparatorTempPathsWithSuperset:
    """Tests for temp path comparison with superset_obj=True."""

    def test_superset_with_temp_paths_in_dict(self):
        """Test superset comparison with temp paths in dictionaries."""
        orig = {"path": "/tmp/pytest-of-user/pytest-0/file.txt"}
        new = {"path": "/tmp/pytest-of-user/pytest-99/file.txt", "extra": "data"}
        assert comparator(orig, new, superset_obj=True)

    def test_superset_temp_paths_must_still_match(self):
        """Test that temp paths must still be equivalent in superset mode."""
        orig = {"path": "/tmp/pytest-of-user/pytest-0/file.txt"}
        new = {"path": "/tmp/pytest-of-user/pytest-99/other.txt", "extra": "data"}
        assert not comparator(orig, new, superset_obj=True)

    def test_superset_nested_dict_with_temp_paths(self):
        """Test superset comparison with temp paths in nested dictionaries."""
        orig = {"config": {"output": "/tmp/pytest-of-alice/pytest-5/results.json"}}
        new = {
            "config": {"output": "/tmp/pytest-of-bob/pytest-100/results.json", "debug": True},
            "metadata": {"version": "1.0"},
        }
        assert comparator(orig, new, superset_obj=True)

    def test_superset_multiple_temp_paths_in_dict(self):
        """Test superset with multiple temp paths in dictionary values."""
        orig = {"input": "/tmp/pytest-of-user/pytest-0/input.txt", "output": "/tmp/pytest-of-user/pytest-0/output.txt"}
        new = {
            "input": "/tmp/pytest-of-user/pytest-99/input.txt",
            "output": "/tmp/pytest-of-user/pytest-99/output.txt",
            "log": "/tmp/pytest-of-user/pytest-99/debug.log",
        }
        assert comparator(orig, new, superset_obj=True)

    def test_superset_temp_path_in_list_inside_dict(self):
        """Test superset with temp paths in lists inside dictionaries."""
        orig = {"files": ["/tmp/pytest-of-user/pytest-0/a.txt", "/tmp/pytest-of-user/pytest-0/b.txt"]}
        new = {"files": ["/tmp/pytest-of-user/pytest-99/a.txt", "/tmp/pytest-of-user/pytest-99/b.txt"], "count": 2}
        assert comparator(orig, new, superset_obj=True)

    def test_superset_false_when_temp_path_missing(self):
        """Test superset fails when temp path key is missing in new."""
        orig = {"path": "/tmp/pytest-of-user/pytest-0/file.txt"}
        new = {"other": "data"}
        assert not comparator(orig, new, superset_obj=True)

    def test_superset_temp_path_with_different_filenames_fails(self):
        """Test superset fails when normalized temp paths have different filenames."""
        orig = {"result": "/tmp/pytest-of-user/pytest-0/output_v1.json"}
        new = {"result": "/tmp/pytest-of-user/pytest-99/output_v2.json", "extra": "data"}
        assert not comparator(orig, new, superset_obj=True)

    def test_superset_mixed_temp_and_regular_paths(self):
        """Test superset with mix of temp paths and regular paths."""
        orig = {"temp_file": "/tmp/pytest-of-user/pytest-0/temp.txt", "config_file": "/etc/app/config.yaml"}
        new = {
            "temp_file": "/tmp/pytest-of-user/pytest-99/temp.txt",
            "config_file": "/etc/app/config.yaml",
            "extra_key": "extra_value",
        }
        assert comparator(orig, new, superset_obj=True)

    def test_superset_regular_path_must_match_exactly(self):
        """Test that regular paths must match exactly even in superset mode."""
        orig = {"temp_file": "/tmp/pytest-of-user/pytest-0/temp.txt", "config_file": "/etc/app/config.yaml"}
        new = {
            "temp_file": "/tmp/pytest-of-user/pytest-99/temp.txt",
            "config_file": "/etc/app/other.yaml",
            "extra_key": "extra_value",
        }
        assert not comparator(orig, new, superset_obj=True)

    def test_superset_deeply_nested_temp_paths(self):
        """Test superset with deeply nested structures containing temp paths."""
        orig = {"level1": {"level2": {"level3": {"path": "/tmp/pytest-of-user/pytest-0/deep.txt"}}}}
        new = {
            "level1": {
                "level2": {
                    "level3": {"path": "/tmp/pytest-of-other/pytest-999/deep.txt", "extra": True},
                    "sibling": "value",
                }
            },
            "top_level_extra": 123,
        }
        assert comparator(orig, new, superset_obj=True)

    def test_superset_with_attrs_class_containing_temp_paths(self):
        """Test superset with attrs classes containing temp paths."""
        try:
            import attr
        except ImportError:
            pytest.skip("attrs not installed")

        @attr.s
        class Config:
            path = attr.ib()
            name = attr.ib(default="default")

        # Test that temp paths are normalized in attrs classes
        orig = Config(path="/tmp/pytest-of-user/pytest-0/config.json")
        new = Config(path="/tmp/pytest-of-user/pytest-99/config.json")
        assert comparator(orig, new, superset_obj=True)

        # Test that different non-temp values still fail
        orig2 = Config(path="/tmp/pytest-of-user/pytest-0/config.json", name="name1")
        new2 = Config(path="/tmp/pytest-of-user/pytest-99/config.json", name="name2")
        assert not comparator(orig2, new2, superset_obj=True)

    def test_superset_with_class_dict_containing_temp_paths(self):
        """Test superset with regular class objects containing temp paths."""

        class Result:
            def __init__(self, output_path):
                self.output_path = output_path

        class ResultExtended:
            def __init__(self, output_path, extra=None):
                self.output_path = output_path
                self.extra = extra

        # Note: These are different classes, so type check will fail first
        # Let's use the same class
        orig = Result("/tmp/pytest-of-user/pytest-0/result.json")
        new = Result("/tmp/pytest-of-user/pytest-99/result.json")
        # Add extra attribute to new
        new.extra_field = "extra_data"
        assert comparator(orig, new, superset_obj=True)

    def test_superset_list_temp_paths_must_have_same_length(self):
        """Test that lists with temp paths must have same length even in superset mode."""
        # superset_obj doesn't apply to list lengths - they must match
        orig = ["/tmp/pytest-of-user/pytest-0/a.txt"]
        new = ["/tmp/pytest-of-user/pytest-99/a.txt", "/tmp/pytest-of-user/pytest-99/b.txt"]
        assert not comparator(orig, new, superset_obj=True)

    def test_superset_tuple_temp_paths_must_have_same_length(self):
        """Test that tuples with temp paths must have same length even in superset mode."""
        orig = ("/tmp/pytest-of-user/pytest-0/a.txt",)
        new = ("/tmp/pytest-of-user/pytest-99/a.txt", "/tmp/pytest-of-user/pytest-99/b.txt")
        assert not comparator(orig, new, superset_obj=True)

    def test_superset_with_exception_containing_temp_path(self):
        """Test superset with exception objects containing temp paths in attributes."""

        class CustomError(Exception):
            def __init__(self, message, path):
                super().__init__(message)
                self.path = path

        orig = CustomError("File error", "/tmp/pytest-of-user/pytest-0/file.txt")
        new = CustomError("File error", "/tmp/pytest-of-user/pytest-99/file.txt")
        new.extra_info = "additional data"
        assert comparator(orig, new, superset_obj=True)


class TestComparatorTempPathsRealisticScenarios:
    """Tests simulating realistic scenarios where temp path comparison matters."""

    def test_test_output_comparison(self):
        """Simulate comparing test outputs that contain temp paths."""
        original_result = {
            "status": "success",
            "output_file": "/tmp/pytest-of-ci-runner/pytest-42/test_output/results.json",
            "log_file": "/tmp/pytest-of-ci-runner/pytest-42/test_output/debug.log",
        }
        replay_result = {
            "status": "success",
            "output_file": "/tmp/pytest-of-local-user/pytest-0/test_output/results.json",
            "log_file": "/tmp/pytest-of-local-user/pytest-0/test_output/debug.log",
        }
        assert comparator(original_result, replay_result)

    def test_exception_message_with_temp_path(self):
        """Test comparing exception-like structures with temp paths."""
        exc1 = {"type": "FileNotFoundError", "message": "File not found: /tmp/pytest-of-user/pytest-0/missing.txt"}
        exc2 = {"type": "FileNotFoundError", "message": "File not found: /tmp/pytest-of-user/pytest-99/missing.txt"}
        assert comparator(exc1, exc2)

    def test_function_return_with_temp_path(self):
        """Test comparing function returns that include temp paths."""
        # Simulating a function that returns a created file path
        return1 = "/tmp/pytest-of-user/pytest-5/generated_file_abc123.txt"
        return2 = "/tmp/pytest-of-user/pytest-10/generated_file_abc123.txt"
        assert comparator(return1, return2)

    def test_list_of_created_files(self):
        """Test comparing lists of created file paths."""
        files1 = [
            "/tmp/pytest-of-user/pytest-0/output/file1.txt",
            "/tmp/pytest-of-user/pytest-0/output/file2.txt",
            "/tmp/pytest-of-user/pytest-0/output/file3.txt",
        ]
        files2 = [
            "/tmp/pytest-of-user/pytest-99/output/file1.txt",
            "/tmp/pytest-of-user/pytest-99/output/file2.txt",
            "/tmp/pytest-of-user/pytest-99/output/file3.txt",
        ]
        assert comparator(files1, files2)

    def test_config_object_with_paths(self):
        """Test comparing config-like objects with multiple paths."""
        config1 = {
            "temp_dir": "/tmp/pytest-of-user/pytest-0/",
            "cache_dir": "/tmp/pytest-of-user/pytest-0/cache/",
            "output_dir": "/tmp/pytest-of-user/pytest-0/output/",
            "permanent_dir": "/home/user/data/",
        }
        config2 = {
            "temp_dir": "/tmp/pytest-of-other/pytest-100/",
            "cache_dir": "/tmp/pytest-of-other/pytest-100/cache/",
            "output_dir": "/tmp/pytest-of-other/pytest-100/output/",
            "permanent_dir": "/home/user/data/",
        }
        assert comparator(config1, config2)


class TestPythonTempfilePaths:
    """Tests for Python tempfile paths (from tempfile.mkdtemp() or TemporaryDirectory())."""

    def test_is_temp_path_detects_python_tempfile(self):
        """Test that _is_temp_path detects Python tempfile paths."""
        assert _is_temp_path("/tmp/tmpqtwy7hpf/special.txt")
        assert _is_temp_path("/tmp/tmpp6wx3tz3/special.txt")
        assert _is_temp_path("/tmp/tmpabcdef12/")
        assert _is_temp_path("/tmp/tmp_underscore/file.txt")

    def test_is_temp_path_various_tempfile_names(self):
        """Test various tempfile naming patterns."""
        assert _is_temp_path("/tmp/tmpABCDEF/file.txt")  # uppercase
        assert _is_temp_path("/tmp/tmp123456/file.txt")  # numeric
        assert _is_temp_path("/tmp/tmpaBc123/file.txt")  # mixed
        assert _is_temp_path("/tmp/tmp_test_dir/subdir/file.txt")  # with underscore

    def test_is_temp_path_non_tempfile(self):
        """Test that non-tempfile paths are not detected."""
        assert not _is_temp_path("/tmp/mydir/file.txt")  # doesn't start with tmp
        assert not _is_temp_path("/tmp/temp/file.txt")  # temp, not tmp
        assert not _is_temp_path("/home/user/tmp123/file.txt")  # not in /tmp/

    def test_normalize_temp_path_python_tempfile(self):
        """Test normalization of Python tempfile paths."""
        path1 = _normalize_temp_path("/tmp/tmpqtwy7hpf/special.txt")
        path2 = _normalize_temp_path("/tmp/tmpp6wx3tz3/special.txt")
        assert path1 == path2 == "/tmp/python-temp/special.txt"

    def test_normalize_temp_path_preserves_subdirs(self):
        """Test that subdirectories are preserved during normalization."""
        result = _normalize_temp_path("/tmp/tmpabcdef12/subdir/nested/file.txt")
        assert result == "/tmp/python-temp/subdir/nested/file.txt"

    def test_comparator_python_tempfile_paths_equal(self):
        """Test that different tempfile paths with same content are equal."""
        path1 = "/tmp/tmpqtwy7hpf/special.txt"
        path2 = "/tmp/tmpp6wx3tz3/special.txt"
        assert comparator(path1, path2)

    def test_comparator_python_tempfile_different_filenames_not_equal(self):
        """Test that different filenames in tempfile paths are not equal."""
        path1 = "/tmp/tmpqtwy7hpf/special.txt"
        path2 = "/tmp/tmpp6wx3tz3/different.txt"
        assert not comparator(path1, path2)

    def test_comparator_python_tempfile_in_tuple(self):
        """Test tempfile paths in tuples."""
        orig = ("/tmp/tmpqtwy7hpf/special.txt",)
        new = ("/tmp/tmpp6wx3tz3/special.txt",)
        assert comparator(orig, new)

    def test_comparator_python_tempfile_in_list(self):
        """Test tempfile paths in lists."""
        orig = ["/tmp/tmpabcdef12/file1.txt", "/tmp/tmpabcdef12/file2.txt"]
        new = ["/tmp/tmpxyz78901/file1.txt", "/tmp/tmpxyz78901/file2.txt"]
        assert comparator(orig, new)

    def test_comparator_python_tempfile_in_dict(self):
        """Test tempfile paths in dictionaries."""
        orig = {"output": "/tmp/tmpabcdef12/result.json"}
        new = {"output": "/tmp/tmpxyz78901/result.json"}
        assert comparator(orig, new)

    def test_comparator_mixed_pytest_and_python_tempfile(self):
        """Test that pytest and Python tempfile paths don't match each other."""
        pytest_path = "/tmp/pytest-of-user/pytest-0/file.txt"
        python_path = "/tmp/tmpabcdef12/file.txt"
        # These should not be equal - they're different temp path types
        assert not comparator(pytest_path, python_path)

    def test_python_tempfile_pattern_regex(self):
        """Test the PYTHON_TEMPFILE_PATTERN regex directly."""
        assert PYTHON_TEMPFILE_PATTERN.search("/tmp/tmpabcdef/file.txt")
        assert PYTHON_TEMPFILE_PATTERN.search("/tmp/tmp123456/")
        assert not PYTHON_TEMPFILE_PATTERN.search("/tmp/mydir/file.txt")
        assert not PYTHON_TEMPFILE_PATTERN.search("/home/tmp123/file.txt")


@pytest.mark.skipif(sys.version_info < (3, 10), reason="types.UnionType requires Python 3.10+")
class TestUnionType:
    def test_union_type_equal(self):
        assert comparator(int | str, int | str)

    def test_union_type_not_equal(self):
        assert not comparator(int | str, int | float)

    def test_union_type_order_independent(self):
        assert comparator(int | str, str | int)

    def test_union_type_multiple_args(self):
        assert comparator(int | str | float, int | str | float)

    def test_union_type_in_list(self):
        assert comparator([int | str, 1], [int | str, 1])

    def test_union_type_in_dict(self):
        assert comparator({"key": int | str}, {"key": int | str})

    def test_union_type_vs_none(self):
        assert not comparator(int | str, None)


class SlotsOnly:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y


class SlotsInherited(SlotsOnly):
    __slots__ = ("z",)

    def __init__(self, x, y, z):
        super().__init__(x, y)
        self.z = z


class TestSlotsObjects:
    def test_slots_equal(self):
        assert comparator(SlotsOnly(1, 2), SlotsOnly(1, 2))

    def test_slots_not_equal(self):
        assert not comparator(SlotsOnly(1, 2), SlotsOnly(1, 3))

    def test_slots_inherited_equal(self):
        assert comparator(SlotsInherited(1, 2, 3), SlotsInherited(1, 2, 3))

    def test_slots_inherited_not_equal(self):
        assert not comparator(SlotsInherited(1, 2, 3), SlotsInherited(1, 2, 4))

    def test_slots_nested(self):
        a = SlotsOnly(SlotsOnly(1, 2), [3, 4])
        b = SlotsOnly(SlotsOnly(1, 2), [3, 4])
        assert comparator(a, b)

    def test_slots_nested_not_equal(self):
        a = SlotsOnly(SlotsOnly(1, 2), [3, 4])
        b = SlotsOnly(SlotsOnly(1, 9), [3, 4])
        assert not comparator(a, b)