Your IP : 216.73.216.196

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__/pytester.cpython-37.pyc

B

C$�X���@s�dZddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
m
Z
ddlmZddl
mZddlZddlZddlmZmZddlmZdd	�Zd
d�ZGdd
�d
e�Zdddddddd�Zifdd�Zejddddddgd�dd ��Zejd!d"��ZGd#d$�d$�Zd%d&�Z Gd'd(�d(�Z!Gd)d*�d*�Z"ejd+d,��Z#ejd-d.�d/d0��Z$ejd1d2��Z%e�&d3�Z'Gd4d5�d5�Z(Gd6d7�d7�Z)d8d9�Z*Gd:d;�d;�Z+Gd<d-�d-�Z,dS)=zF (disabled by default) support for testing pytest and pytest plugins. �N)�fnmatch)�print_)�Source)�Session�EXIT_OK)�AssertionRewritingHookcCs,|jdddddd�|jddd	d
dd�dS)
Nz--lsof�
store_true�lsofFz"run FD checks if lsof is available)�action�dest�default�helpz--runpytest�	inprocess�	runpytest)r�
subprocesszYrun pytest sub runs in tests using an 'inprocess' or 'subprocess' (python -m main) method)rr�choicesr
)Z	addoption)�parser�r�A/opt/alt/python37/lib/python3.7/site-packages/_pytest/pytester.py�pytest_addoptions
rcCsfytWn4tk
r<tj�tj�d��at�dd�aYnX|�	d�rbt
�}|��rb|j�
|�dS)N�ocz	$py.classz.pyr	)�_pytest_fullpath�	NameError�os�path�abspath�pytest�__file__�rstrip�replace�getvalue�LsofFdLeakChecker�matching_platform�
pluginmanager�register)�configZcheckerrrr�pytest_configure"s
r&c@sBeZdZdd�Zdd�Zdd�Zdd�Zejd	d	d
�dd��Z	d
S)r!cCs|��}|�|�}|S)N)�
_exec_lsof�_parse_lsof_output)�self�out�
open_filesrrr�get_open_files2s
z LsofFdLeakChecker.get_open_filescCst��}tj�d|�S)Nzlsof -Ffn0 -p %d)r�getpid�py�process�cmdexec)r)�pidrrrr'7szLsofFdLeakChecker._exec_lsofcCsndd�}g}x\|�d�D]N}||�r|�d�}|ddd�}|ddd�}|�d�r|�||f�qW|S)NcSs*|�d�o(d|ko(d|ko(d|ko(d|kS)N�fZdeletedZmemZtxt�cwd)�
startswith)�linerrr�isopen<sz4LsofFdLeakChecker._parse_lsof_output.<locals>.isopen�
�r��/)�splitr4�append)r)r*r6r+r5�fields�fd�filenamerrrr(;s

z$LsofFdLeakChecker._parse_lsof_outputc	Cs8ytj�d�Wntjjjtfk
r.dSXdSdS)Nzlsof -vFT)r.r/r0�Error�UnicodeDecodeError)r)rrrr"Ls
z#LsofFdLeakChecker.matching_platformT)ZhookwrapperZtryfirstc#s�|��}dVttd�r t��|��}tdd�|D��tdd�|D����fdd�|D�}|r�g}|�dt|��|�dd�|D��|�d�|�dd�|D��|�d	�|�d
d�|D��|�|d�|�d|j	�t
jd
�|�dd�dS)N�pypy_version_infocSsg|]}|d�qS)rr)�.0�trrr�
<listcomp>_sz9LsofFdLeakChecker.pytest_runtest_item.<locals>.<listcomp>csg|]}|d�kr|�qS)rr)rCrD)�new_fdsrrrE`sz***** %s FD leakage detectedcSsg|]}t|��qSr)�str)rCr2rrrrEdsz*** Before:cSsg|]}t|��qSr)rG)rCr2rrrrEfsz
*** After:cSsg|]}t|��qSr)rG)rCr2rrrrEhsrz*** function %s:%s: %s r7F)Zpytrace)
r,�hasattr�sys�gcZcollect�setr<�len�extend�locationr�fail�join)r)�item�lines1�lines2Zleaked_files�errorr)rFr�pytest_runtest_itemWs$
$

z%LsofFdLeakChecker.pytest_runtest_itemN)
�__name__�
__module__�__qualname__r,r'r(r"rZhookimplrUrrrrr!1s
r!zC:\Python27\python.exezC:\Python26\python.exezC:\Python31\python.exezC:\Python32\python.exezC:\Python33\python.exezC:\Python34\python.exezC:\Python35\python.exe)z	python2.7z	python2.6z	python3.1z	python3.2z	python3.3z	python3.4z	python3.5cCs�y||Stk
r�tjj�|�}|r�ddl}|jt|�dgd|jd�}|�	�\}}|dkr~|rld|krpd}d|kr�d}n|j
dkr�d}|||<|SXdS)Nrz	--versionT)�universal_newlines�stderrZjythonz2.5z2.5.2)�KeyErrorr.r�localZsysfindr�PopenrG�PIPE�communicate�
returncode)�name�cache�
executabler�popenr*�errrrr�
getexecutableys$
rfz	python2.6z	python2.7z	python3.3z	python3.4ZpypyZpypy3)�paramscCs\|j}t|�}|dkrXtjdkrHt�|d�}|rHtj�|�}|�	�rH|St
�d|f�|S)N�win32zno suitable %s found)�paramrfrI�platform�winpymap�getr.rr\�checkr�skip)�requestrarcrrr�	anypython�s
rpcCst|�S)z� Return a helper which offers a gethookrecorder(hook)
    method which returns a HookRecorder instance which helps
    to make assertions about called hooks.
    )�	PytestArg)rorrr�_pytest�srrc@seZdZdd�Zdd�ZdS)rqcCs
||_dS)N)ro)r)rorrr�__init__�szPytestArg.__init__cCst|j�}|j�|j�|S)N)�HookRecorderZ_pmro�addfinalizer�finish_recording)r)�hookZhookrecorderrrr�gethookrecorder�s
zPytestArg.gethookrecorderN)rVrWrXrsrxrrrrrq�srqcCsdd�|D�S)z?Only return names from iterator l without a leading underscore.cSsg|]}|ddkr|�qS)r�_r)rC�xrrrrE�sz$get_public_names.<locals>.<listcomp>r)�lrrr�get_public_names�sr|c@seZdZdd�Zdd�ZdS)�
ParsedCallcCs|j�|�||_dS)N)�__dict__�update�_name)r)ra�kwargsrrrrs�szParsedCall.__init__cCs|j��}|d=d|j|fS)Nr�z<ParsedCall %r(**%r)>)r~�copyr�)r)�drrr�__repr__�s
zParsedCall.__repr__N)rVrWrXrsr�rrrrr}�sr}c@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	d"dd�Z
d#dd�Zd$dd�Zdd�Z
dd�Zdd�Zd%dd�Zd d!�ZdS)&rtz�Record all hooks called in a plugin manager.

    This wraps all the hook calls in the plugin manager, recording
    each call before propagating the normal calls.

    cs2|�_g�_�fdd�}dd�}|�||��_dS)Ncs�j�t||��dS)N)�callsr<r})�	hook_name�
hook_implsr�)r)rr�before�sz%HookRecorder.__init__.<locals>.beforecSsdS)Nr)Zoutcomer�r�r�rrr�after�sz$HookRecorder.__init__.<locals>.after)Z_pluginmanagerr�Zadd_hookcall_monitoring�_undo_wrapping)r)r#r�r�r)r)rrs�s
zHookRecorder.__init__cCs|��dS)N)r�)r)rrrrv�szHookRecorder.finish_recordingcs&t�t�r�����fdd�|jD�S)Ncsg|]}|j�kr|�qSr)r�)rC�call)�namesrrrE�sz)HookRecorder.getcalls.<locals>.<listcomp>)�
isinstancerGr;r�)r)r�r)r�r�getcalls�s
zHookRecorder.getcallsc	Cs�d}d}t|�}t�d�j}x�|r�|�d�\}}x�t|j|d��D]p\}}|j|kr�td||�t	|||j
�r�tdt|�d|�ntdt|�d|�qD||d7}Ptd	|d
|�qDWt�
d||f�qWdS)NTrr9Z	NAMEMATCHZCHECKERMATCHz->ZNOCHECKERMATCH�-ZNONAMEMATCH�withzcould not find %r check %r)�listrI�	_getframe�f_locals�pop�	enumerater�r�r�evalr~�reprrrO)	r)�entries�__tracebackhide__�iZ
backlocalsrarm�indr�rrr�assert_contains�s"
zHookRecorder.assert_containscCshd}x,t|j�D]\}}|j|kr|j|=|SqWd|fg}|�dd�|jD��t�d�|��dS)NTzcould not find call %r, in:cSsg|]}dt|��qS)z  %s)rG)rCrzrrrrE�sz(HookRecorder.popcall.<locals>.<listcomp>r7)r�r�r�rMrrOrP)r)rar�r�r��linesrrr�popcall�s
zHookRecorder.popcallcCs*|�|�}t|�dks"t||f��|dS)Nr9r)r�rL�AssertionError)r)rar{rrr�getcall�s
zHookRecorder.getcall�-pytest_runtest_logreport pytest_collectreportcCsdd�|�|�D�S)NcSsg|]
}|j�qSr)�report)rCrzrrrrEsz+HookRecorder.getreports.<locals>.<listcomp>)r�)r)r�rrr�
getreportsszHookRecorder.getreports�Nc	Cs�g}xx|j|d�D]h}y|s.|jdkr.|jr.wWntk
rDYnX|r\t|dd�|kr\q|rp||j�d�kr|�|�qW|s�td|f��t	|�dkr�td||f��|d	S)
z6 return a testreport whose dotted import path matches )r�r��whenNz::z?could not find test report matching %r: no test reports at all!r9z+found 2 or more testreports matching %r: %sr)
r�r��passed�AttributeError�getattrZnodeidr;r<�
ValueErrorrL)r)Z	inamepartr�r�r{�reprrr�matchreports$
zHookRecorder.matchreportcCsdd�|�|�D�S)NcSsg|]}|jr|�qSr)�failed)rCr�rrrrEsz,HookRecorder.getfailures.<locals>.<listcomp>)r�)r)r�rrr�getfailuresszHookRecorder.getfailurescCs
|�d�S)NZpytest_collectreport)r�)r)rrr�getfailedcollections!sz!HookRecorder.getfailedcollectionscCsng}g}g}xV|�d�D]H}|jr>t|dd�dkr`|�|�q|jrP|�|�q|jr|�|�qW|||fS)Nz-pytest_collectreport pytest_runtest_logreportr�r�)r�r�r�r<�skippedr�)r)r�r�r�r�rrr�listoutcomes$s
zHookRecorder.listoutcomescCsdd�|��D�S)NcSsg|]}t|��qSr)rL)rCrzrrrrE4sz.HookRecorder.countoutcomes.<locals>.<listcomp>)r�)r)rrr�
countoutcomes3szHookRecorder.countoutcomesrcCsB|��\}}}|t|�kst�|t|�ks.t�|t|�ks>t�dS)N)r�rLr�)r)r�r�r�Z
realpassedZrealskippedZ
realfailedrrr�
assertoutcome6szHookRecorder.assertoutcomecCsg|jdd�<dS)N)r�)r)rrr�clear<szHookRecorder.clear)r�)r�r�N)r�)rrr)rVrWrX�__doc__rsrvr�r�r�r�r�r�r�r�r�r�r�r�rrrrrt�s 




