Your IP : 216.73.216.213

Current Path : /opt/alt/python37/lib/python3.7/site-packages/_pytest/__pycache__/
Upload File :
Current File : //opt/alt/python37/lib/python3.7/site-packages/_pytest/__pycache__/python.cpython-37.pyc

B

C$�X9��@s�dZddlZddlZddlZddlZddlZddlmZddlZddl	Z	ddl
mZddlZddl
mZddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZej� ej!�"d��Z#ej� ej!��$�Z%ej� ej!��$�Z&dd	�Z'd
d�Z(dd
�Z)dd�Z*dd�Z+dd�Z,e	j-dd�dd��Z.e	j-dd�dd��Z/dd�Z0dd�Z1e	j-dd�dd ��Z2d!d"�Z3Gd#d$�d$e4�Z5Gd%d&�d&e5�Z6Gd'd(�d(e6e	j7�Z8d)d*�Z9d+d,�Z:Gd-d.�d.e	j;e8�Z<d]d/d0�Z=d1d2�Z>Gd3d4�d4e8�Z?Gd5d6�d6e8�Z@Gd7d8�d8e6�ZAGd9d:�d:eAe8�ZBd;d<�ZCd=d>�ZDGd?d@�d@e4�ZEGdAdB�dBejF�ZGdCdD�ZHd^dEdF�ZId_dGdH�ZJd`dIdJ�ZKdKdL�ZLdMdN�ZMdOdP�ZNdQdR�ZOdSdT�ZPGdUdV�dVe4�ZQGdWdX�dXe4�ZRGdYdZ�dZe4�ZSGd[d\�d\eAe	jTejF�ZUdS)az9 Python test discovery, setup and run of test functions. �N)�count)�MarkerError)�fixtures)
�isclass�
isfunction�is_generator�_escape_strings�
REGEX_TYPE�STRING_TYPES�NoneType�NOTSET�
get_real_func�getfslineno�safe_getattr�getlocation�enum�occCsR|jjjj}d|kod|k}|r$dStj�|j�}|tkoP|�t	�oP|�t
�S)z�Return True if a TracebackEntry instance should be removed from tracebacks:
    * dynamically generated code (no code to show up for it);
    * internal traceback from pytest or its internal libraries, py and pluggy.
    �<�>F)�frame�code�raw�co_filename�py�path�local�cutdir1Zrelto�cutdir2�cutdir3)�entryZraw_filenameZis_generated�p�r!�?/opt/alt/python37/lib/python3.7/site-packages/_pytest/python.py�filter_tracebacksr#cs(�fdd�}d���f}t|dd|�S)Ncs"|�tt���}|dk	r|jSdS)N)�	getparent�getattr�pytest�obj)�self�node)�namer!r"�get2szpyobj_property.<locals>.getz<python %s object this node was collected from (can be None).)�lower�property)r*r+�docr!)r*r"�pyobj_property1sr/cCs�|�d�}|jddddddd�|jd	dd
ddd�|jdd
gdd�|jdd
ddgdd�|jdd
dgdd�|jdd
dgdd�|jddddgddd�dS) NZgeneralz
--fixturesz
--funcargs�
store_true�showfixturesFz4show available fixtures, sorted by plugin appearance)�action�dest�default�helpz--fixtures-per-test�show_fixtures_per_testzshow fixtures per testZusefixtures�argsz5list of default fixtures to be used with this project)�typer4r5�python_filesz	test_*.pyz	*_test.pyz9glob-style file patterns for Python test module discovery�python_classesZTestz6prefixes or glob names for Python test class discovery�python_functions�testzDprefixes or glob names for Python test function and method discoveryz
--import-modeZprepend�append�
importmodezNprepend/append to sys.path when importing test modules, default is to prepend.)r4�choicesr3r5)ZgetgroupZ	addoptionZaddini)�parser�groupr!r!r"�pytest_addoption;s,

rBcCs,|jjrt|�dS|jjr(t|�dSdS)Nr)�optionr1r6)�configr!r!r"�pytest_cmdline_mainXsrEcCs�dddg}x0|D](}t|j|�rd}t|�|jj|���qWy|jj}Wntk
r\dSXx|D]}|j|j|j�qdWdS)NZparameterizeZparametriseZparameterisez/{0} has '{1}', spelling should be 'parametrize')	�hasattr�functionr�format�__name__�parametrize�AttributeErrorr7�kwargs)�metafuncZ
alt_spellings�attr�msg�markers�markerr!r!r"�pytest_generate_testsas


