B '(bΝ@s4ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z m Z mZddlZddlmZmZddlmZejee edddZdZd Zd Zdeee eeeed d d ZGdddZe de efe ddddZGdddejZeedddZ GdddejZ!dS)N)AnyCallableIteratorListOptional) parse_options test_stubs)root_dir)mod_namereturnc cst}tjdd}td}z0t|tjd|krHtjd||VWd|ddt_|tjkrrtj|=t|XWdQRXdS)Nr) osgetcwdsyspathtempfileTemporaryDirectorychdirinsertmodules)r currentZcurrent_syspathtmprE/home/dcms/DCMS/lib/python3.7/site-packages/mypy/test/teststubtest.py use_tmp_dirs    rZ test_modulea Any = object() class _SpecialForm: def __getitem__(self, typeargs: Any) -> object: ... Callable: _SpecialForm = ... Generic: _SpecialForm = ... Protocol: _SpecialForm = ... class TypeVar: def __init__(self, name, covariant: bool = ..., contravariant: bool = ...) -> None: ... class ParamSpec: def __init__(self, name: str) -> None: ... _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _K = TypeVar("_K") _V = TypeVar("_V") _S = TypeVar("_S", contravariant=True) _R = TypeVar("_R", covariant=True) class Coroutine(Generic[_T_co, _S, _R]): ... class Iterable(Generic[_T_co]): ... class Mapping(Generic[_K, _V]): ... class Sequence(Iterable[_T_co]): ... class Tuple(Sequence[_T_co]): ... def overload(func: _T) -> _T: ... aI from typing import Generic, Mapping, Sequence, TypeVar, overload T = TypeVar('T') T_co = TypeVar('T_co', covariant=True) KT = TypeVar('KT') VT = TypeVar('VT') class object: __module__: str def __init__(self) -> None: pass class type: ... class tuple(Sequence[T_co], Generic[T_co]): ... class dict(Mapping[KT, VT]): ... class function: pass class ellipsis: pass class int: ... class float: ... class bool(int): ... class str: ... class bytes: ... class list(Sequence[T]): ... def property(f: T) -> T: ... def classmethod(f: T) -> T: ... def staticmethod(f: T) -> T: ... )stubruntimeoptions config_filer c Cs(tt}tdd}|tWdQRXtdd}|tWdQRXttdd}||WdQRXttdd}||WdQRX|rttdd}||WdQRX|dtdg}t}t |t t tg|dd WdQRX| |tjd SQRXdS) Nz builtins.pyiwz typing.pyiz.pyiz.pyz _config.iniz--mypy-config-fileT)Zuse_builtins_fixtures)rTEST_MODULE_NAMEopenwritestubtest_builtins_stubstubtest_typing_stubioStringIO contextlibredirect_stdoutrrgetvaluereplacer sep)rrrrZtmp_dirfoutputrrr run_stubtestfs&     r.c@s"eZdZeeeedddZdS)Case)rrerrorcCs||_||_||_dS)N)rrr0)selfrrr0rrr__init__sz Case.__init__N)__name__ __module__ __qualname__strrr2rrrrr/sr/.).N)fnr csttddfdd }|S)zrun_stubtest used to be slow, so we used this decorator to combine cases. If you're reading this and bored, feel free to refactor this and make it more like other mypy tests. N)argskwargsr cst||}t}xj|D]b}|jdkr*q|j}|dkr>t}n|tds\td|}||ksrtd|||qWtd dd|Dd dd|Ddgd }t| }||kst|dS) Nr.z_collect_cases merges cases into a single stubtest invocation; we already expect an error for {}z css |]}t|jdVqdS) N)textwrapdedentrlstrip).0crrr sz.collect_cases..test..css |]}t|jdVqdS)r;N)r<r=rr>)r?r@rrrrAsz--generate-allowlist)rrr) listsetr0r startswithAssertionErrorformataddr.join splitlines)r8r9ZcasesZexpected_errorsr@Zexpected_errorr-Z actual_errors)r7rrtests(     zcollect_cases..test)r)r7rJr)r7r collect_casessrKc@steZdZeeedddZeeedddZeeedddZeeeddd Z eeedd d Z eeedd d Z eeedddZ eeedddZ eeedddZeeedddZeeedddZeeedddZeeedddZeeedddZeeedddZeeedd d!Zeeedd"d#Zeeedd$d%Zeeedd&d'Zeeedd(d)Zeeedd*d+Zeeedd,d-Zeeedd.d/Zeeedd0d1Zeeedd2d3Zeeedd4d5Zeeedd6d7Z eeedd8d9Z!d:S); StubtestUnit)r ccs$tddddVtddddVdS)Nz*def f(number: int, text: str) -> None: ...zdef f(number, text): pass)rrr0zc class X: def f(self, number: int, text: str) -> None: ... zR class X: def f(self, number, text): pass )r/)r1rrrtest_basic_goods zStubtestUnit.test_basic_goodccs4tddddVtddddVtdd d dVdS) Nz!def mistyped_class() -> None: ...zclass mistyped_class: passZmistyped_class)rrr0zclass mistyped_fn: ...zdef mistyped_fn(): passZ mistyped_fnzU class X: def mistyped_var(self) -> int: ... zC class X: mistyped_var = 1 zX.mistyped_var)r/)r1rrr test_typess zStubtestUnit.test_typesccsDtddddVtddddVtddddVtd d ddVdS) Nzdef bar() -> int: ...zasync def bar(): return 5bar)rrr0zasync def foo() -> int: ...zdef foo(): return 5zdef baz() -> int: ...zdef baz(): return 5zasync def bingo() -> int: ...zasync def bingo(): return 5)r/)r1rrrtest_coroutiness    zStubtestUnit.test_coroutinesccs^tddddVtjdkr:tddddVtdd d dVtd d d dVtddddVdS)Nz,def bad(number: int, text: str) -> None: ...z def bad(num, text) -> None: passbad)rrr0)z7def good_posonly(__number: int, text: str) -> None: ...z$def good_posonly(num, /, text): passz6def bad_posonly(__number: int, text: str) -> None: ...z$def bad_posonly(flag, /, text): passZ bad_posonlyzk class BadMethod: def f(self, number: int, text: str) -> None: ... zU class BadMethod: def f(self, n, text): pass z BadMethod.fze class GoodDunder: def __exit__(self, t, v, tb) -> None: ... zo class GoodDunder: def __exit__(self, exc_type, exc_val, exc_tb): pass )r/r version_info)r1rrr test_arg_names*     zStubtestUnit.test_arg_nameccs^tddddVtddddVtdd d dVtjd krZtd d ddVtddddVdS)Nz7def runtime_kwonly(number: int, text: str) -> None: ...z)def runtime_kwonly(number, *, text): passZruntime_kwonly)rrr0z7def stub_kwonly(number: int, *, text: str) -> None: ...z#def stub_kwonly(number, text): passZ stub_kwonlyz7def stub_posonly(__number: int, text: str) -> None: ...z$def stub_posonly(number, text): passZ stub_posonly)rRrSz7def good_posonly(__number: int, text: str) -> None: ...z'def good_posonly(number, /, text): passz8def runtime_posonly(number: int, text: str) -> None: ...z*def runtime_posonly(number, /, text): passZruntime_posonly)r/rrT)r1rrr test_arg_kinds*     zStubtestUnit.test_arg_kindccsdtddddVtddddVtddd dVtd d d dVtd dddVtddddVdS)Nz$def f1(text: str = ...) -> None: ...zdef f1(text = 'asdf'): pass)rrr0z$def f2(text: str = ...) -> None: ...zdef f2(text): passf2zdef f3(text: str) -> None: ...zdef f3(text = 'asdf'): passf3z$def f4(text: str = ...) -> None: ...zdef f4(text = None): passf4z&def f5(data: bytes = ...) -> None: ...zdef f5(data = 'asdf'): passf5z from typing import TypeVar _T = TypeVar("_T", bound=str) def f6(text: _T = ...) -> None: ... zdef f6(text = None): passZf6)r/)r1rrrtest_default_value3s,    zStubtestUnit.test_default_valueccsTtddddVtddddVtddd dVtd d d dVtd dddVdS)Nz class Good: @classmethod def f(cls, number: int, text: str) -> None: ... zq class Good: @classmethod def f(cls, number, text): pass )rrr0ze class Bad1: def f(cls, number: int, text: str) -> None: ... zq class Bad1: @classmethod def f(cls, number, text): pass zBad1.fz class Bad2: @classmethod def f(cls, number: int, text: str) -> None: ... zs class Bad2: @staticmethod def f(self, number, text): pass zBad2.fz class Bad3: @staticmethod def f(cls, number: int, text: str) -> None: ... zr class Bad3: @classmethod def f(self, number, text): pass zBad3.fz_ class GoodNew: def __new__(cls, *args, **kwargs): ... z` class GoodNew: def __new__(cls, *args, **kwargs): pass )r/)r1rrrtest_static_class_methodVs(    z%StubtestUnit.test_static_class_methodccsTtddddVtddddVtddd dVtd d d dVtd dddVdS)Nzdef f1(a, *, b, c) -> None: ...zdef f1(a, *, b, c): pass)rrr0zdef f2(a, *, b) -> None: ...zdef f2(a, *, b, c): passrWzdef f3(a, *, b, c) -> None: ...zdef f3(a, *, b): passrXzdef f4(a, *, b, c) -> None: ...zdef f4(a, b, *, c): passrYzdef f5(a, b, *, c) -> None: ...zdef f5(a, *, b, c): passrZ)r/)r1rrrtest_arg_mismatchszStubtestUnit.test_arg_mismatchccstddddVtddddVtddddVtd d d dVtd d ddVtddddVtddddVtddddVtddddVtddddVtddddVtd d!d"dVtd#d$ddVtd%d&d'dVtd(d)ddVtd*d+d,dVtd-d.d/dVdS)0Nz$def f1(*args, **kwargs) -> None: ...zdef f1(*args, **kwargs): pass)rrr0z$def f2(*args, **kwargs) -> None: ...zdef f2(**kwargs): passrWzdef g1(a, b, c, d) -> None: ...zdef g1(a, *args): passz&def g2(a, b, c, d, *args) -> None: ...zdef g2(a): passZg2z&def g3(a, b, c, d, *args) -> None: ...zdef g3(a, *args): passzdef h1(a) -> None: ...zdef h1(a, b, c, d, *args): passh1zdef h2(a, *args) -> None: ...zdef h2(a, b, c, d): passh2zdef h3(a, *args) -> None: ...zdef h3(a, b, c, d, *args): passh3z"def j1(a: int, *args) -> None: ...zdef j1(a): passZj1zdef j2(a: int) -> None: ...zdef j2(a, *args): passZj2zdef j3(a, b, c) -> None: ...zdef j3(a, *args, c): passZj3z def k1(a, **kwargs) -> None: ...zdef k1(a): passZk1zdef k2(a) -> None: ...zdef k2(a, **kwargs): passzdef k3(a, b) -> None: ...zdef k3(a, **kwargs): passZk3zdef k4(a, *, b) -> None: ...zdef k4(a, **kwargs): passzdef k5(a, *, b) -> None: ...z"def k5(a, *, b, c, **kwargs): passZk5z&def k6(a, *, b, **kwargs) -> None: ...z"def k6(a, *, b, c, **kwargs): passZk6)r/)r1rrrtest_varargs_varkwargss^      z#StubtestUnit.test_varargs_varkwargsccs^tddddVtddddVtddd dVtd d ddVtjd krZtd dddVdS)Nz from typing import overload @overload def f1(a: int, *, c: int = ...) -> int: ... @overload def f1(a: int, b: int, c: int = ...) -> str: ... zdef f1(a, b = 0, c = 0): pass)rrr0z @overload def f2(a: int, *, c: int = ...) -> int: ... @overload def f2(a: int, b: int, c: int = ...) -> str: ... zdef f2(a, b, c = 0): passrWz @overload def f3(a: int) -> int: ... @overload def f3(a: int, b: str) -> str: ... zdef f3(a, b = None): passrXz @overload def f4(a: int, *args, b: int, **kwargs) -> int: ... @overload def f4(a: str, *args, b: int, **kwargs) -> str: ... z#def f4(a, *args, b, **kwargs): pass)rRrSz @overload def f5(__a: int) -> int: ... @overload def f5(__b: str) -> str: ... zdef f5(x, /): pass)r/rrT)r1rrr test_overloads*     zStubtestUnit.test_overloadccsdtddddVtddddVtddddVtd d d dVtd d ddVtddddVdS)Nzt class Good: @property def read_only_attr(self) -> int: ... zr class Good: @property def read_only_attr(self): return 1 )rrr0zf class Bad: @property def f(self) -> int: ... zQ class Bad: def f(self) -> int: return 1 zBad.fzo class GoodReadOnly: @property def f(self) -> int: ... zC class GoodReadOnly: f = 1 zn class BadReadOnly: @property def f(self) -> str: ... zB class BadReadOnly: f = 1 z BadReadOnly.fz class Y: @property def read_only_attr(self) -> int: ... @read_only_attr.setter def read_only_attr(self, val: int) -> None: ... zo class Y: @property def read_only_attr(self): return 5 zY.read_only_attrz class Z: @property def read_write_attr(self) -> int: ... @read_write_attr.setter def read_write_attr(self, val: int) -> None: ... z class Z: @property def read_write_attr(self): return self._val @read_write_attr.setter def read_write_attr(self, val): self._val = val )r/)r1rrr test_property$s0     zStubtestUnit.test_propertyccstddddVtddddVtdddVtd d ddVtd d d dVtddddVtddddVtddddVtddddVtddddVdS)Nzx1: intzx1 = 5)rrr0zx2: strzx2 = 5Zx2zfrom typing import Tuplerz- x3: Tuple[int, int] z x3 = (1, 3)z- x4: Tuple[int, int] zx4 = (1, 3, 5)Zx4zx5: intzdef x5(a, b): passZx5z-def foo(a: int, b: int) -> None: ... x6 = fooz&def foo(a, b): pass def x6(c, d): passZx6z9 class X: f: int zj class X: def __init__(self): self.f = "asdf" zF class Y: read_only_attr: int zo class Y: @property def read_only_attr(self): return 5 zY.read_only_attrzG class Z: read_write_attr: int z class Z: @property def read_write_attr(self): return self._val @read_write_attr.setter def read_write_attr(self, val): self._val = val )r/)r1rrrtest_varxs8     zStubtestUnit.test_varccsDtddddVtddddVtdd d dVtd d ddVdS) Nz] class X: def f(self) -> None: ... Y = X zd class X: def f(self) -> None: ... class Y: ... zY.f)rrr0zR from typing import Tuple A = Tuple[int, str] zA = (int, str)AzB = strrBz_C = int)r/)r1rrrtest_type_aliass    zStubtestUnit.test_type_aliasccstddddVdS)Nz import enum class X(enum.Enum): a: int b: str c: str z import enum class X(enum.Enum): a = 1 b = "asdf" c = 2 zX.c)rrr0)r/)r1rrr test_enumszStubtestUnit.test_enumccstddddVdS)Nz from typing import Any, Callable def decorator(f: Callable[[], int]) -> Callable[..., Any]: ... @decorator def f() -> Any: ... zi def decorator(f): return f @decorator def f(): return 3 )rrr0)r/)r1rrrtest_decoratorszStubtestUnit.test_decoratorccstddddVtddddVtddddVtd dd dVtdd ddVtdd d dVtddddVtddddVtddddVtddddVdS)Nzx = 5rx)rrr0z def f(): ...r,z class X: ...Xz from typing import overload @overload def h(x: int): ... @overload def h(x: str): ... hz __all__ = []z__all__ += ['y'] y = 5yz__all__ += ['g'] def g(): passgz5from mystery import A, B as B, C as D # type: ignorerfz class Y: ...zF__all__ += ['Y'] class Y: def __or__(self, other): return self|otherzY.__or__z class Z: ...z=__all__ += ['Z'] class Z: def __reduce__(self): return (Z,))r/)r1rrr test_missings(  zStubtestUnit.test_missingccs4tddddVtddddVtddddVdS)Nrz import sys)rrr0z def g(): ...rnz CONSTANT = 0ZCONSTANT)r/)r1rrrtest_missing_no_runtime_all#sz(StubtestUnit.test_missing_no_runtime_allccs*tddtddVtddddVdS)Nz__all__: list[str]rz.__all__)rrr0z_f: intz def _f(): ..._f)r/r )r1rrrtest_non_public_1)szStubtestUnit.test_non_public_1ccs4tddddVtddddVtddd dVdS) Nz__all__: list[str] = ['f']z__all__ = ['f'])rrr0zf: intz def f(): ...r,zg: intz def g(): ...rn)r/)r1rrrtest_non_public_20szStubtestUnit.test_non_public_2ccsNtddddVtddddVtdd ddVtjd krJtd d ddVdS) Nz:class A: def __init__(self, a: int, b: int) -> None: ...z*class A: def __init__(self, a, bx): passz A.__init__)rrr0z:class B: def __call__(self, c: int, d: int) -> None: ...z*class B: def __call__(self, c, dx): passz B.__call__zXclass C: def __init_subclass__( cls, e: int = ..., **kwargs: int ) -> None: ... z:class C: def __init_subclass__(cls, e=1, **kwargs): pass)rR z>class D: def __class_getitem__(cls, type: type) -> type: ...z0class D: def __class_getitem__(cls, type): ...)r/rrT)r1rrr test_dunders8s"    zStubtestUnit.test_dundersccs$tddddVtddddVdS)Nzclass CanBeSubclassed: ...)rrr0zCclass CannotBeSubclassed: def __init_subclass__(cls) -> None: ...zGclass CannotBeSubclassed: def __init_subclass__(cls): raise TypeErrorZCannotBeSubclassed)r/)r1rrrtest_not_subclassableUs z"StubtestUnit.test_not_subclassableccstddddVdS)Nz class X: def __mangle_good(self, text: str) -> None: ... def __mangle_bad(self, number: int) -> None: ... z class X: def __mangle_good(self, text): pass def __mangle_bad(self, text): pass zX.__mangle_bad)rrr0)r/)r1rrrtest_name_manglingbszStubtestUnit.test_name_manglingccs$tddddVtddddVdS)Nz class A: def foo(self, x: int) -> None: ... class B(A): pass class C(A): pass z class A: def foo(self, x: int) -> None: ... class B(A): def foo(self, x: int) -> None: ... class C(A): def foo(self, y: int) -> None: ... zC.foo)rrr0z& class X: ... zN class X: def __init__(self, x): pass z X.__init__)r/)r1rrrtest_mrors zStubtestUnit.test_mroccstddddVdS)Naz from typing_extensions import Literal import enum class Color(enum.Enum): RED: int NUM: Literal[1] CHAR: Literal['a'] FLAG: Literal[True] NON: Literal[None] BYT1: Literal[b'abc'] BYT2: Literal[b'\x90'] ENUM: Literal[Color.RED] a import enum class Color(enum.Enum): RED = 3 NUM = 1 CHAR = 'a' NON = None FLAG = True BYT1 = b"abc" BYT2 = b'\x90' ENUM = Color.RED )rrr0)r/)r1rrrtest_good_literals zStubtestUnit.test_good_literalccstdddVtddddVtddd dVtd d d dVtd dddVtddddVtddddVtddddVtddddVdS)Nz%from typing_extensions import LiteralrzINT_FLOAT_MISMATCH: Literal[1]zINT_FLOAT_MISMATCH = 1.0ZINT_FLOAT_MISMATCH)rrr0zWRONG_INT: Literal[1]z WRONG_INT = 2Z WRONG_INTzWRONG_STR: Literal['a']zWRONG_STR = 'b'Z WRONG_STRz%BYTES_STR_MISMATCH: Literal[b'value']zBYTES_STR_MISMATCH = 'value'ZBYTES_STR_MISMATCHz$STR_BYTES_MISMATCH: Literal['value']zSTR_BYTES_MISMATCH = b'value'ZSTR_BYTES_MISMATCHzWRONG_BYTES: Literal[b'abc']zWRONG_BYTES = b'xyz'Z WRONG_BYTESzWRONG_BOOL_1: Literal[True]zWRONG_BOOL_1 = FalseZ WRONG_BOOL_1zWRONG_BOOL_2: Literal[False]zWRONG_BOOL_2 = TrueZ WRONG_BOOL_2)r/)r1rrrtest_bad_literalsB       zStubtestUnit.test_bad_literalccs$tddddVtddddVdS)NzL b1: bool b2: bool b3: bool zF b1 = 0 b2 = 1 b3 = 2 Zb3)rrr0z from typing_extensions import TypedDict class _Options(TypedDict): a: str b: int opt1: _Options opt2: _Options opt3: _Options z opt1 = {"a": "3.", "b": 14} opt2 = {"some": "stuff"} # false negative opt3 = 0 Zopt3)r/)r1rrrtest_special_subtypes  z!StubtestUnit.test_special_subtypeccs"tjdkrdStddddVdS)N)rRz from typing_extensions import Protocol class X(Protocol): def foo(self, x: int, y: bytes = ...) -> str: ... z X.__init__)rrr0)rrTr/)r1rrr test_protocols  zStubtestUnit.test_protocolccs^tddddVtddddVtddddVtjdkrZtddddVtd d ddVdS) Nzfrom typing import TypeVar)rrr0zA = TypeVar('A')zB = TypeVar('B')zB = 5rf)rR zfrom typing import ParamSpeczC = ParamSpec('C'))r/rrT)r1rrr test_type_vars&    zStubtestUnit.test_type_varN)"r3r4r5rKrr/rMrNrPrUrVr[r\r]rarbrcrdrgrhrirorprrrsrurvrwrxryrzr{r}rrrrrrLsp("@B7S?#! !+"rL)sr cCstdd|S)Nz\x1b.*?mr)resub)rrrrremove_color_code4src@seZdZddddZddddZddddZddd d Zddd d Zddd dZddddZ ddddZ ddddZ ddddZ ddddZ dS)StubtestMiscUnitN)r cCs^tddgd}dtdtd}t||ks0ttdddgd}dt}t||ksZtdS) Nz,def bad(number: int, text: str) -> None: ...zdef bad(num, text): pass)rrrzerror: z.bad is inconsistent, stub argument "number" differs from runtime argument "num" Stub: at line 1 def (number: builtins.int, text: builtins.str) Runtime: at line 1 in file z6.py def (num, text) Found 1 error (checked 1 module) z --concisezS{}.bad is inconsistent, stub argument "number" differs from runtime argument "num" )r.r rrErF)r1r-expectedrrr test_output9s zStubtestMiscUnit.test_outputcCsXtdddgd}|dksttdddgd}|dks8ttddd gd}|dksTtdS) Nrz__all__ = ['f'] def f(): passz--ignore-missing-stub)rrrz%Success: no issues found in 1 module z def f(): passzdef f(__a): ...zdef f(a): passz--ignore-positional-only)r.rE)r1r-rrrtest_ignore_flagsSs  z"StubtestMiscUnit.test_ignore_flagsc Cs4tjddd}z||tdWdQRXtddd|jgd}|d ksRttd d d|jgd}|d td kszttd d d|jd gd}|d kstt|jdd*}|td|d|dWdQRXtt d dt d dd|jdgd}|dtdkstWdt |jXdS)Nzw+F)modedeletez.bad # comment # commentz,def bad(number: int, text: str) -> None: ...zdef bad(asdf, text): passz --allowlist)rrrz%Success: no issues found in 1 module rznote: unused allowlist entry z&.bad Found 1 error (checked 1 module) z--ignore-unused-allowlist)rz.b.* z(unused_missing)? z unused.* z def good() -> None: ... def bad(number: int) -> None: ... def also_bad(number: int) -> None: ... r;z def good(): pass def bad(asdf): pass def also_bad(asdf): pass z--generate-allowlistz¬e: unused allowlist entry unused.* z .also_bad ) rNamedTemporaryFiler"r r.namerEr!r<r=r>r unlink)r1Z allowlistr-r,rrrtest_allowlistcs<     zStubtestMiscUnit.test_allowlistcCsLtddgd}t|dtks$ttddgd}t|dtksHtdS)N+r)rrrzVerror: not checking stubs due to failed mypy compile: {}.pyi:1: error: invalid syntax zdef f(): ... def f(): ...zherror: not checking stubs due to mypy build errors: {}.pyi:2: error: Name "f" already defined on line 1 )r.rrFr rE)r1r-rrrtest_mypy_builds z StubtestMiscUnit.test_mypy_buildc CsDt}t|ttdgWdQRXt|dks@tdS)NZ not_a_modulezferror: not_a_module failed to find stubs Stub: MISSING Runtime: N/A Found 1 error (checked 1 module) ) r%r&r'r(rrrr)rE)r1r-rrrtest_missing_stubss   z#StubtestMiscUnit.test_missing_stubsc Csttpttdd}|dWdQRXt}t|tt tgWdQRXt | }|dkstt WdQRXdS)Nz.pyrza = 1z%Success: no issues found in 1 module ) rr r!r"r%r&r'r(rrrr)rE)r1r,r-Z output_strrrr test_only_pys   zStubtestMiscUnit.test_only_pycCstjdd}d|kstd|ks&td|ks2td|ks>td|ksJtd|ksVtd|ksbttjdd }d|ks|td|kstd|kstdS) N)rRbuiltinsr zos.pathZasyncioZgraphlib formatterzimportlib.metadata)rRr~)mypystubtestZget_typeshed_stdlib_modulesrE)r1stdlibrrr test_get_typeshed_stdlib_moduless         z1StubtestMiscUnit.test_get_typeshed_stdlib_modulescCsBddtttttdddd}ttjjt|dks>t dS)Nr)d)abr@rr9r c[sdS)Nr)rrr@rr9rrrr,sz*StubtestMiscUnit.test_signature..fz#def (a, b, *, c, d = ..., **kwargs)) intrr6rr SignatureZfrom_inspect_signatureinspect signaturerE)r1r,rrrtest_signatureszStubtestMiscUnit.test_signaturecCsZd}d}dtd}t||gd}t|dtdks:tt||g|d}|d ksVtdS) Nz temp = 5 z*from decimal import Decimal temp: Decimal z[mypy] plugins=z*/test-data/unit/plugins/decimal_to_int.py )rrrzerror: z.temp variable differs from runtime type Literal[5] Stub: at line 2 _decimal.Decimal Runtime: 5 Found 1 error (checked 1 module) )rrrrz%Success: no issues found in 1 module )r r.rr rE)r1rrrr-rrrtest_config_files z!StubtestMiscUnit.test_config_filec CsBt}t|ttgWdQRXt|dks>tdS)Nzerror: no modules to check ) r%r&r'r(rrrr)rE)r1r-rrrtest_no_moduless z StubtestMiscUnit.test_no_modulesc CsFt}t|ttddgWdQRXt|dksBtdS)Nz--check-typeshedZ some_modulez?error: cannot pass both --check-typeshed and a list of modules ) r%r&r'r(rrrr)rE)r1r-rrrtest_module_and_typesheds   z)StubtestMiscUnit.test_module_and_typeshed)r3r4r5rrrrrrrrrrrrrrrr8s:    r)N)"r'rr%r rrrr<ZunittesttypingrrrrrZ mypy.stubtestrrrZmypy.test.datar contextmanagerr6rr r$r#r.r/rKZTestCaserLrrrrrrs>    $