rtcCst�S)N)�LineComp)rorrr�linecomp@sr��LineMatcher)racCstS)N)r�)rorrr�LineMatcher_fixtureEsr�cCs
t||�S)N)�Testdir)ro�tmpdir_factoryrrr�testdirJsr�z(\d+) ([\w-]+)c@s*eZdZdZdd�Zdd�Zd
dd�Zd	S)�	RunResulta�The result of running a command.

    Attributes:

    :ret: The return value.
    :outlines: List of lines captured from stdout.
    :errlines: List of lines captures from stderr.
    :stdout: :py:class:`LineMatcher` of stdout, use ``stdout.str()`` to
       reconstruct stdout or the commonly used
       ``stdout.fnmatch_lines()`` method.
    :stderrr: :py:class:`LineMatcher` of stderr.
    :duration: Duration in seconds.

    cCs0||_||_||_t|�|_t|�|_||_dS)N)�ret�outlines�errlinesr��stdoutrZ�duration)r)r�r�r�r�rrrrs_s

zRunResult.__init__cCs\xNt|j�D]@}d|krt�|�}|ri}x|D]\}}t|�||<q0W|SqWtd��dS)zs Return a dictionary of outcomestring->num from parsing
        the terminal output that the test process produced.�secondsz Pytest terminal report not foundN)�reversedr��rex_outcome�findall�intr�)r)r5Zoutcomesr��num�catrrr�
parseoutcomesgs
zRunResult.parseoutcomesrcCsH|��}||�dd�kst�||�dd�ks0t�||�dd�ksDt�dS)z� assert that the specified outcomes appear with the respective
        numbers (0 means it didn't occur) in the text output from a test run.r�rr�r�N)r�rlr�)r)r�r�r�r�rrr�assert_outcomestszRunResult.assert_outcomesN)rrr)rVrWrXr�rsr�r�rrrrr�Ps
r�c@sveZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zd]dd�Zdd �Zd!d"�Zd#d$�ZeZd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Z d;d<�Z!d^d>d?�Z"d@dA�Z#d_dDdE�Z$dFdG�Z%dHdI�Z&dJdK�Z'dLdM�Z(dNdO�Z)dPdQ�Z*dRdS�Z+dTdU�Z,dVdW�Z-d`dYdZ�Z.dad[d\�Z/dS)br�a�Temporary test directory with tools to test/run pytest itself.

    This is based on the ``tmpdir`` fixture but provides a number of
    methods which aid with testing pytest itself.  Unless
    :py:meth:`chdir` is used all methods will use :py:attr:`tmpdir` as
    current working directory.

    Attributes:

    :tmpdir: The :py:class:`py.path.local` instance of the temporary
       directory.

    :plugins: A list of plugins to use with :py:meth:`parseconfig` and
       :py:meth:`runpytest`.  Initially this is an empty list but
       plugins can be added to the list.  The type of items to add to
       the list depend on the method which uses them so refer to them
       for details.

    c	Cs�||_|�d�}|jj}xDtd�D]8}y|�|t|��}Wntjj	k