rRcCs|�dd�|�dd�dS)NrPa�parametrize(argnames, argvalues): call a test function multiple times passing in different arguments in turn. argvalues generally needs to be a list of values if argnames specifies only one name or a list of tuples of values if argnames specifies multiple names. Example: @parametrize('arg1', [1,2]) would lead to two calls of the decorated test function, one with arg1=1 and another with arg1=2.see http://pytest.org/latest/parametrize.html for more info and examples.z�usefixtures(fixturename1, fixturename2, ...): mark tests as needing all of the specified fixtures. see http://pytest.org/latest/fixture.html#usefixtures )Zaddinivalue_line)rDr!r!r"�pytest_configureps	rST)ZtrylastcCs"tjjt_ttttttt	d�d�S)N)�Module�Class�Instance�Function�	Generator)�raises�approx�collect)
r&�fail�	ExceptionrYrZrTrUrVrWrXr!r!r!r"�pytest_namespace�s
r^cCsP|j}|��r||j�n2|j}i}x|jjD]}||||<q.W|f|�dS)NT)r'�_isyieldedfunction�_args�funcargs�_fixtureinfo�argnames)�
pyfuncitemZtestfunctionraZtestargs�argr!r!r"�pytest_pyfunc_call�s
rfcCs^|j}|dkrZ|j�|�s@x$|j�d�D]}|�|�r(Pq(WdS|j�|�}|j||d�SdS)Nz.pyr9)r�parent)�ext�sessionZ
isinitpathrD�getini�fnmatchZgethookproxy�pytest_pycollect_makemodule)rrgrh�pat�ihookr!r!r"�pytest_collect_file�s
rocCs
t||�S)N)rT)rrgr!r!r"rl�srl)Zhookwrapperccs�dV}|��}|dk	rdSt|�rL|�||�r�|�d�}|�|||d��n||�||�r�t|d|�}t|�s�tt|��s�|j	dd|d�n<t|dd�r�t
|�r�t||d�}nt|�
||��}|�|�dS)	NrU)rg�__func__ZC2z/cannot collect %r because it is not a function.)r�message�__test__T)Z
get_resultr�istestclass�_getcustomclassZforce_result�istestfunctionr%rr
�warnrrX�list�
_genfunctions)�	collectorr*r'Zoutcome�resrUr!r!r"�pytest_pycollect_makeitem�s&
r{cCsdS)Nr!)rD�valr!r!r"�pytest_make_parametrize_id�sr}c@s$eZdZed�Zed�Zed�ZdS)�PyobjContextrTrUrVN)rI�
__module__�__qualname__r/�module�cls�instancer!r!r!r"r~�sr~c@s<eZdZdd�Ze�Zdd�Zddd�Zd	d
�Zdd�Zd
S)�
PyobjMixincCsdd�}dd�}t||dd�S)NcSs&t|dd�}|dkr"|��|_}|S)N�_obj)r%�_getobjr�)r(r'r!r!r"�fget�szPyobjMixin.obj.<locals>.fgetcSs
||_dS)N)r�)r(�valuer!r!r"�fset�szPyobjMixin.obj.<locals>.fsetzunderlying python object)r-)r�r�r!r!r"r'�szPyobjMixin.objcCst|jj|j�S)N)r%rgr'r*)r(r!r!r"r��szPyobjMixin._getobjTFcCs�|��}|��g}x`|D]X}t|t�r*q|j}t|t�rh|�d�sHt�|dd�}|rh|rf|�|�P|�|�qW|��d�	|�}|�
dd�S)z7 return python path relative to the containing module. z.pyN����.z.[�[)Z	listchain�reverse�
isinstancerVr*rT�endswith�AssertionErrorr=�join�replace)r(ZstopatmoduleZ
includemodule�chain�partsr)r*�sr!r!r"�
getmodpath�s$




zPyobjMixin.getmodpathcCs
t|j�S)N)rr')r(r!r!r"�_getfslineno�szPyobjMixin._getfslinenocCsr|j}t|dd�}t|t�rFtj|jj}|�d�r@|dd�}|}nt	|�\}}|�
�}t|t�sht�|||fS)N�compat_co_firstlinenoz.pyc���)r'r%r��int�sys�modulesr�__file__r�rr�r�)r(r'r��fspath�linenoZmodpathr!r!r"�
reportinfo�s

zPyobjMixin.reportinfoN)TF)rIrr�r'r�r�r�r�r!r!r!r"r��s
r�c@sTeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�ZdS)�PyCollectorcCs|�d|�S)Nr;)�_matches_prefix_or_glob_option)r(r*r!r!r"�funcnamefilterszPyCollector.funcnamefiltercCst|dd�dkS)zg Look for the __test__ attribute, which is applied by the
        @nose.tools.istest decorator
        rrFT)r)r(r'r!r!r"�
isnosetestszPyCollector.isnosetestcCs|�d|�S)Nr:)r�)r(r*r!r!r"�classnamefilterszPyCollector.classnamefiltercCs.|�|�s|�|�o,t|dd�o,t�|�dkS)N�__call__F)r�r�rr�getfixturemarker)r(r'r*r!r!r"ruszPyCollector.istestfunctioncCs|�|�p|�|�S)N)r�r�)r(r'r*r!r!r"rs#szPyCollector.istestclasscCsPxJ|j�|�D]:}|�|�r dSd|ks8d|ks8d|krt�||�rdSqWdS)zs
        checks if the given name matches the prefix or glob-pattern defined
        in ini configuration.
        T�*�?r�F)rDrj�
startswithrk)r(�option_namer*rCr!r!r"r�&s
z*PyCollector._matches_prefix_or_glob_optionc	Cs�t|jdd�sgSt|jdi�g}x"t�|jj�D]}|�|j�q2Wi}g}xh|D]`}xZt|���D]J\}}||krxqfd||<|�	||�}|dkr�qft
|t�s�|g}|�|�qfWqTW|jdd�d�|S)NrrT�__dict__cSs|��dd�S)N�)r�)�itemr!r!r"�<lambda>L�z%PyCollector.collect.<locals>.<lambda>)�key)
r%r'�inspect�getmro�	__class__r=r�rw�items�makeitemr��extend�sort)	r(ZdictsZbasecls�seen�lZdicr*r'rzr!r!r"r[6s(

zPyCollector.collectcCs|jj|||d�S)N)ryr*r')rnr{)r(r*r'r!r!r"r�OszPyCollector.makeitemc

cs&|�t�j}|�t�}|r |jp"d}t|||�|jj}|�|||�}t|||j	||d�}g}	t
|d�rt|	�|j�t
|d�r�|	�|�j�|	r�|j
j�|	t|d��n|j
j|d�|�d�}
|js�|
|||d�VnJt�|||�x:|jD]0}d||jf}|
||||||jdi|d�Vq�WdS)	N)r�r�rR)rMrW)rg�fixtureinfoz%s[%s]T)r*rg�callspec�callobjr��keywords�originalname)r$rTr'rU�transfer_markersri�_fixturemanager�getfixtureinfo�MetafuncrDrFr=rRrnZ
call_extra�dictrt�_callsrZadd_funcarg_pseudo_fixture_def�id)
r(r*�funcobjr�Zclscolr��fmr�rM�methodsrWr��subnamer!r!r"rxTs8






zPyCollector._genfunctionsN)rIrr�r�r�r�rursr�r[r�rxr!r!r!r"r�s	r�cCs>yt||j�}Wntk
r$dSX|j|jko<|j|jkS)z� Returns True if :func: is already marked with :mark:, False otherwise.
    This can happen if marker is applied to class and the test file is
    invoked more than once.
    F)r%r*rKr7rL)�func�markZ	func_markr!r!r"�_markedys
