B
    '(bΝ                 @   s4  d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl	m
Z
mZmZmZmZ d dlZd dlmZmZ d dlmZ e jeee dddZdZd	Zd
Zdeeee ee edddZG dd dZedee f ed dddZG dd dejZeedddZ G dd dejZ!dS )    N)AnyCallableIteratorListOptional)parse_options
test_stubs)root_dir)mod_namereturnc          
   c   s   t  }tjd d  }t d}z0t | tjd |krHtjd| |V  W d |d d  t_| tjkrrtj| = t | X W d Q R X d S )Nr   )	osgetcwdsyspathtempfileTemporaryDirectorychdirinsertmodules)r
   currentZcurrent_syspathtmp r   E/home/dcms/DCMS/lib/python3.7/site-packages/mypy/test/teststubtest.pyuse_tmp_dir   s    



r   Z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: ...
)stubruntimeoptionsconfig_filer   c          
   C   s(  t t}tdd}|t W d Q R X tdd}|t W d Q R X tt dd}||  W d Q R X tt dd}|| W d Q R X |rtt dd}|| W d Q R X |dt dg }t }t	| t
ttg| dd	 W d Q R X | |tj d
S Q R X d S )Nzbuiltins.pyiwz
typing.pyiz.pyiz.pyz_config.iniz--mypy-config-fileT)Zuse_builtins_fixtures )r   TEST_MODULE_NAMEopenwritestubtest_builtins_stubstubtest_typing_stubioStringIO
contextlibredirect_stdoutr   r   getvaluereplacer   sep)r   r   r   r   Ztmp_dirfoutputr   r   r   run_stubtestf   s&    r.   c               @   s"   e Zd Zeeee dddZdS )Case)r   r   errorc             C   s   || _ || _|| _d S )N)r   r   r0   )selfr   r   r0   r   r   r   __init__   s    zCase.__init__N)__name__
__module____qualname__strr   r2   r   r   r   r   r/      s   r/   .).N)fnr   c                s   t t dd fdd}|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)argskwargsr   c                 s   t  | |}t }xj|D ]b}|jd kr*q|j}|dkr>t}n|t ds\t d| }||ksrtd||| qW td	dd |D d	dd |D dgd	}t|
 }||kst|d S )
Nr   .z_collect_cases merges cases into a single stubtest invocation; we already expect an error for {}z

c             s   s    | ]}t |jd V  qdS )
N)textwrapdedentr   lstrip).0cr   r   r   	<genexpr>   s    z.collect_cases.<locals>.test.<locals>.<genexpr>c             s   s    | ]}t |jd V  qdS )r;   N)r<   r=   r   r>   )r?   r@   r   r   r   rA      s    z--generate-allowlist)r   r   r   )listsetr0   r    
startswithAssertionErrorformataddr.   join
splitlines)r8   r9   ZcasesZexpected_errorsr@   Zexpected_errorr-   Zactual_errors)r7   r   r   test   s(    



zcollect_cases.<locals>.test)r   )r7   rJ   r   )r7   r   collect_cases   s    rK   c               @   st  e Zd Zeee dddZeee dddZeee dddZeee ddd	Z	eee dd
dZ
eee dddZeee dddZeee dddZeee dddZeee dddZeee dddZeee dddZeee dddZeee dddZeee dddZeee dd d!Zeee dd"d#Zeee dd$d%Zeee dd&d'Zeee dd(d)Zeee dd*d+Zeee dd,d-Zeee dd.d/Zeee dd0d1Zeee dd2d3Zeee dd4d5Zeee dd6d7Z eee dd8d9Z!d:S );StubtestUnit)r   c             c   s$   t ddd dV  t ddd dV  d S )Nz*def f(number: int, text: str) -> None: ...zdef f(number, text): pass)r   r   r0   zc
            class X:
                def f(self, number: int, text: str) -> None: ...
            zR
            class X:
                def f(self, number, text): pass
            )r/   )r1   r   r   r   test_basic_good   s    
zStubtestUnit.test_basic_goodc             c   s4   t ddddV  t ddddV  t dd	d
dV  d S )Nz!def mistyped_class() -> None: ...zclass mistyped_class: passZmistyped_class)r   r   r0   zclass mistyped_fn: ...zdef mistyped_fn(): passZmistyped_fnzU
            class X:
                def mistyped_var(self) -> int: ...
            zC
            class X:
                mistyped_var = 1
            zX.mistyped_var)r/   )r1   r   r   r   