rVw"YnXPq"W||_
g|_tt
j�tt
j�f|_tt
j�|_|��|j�|j�|jj�d�}|dkr�|j|_n|dkr�|j|_dS)Nr��dz--runpytestrr)roZ
ensuretemp�functionrV�range�mkdirrGr.rT�EEXIST�tmpdir�pluginsr�rIr�	meta_path�_savesyspathrK�modules�_savemodulekeys�chdirru�finalizer%Z	getoption�runpytest_inprocess�_runpytest_method�runpytest_subprocess)r)ror�Zbasetmprar�r��methodrrrrs�s(

zTestdir.__init__cCsd|jfS)Nz<Testdir %r>)r�)r)rrrr��szTestdir.__repr__cCs>|j\tjdd�<tjdd�<t|d�r2|j��|��dS)a	Clean up global state artifacts.

        Some methods modify the global interpreter state and this
        tries to clean this up.  It does not remove the temporary
        directory however so it can be looked at after the test run
        has finished.

        N�_olddir)r�rIrr�rHr�r��delete_loaded_modules)r)rrrr��s	

zTestdir.finalizecCs2x,ttj��|j�D]}|�d�stj|=qWdS)z�Delete modules that have been loaded during a test.

        This allows the interpreter to catch module changes in case
        the module is re-imported.
        zzope.interfaceN)rKrIr��
differencer�r4)r)rarrrr��s
zTestdir.delete_loaded_modulescCs.t|d�rt�t|�|_}|j�|j�|S)z:Create a new :py:class:`HookRecorder` for a PluginManager.�reprec)rHr�rtr�rorurv)r)r#r�rrr�make_hook_recorder�szTestdir.make_hook_recordercCs|j��}t|d�s||_dS)zbCd into the temporary directory.

        This is done automatically upon instantiation.

        r�N)r�r�rHr�)r)�oldrrrr��s

z
Testdir.chdirc
s�t|���}|rRtj�d��ttjj|��tj�d�}|jjj	}|�
d||f�d}x�|D]�\}}	|j�|�j|d�}
|
�
���t|	�}d
dd��d��fdd�|jD��}tj�|�}|���d�}|
�|d	�|dkr\|
}q\W|S)Nr7r)�ext�utf-8cSs tj�|�rtjj||d�}|S)N)�encoding)r.�builtinZ_isbytes�_totext)�sr�rrr�	my_totext�sz$Testdir._makefile.<locals>.my_totextcsg|]}�|��qSrr)rCr5)r�rrrE�sz%Testdir._makefile.<locals>.<listcomp>�wb)r�)r��itemsr.r�r�rP�mapror�rV�insertr��new�dirpathZ
ensure_dirrr��strip�encode�write)
r)r��argsr�r��source�basenamer�ra�value�pZsource_unicode�contentr)r�r�	_makefile�s&

zTestdir._makefilecOs|�|||�S)a�Create a new file in the testdir.

        ext: The extension the file should use, including the dot.
           E.g. ".py".

        args: All args will be treated as strings and joined using
           newlines.  The result will be written as contents to the
           file.  The name of the file will be based on the test
           function requesting this fixture.
           E.g. "testdir.makefile('.txt', 'line1', 'line2')"

        kwargs: Each keyword is the name of a file, while the value of
           it will be written as contents of the file.
           E.g. "testdir.makefile('.ini', pytest='[pytest]
addopts=-rs
')"

        )r�)r)r�r�r�rrr�makefile�szTestdir.makefilecCs|j|d�S)z2Write a contest.py file with 'source' as contents.)Zconftest)�
makepyfile)r)r�rrr�makeconftestszTestdir.makeconftestcCs|jd|d�S)z/Write a tox.ini file with 'source' as contents.z.ini)Ztox)r�)r)r�rrr�makeini
szTestdir.makeinicCs|�|�}tj�|�dS)z7Return the pytest section from the tox.ini config file.r)r�r.Z	iniconfigZ	IniConfig)r)r�r�rrr�	getinicfgs
zTestdir.getinicfgcOs|�d||�S)z.Shortcut for .makefile() with a .py extension.z.py)r�)r)r�r�rrrr�szTestdir.makepyfilecOs|�d||�S)z/Shortcut for .makefile() with a .txt extension.z.txt)r�)r)r�r�rrr�maketxtfileszTestdir.maketxtfileNcCs,|dkr|j}tj�dt|��|��dS)z~Prepend a directory to sys.path, defaults to :py:attr:`tmpdir`.

        This is undone automatically after the test.
        Nr)r�rIrr�rG�"_possibly_invalidate_import_caches)r)rrrr�
syspathinsertszTestdir.syspathinsertcCs8yddl}Wntk
r YnXt|d�r4|��dS)Nr�invalidate_caches)�	importlib�ImportErrorrHr)r)rrrrr�(s
z*Testdir._possibly_invalidate_import_cachescCs|j�|�S)zCreate a new (sub)directory.)r�r�)r)rarrrr�2sz
Testdir.mkdircCs|�|�}|�d�|S)z�Create a new python package.

        This creates a (sub)directory with an empty ``__init__.py``
        file so that is recognised as a python package.

        z__init__.py)r�Zensure)r)rar�rrr�mkpydir6s

zTestdir.mkpydircCs^t|�}dt|�kst�tj�|�}|jj|d�|jt|�gdd�d}|jj	|t
d�|S)a&Return the collection node of a file.

        :param config: :py:class:`_pytest.config.Config` instance, see
           :py:meth:`parseconfig` and :py:meth:`parseconfigure` to
           create the configuration.

        :param arg: A :py:class:`py.path.local` instance of the file.

        z::)�sessionF)�genitemsr)r�
exitstatus)rrGr�r.rr\rw�pytest_sessionstart�perform_collect�pytest_sessionfinishr)r)r%�argrr��resrrr�getnodeBs
zTestdir.getnodecCsT|�|�}t|�}|j�|�}|jj|d�|j|gdd�d}|jj|td�|S)aReturn the collection node of a file.

        This is like :py:meth:`getnode` but uses
        :py:meth:`parseconfigure` to create the (configured) pytest
        Config instance.

        :param path: A :py:class:`py.path.local` instance of the file.

        )rF)rr)rr)	�parseconfigurer�fspathZbestrelpathrwrr	r
r)r)rr%rrzrrrr�getpathnodeTs

zTestdir.getpathnodecCs0|dj}g}x|D]}|�|�|��qW|S)z�Generate all test items from a collection node.

        This recurses into the collection node and returns a list of
        all the test items contained within.

        r)rrMr)r)Zcolitemsr�result�colitemrrrrfs


zTestdir.genitemscCs"|�|�}|jj}|��}||�S)a5Run the "test_func" Item.

        The calling test instance (the class which contains the test
        method) must provide a ``.getrunner()`` method which should
        return a runner which can run the test protocol for a single
        item, like e.g. :py:func:`_pytest.runner.runtestprotocol`.

        )�getitemro�instanceZ	getrunner)r)r�rQZtestclassinstanceZrunnerrrr�runitemss

zTestdir.runitemcGs"|�|�}t|�|g}|j|�S)a�Run a test module in process using ``pytest.main()``.

        This run writes "source" into a temporary file and runs
        ``pytest.main()`` on it, returning a :py:class:`HookRecorder`
        instance for the result.

        :param source: The source code of the test module.

        :param cmdlineargs: Any extra command line arguments to use.

        :return: :py:class:`HookRecorder` instance of the result.

        )r�r��
inline_run)r)r�Zcmdlineargsr�r{rrr�inline_runsource�s
zTestdir.inline_runsourcecGs*|jd|��}dd�|�d�D�}||fS)a�Run ``pytest.main(['--collectonly'])`` in-process.

        Returns a tuple of the collected items and a
        :py:class:`HookRecorder` instance.

        This runs the :py:func:`pytest.main` function to run all of
        pytest inside the test process itself like
        :py:meth:`inline_run`.  However the return value is a tuple of
        the collection items and a :py:class:`HookRecorder` instance.

        �--collect-onlycSsg|]
}|j�qSr)rQ)rCrzrrrrE�sz+Testdir.inline_genitems.<locals>.<listcomp>Zpytest_itemcollected)r)rr�)r)r��recr�rrr�inline_genitems�szTestdir.inline_genitemsc	s�tj��fdd�}�j�|�dd�t_g�G��fdd�d�}|�d�pLg}|�|��tjt|�|d�}��	�t
��d	kr����}nGd
d�d�}||_|dkr�|�d
�s�|�
d�}|r�|djjtkr�t��|S)a�Run ``pytest.main()`` in-process, returning a HookRecorder.

        This runs the :py:func:`pytest.main` function to run all of
        pytest inside the test process itself.  This means it can
        return a :py:class:`HookRecorder` instance which gives more
        detailed results from then run then can be done by matching
        stdout/stderr from :py:meth:`runpytest`.

        :param args: Any command line arguments to pass to
           :py:func:`pytest.main`.

        :param plugin: (keyword-only) Extra plugin instances the
           ``pytest.main()`` instance should use.

        :return: A :py:class:`HookRecorder` instance.
        cs
