Skip to content

Commit a07c067

Browse files
dnwparkdnwpark
committed
Add tests.
1 parent a5d2429 commit a07c067

File tree

1 file changed

+214
-2
lines changed

1 file changed

+214
-2
lines changed

‎tests/test_type_eval.py‎

Lines changed: 214 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -434,14 +434,14 @@ def f[TX](self, x: TX) -> OnlyIntToSet[TX]: ...
434434
ft = m.__args__[1].__args__[1]
435435
with _ensure_context():
436436
assert (
437-
ft(str)
437+
eval_typing(ft(str))
438438
== Callable[
439439
[Param[Literal["self"], C], Param[Literal["x"], str]],
440440
str,
441441
]
442442
)
443443
assert (
444-
ft(int)
444+
eval_typing(ft(int))
445445
== Callable[
446446
[Param[Literal["self"], C], Param[Literal["x"], int]],
447447
set[int],
@@ -720,6 +720,218 @@ class B(A):
720720
assert eval_typing(ft(B)) == classmethod[B, tuple[()], tuple[bool, str]]
721721

722722

723+
def test_getmember_11():
724+
class C:
725+
def member_method(self, x: T) -> T: ...
726+
@classmethod
727+
def class_method(cls, x: T) -> T: ...
728+
@staticmethod
729+
def static_method(x: T) -> T: ...
730+
731+
# member method
732+
m = eval_typing(GetMember[C, Literal["member_method"]])
733+
assert eval_typing(GetName[m]) == Literal["member_method"]
734+
assert eval_typing(IsAssignable[GetType[m], GenericCallable])
735+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
736+
assert eval_typing(GetDefiner[m]) == C
737+
738+
ft = m.__args__[1].__args__[1]
739+
with _ensure_context():
740+
assert (
741+
ft(str)
742+
== Callable[
743+
[Param[Literal["self"], C], Param[Literal["x"], str, Never]],
744+
str,
745+
]
746+
)
747+
748+
# class method
749+
m = eval_typing(GetMember[C, Literal["class_method"]])
750+
assert eval_typing(GetName[m]) == Literal["class_method"]
751+
assert eval_typing(IsAssignable[GetType[m], GenericCallable])
752+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
753+
assert eval_typing(GetDefiner[m]) == C
754+
755+
ft = m.__args__[1].__args__[1]
756+
with _ensure_context():
757+
assert (
758+
ft(str)
759+
== classmethod[
760+
C,
761+
tuple[Param[Literal["x"], str, Never]],
762+
str,
763+
]
764+
)
765+
766+
# static method
767+
m = eval_typing(GetMember[C, Literal["static_method"]])
768+
assert eval_typing(GetName[m]) == Literal["static_method"]
769+
assert eval_typing(IsAssignable[GetType[m], GenericCallable])
770+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
771+
assert eval_typing(GetDefiner[m]) == C
772+
773+
ft = m.__args__[1].__args__[1]
774+
with _ensure_context():
775+
assert (
776+
ft(str) == staticmethod[tuple[Param[Literal["x"], str, Never]], str]
777+
)
778+
779+
780+
def test_getmember_12():
781+
class C[T]:
782+
def member_method(
783+
self, x: T
784+
) -> set[T] if IsAssignable[T, int] else T: ...
785+
@classmethod
786+
def class_method(
787+
cls, x: T
788+
) -> set[T] if IsAssignable[T, int] else T: ...
789+
@staticmethod
790+
def static_method(x: T) -> set[T] if IsAssignable[T, int] else T: ...
791+
792+
# member method
793+
m = eval_typing(GetMember[C[int], Literal["member_method"]])
794+
assert eval_typing(GetName[m]) == Literal["member_method"]
795+
assert (
796+
eval_typing(GetType[m])
797+
== Callable[
798+
[Param[Literal["self"], C[int]], Param[Literal["x"], int]], set[int]
799+
]
800+
)
801+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
802+
assert eval_typing(GetDefiner[m]) == C[int]
803+
804+
m = eval_typing(GetMember[C[str], Literal["member_method"]])
805+
assert eval_typing(GetName[m]) == Literal["member_method"]
806+
assert (
807+
eval_typing(GetType[m])
808+
== Callable[
809+
[Param[Literal["self"], C[str]], Param[Literal["x"], str]], str
810+
]
811+
)
812+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
813+
assert eval_typing(GetDefiner[m]) == C[str]
814+
815+
# class method
816+
m = eval_typing(GetMember[C[int], Literal["class_method"]])
817+
assert eval_typing(GetName[m]) == Literal["class_method"]
818+
assert (
819+
eval_typing(GetType[m])
820+
== classmethod[C[int], tuple[Param[Literal["x"], int]], set[int]]
821+
)
822+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
823+
assert eval_typing(GetDefiner[m]) == C[int]
824+
825+
m = eval_typing(GetMember[C[str], Literal["class_method"]])
826+
assert eval_typing(GetName[m]) == Literal["class_method"]
827+
assert (
828+
eval_typing(GetType[m])
829+
== classmethod[C[str], tuple[Param[Literal["x"], str]], str]
830+
)
831+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
832+
assert eval_typing(GetDefiner[m]) == C[str]
833+
834+
# static method
835+
m = eval_typing(GetMember[C[int], Literal["static_method"]])
836+
assert eval_typing(GetName[m]) == Literal["static_method"]
837+
assert (
838+
eval_typing(GetType[m])
839+
== staticmethod[tuple[Param[Literal["x"], int]], set[int]]
840+
)
841+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
842+
assert eval_typing(GetDefiner[m]) == C[int]
843+
844+
m = eval_typing(GetMember[C[str], Literal["static_method"]])
845+
assert eval_typing(GetName[m]) == Literal["static_method"]
846+
assert (
847+
eval_typing(GetType[m])
848+
== staticmethod[tuple[Param[Literal["x"], str]], str]
849+
)
850+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
851+
assert eval_typing(GetDefiner[m]) == C[str]
852+
853+
854+
def test_getmember_13():
855+
# T defined externally
856+
class C:
857+
def member_method(
858+
self, x: T
859+
) -> set[T] if IsAssignable[T, int] else T: ...
860+
@classmethod
861+
def class_method(
862+
cls, x: T
863+
) -> set[T] if IsAssignable[T, int] else T: ...
864+
@staticmethod
865+
def static_method(x: T) -> set[T] if IsAssignable[T, int] else T: ...
866+
867+
# member method
868+
m = eval_typing(GetMember[C, Literal["member_method"]])
869+
assert eval_typing(GetName[m]) == Literal["member_method"]
870+
assert eval_typing(IsAssignable[GetType[m], GenericCallable])
871+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
872+
assert eval_typing(GetDefiner[m]) == C
873+
874+
ft = m.__args__[1].__args__[1]
875+
with _ensure_context():
876+
assert (
877+
ft(str)
878+
== Callable[
879+
[Param[Literal["self"], C], Param[Literal["x"], str, Never]],
880+
str,
881+
]
882+
)
883+
assert (
884+
ft(int)
885+
== Callable[
886+
[Param[Literal["self"], C], Param[Literal["x"], int, Never]],
887+
set[int],
888+
]
889+
)
890+
891+
# class method
892+
m = eval_typing(GetMember[C, Literal["class_method"]])
893+
assert eval_typing(GetName[m]) == Literal["class_method"]
894+
assert eval_typing(IsAssignable[GetType[m], GenericCallable])
895+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
896+
assert eval_typing(GetDefiner[m]) == C
897+
898+
ft = m.__args__[1].__args__[1]
899+
with _ensure_context():
900+
assert (
901+
ft(str)
902+
== classmethod[
903+
C,
904+
tuple[Param[Literal["x"], str, Never]],
905+
str,
906+
]
907+
)
908+
assert (
909+
ft(int)
910+
== classmethod[
911+
C,
912+
tuple[Param[Literal["x"], int, Never]],
913+
set[int],
914+
]
915+
)
916+
917+
# static method
918+
m = eval_typing(GetMember[C, Literal["static_method"]])
919+
assert eval_typing(GetName[m]) == Literal["static_method"]
920+
assert eval_typing(IsAssignable[GetType[m], GenericCallable])
921+
assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
922+
assert eval_typing(GetDefiner[m]) == C
923+
924+
ft = m.__args__[1].__args__[1]
925+
with _ensure_context():
926+
assert (
927+
ft(str) == staticmethod[tuple[Param[Literal["x"], str, Never]], str]
928+
)
929+
assert (
930+
ft(int)
931+
== staticmethod[tuple[Param[Literal["x"], int, Never]], set[int]]
932+
)
933+
934+
723935
def test_getarg_never():
724936
d = eval_typing(GetArg[Never, object, Literal[0]])
725937
assert d is Never

0 commit comments

Comments
 (0)