test_types   s    
zStubtestUnit.test_typesc             c   sD   t ddddV  t ddd dV  t ddd dV  t d	d
d dV  d S )Nzdef bar() -> int: ...zasync def bar(): return 5bar)r   r   r0   zasync def foo() -> int: ...zdef foo(): return 5zdef baz() -> int: ...zdef baz(): return 5zasync def bingo() -> int: ...zasync def bingo(): return 5)r/   )r1   r   r   r   test_coroutines   s     


zStubtestUnit.test_coroutinesc             c   s^   t ddddV  tjdkr:t ddd dV  t dd	d
dV  t ddddV  t ddd dV  d S )Nz,def bad(number: int, text: str) -> None: ...z def bad(num, text) -> None: passbad)r   r   r0   )      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)r1   r   r   r   test_arg_name   s*    




zStubtestUnit.test_arg_namec             c   s^   t ddddV  t ddddV  t dd	d
dV  tjdkrZt ddd dV  t ddddV  d S )Nz7def runtime_kwonly(number: int, text: str) -> None: ...z)def runtime_kwonly(number, *, text): passZruntime_kwonly)r   r   r0   z7def 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)rR   rS   z7def 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): passZruntime_posonly)r/   r   rT   )r1   r   r   r   test_arg_kind  s*    




zStubtestUnit.test_arg_kindc             c   sd   t ddd dV  t ddddV  t ddd	dV  t d
dddV  t ddddV  t ddddV  d S )Nz$def f1(text: str = ...) -> None: ...zdef f1(text = 'asdf'): pass)r   r   r0   z$def f2(text: str = ...) -> None: ...zdef f2(text): passf2zdef f3(text: str) -> None: ...zdef f3(text = 'asdf'): passf3z$def f4(text: str = ...) -> None: ...zdef f4(text = None): passf4z&def f5(data: bytes = ...) -> None: ...zdef f5(data = 'asdf'): passf5z
            from typing import TypeVar
            _T = TypeVar("_T", bound=str)
            def f6(text: _T = ...) -> None: ...
            zdef f6(text = None): passZf6)r/   )r1   r   r   r   test_default_value3  s,    



