[case testPEP695Basics]
from enum import Enum
from typing import Any, Literal, TypeAliasType, cast

from testutil import assertRaises

def id[T](x: T) -> T:
    return x

def test_call_generic_function() -> None:
    assert id(2) == 2
    assert id('x') == 'x'

class C[T]:
    x: T

    def __init__(self, x: T) -> None:
        self.x = x

class D[T, S]:
    x: T
    y: S

    def __init__(self, x: T, y: S) -> None:
        self.x = x
        self.y = y

    def set(self, x: object, y: object) -> None:
        self.x = cast(T, x)
        self.y = cast(S, y)

def test_generic_class() -> None:
    c = C(5)
    assert c.x == 5
    c2 = C[str]('x')
    assert c2.x == 'x'
    d = D[str, int]('a', 5)
    assert d.x == 'a'
    assert d.y == 5
    d.set('b', 6)
    assert d.x == 'b'
    assert d.y == 6

def test_generic_class_via_any() -> None:
    c_any: Any = C
    c = c_any(2)
    assert c.x == 2
    c2 = c_any[str]('y')
    assert c2.x == 'y'
    assert str(c_any[str]) == 'native.C[str]'

    d_any: Any = D
    d = d_any(1, 'x')
    assert d.x == 1
    assert d.y == 'x'
    d2 = d_any[int, str](2, 'y')
    assert d2.x == 2
    assert d2.y == 'y'

    with assertRaises(TypeError):
        c_any[int, str]
    with assertRaises(TypeError):
        d_any[int]

class E[*Ts]: pass

def test_type_var_tuple() -> None:
    e: E[int, str] = E()
    e_any: Any = E
    assert isinstance(e_any(), E)
    assert isinstance(e_any[int](), E)
    assert isinstance(e_any[int, str](), E)

class F[**P]: pass

def test_param_spec() -> None:
    f: F[[int, str]] = F()
    f_any: Any = F
    assert isinstance(f_any(), F)
    assert isinstance(f_any[[int, str]](), F)

class SubC[S](C[S]):
    def __init__(self, x: S) -> None:
       super().__init__(x)

def test_generic_subclass() -> None:
    s = SubC(1)
    assert s.x == 1
    s2 = SubC[str]('y')
    assert s2.x == 'y'
    sub_any: Any = SubC
    assert sub_any(1).x == 1
    assert sub_any[str]('x').x == 'x'
    assert isinstance(s, SubC)
    assert isinstance(s, C)

class SubD[
           T,  # Put everything on separate lines
           S](
              D[T,
                S]): pass

def test_generic_subclass_two_params() -> None:
    s = SubD(3, 'y')
    assert s.x == 3
    assert s.y == 'y'
    s2 = SubD[str, int]('z', 4)
    assert s2.x == 'z'
    assert s2.y == 4
    sub_any: Any = SubD
    assert sub_any(3, 'y').y == 'y'
    assert sub_any[int, str](3, 'y').y == 'y'
    assert isinstance(s, SubD)
    assert isinstance(s, D)

class SubE[*Ts](E[*Ts]): pass

def test_type_var_tuple_subclass() -> None:
    sub_any: Any = SubE
    assert isinstance(sub_any(), SubE)
    assert isinstance(sub_any(), E)
    assert isinstance(sub_any[int](), SubE)
    assert isinstance(sub_any[int, str](), SubE)


class SubF[**P](F[P]): pass

def test_param_spec_subclass() -> None:
    sub_any: Any = SubF
    assert isinstance(sub_any(), SubF)
    assert isinstance(sub_any(), F)
    assert isinstance(sub_any[[int]](), SubF)
    assert isinstance(sub_any[[int, str]](), SubF)

# We test that upper bounds and restricted values can be used, but not that
# they are introspectable

def bound[T: C](x: T) -> T:
    return x

def test_function_with_upper_bound() -> None:
    c = C(1)
    assert bound(c) is c

def restriction[T: (int, str)](x: T) -> T:
    return x

def test_function_with_value_restriction() -> None:
    assert restriction(1) == 1
    assert restriction('x') == 'x'

class Bound[T: C]:
     def __init__(self, x: T) -> None:
         self.x = x

def test_class_with_upper_bound() -> None:
    c = C(1)
    b = Bound(c)
    assert b.x is c
    b2 = Bound[C](c)
    assert b2.x is c

class Restriction[T: (int, str)]:
    def __init__(self, x: T) -> None:
        self.x = x

def test_class_with_value_restriction() -> None:
    r = Restriction(1)
    assert r.x == 1
    r2 = Restriction[str]('a')
    assert r2.x == 'a'

type A = int

def test_simple_type_alias() -> None:
    assert isinstance(A, TypeAliasType)
    assert getattr(A, "__value__") is int
    assert str(A) == "A"

type B = Fwd[int]
Fwd = list

def test_forward_reference_in_alias() -> None:
    assert isinstance(B, TypeAliasType)
    assert getattr(B, "__value__") == list[int]

type R = int | list[R]

def test_recursive_type_alias() -> None:
    assert isinstance(R, TypeAliasType)
    assert getattr(R, "__value__") == (int | list[R])

class SomeEnum(Enum):
    AVALUE = "a"

type EnumLiteralAlias1 = Literal[SomeEnum.AVALUE]
type EnumLiteralAlias2 = Literal[SomeEnum.AVALUE] | None
EnumLiteralAlias3 = Literal[SomeEnum.AVALUE] | None
[typing fixtures/typing-full.pyi]

[case testPEP695GenericTypeAlias]
import sys
from typing import Callable
from types import GenericAlias

from testutil import assertRaises

type A[T] = list[T]

def test_generic_alias() -> None:
    assert type(A[str]) is GenericAlias
    if sys.version_info >= (3, 15):  # type: ignore[operator]
        assert str(A[str]) == "_frozen_importlib.A[str]"
    else:
        assert str(A[str]) == "A[str]"
    assert str(getattr(A, "__value__")) == "list[T]"

type B[T, S] = dict[S, T]

def test_generic_alias_with_two_args() -> None:
    if sys.version_info >= (3, 15):   # type: ignore[operator]
        assert str(B[str, int]) == "_frozen_importlib.B[str, int]"
    else:
        assert str(B[str, int]) == "B[str, int]"
    assert str(getattr(B, "__value__")) == "dict[S, T]"

type C[*Ts] = tuple[*Ts]

def test_type_var_tuple_type_alias() -> None:
    if sys.version_info >= (3, 15):   # type: ignore[operator]
        assert str(C[int, str]) == "_frozen_importlib.C[int, str]"
    else:
        assert str(C[int, str]) == "C[int, str]"
    assert str(getattr(C, "__value__")) == "tuple[typing.Unpack[Ts]]"

type D[**P] = Callable[P, int]

def test_param_spec_type_alias() -> None:
    if sys.version_info >= (3, 15):   # type: ignore[operator]
        assert str(D[[int, str]]) == "_frozen_importlib.D[[int, str]]"
    else:
        assert str(D[[int, str]]) == "D[[int, str]]"
    assert str(getattr(D, "__value__")) == "typing.Callable[P, int]"
[typing fixtures/typing-full.pyi]