r�c	Csvxp||fD]d}y
|j}Wntk
r.w
YnXt|t�r\x2|D]}t||�s@||�q@Wq
t||�s
||�q
WdS)N)�
pytestmarkrKr�rwr�)r�r��mod�holderr�r�r!r!r"r��s




r�cs8eZdZdZdd�Z�fdd�Zdd�Zdd	�Z�ZS)
rTz+ Collector for test classes and functions. cCs|�d|j�S)Nr�)Z
_memoizedcall�_importtestmodule)r(r!r!r"r��szModule._getobjcs|jj�|�tt|���S)N)rir��parsefactories�superrTr[)r()r�r!r"r[�szModule.collectc
CsJ|j�d�}y|jj|d�}W�ntk
rL|�tj��j	dd���Yn�|jj
k
r~t��d}|�d|j
��Yn�tk
r�ddlm}|�}|j�d	�d
kr�|j�t�|_|jr�|j	dd�n|��}tj�|�}|�dj|j|d���Yn<tjjk
�r6}z|j�r�|�d
��Wdd}~XYnX|jj�|�|S)Nz
--import-mode)Z
ensuresyspath�short)�style�z�import file mismatch:
imported module %r has this __file__ attribute:
  %s
which is not the same as the test file we want to collect:
  %s
HINT: remove __pycache__ / .pyc files and/or use a unique basename for your test file modulesr)�
ExceptionInfo�verboser�z�ImportError while importing test module '{fspath}'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
{traceback})r��	tracebackz�Using pytest.skip outside of a test is not allowed. If you are trying to decorate a test function, use the @pytest.mark.skip or @pytest.mark.skipif decorators instead.)rDZ	getoptionr�Zpyimport�SyntaxErrorZCollectError�_pytest�_coder�ZgetreprZImportMismatchErrorr��exc_infor7�ImportErrorZ_pytest._code.coder��filterr#Zexconlyr�_builtin�_totextrHZrunnerZSkippedZallow_module_levelZ
pluginmanagerZconsider_module)r(r>r��er�r�Zexc_reprZformatted_tbr!r!r"r��s8zModule._importtestmodulecCsdt|jd�}|dkr t|jd�}|dk	r.|�t|jd�}|dkrNt|jd�}|dk	r`|�|�dS)NZsetUpModule�setup_moduleZtearDownModule�teardown_module)�_get_xunit_setup_teardownr'�addfinalizer)r(r�r�r!r!r"�setup�szModule.setup)	rIrr��__doc__r�r[r�r��
__classcell__r!r!)r�r"rT�s
,rTcsV�dk	r�n|�t||���dk	rR�jj}t���r<|d8}|rN��fdd�S�SdS)a^
    Return a callable to perform xunit-style setup or teardown if
    the function exists in the ``holder`` object.
    The ``param_obj`` parameter is the parameter which will be passed to the function
    when the callable is called without arguments, defaults to the ``holder`` object.
    Return ``None`` if a suitable callable is not found.
    Nr�cs���S)Nr!r!)�	param_obj�resultr!r"r��r�z+_get_xunit_setup_teardown.<locals>.<lambda>)�_get_xunit_func�__code__�co_argcountr��ismethod)r��	attr_namer�Z	arg_countr!)r�r�r"r��s

r�cCs"t||d�}t�|�dkr|SdS)z�Return the attribute from the given object to be used as a setup/teardown
    xunit-style function, but only if not marked as a fixture to
    avoid calling it twice.
    N)r%rr�)r'r*�methr!r!r"r��sr�c@s eZdZdZdd�Zdd�ZdS)rUz Collector for test methods. cCsXt|j�r"|�dd|jj�gSt|j�rD|�dd|jj�gS|�d�d|d�gS)N�C1zBcannot collect test class %r because it has a __init__ constructorzAcannot collect test class %r because it has a __new__ constructorrVz())r*rg)�hasinitr'rvrI�hasnewrt)r(r!r!r"r[�s

z
Class.collectcs|t�jd�}|dk	r6t|d|�}t|d|�}|�j�t�jdd���dk	rxt�d���t�d�������fdd��dS)N�setup_class�im_funcrpZteardown_classcs
��j�S)N)r'r!)�	fin_classr(r!r"r�r�zClass.setup.<locals>.<lambda>)r�r'r%r�)r(r�r!)r�r(r"r�s
zClass.setupN)rIrr�r�r[r�r!r!r!r"rU�srUcs,eZdZdd�Z�fdd�Zdd�Z�ZS)rVcCs
|j��S)N)rgr')r(r!r!r"r�szInstance._getobjcs|jj�|�tt|���S)N)rir�r�r�rVr[)r()r�r!r"r[szInstance.collectcCs|��|_|jS)N)r�r')r(r!r!r"�newinstances
zInstance.newinstance)rIrr�r�r[r�r�r!r!)r�r"rVsrVcs<eZdZdZdd�Zdd�Zd�fdd�	Zd
d
d�Z�ZS)�
FunctionMixinz: mixin for the code common to Function and Generator.
    cCs�t|d�r|j}n*t|jt�r4|j��}|��|_n|jj}t�	|j�rRd}d}nd}d}t
|||jd�}|dk	rx|�t
|||jd�}|dk	r�|�|�dS)z' perform setup for this test function. �_preservedparentZsetup_methodZteardown_methodZsetup_functionZteardown_function)r�N)rFr�r�rgrVr�r�r'r�r�r�r�)r(r'Z
setup_nameZ
teardown_nameZsetup_func_or_methodZteardown_func_or_methodr!r!r"r� s"

zFunctionMixin.setupcCs�t|d�r�|jjjs�tj�t|j��}|j	|j
}}|j}|j||d�}||krv|j|d�}||krv|�
t�}|sv|}|�
�|_|jjjdkr�t|j�dkr�x |jdd�D]}|�d�q�WdS)	Nr�)r�firstlineno)r�autor�r�r�r�)rFrDrCZ	fulltracer�r�ZCoder
r'rr�r�Zcutr�r#�tbstyle�lenZset_repr_style)r(�excinforrr�r�Z
ntracebackrr!r!r"�_prunetraceback6s 