�t_dS)N)r�_warn_already_importedr)�	orig_warnrr�revert�sz"Testdir.inline_run.<locals>.revertcWsdS)Nr)�arrr�<lambda>��z$Testdir.inline_run.<locals>.<lambda>cseZdZ��fdd�ZdS)z#Testdir.inline_run.<locals>.Collectcs����|j��dS)N)r<r�r#)rzr%)rr)rrr&�sz4Testdir.inline_run.<locals>.Collect.pytest_configureN)rVrWrXr&r)rr)rr�Collect�sr!r�)r�r9c@seZdZdS)z"Testdir.inline_run.<locals>.reprecN)rVrWrXrrrrr��sr��Zno_reraise_ctrlcZpytest_keyboard_interrupt���)rrrorurlr<r�mainr�r�rLr�r�r��excinfo�type�KeyboardInterrupt)	r)r�r�rr!r�r�r�r�r)rrr)rr�s&


zTestdir.inline_runc	
s�|�d�r|��t��}tj��}zry|j||�}Wn\tk
rj�zG�fdd�d�}Wdd��XYn*tk
r�t	�
�Gdd�d�}YnXWd|��\}}tj
�|�tj�|�Xt|j|�d�|�d�t��|�}||_|S)zv Return result of running pytest in-process, providing a similar
        interface to what self.runpytest() provides. rcseZdZ�jdZdS)z+Testdir.runpytest_inprocess.<locals>.reprecrN)rVrWrXr�r�r)�errr��sr�Nc@seZdZdZdS)z+Testdir.runpytest_inprocess.<locals>.reprec�N)rVrWrXr�rrrrr��sr7)rlr�timer.�ioZ
StdCapturer�
SystemExit�	Exception�	traceback�	print_exc�resetrIr�r�rZr�r�r;r�)	r)r�r��nowZcapturer�r*rerr)r(rr��s(

"zTestdir.runpytest_inprocesscOs|�|�}|j||�S)z� Run pytest inline or in a subprocess, depending on the command line
        option "--runpytest" and return a :py:class:`RunResult`.

        )�_ensure_basetempr�)r)r�r�rrrr�s
zTestdir.runpytestcCsFdd�|D�}x2|D]}t|��d�rPqW|�d|j�d��|S)NcSsg|]}t|��qSr)rG)rCrzrrrrEsz,Testdir._ensure_basetemp.<locals>.<listcomp>z
--basetempz
--basetemp=%s�basetemp)rGr4r<r�r�)r)r�rzrrrr2s
zTestdir._ensure_basetempcGs4|�|�}ddl}|j�||j�}|j�|j�|S)a�Return a new pytest Config instance from given commandline args.

        This invokes the pytest bootstrapping code in _pytest.config
        to create a new :py:class:`_pytest.core.PluginManager` and
        call the pytest_cmdline_parse hook to create new
        :py:class:`_pytest.config.Config` instance.

        If :py:attr:`plugins` has been populated they should be plugin
        modules which will be registered with the PluginManager.

        rN)r2Z_pytest.configr%Z_prepareconfigr�roru�_ensure_unconfigure)r)r�rrr%rrr�parseconfig
s

zTestdir.parseconfigcGs$|j|�}|��|j�|j�|S)z�Return a new pytest configured Config instance.

        This returns a new :py:class:`_pytest.config.Config` instance
        like :py:meth:`parseconfig`, but also calls the
        pytest_configure hook.

        )r5Z
_do_configurerorur4)r)r�r%rrrr#s
zTestdir.parseconfigure�	test_funccCs@|�|�}x|D]}|j|kr|SqWds<td|||f��dS)avReturn the test item for a test function.

        This writes the source to a python file and runs pytest's
        collection on the resulting module, returning the test item
        for the requested function name.

        :param source: The module source.

        :param funcname: The name of the test function for which the
           Item must be returned.

        rz)%r item not found in module:
%s
items: %sN)�getitemsrar�)r)r��funcnamer�rQrrrr0s


zTestdir.getitemcCs|�|�}|�|g�S)z�Return all test items collected from the module.

        This writes the source to a python file and runs pytest's
        collection on the resulting module, returning all test items
        contained within.

        )�getmodulecolr)r)r��modcolrrrr7Ds