zStubtestUnit.test_default_valuec             c   sT   t ddd dV  t ddddV  t ddd	dV  t d
dddV  t ddd dV  d S )Nz
            class Good:
                @classmethod
                def f(cls, number: int, text: str) -> None: ...
            zq
            class Good:
                @classmethod
                def f(cls, number, text): pass
            )r   r   r0   ze
            class Bad1:
                def f(cls, number: int, text: str) -> None: ...
            zq
            class Bad1:
                @classmethod
                def f(cls, number, text): pass
            zBad1.fz
            class Bad2:
                @classmethod
                def f(cls, number: int, text: str) -> None: ...
            zs
            class Bad2:
                @staticmethod
                def f(self, number, text): pass
            zBad2.fz
            class Bad3:
                @staticmethod
                def f(cls, number: int, text: str) -> None: ...
            zr
            class Bad3:
                @classmethod
                def f(self, number, text): pass
            zBad3.fz_
            class GoodNew:
                def __new__(cls, *args, **kwargs): ...
            z`
            class GoodNew:
                def __new__(cls, *args, **kwargs): pass
            )r/   )r1   r   r   r   test_static_class_methodV  s(    



z%StubtestUnit.test_static_class_methodc             c   sT   t ddd dV  t ddddV  t ddd	dV  t d
dddV  t ddddV  d S )Nzdef f1(a, *, b, c) -> None: ...zdef f1(a, *, b, c): pass)r   r   r0   zdef f2(a, *, b) -> None: ...zdef f2(a, *, b, c): passrW   zdef f3(a, *, b, c) -> None: ...zdef f3(a, *, b): passrX   zdef f4(a, *, b, c) -> None: ...zdef f4(a, b, *, c): passrY   zdef f5(a, b, *, c) -> None: ...zdef f5(a, *, b, c): passrZ   )r/   )r1   r   r   r   test_arg_mismatch  s    zStubtestUnit.test_arg_mismatchc             c   s  t ddd dV  t ddddV  t ddd dV  t d	d
ddV  t ddd dV  t ddddV  t ddddV  t ddddV  t ddddV  t ddddV  t ddddV  t d d!d"dV  t d#d$d dV  t d%d&d'dV  t d(d)d dV  t d*d+d,dV  t d-d.d/dV  d S )0Nz$def f1(*args, **kwargs) -> None: ...zdef f1(*args, **kwargs): pass)r   r   r0   z$def f2(*args, **kwargs) -> None: ...zdef f2(**kwargs): passrW   zdef g1(a, b, c, d) -> None: ...zdef g1(a, *args): passz&def g2(a, b, c, d, *args) -> None: ...zdef g2(a): passZg2z&def g3(a, b, c, d, *args) -> None: ...zdef g3(a, *args): passzdef h1(a) -> None: ...zdef h1(a, b, c, d, *args): passh1zdef h2(a, *args) -> None: ...zdef h2(a, b, c, d): passh2zdef h3(a, *args) -> None: ...zdef h3(a, b, c, d, *args): passh3z"def j1(a: int, *args) -> None: ...zdef j1(a): passZj1zdef j2(a: int) -> None: ...zdef j2(a, *args): passZj2zdef j3(a, b, c) -> None: ...zdef j3(a, *args, c): passZj3z def k1(a, **kwargs) -> None: ...zdef k1(a): passZk1zdef k2(a) -> None: ...zdef k2(a, **kwargs): passzdef k3(a, b) -> None: ...zdef k3(a, **kwargs): passZk3zdef k4(a, *, b) -> None: ...zdef k4(a, **kwargs): passzdef k5(a, *, b) -> None: ...z"def k5(a, *, b, c, **kwargs): passZk5z&def k6(a, *, b, **kwargs) -> None: ...z"def k6(a, *, b, c, **kwargs): passZk6)r/   )r1   r   r   r   test_varargs_varkwargs  s^    





z#StubtestUnit.test_varargs_varkwargsc             c   s^   t ddd dV  t ddddV  t ddd	dV  t d
dd dV  tjdkrZt ddd dV  d S )Nz
            from typing import overload

            @overload
            def f1(a: int, *, c: int = ...) -> int: ...
            @overload
            def f1(a: int, b: int, c: int = ...) -> str: ...
            zdef f1(a, b = 0, c = 0): pass)r   r   r0   z
            @overload
            def f2(a: int, *, c: int = ...) -> int: ...
            @overload
            def f2(a: int, b: int, c: int = ...) -> str: ...
            zdef f2(a, b, c = 0): passrW   z
            @overload
            def f3(a: int) -> int: ...
            @overload
            def f3(a: int, b: str) -> str: ...
            zdef f3(a, b = None): passrX   z
            @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)rR   rS   z
                @overload
                def f5(__a: int) -> int: ...
                @overload
                def f5(__b: str) -> str: ...
                zdef f5(x, /): pass)r/   r   rT   )r1   r   r   r   test_overload  s*    




zStubtestUnit.test_overloadc             c   sd   t ddd dV  t ddddV  t ddd dV  t d	d
ddV  t ddddV  t ddd dV  d S )Nzt
            class Good:
                @property
                def read_only_attr(self) -> int: ...
            zr
            class Good:
                @property
                def read_only_attr(self): return 1
            )r   r   r0   zf
            class Bad:
                @property
                def f(self) -> int: ...
            zQ
            class Bad:
                def f(self) -> int: return 1
            zBad.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
            zY.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/   )r1   r   r   r   test_property$  s0    




zStubtestUnit.test_propertyc             c   s   t ddd dV  t ddddV  t ddd V  t d	d
d dV  t ddddV  t ddddV  t ddddV  t ddd dV  t ddddV  t ddd dV  d S )Nzx1: intzx1 = 5)r   r   r0   zx2: strzx2 = 5Zx2zfrom typing import Tupler   z-
            x3: Tuple[int, int]
            zx3 = (1, 3)z-
            x4: Tuple[int, int]
            zx4 = (1, 3, 5)Zx4zx5: intzdef x5(a, b): passZx5z-def foo(a: int, b: int) -> None: ...
x6 = fooz&def foo(a, b): pass
def x6(c, d): passZx6z9
            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
            zY.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/   )r1   r   r   r   test_varx  s8    




zStubtestUnit.test_varc             c   sD   t ddddV  t ddddV  t dd	d
dV  t dd	d dV  d S )Nz]
            class X:
                def f(self) -> None: ...
            Y = X
            zd
            class X:
                def f(self) -> None: ...
            class Y: ...
            zY.f)r   r   r0   zR
            from typing import Tuple
            A = Tuple[int, str]
            zA = (int, str)AzB = strr   Bz_C = int)r/   )r1   r   r   r   test_type_alias  s     


zStubtestUnit.test_type_aliasc             c   s   t ddddV  d S )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
            zX.c)r   r   r0   )r/   )r1   r   r   r   	test_enum  s    zStubtestUnit.test_enumc             c   s   t ddd dV  d S )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
            )r   r   r0   )r/   )r1   r   r   r   test_decorator  s    zStubtestUnit.test_decoratorc             c   s   t ddddV  t ddddV  t ddddV  t d	dd
dV  t ddd dV  t ddddV  t ddddV  t ddddV  t ddddV  t ddd dV  d S )Nzx = 5r   x)r   r   r0   z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 = 5yz__all__ += ['g']
def g(): passgz5from mystery import A, B as B, C as D  # type: ignorerf   zclass Y: ...zF__all__ += ['Y']
class Y:
  def __or__(self, other): return self|otherzY.__or__zclass Z: ...z=__all__ += ['Z']
class Z:
  def __reduce__(self): return (Z,))r/   )r1   r   r   r   test_missing  s(    

zStubtestUnit.test_missingc             c   s4   t ddd dV  t ddddV  t ddddV  d S )Nr   z
import sys)r   r   r0   zdef g(): ...rn   zCONSTANT = 0ZCONSTANT)r/   )r1   r   r   r   test_missing_no_runtime_all#  s    z(StubtestUnit.test_missing_no_runtime_allc             c   s*   t ddt ddV  t ddddV  d S )Nz__all__: list[str]r   z.__all__)r   r   r0   z_f: intzdef _f(): ..._f)r/   r    )r1   r   r   r   test_non_public_1)  s    zStubtestUnit.test_non_public_1c             c   s4   t ddd dV  t ddddV  t ddd	dV  d S )
Nz__all__: list[str] = ['f']z__all__ = ['f'])r   r   r0   zf: intzdef f(): ...r,   zg: intzdef g(): ...rn   )r/   )r1   r   r   r   test_non_public_20  s    zStubtestUnit.test_non_public_2c             c   sN   t ddddV  t ddddV  t dd	d dV  tjd
krJt ddd dV  d S )Nz:class A:
  def __init__(self, a: int, b: int) -> None: ...z*class A:
  def __init__(self, a, bx): passz
A.__init__)r   r   r0   z: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/   r   rT   )r1   r   r   r   test_dunders8  s"    



zStubtestUnit.test_dundersc             c   s$   t ddd dV  t ddddV  d S )Nzclass CanBeSubclassed: ...)r   r   r0   zCclass CannotBeSubclassed:
  def __init_subclass__(cls) -> None: ...zGclass CannotBeSubclassed:
  def __init_subclass__(cls): raise TypeErrorZCannotBeSubclassed)r/   )r1   r   r   r   test_not_subclassableU  s    
z"StubtestUnit.test_not_subclassablec             c   s   t ddddV  d S )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
            zX.__mangle_bad)r   r   r0   )r/   )r1   r   r   r   test_name_manglingb  s    zStubtestUnit.test_name_manglingc             c   s$   t ddddV  t ddddV  d S )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: ...
            zC.foo)r   r   r0   z&
            class X: ...
            zN
            class X:
                def __init__(self, x): pass
            z
X.__init__)r/   )r1   r   r   r   test_mror  s    
zStubtestUnit.test_mroc             c   s   t ddd dV  d S )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
            )r   r   r0   )r/   )r1   r   r   r   test_good_literal  s    zStubtestUnit.test_good_literalc             c   s   t ddd V  t ddddV  t ddd	dV  t d
dddV  t ddddV  t ddddV  t ddddV  t ddddV  t ddddV  d S )Nz%from typing_extensions import Literalr   zINT_FLOAT_MISMATCH: Literal[1]zINT_FLOAT_MISMATCH = 1.0ZINT_FLOAT_MISMATCH)r   r   r0   zWRONG_INT: Literal[1]zWRONG_INT = 2Z	WRONG_INTzWRONG_STR: Literal['a']zWRONG_STR = 'b'Z	WRONG_STRz%BYTES_STR_MISMATCH: Literal[b'value']zBYTES_STR_MISMATCH = 'value'ZBYTES_STR_MISMATCHz$STR_BYTES_MISMATCH: Literal['value']zSTR_BYTES_MISMATCH = b'value'ZSTR_BYTES_MISMATCHzWRONG_BYTES: Literal[b'abc']zWRONG_BYTES = b'xyz'ZWRONG_BYTESzWRONG_BOOL_1: Literal[True]zWRONG_BOOL_1 = FalseZWRONG_BOOL_1zWRONG_BOOL_2: Literal[False]zWRONG_BOOL_2 = TrueZWRONG_BOOL_2)r/   )r1   r   r   r   test_bad_literal  sB    






zStubtestUnit.test_bad_literalc             c   s$   t ddddV  t ddddV  d S )NzL
            b1: bool
            b2: bool
            b3: bool
            zF
            b1 = 0
            b2 = 1
            b3 = 2
            Zb3)r   r   r0   z
            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
            Zopt3)r/   )r1   r   r   r   test_special_subtype  s    
z!StubtestUnit.test_special_subtypec             c   s"   t jdk rd S tddddV  d S )N)rR      z
            from typing_extensions import Protocol

            class X(Protocol):
                def foo(self, x: int, y: bytes = ...) -> str: ...
            z
X.__init__)r   r   r0   )r   rT   r/   )r1   r   r   r   test_protocol  s    
zStubtestUnit.test_protocolc             c   s^   t ddd dV  t ddd dV  t ddddV  tjdkrZt ddd dV  t d	d	d dV  d S )
Nzfrom typing import TypeVar)r   r   r0   zA = TypeVar('A')zB = TypeVar('B')zB = 5rf   )rR   
   zfrom typing import ParamSpeczC = ParamSpec('C'))r/   r   rT   )r1   r   r   r   test_type_var  s&    



zStubtestUnit.test_type_varN)"r3   r4   r5   rK   r   r/   rM   rN   rP   rU   rV   r[   r\   r]   ra   rb   rc   rd   rg   rh   ri   ro   rp   rr   rs   ru   rv   rw   rx   ry   rz   r{   r}   r   r   r   r   r   rL      sp   ("@B7S?#!!+"rL   )sr   c             C   s   t dd| S )Nz\x1b.*?mr   )resub)r   r   r   r   remove_color_code4  s    r   c               @   s   e Zd ZddddZddddZddddZddd	d
ZddddZddddZddddZ	ddddZ
ddddZddddZddddZdS )StubtestMiscUnitN)r   c             C   s^   t ddg d}dt dt d}t||ks0tt dddgd}dt}t||ksZtd S )	Nz,def bad(number: int, text: str) -> None: ...zdef bad(num, text): pass)r   r   r   zerror: 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    r   rE   rF   )r1   r-   expectedr   r   r   test_output9  s    
zStubtestMiscUnit.test_outputc             C   sX   t dddgd}|dkstt dddgd}|dks8tt ddd	gd}|dksTtd S )
Nr   z__all__ = ['f']
def f(): passz--ignore-missing-stub)r   r   r   z%Success: no issues found in 1 module
zdef f(): passzdef f(__a): ...zdef f(a): passz--ignore-positional-only)r.   rE   )r1   r-   r   r   r   test_ignore_flagsS  s    z"StubtestMiscUnit.test_ignore_flagsc          	   C   s4  t jddd}z| |t d W d Q R X tddd|jgd}|d	ksRttd
d
d|jgd}|dt dkszttd
d
d|jdgd}|d	kstt|jdd*}|t d |d |d W d Q R X tt	d
dt	d
dd|jdgd}|dt dkstW d t|j X d S )Nzw+F)modedeletez.bad  # comment
# commentz,def bad(number: int, text: str) -> None: ...zdef bad(asdf, text): passz--allowlist)r   r   r   z%Success: no issues found in 1 module
r   znote: unused allowlist entry z&.bad
Found 1 error (checked 1 module)
z--ignore-unused-allowlist)r   z.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&note: unused allowlist entry unused.*
z
.also_bad
)r   NamedTemporaryFiler"   r    r.   namerE   r!   r<   r=   r>   r   unlink)r1   Z	allowlistr-   r,   r   r   r   test_allowlistc  s<    


zStubtestMiscUnit.test_allowlistc             C   sL   t ddg d}t|dtks$tt ddg d}t|dtksHtd S )N+r   )r   r   r   zVerror: not checking stubs due to failed mypy compile:
{}.pyi:1: error: invalid syntax
zdef f(): ...
def f(): ...zherror: not checking stubs due to mypy build errors:
{}.pyi:2: error: Name "f" already defined on line 1
)r.   r   rF   r    rE   )r1   r-   r   r   r   test_mypy_build  s    z StubtestMiscUnit.test_mypy_buildc          	   C   sD   t  }t| ttdg W d Q R X t| dks@td S )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(   r   r   r   r)   rE   )r1   r-   r   r   r   test_missing_stubs  s
    
z#StubtestMiscUnit.test_missing_stubsc          
   C   s   t tp tt dd}|d W d Q R X t }t| tt	tg W d Q R X t
| }|dksttW d Q R X d S )Nz.pyr   za = 1z%Success: no issues found in 1 module
)r   r    r!   r"   r%   r&   r'   r(   r   r   r   r)   rE   )r1   r,   r-   Z
output_strr   r   r   test_only_py  s    
zStubtestMiscUnit.test_only_pyc             C   s   t jd d}d|kstd|ks&td|ks2td|ks>td|ksJtd|ksVtd|ksbtt jd d	}d|ks|td|kstd|kstd S )
N)rR      builtinsr   zos.pathZasyncioZgraphlib	formatterzimportlib.metadata)rR   r~   )mypystubtestZget_typeshed_stdlib_modulesrE   )r1   stdlibr   r   r    test_get_typeshed_stdlib_modules  s    z1StubtestMiscUnit.test_get_typeshed_stdlib_modulesc             C   sB   ddt t t t td ddd}ttjjt|dks>t	d S )Nr   )d)abr@   r   r9   r   c            [   s   d S )Nr   )r   r   r@   r   r9   r   r   r   r,     s    z*StubtestMiscUnit.test_signature.<locals>.fz#def (a, b, *, c, d = ..., **kwargs))
intr   r6   r   r   	SignatureZfrom_inspect_signatureinspect	signaturerE   )r1   r,   r   r   r   test_signature  s    zStubtestMiscUnit.test_signaturec             C   sZ   d}d}dt  d}t||g d}t|dt dks:tt||g |d}|d	ksVtd S )
Nz	temp = 5
z*from decimal import Decimal
temp: Decimal
z[mypy]
plugins=z*/test-data/unit/plugins/decimal_to_int.py
)r   r   r   zerror: z.temp variable differs from runtime type Literal[5]
Stub: at line 2
_decimal.Decimal
Runtime:
5

Found 1 error (checked 1 module)
)r   r   r   r   z%Success: no issues found in 1 module
)r	   r.   r   r    rE   )r1   r   r   r   r-   r   r   r   test_config_file  s    z!StubtestMiscUnit.test_config_filec          	   C   sB   t  }t| ttg  W d Q R X t| dks>td S )Nzerror: no modules to check
)	r%   r&   r'   r(   r   r   r   r)   rE   )r1   r-   r   r   r   test_no_modules  s    z StubtestMiscUnit.test_no_modulesc          	   C   sF   t  }t| ttddg W d Q R X t| dksBtd S )Nz--check-typeshedZsome_modulez?error: cannot pass both --check-typeshed and a list of modules
)	r%   r&   r'   r(   r   r   r   r)   rE   )r1   r-   r   r   r   test_module_and_typeshed  s
    
z)StubtestMiscUnit.test_module_and_typeshed)r3   r4   r5   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   8  s   :
	r   )N)"r'   r   r%   r   r   r   r   r<   Zunittesttypingr   r   r   r   r   Zmypy.stubtestr   r   r   Zmypy.test.datar	   contextmanagerr6   r   r    r$   r#   r.   r/   rK   ZTestCaserL   r   r   r   r   r   r   <module>   s>      $       