zFunctionMixin._prunetraceback�longcs8|�tjj�r$|jjs$tj�|j�St	t
|�j||d�S)N)r�)Z
errisinstancer&r\r]r�Zpytracerr�r�r�r��_repr_failure_py)r(r�r�)r�r!r"rLs
zFunctionMixin._repr_failure_pyNcCs4|dkstd��|jjj}|dkr&d}|j||d�S)NzXXX outerr usage is deprecatedr�r)r�)r�rDrCr�r)r(r�Zouterrr�r!r!r"�repr_failureSs

zFunctionMixin.repr_failure)r)N)	rIrr�r�r�rrrr�r!r!)r�r"r�s
r�c@seZdZdd�Zdd�ZdS)rXc		Cs�ddlm}|jj�|�|jj|_g}i}x�t|���D]�\}}|�	|�\}}}t
|�sltd|j|f��|dkr~d|}nd|}||kr�td||f��d||<|�
|j||||d��|jjd	|j|jd
�q:W|S)Nr)�
deprecatedz%r yielded non callable test %rz[%d]z['%s']z*%r generated tests with non-unique name %rT)r7r�r�)Z
fslocation)r�rriZ_setupstateZpreparergr'r��	enumerate�getcallargs�callable�	TypeError�
ValueErrorr=rWrDrvZYIELD_TESTSr�)	r(rr�r��i�xr*�callr7r!r!r"r[\s$

zGenerator.collectcCs`t|ttf�s|f}t|dtjj�r<|d}|dd�}nd}|d|dd�}}|||fS)Nrr�)r��tuplerwr�builtin�_basestring)r(r'r*rr7r!r!r"ruszGenerator.getcallargsN)rIrr�r[rr!r!r!r"rX[srXcCst|dd�}|r|tjkSdS)N�__init__)r%�objectr)r'�initr!r!r"r��sr�cCst|dd�}|r|tjkSdS)N�__new__)r%rr)r'�newr!r!r"r��sr�c@sHeZdZdd�Zdd�Zdd�Zdd�Zed	d
��Zdd�Z	d
d�Z
dS)�	CallSpec2cCsB||_i|_g|_i|_t|_t�|_t|_i|_	i|_
i|_dS)N)rMra�_idlist�paramsr�	_globalid�set�_globalid_args�_globalparam�
_arg2scopenumr��indices)r(rMr!r!r"r�szCallSpec2.__init__cCsxt|j�}|j�|j�|j�|j�|j�|j�|j�|j�|j�|j�t|j	�|_	|j
|_
|j|_|j|_|S)N)
rrMra�updaterr�rrrwrrrr)r(rM�csr!r!r"�copy�s
zCallSpec2.copycCs&||jks||jkr"td|f��dS)Nzduplicate %r)rrar	)r(rer!r!r"�_checkargnotcontained�szCallSpec2._checkargnotcontainedcCs8y
|j|Stk
r2|jtkr,t|��|jSXdS)N)r�KeyErrorrrr	)r(r*r!r!r"�getparam�s

zCallSpec2.getparamcCsd�tttd|j���S)N�-)r��map�strr�r)r(r!r!r"r��szCallSpec2.idcCshxJt||�D]<\}}	|�|�||}
|	t||
�|<||j|<||j|<qW|j�|�|j�|�dS)N)	�zipr!r%rrrr=r�r)r(�valtypesrc�valsetr�r��scopenum�param_indexrer|Zvaltype_for_argr!r!r"�setmulti�s

zCallSpec2.setmulticCsrx|D]}|�|�qW|j�|�|tk	r8|j�|�|tk	rT|jtksNt�||_x|D]}tj	|j
|<qZWdS)N)r!rarrrr=rr�rZscopenum_functionr)r(rar��paramrrer!r!r"�setall�s

zCallSpec2.setallN)rIrr�rr r!r#r-r�r,r.r!r!r!r"r�s
rc@s4eZdZdZd
dd�Zddd�Zdeefdd	�ZdS)r�a
    Metafunc objects are passed to the ``pytest_generate_tests`` hook.
    They help to inspect a test function and to generate tests according to
    test configuration or values specified in the class or module where a
    test function is defined.
    NcCs>||_||_||_|j|_||_g|_tj�	�|_
|j|_dS)N)
rDr�rG�
names_closure�fixturenamesr�r�rrr�_ids�name2fixturedefs�_arg2fixturedefs)r(rGr�rDr�r�r!r!r"r�szMetafunc.__init__Fc Cs*ddlm}ddlm}ddlm}g}	g}
x,|D]$}||�\}}
|	�|�|
�|
�q2W|	}t|tt	f�s�dd�|�
d�D�}t|�dkr�d	d�|D�}|s�tft|�g}t
|j�\}}tjjd
||jj||fd�}|j|ig}
|dkr�t||j|�}||d
�|j�d�}i}x`|D]X}||jk�rt|tt	f��rN||k�rHdnd}n|�rXdnd}td|j||f���qW|dk�r�t�|d�}nh|dk�r�t�|d�}nPt|tt	f��r�t�|d�}x2|D]*}||k�r�td|j|f��d||<�q�Wd}t|��r|}d}|�r�t|�t|�k�r<tdt|�t|�f��xF|D]>}|dk	�rBt|tjj��sBd}t|||�t |�jf���qBWt!|||||j"�}g}x�|j#�p�t$|�gD]n}t%|||
t&��}xV|D]N\}}}}t|�t|�k�s�t'�|�(|�}|�)|||||||�|�|��q�W�q�W||_#dS)a� Add new invocations to the underlying test function using the list
        of argvalues for the given argnames.  Parametrization is performed
        during the collection phase.  If you need to setup expensive resources
        see about setting indirect to do it rather at test setup time.

        :arg argnames: a comma-separated string denoting one or more argument
                       names, or a list/tuple of argument strings.

        :arg argvalues: The list of argvalues determines how often a
            test is invoked with different argument values.  If only one
            argname was specified argvalues is a list of values.  If N
            argnames were specified, argvalues must be a list of N-tuples,
            where each tuple-element specifies a value for its respective
            argname.

        :arg indirect: The list of argnames or boolean. A list of arguments'
            names (subset of argnames). If True the list contains all names from
            the argnames. Each argvalue corresponding to an argname in this list will
            be passed as request.param to its respective argname fixture
            function so that it can perform more expensive setups during the
            setup phase of a test rather than at collection time.

        :arg ids: list of string ids, or a callable.
            If strings, each is corresponding to the argvalues so that they are
            part of the test id. If None is given as id of specific test, the
            automatically generated id for that argument will be used.
            If callable, it should take one argument (a single argvalue) and return
            a string or return None. If None, the automatically generated id for that
            argument will be used.
            If no ids are provided they will be generated automatically from
            the argvalues.

        :arg scope: if specified it denotes the scope of the parameters.
            The scope is used for grouping tests by parameter instances.
            It will also override any fixture-function defined scope, allowing
            to set a dynamic scope using test context or configuration.
        r)�scope2index)�extract_argvalue)�safereprcSsg|]}|��r|���qSr!)�strip)�.0rr!r!r"�
<listcomp>sz(Metafunc.parametrize.<locals>.<listcomp>�,r�cSsg|]
}|f�qSr!r!)r8r|r!r!r"r9!sz0got empty parameter set %r, function %s at %s:%d)�reasonNzcall to {0})�descrZfixtureZargumentz%r uses no %s %rTrFraz.indirect given to %r: fixture %r doesn't existz%d tests specified with %d idsz1ids must be list of strings, found: %s (type: %s))*�_pytest.fixturesr4�_pytest.markr5Zpy.ior6r=r�r
rw�splitr�rrrGr&r��skiprIZmarkname�_find_parametrized_scoper3rHrJr0r	r��fromkeysrrrrr8�idmakerrDr�rr'rr�r r,) r(rc�	argvalues�indirect�ids�scoper4r5r6Zunwrapped_argvaluesZnewkeywordsZmaybe_marked_args�argvalZnewmarksZfsr�Znewmarkr*r(rer*�idfnZid_valuerOZnewcallsr��elementsZa_idr)r�r+Znewcallspecr!r!r"rJ�s�'








 

zMetafunc.parametrizecCs�|dkst|t�st�|dk	rFx*|D]}||jkr$t�d|�q$Wni}|dkrZtd��|tkrlt|j	�}t
|�}||jkr�td|��|j�|�t
|�}|�|||�|j	�|�dS)a (deprecated, use parametrize) Add a new call to the underlying
        test function during the collection phase of a test run.  Note that
        request.addcall() is called during the test collection phase prior and
        independently to actual test execution.  You should only use addcall()
        if you need to specify multiple arguments of a test function.

        :arg funcargs: argument keyword dictionary used when invoking
            the test function.

        :arg id: used for reporting and identification purposes.  If you
            don't supply an `id` an automatic unique id will be generated.

        :arg param: a parameter which will be exposed to a later fixture function
            invocation through the ``request.param`` attribute.
        Nz%funcarg %r not used in this function.zid=None not allowedzduplicate id %r)r�r�r�r0r&r\r	rr�r�r&r1�addrr.r=)r(rar�r-r*rr!r!r"�addcall_s"



zMetafunc.addcall)NN)FNN)rIrr�r�rrJrrLr!r!r!r"r��s


sr�c	Csvddlm}t|ttf�}|dkp0|o0t|�|k}|rr|p<i}dd�|��D�}|rrxt|�D]}||kr^|Sq^WdS)a}Find the most appropriate scope for a parametrized call based on its arguments.

    When there's at least one direct argument, always use "function" scope.

    When a test function is parametrized and all its arguments are indirect
    (e.g. fixtures), return the most narrow scope based on the fixtures used.

    Related to issue #1832, based on code posted by @Kingdread.
    r)�scopesTcSsg|]\}}|dj�qS)r)rG)r8r*�
fixturedefr!r!r"r9�sz,_find_parametrized_scope.<locals>.<listcomp>rG)r=rMr�rwr
r�r��reversed)	rcZarg2fixturedefsrErMZindirect_as_listZall_arguments_are_fixtures�fixturedefsZused_scopesrGr!r!r"rA�s
rAcCs�|r2y||�}|rt|�SWntk
r0YnX|rN|jj||d�}|rN|St|t�r`t|�St|tttt	f�rzt
|�St|t�r�t|j�St
dk	r�t|t
j�r�t
|�St|�r�t|d�r�|jSt
|�t
|�S)N)rDr|rI)rr]�hookr}r�r
�floatr��boolrr&r	�patternr�EnumrrFrI)r|�argname�idxrIrDr�Zhook_idr!r!r"�_idval�s,


rXcsV|dks �t|�ks |�dkrF���fdd�t||�D�}d�|�St|��SdS)Ncs g|]\}}t||�����qSr!)rX)r8r|rV)rDrIrWr!r"r9�sz_idvalset.<locals>.<listcomp>r$)r�r'r�r)rWr)rcrIrFrDZthis_idr!)rDrIrWr"�	_idvalset�s
 
rYc	s�����fdd�t|�D��tt���t��kr��fdd��D�}t�dd��}x@t��D]4\}}||krZ|t||��|<||d7<qZW�S)Nc	s"g|]\}}t||������qSr!)rY)r8Zvalindexr))rcrDrIrFr!r"r9�szidmaker.<locals>.<listcomp>csg|]}��|�dkr|�qS)r�)r)r8�testid)rFr!r"r9�scSsdS)Nrr!r!r!r!r"r��r�zidmaker.<locals>.<lambda>r�)rr�r�collections�defaultdictr&)	rcrDrIrFrD�
duplicatesZcounters�indexrZr!)rcrDrIrFr"rC�srCcCsddlm}||t�S)Nr)�wrap_session)�_pytest.mainr_�_show_fixtures_per_test)rDr_r!r!r"r6�sr6csxddl}|��tj���|j�|��|�d���fdd�����fdd�����fdd�}x|jD]}||�qdWdS)	Nrr�cst|��}��|�S)N)r�bestrelpath)r��loc)�curdirr!r"�get_best_rel�s
z-_show_fixtures_per_test.<locals>.get_best_relcs�|j}�dkr|�d�rdS�dkr<�|j�}d�||�}n|}�j|dd�d}|jj}|r�x@|���d�D]}��|�|����qnWn�j|�d�dd	�dS)
Nr�_z
{0} -- {1}T)�greenz    {0}�
zno docstring available)�red)rVr�r�rH�liner�r7r?)Zfixture_defrV�bestrel�funcargspec�INDENTZfixture_docrj)re�twr�r!r"�
write_fixture�s
z._show_fixtures_per_test.<locals>.write_fixturecs�|jj}|sdS�|j�}�����dd�|j����dd�|��x6t|���D]&\}}|dk	sjt	�|spqV�|d�qVWdS)Nr$zfixtures used by {0}z({0})r�)
rbr2rGrj�seprHr*�sortedr�r�)r�r2rkrVZfixture_defs)rernror!r"�
write_item�s
z+_show_fixtures_per_test.<locals>.write_item)	�_pytest.config�perform_collectrrrrD�create_terminal_writer�getvaluer�)rDrir�rrr�r!)rdrernr�ror"ra�s

racCsddlm}||t�S)Nr)r_)r`r_�_showfixtures_main)rDr_r!r!r"r1
sr1c	Cs�ddl}|��tj��}|j�|�}|�d�}|j}g}t	�}x�|j
��D]z\}	}
|
dk	s`t�|
sfqLx^|
D]V}t
|j|�}|j|f|kr�ql|�|j|f�|�t|j�|jj|�|�|j|f�qlWqLW|��d}
x�|D]�\}}}}	}|
|k�r|�d��s|��|�dd|f�|}
|dk�r8|	ddk�r8q�|dk�rPd|	|f}n|	}|j|dd	�t
|j|�}|jj�pzd
}|�r�x@|���d�D]}|�d|����q�Wq�|jd
|fdd�q�WdS)Nrr�z_pytest.r$zfixtures defined from %srfz%s -- %sT)rg�rhz    z    %s: no docstring available)ri)rsrtrrrrDrurvr�rr3r�r�rr�rVrKr=r��baseidrrbr�r�rjrpr�r7r?)rDrir�rdrnr�r��	availabler�rVrPrNrcZ
currentmoduleryr�rkrlr.rjr!r!r"rwsT




rwcOsbd}|tkrddlm}d}t|t�rNx>|D]}t|�s,t|t|���q,Wnt|�sft|t|���d�|�}|s�d|kr�|�	d�}t
||�St|dt��r|\}t|t�s�t�t�
d�}|j��}	|	�|�y&tj�|���}tj�||j|	�Wn|k
�rtj��SXn<|d}
y|
|dd�|�Wn|k
�rRtj��SXt�|�dS)	a�
    Assert that a code block/function call raises ``expected_exception``
    and raise a failure exception otherwise.

    This helper produces a ``ExceptionInfo()`` object (see below).

    If using Python 2.5 or above, you may use this function as a
    context manager::

        >>> with raises(ZeroDivisionError):
        ...    1/0

    .. versionchanged:: 2.10

    In the context manager form you may use the keyword argument
    ``message`` to specify a custom failure message::

        >>> with raises(ZeroDivisionError, message="Expecting ZeroDivisionError"):
        ...    pass
        Traceback (most recent call last):
          ...
        Failed: Expecting ZeroDivisionError


    .. note::

       When using ``pytest.raises`` as a context manager, it's worthwhile to
       note that normal context manager rules apply and that the exception
       raised *must* be the final line in the scope of the context manager.
       Lines of code after that, within the scope of the context manager will
       not be executed. For example::

           >>> value = 15
           >>> with raises(ValueError) as exc_info:
           ...     if value > 10:
           ...         raise ValueError("value must be <= 10")
           ...     assert str(exc_info.value) == "value must be <= 10"  # this will not execute

       Instead, the following approach must be taken (note the difference in
       scope)::

           >>> with raises(ValueError) as exc_info:
           ...     if value > 10:
           ...         raise ValueError("value must be <= 10")
           ...
           >>> assert str(exc_info.value) == "value must be <= 10"


    Or you can specify a callable by passing a to-be-called lambda::

        >>> raises(ZeroDivisionError, lambda: 1/0)
        <ExceptionInfo ...>

    or you can specify an arbitrary callable with arguments::

        >>> def f(x): return 1/x
        ...
        >>> raises(ZeroDivisionError, f, 0)
        <ExceptionInfo ...>
        >>> raises(ZeroDivisionError, f, x=0)
        <ExceptionInfo ...>

    A third possibility is to use a string to be executed::

        >>> raises(ZeroDivisionError, "f(0)")
        <ExceptionInfo ...>

    .. autoclass:: _pytest._code.ExceptionInfo
        :members:

    .. note::
        Similar to caught exception objects in Python, explicitly clearing
        local references to returned ``ExceptionInfo`` objects can
        help the Python interpreter speed up its garbage collection.

        Clearing those references breaks a reference cycle
        (``ExceptionInfo`` --> caught exception --> frame stack raising
        the exception --> current frame stack --> local variables -->
        ``ExceptionInfo``) which makes Python keep all objects referenced
        from that cycle (including all local variables in the current
        frame) alive until the next cyclic garbage collection run. See the
        official Python ``try`` statement documentation for more detailed
        information.

    Tr)�BuiltinAssertionErrorzJexceptions must be old-style classes or derived from BaseException, not %szDID NOT RAISE {0}rqr�N)r�Z_pytest.assertion.utilr{r�r
rrr8rH�pop�
RaisesContextr&r��	_getframe�f_localsr rr�r�ZSource�compilerr�exec_�	f_globalsr�r&r\)�expected_exceptionr7rL�__tracebackhide__rO�excrqrrrcr�r!r!r"rYCs@V







rYc@s$eZdZdd�Zdd�Zdd�ZdS)r}cCs||_||_d|_dS)N)r�rqr�)r(r�rqr!r!r"r�szRaisesContext.__init__cCst�tjj�|_|jS)N)rrr�r�r�r�)r(r!r!r"�	__enter__�szRaisesContext.__enter__cGs�d}|ddkrt�|j�tjdkrLt|dt�sL|\}}}|||�|f}|j�|�t	|jj
|j�}tjddkr�|r�t��|S)NTr)r��r�r�)
r&r\rqr��version_infor��
BaseExceptionr�r�
issubclassr8r�Z	exc_clear)r(�tpr��exc_typer�r�Zsuppress_exceptionr!r!r"�__exit__�s

zRaisesContext.__exit__N)rIrr�rr�r�r!r!r!r"r}�sr}c@sPeZdZdZddd�Zdd�Zdd�ZdZd	d
�Ze	dd��Z
e
jd
d��Z
dS)rZa[
    Assert that two numbers (or two sets of numbers) are equal to each other
    within some tolerance.

    Due to the `intricacies of floating-point arithmetic`__, numbers that we
    would intuitively expect to be equal are not always so::

        >>> 0.1 + 0.2 == 0.3
        False

    __ https://docs.python.org/3/tutorial/floatingpoint.html

    This problem is commonly encountered when writing tests, e.g. when making
    sure that floating-point values are what you expect them to be.  One way to
    deal with this problem is to assert that two floating-point numbers are
    equal to within some appropriate tolerance::

        >>> abs((0.1 + 0.2) - 0.3) < 1e-6
        True

    However, comparisons like this are tedious to write and difficult to
    understand.  Furthermore, absolute comparisons like the one above are
    usually discouraged because there's no tolerance that works well for all
    situations.  ``1e-6`` is good for numbers around ``1``, but too small for
    very big numbers and too big for very small ones.  It's better to express
    the tolerance as a fraction of the expected value, but relative comparisons
    like that are even more difficult to write correctly and concisely.

    The ``approx`` class performs floating-point comparisons using a syntax
    that's as intuitive as possible::

        >>> from pytest import approx
        >>> 0.1 + 0.2 == approx(0.3)
        True

    The same syntax also works on sequences of numbers::

        >>> (0.1 + 0.2, 0.2 + 0.4) == approx((0.3, 0.6))
        True

    By default, ``approx`` considers numbers within a relative tolerance of
    ``1e-6`` (i.e. one part in a million) of its expected value to be equal.
    This treatment would lead to surprising results if the expected value was
    ``0.0``, because nothing but ``0.0`` itself is relatively close to ``0.0``.
    To handle this case less surprisingly, ``approx`` also considers numbers
    within an absolute tolerance of ``1e-12`` of its expected value to be
    equal.  Infinite numbers are another special case.  They are only
    considered equal to themselves, regardless of the relative tolerance.  Both
    the relative and absolute tolerances can be changed by passing arguments to
    the ``approx`` constructor::

        >>> 1.0001 == approx(1)
        False
        >>> 1.0001 == approx(1, rel=1e-3)
        True
        >>> 1.0001 == approx(1, abs=1e-3)
        True

    If you specify ``abs`` but not ``rel``, the comparison will not consider
    the relative tolerance at all.  In other words, two numbers that are within
    the default relative tolerance of ``1e-6`` will still be considered unequal
    if they exceed the specified absolute tolerance.  If you specify both
    ``abs`` and ``rel``, the numbers will be considered equal if either
    tolerance is met::

        >>> 1 + 1e-8 == approx(1)
        True
        >>> 1 + 1e-8 == approx(1, abs=1e-12)
        False
        >>> 1 + 1e-8 == approx(1, rel=1e-6, abs=1e-12)
        True

    If you're thinking about using ``approx``, then you might want to know how
    it compares to other good ways of comparing floating-point numbers.  All of
    these algorithms are based on relative and absolute tolerances and should
    agree for the most part, but they do have meaningful differences:

    - ``math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)``:  True if the relative
      tolerance is met w.r.t. either ``a`` or ``b`` or if the absolute
      tolerance is met.  Because the relative tolerance is calculated w.r.t.
      both ``a`` and ``b``, this test is symmetric (i.e.  neither ``a`` nor
      ``b`` is a "reference value").  You have to specify an absolute tolerance
      if you want to compare to ``0.0`` because there is no tolerance by
      default.  Only available in python>=3.5.  `More information...`__

      __ https://docs.python.org/3/library/math.html#math.isclose

    - ``numpy.isclose(a, b, rtol=1e-5, atol=1e-8)``: True if the difference
      between ``a`` and ``b`` is less that the sum of the relative tolerance
      w.r.t. ``b`` and the absolute tolerance.  Because the relative tolerance
      is only calculated w.r.t. ``b``, this test is asymmetric and you can
      think of ``b`` as the reference value.  Support for comparing sequences
      is provided by ``numpy.allclose``.  `More information...`__

      __ http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.isclose.html

    - ``unittest.TestCase.assertAlmostEqual(a, b)``: True if ``a`` and ``b``
      are within an absolute tolerance of ``1e-7``.  No relative tolerance is
      considered and the absolute tolerance cannot be changed, so this function
      is not appropriate for very large or very small numbers.  Also, it's only
      available in subclasses of ``unittest.TestCase`` and it's ugly because it
      doesn't follow PEP8.  `More information...`__

      __ https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertAlmostEqual

    - ``a == pytest.approx(b, rel=1e-6, abs=1e-12)``: True if the relative
      tolerance is met w.r.t. ``b`` or if the absolute tolerance is met.
      Because the relative tolerance is only calculated w.r.t. ``b``, this test
      is asymmetric and you can think of ``b`` as the reference value.  In the
      special case that you explicitly specify an absolute tolerance but not a
      relative tolerance, only the absolute tolerance is considered.
    NcCs||_||_||_dS)N)�expected�abs�rel)r(r�r�r�r!r!r"rUszapprox.__init__cCsd�dd�|jD��S)Nz, css|]}t|�VqdS)N)�repr)r8rr!r!r"�	<genexpr>[sz"approx.__repr__.<locals>.<genexpr>)r�r�)r(r!r!r"�__repr__Zszapprox.__repr__cCsLddlm}t||�s|g}t|�t|j�kr2dStdd�t||j�D��S)Nr)�IterableFcss|]\}}||kVqdS)Nr!)r8�arr!r!r"r�csz approx.__eq__.<locals>.<genexpr>)r[r�r�r�r��allr')r(�actualr�r!r!r"�__eq__]s
z
approx.__eq__cCs
||kS)Nr!)r(r�r!r!r"�__ne__gsz
approx.__ne__csHddlm}�fdd��t�j|�r8�fdd��jD�S��j�gSdS)Nr)r�cst|�j�j�S)N)�ApproxNonIterabler�r�)r)r(r!r"r�pr�z!approx.expected.<locals>.<lambda>csg|]}�|��qSr!r!)r8r)�approx_non_iterr!r"r9rsz#approx.expected.<locals>.<listcomp>)r[r�r��	_expected)r(r�r!)r�r(r"r�js
zapprox.expectedcCs
||_dS)N)r�)r(r�r!r!r"r�vs)NN)rIrr�r�rr�r��__hash__r�r-r��setterr!r!r!r"rZ�sp
rZc@sBeZdZdZd
dd�Zdd�Zdd�ZdZd	d
�Ze	dd��Z
dS)r�a5
    Perform approximate comparisons for single numbers only.

    In other words, the ``expected`` attribute for objects of this class must
    be some sort of number.  This is in contrast to the ``approx`` class, where
    the ``expected`` attribute can either be a number of a sequence of numbers.
    This class is responsible for making comparisons, while ``approx`` is
    responsible for abstracting the difference between numbers and sequences of
    numbers.  Although this class can stand on its own, it's only meant to be
    used within ``approx``.
    NcCs||_||_||_dS)N)r�r�r�)r(r�r�r�r!r!r"r�szApproxNonIterable.__init__cCs�t|jt�rt|j�St�|j�r,t|j�Syd�|j�}Wntk
rTd}YnXt	j
ddkrrd�|j|�Sd�|j|�SdS)Nz{:.1e}z???rr�z
{0} +- {1}u
{0} ± {1})r�r��complexr&�math�isinfrH�	tolerancer	r�r�)r(Zvetted_tolerancer!r!r"r��s


zApproxNonIterable.__repr__cCs6||jkrdSt�t|j��r"dSt|j|�|jkS)NTF)r�r�r�r�r�)r(r�r!r!r"r��s

zApproxNonIterable.__eq__cCs
||kS)Nr!)r(r�r!r!r"r��szApproxNonIterable.__ne__cCs�dd�}||jd�}|dkr*td�|���t�|�r<td��|jdkrT|jdk	rT|S||jd�t|j�}|dkr�td�|���t�|�r�td	��t||�S)
NcSs|dk	r|S|S)Nr!)rr4r!r!r"r��r�z-ApproxNonIterable.tolerance.<locals>.<lambda>g�-���q=rz(absolute tolerance can't be negative: {}z absolute tolerance can't be NaN.g���ư>z(relative tolerance can't be negative: {}z relative tolerance can't be NaN.)r�r	rHr��isnanr�r��max)r(Zset_defaultZabsolute_toleranceZrelative_tolerancer!r!r"r��s



zApproxNonIterable.tolerance)NN)rIrr�r�rr�r�r�r�r-r�r!r!r!r"r�{s
r�cszeZdZdZdZdddeddddf�fdd�	Zdd�Zedd��Z	d	d
�Z
edd��Zd
d�Zdd�Z
�fdd�Z�ZS)rWz] a Function Item is responsible for setting up and executing a
    Python test function.
    Ncs�tt|�j||||d�||_|tk	r,||_|j�|jj�|rT||_	|j�|j�|rd|j�|�|	dkr�|j
jj|j
|j|j|��d�}	|	|_|	j|_|��|
|_dS)N)rDri)ra)r�rWrr`rr'r�rr�r�rir�r�rgr�r_rbr/r0�_initrequestr�)r(r*rgr7rDr�r�r�rir�r�)r�r!r"r�s&zFunction.__init__cCsfi|_|��r"t|d�rVtd��n4t|d�rV|j}|jr<t�|j|_t|d�rV|j|_t�	|�|_
dS)Nr�z3yielded functions (deprecated) cannot have funcargsr-)rar_rFr�r�r��_genidr-rZFixtureRequestZ_request)r(r�r!r!r"r�s


zFunction._initrequestcCst|jd|j�S)z#underlying python 'function' objectr�)r%r')r(r!r!r"rGszFunction.functioncCs2|j}|�d�}|dkr$|d|�}t|jj|�S)Nr�r�)r*�findr%rgr')r(r*r
r!r!r"r�s

zFunction._getobjcCs|S)z@(compatonly) for code expecting pytest-2.2 style request objectsr!)r(r!r!r"�_pyfuncitemszFunction._pyfuncitemcCst|dd�dk	S)Nr`)r%)r(r!r!r"r_!szFunction._isyieldedfunctioncCs|jj|d�dS)z' execute the underlying test function. )rdN)rnrf)r(r!r!r"�runtest$szFunction.runtestcstt|���t�|�dS)N)r�rWr�rZfillfixtures)r()r�r!r"r�(szFunction.setup)rIrr�r�r�rrr�r-rGr�r�r_r�r�r�r!r!)r�r"rW�srW)N)N)N)NNN)Vr�rkr�r�r[r��	itertoolsrrr&r>rr�Z_pytest._pluggyZ_pluggyZpluggyrZ_pytest.compatrrrrr	r
rrr
rrrrrrr��rstripr�dirpathrrr#r/rBrErRrSZhookimplr^rfrorlr{r}rr~r�Z	Collectorr�r�r�ZFilerTr�r�rUrVr�rXr�r�rZFuncargnamesCompatAttrr�rArXrYrCr6rar1rwrYr}rZr�ZItemrWr!r!r!r"�<module>sx<
	
:mC

?'B5


75d