zTestdir.getitemsrFcCsX|jjjt|���i}|jf|�}|r2|jdd�|j|f|��|_}|�||�}|S)aReturn the module collection node for ``source``.

        This writes ``source`` to a file using :py:meth:`makepyfile`
        and then runs the pytest collection on it, returning the
        collection node for the test module.

        :param source: The source code of the module to collect.

        :param configargs: Any extra arguments to pass to
           :py:meth:`parseconfigure`.

        :param withinit: Whether to also write a ``__init__.py`` file
           to the temporary directory to ensure it is a package.

        �#)rs)	ror�rVrr�r�rr%r
)r)r�Z
configargsZwithinit�kwrr%�noderrrr9OszTestdir.getmodulecolcCs$x|��D]}|j|kr
|Sq
WdS)aCReturn the collection node for name from the module collection.

        This will search a module collection node for a collection
        node matching the given name.

        :param modcol: A module collection node, see
           :py:meth:`getmodulecol`.

        :param name: The name of the node to return.

        N)Z_memocollectra)r)r:rarrrr�collect_by_namegs
zTestdir.collect_by_namec	KsTtj��}tj�tdtt���|�dd�g��|d<||d<t	j
|f||d�|��S)z�Invoke subprocess.Popen.

        This calls subprocess.Popen making sure the current working
        directory is the PYTHONPATH.

        You probably want to use :py:meth:`run` instead.

        N�
PYTHONPATHr��env)r�rZ)r�environr��pathseprP�filterrG�getcwdrlrr])r)�cmdargsr�rZr<r@rrrrdws	

 z
Testdir.popencGs
|j|�S)z�Run a command with arguments.

        Run a process using subprocess.Popen saving the stdout and
        stderr.

        Returns a :py:class:`RunResult`.

        )�_run)r)rErrr�run�s	zTestdir.runcGs<dd�|D�}|j�d�}|j�d�}tdd�|��tdttj����tjt|�dd	d
�}tjt|�dd	d
�}z,t	�	�}|j
|||tjdkd�}|�
�}Wd|��|��Xtjt|�d
d	d
�}tjt|�d
d	d
�}z|����}	|����}
Wd|��|��X|�|	tj�|�|
tj�t||	|
t	�	�|�S)NcSsg|]}t|��qSr)rG)rCrzrrrrE�sz Testdir._run.<locals>.<listcomp>r�rZzrunning:� z     in:�w�utf8)r�rh)r�rZ�	close_fds�r)r�rPrrGr.rr\�codecs�openr*rdrIrj�wait�close�read�
splitlines�_dump_linesr�rZr�)r)rE�p1�p2�f1�f2r1rdr�r*rerrrrF�s0


zTestdir._runcCsJy"x|D]}tjj||d�qWWn"tk
rDtd|f�YnXdS)N)�filez(couldn't print to %s because of encoding)r.r�r�UnicodeEncodeError�print)r)r��fpr5rrrrS�s

zTestdir._dump_linescCs
tjtfS)N)rIrcr)r)rrr�_getpytestargs�szTestdir._getpytestargscCs|�tj|�S)zkRun a python script using sys.executable as interpreter.

        Returns a :py:class:`RunResult`.
        )rGrIrc)r)�scriptrrr�	runpython�szTestdir.runpythoncCs|�tjd|�S)z8Run python -c "command", return a :py:class:`RunResult`.z-c)rGrIrc)r)�commandrrr�runpython_c�szTestdir.runpython_ccOs^tjjjdd|jd�}d|f|}dd�|jD�}|rHd|df|}|��|}|j|�S)	a�Run pytest as a subprocess with given arguments.

        Any plugins added to the :py:attr:`plugins` list will added
        using the ``-p`` command line option.  Addtionally
        ``--basetemp`` is used put any temporary files and directories
        in a numbered directory prefixed with "runpytest-" so they do
        not conflict with the normal numberd pytest location for
        temporary files and directories.

        Returns a :py:class:`RunResult`.

        z
runpytest-N)�prefixZkeepZrootdirz
--basetemp=%scSsg|]}t|t�r|�qSr)r�rG)rCrzrrrrE�sz0Testdir.runpytest_subprocess.<locals>.<listcomp>z-pr)r.rr\Zmake_numbered_dirr�r�r\rG)r)r�r�r�r�rrrr��s
zTestdir.runpytest_subprocess�$@cCs<|j�d�}d�tt|����}d|||f}|j||d�S)z�Run pytest using pexpect.

        This makes sure to use the right pytest and sets up the
        temporary directory locations.

        The pexpect child is returned.

        �pexpectrHz%s --basetemp=%s %s)�expect_timeout)r�r�rPr�rGr\�spawn)r)�stringrdr3Zinvoke�cmdrrr�spawn_pytest�s	zTestdir.spawn_pytestcCszt�dd�}ttd�r,dt��kr,t�d�tj�d�rBt�d�|j	�
d��d	�}|j||d
�}|j
�|j�||_|S)zMRun a command using pexpect.

        The pexpect child is returned.
        rcz3.0rBZ64zpypy-64 bit not supportedZfreebsdz)pexpect does not work reliably on freebsdz	spawn.outr�)�logfile)rZimportorskiprHrIrj�machinernr4Zxfailr�rPrNrerorurP�timeout)r)rgrdrcri�childrrrre�s

z
Testdir.spawn)N)r6)rF)rb)rb)0rVrWrXr�rsr�r�r�r�r�r�r�r�r�r�r�r�rr�r�rrr
rrrrrrr�rr2r5rrr7r9r>rdrGrFrSr\r^r`r�rhrerrrrr�~sZ




6


r�cCs2y
|�d�Stk
r,dtj�|�fSXdS)Nzutf-8z2INTERNAL not-utf8-decodeable, truncated string:
%s)�decoderAr.r+�saferepr)r*rrr�
getdecoded�s

roc@seZdZdd�Zdd�ZdS)r�cCstj��|_dS)N)r.r+ZTextIO�stringio)r)rrrrsszLineComp.__init__cCs>d}|j��}|j�d�|j�d�|�d�}t|��|�S)zo assert that lines2 are contained (linearly) in lines1.
            return a list of extralines found.
        Trr7)rpr �truncate�seekr;r��
fnmatch_lines)r)rSr��valrRrrr�assert_contains_liness

zLineComp.assert_contains_linesN)rVrWrXrsrurrrrr�sr�c@sTeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	e
dd��Zdd�ZdS)r�z�Flexible matching of text.

    This is a convenience class to test large texts like the output of
    commands.

    The constructor takes a list of lines without their trailing
    newlines, i.e. ``text.splitlines()``.

    cCs||_g|_dS)N)r��_log_output)r)r�rrrrs"szLineMatcher.__init__cCsd�|j�S)z Return the entire original text.r7)rPr�)r)rrrrG&szLineMatcher.strcCs*t|t�rt|�}t|t�r&|��j}|S)N)r�rGrr�r�)r)rSrrr�	_getlines*s



zLineMatcher._getlinescCsh|�|�}xX|D]P}xJ|jD](}||ks2t||�r|�dt|��PqW|�d|�t|j��qWdS)z�Check lines exist in the output.

        The argument is a list of lines which have to occur in the
        output, in any order.  Each line can contain glob whildcards.

        z	matched: zline %r not found in outputN)rwr�r�_logr�r��	_log_text)r)rSr5rzrrr�fnmatch_lines_random1s

z LineMatcher.fnmatch_lines_randomcCsLx:t|j�D],\}}||ks&t||�r|j|dd�SqWtd|��dS)zsReturn all lines following the given line in the text.

        The given line can contain glob wildcards.
        r9Nzline %r not found in output)r�r�rr�)r)Zfnliner�r5rrr�get_lines_afterBszLineMatcher.get_lines_aftercGs |j�d�dd�|D���dS)NrHcss|]}t|�VqdS)N)rG)rCrzrrr�	<genexpr>Msz#LineMatcher._log.<locals>.<genexpr>)rvr<rP)r)r�rrrrxLszLineMatcher._logcCsd�|j�S)Nr7)rPrv)r)rrrryOszLineMatcher._log_textcCs�|�|�}|jdd�}d}g}d}x�|D]�}d}x�|r�|�d�}||kr^|�dt|��PnVt||�r�|�dt|��|�dt|��Pn(|s�|�dt|��d}|�d	t|��|�|�q4W|�d
|f�t�|j	�q*WdS)a	Search the text for matching lines.

        The argument is a list of lines which have to match and can
        use glob wildcards.  If they do not match an pytest.fail() is
        called.  The matches and non-matches are also printed on
        stdout.

        NTFrzexact match:zfnmatch:z   with:znomatch:z    and:zremains unmatched: %r)
rwr�r�rxr�rr<rrOry)r)rSrRZnextlineZ
extralinesr�r5ZnomatchprintedrrrrsSs.	



zLineMatcher.fnmatch_linesN)
rVrWrXr�rsrGrwrzr{rx�propertyryrsrrrrr�s	
)-r�rMrJrrj�rerrIr*r.rZ
py.builtinrZ
_pytest._coderr.rZ_pytest.mainrrZ_pytest.assertion.rewriterrr&�objectr!rkrfZfixturerprrrqr|r}rtr�r�r��compiler�r�r�ror�r�rrrr�<module>sb?

.