????

Your IP : 3.138.175.132

Current Path : /usr/lib/python3.6/site-packages/future/tests/__pycache__/
Upload File :
Current File : //usr/lib/python3.6/site-packages/future/tests/__pycache__/base.cpython-36.opt-1.pyc

3

�c�M�@s�ddlmZmZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZddlm
Z
mZmZmZmZddlmZmZmZer�ddlZdd�Zdd	�ZGd
d�de�ZGdd
�d
e�ZGdd�de�ZGdd�dej�Zejed�Zdd�Z dd�Z!dd�Z"dd�Z#e$ejd��s(ejj%ej_&d$dd�Z'e$ejd��sNe
ejde'�Gdd�de(�Z)Gd d!�d!e)�Z*d%d"d#�Z+e$ejd#��s�e
ejd#e+�dS)&�)�print_function�absolute_importN)�dedent)�bind_method�PY26�PY3�PY2�PY27)�check_output�STDOUT�CalledProcessErrorcCs|jd�r|dd�}t|�S)z,
    Removes any leading 
 and dedents.
    �
�N)�
startswithr)�code�r�/usr/lib/python3.6/base.py�
reformat_codes
rcs:|jd��dd�t��D�}dd�t��D�}dd�t��D�}dd�}dd	�}t�fd
d�|D��}tt||��}t�fdd�|D��}tt||��}	t�fdd�|D��}
tt||
��}g}xntt���D]^}
|
|kr�|j||
�q�|
|k�r|j|	|
�q�|
|k�r|j||
�q�|j�|
�q�Wdj|�S)
a
    Returns the code block with any ``__future__`` import lines sorted, and
    then any ``future`` import lines sorted, then any ``builtins`` import lines
    sorted.

    This only sorts the lines within the expected blocks.

    See test_order_future_lines() for an example.
    r
cSsg|]\}}|jd�r|�qS)zfrom __future__ import )r)�.0�i�linerrr�
<listcomp>*sz&order_future_lines.<locals>.<listcomp>cSs(g|] \}}|jd�s |jd�r|�qS)zfrom futurez	from past)r)rrrrrrr-s
cSsg|]\}}|jd�r|�qS)z
from builtins)r)rrrrrrr1scSst|�dkrt|�SdS)Nr)�len�max)�numbersrrr�mymax7sz!order_future_lines.<locals>.mymaxcSst|�dkrt|�Std�S)Nr�inf)r�min�float)rrrr�mymin:sz!order_future_lines.<locals>.mymincsg|]}�|�qSrr)rr)�linesrrrCscsg|]}�|�qSrr)rr)r rrrFscsg|]}�|�qSrr)rr)r rrrIs)	�split�	enumerate�sorted�dict�zip�ranger�append�join)rZuufuture_line_numbersZfuture_line_numbersZbuiltins_line_numbersrrZuulZsorted_uufuture_linesZflZsorted_future_linesZblZsorted_builtins_linesZ	new_linesrr)r r�order_future_liness,
	

r)c@s"eZdZdZddd�Zdd�ZdS)�VerboseCalledProcessErrorz�
    Like CalledProcessError, but it displays more information (message and
    script output) for diagnosing test failures etc.
    NcCs||_||_||_||_dS)N)�msg�
returncode�cmd�output)�selfr+r,r-r.rrr�__init__`sz"VerboseCalledProcessError.__init__cCsd|j|j|j|jfS)Nz>Command '%s' failed with exit status %d
Message: %s
Output: %s)r-r,r+r.)r/rrr�__str__fsz!VerboseCalledProcessError.__str__)N)�__name__�
__module__�__qualname__�__doc__r0r1rrrrr*[s
r*c@seZdZdS)�
FuturizeErrorN)r2r3r4rrrrr6jsr6c@seZdZdS)�PasteurizeErrorN)r2r3r4rrrrr7msr7c@steZdZdZdd�Zddd	�Zdd
d�Zdd
�Zd dd�Zdd�Z	d!dd�Z
d"dd�Zd$dd�Zde
jfdd�ZdS)%�CodeHandlerzt
    Handy mixin for test classes for writing / reading / futurizing /
    running .py files in the test suite.
    cCsjtd�|_td�|_tjg|_tj�tj	j
|_tjd�}|rXdtj
�tj|i|_ndtj
�i|_dS)zi
        The outputs from the various futurize stages should have the
        following headers:
        z�
        from __future__ import absolute_import
        from __future__ import division
        from __future__ import print_function
        a4
        from __future__ import absolute_import
        from __future__ import division
        from __future__ import print_function
        from __future__ import unicode_literals
        from future import standard_library
        standard_library.install_aliases()
        from builtins import *
        �
PYTHONPATHN)r�headers1�headers2�sys�
executable�interpreters�tempfileZmkdtemp�os�path�sep�tempdir�getenv�getcwd�pathsep�env)r/Zpypathrrr�setUpvs

zCodeHandler.setUpr�FTcCsT|rt|�}|j|�|j||||d�|j�}|rPx|jD]}	|j|	d�}
q<W|S)a�
        Converts the code block using ``futurize`` and returns the
        resulting code.

        Passing stages=[1] or stages=[2] passes the flag ``--stage1`` or
        ``stage2`` to ``futurize``. Passing both stages runs ``futurize``
        with both stages by default.

        If from3 is False, runs ``futurize``, converting from Python 2 to
        both 2 and 3. If from3 is True, runs ``pasteurize`` to convert
        from Python 3 to both 2 and 3.

        Optionally reformats the code block first using the reformat() function.

        If run is True, runs the resulting code under all Python
        interpreters in self.interpreters.
        )�stages�all_imports�from3�conservative)�interpreter)r�_write_test_script�_futurize_test_script�_read_test_scriptr>�_run_test_script)r/rrJrKrLZreformat�runrMr.rN�_rrr�convert�s

zCodeHandler.convertcCst|r|j|�}|j|�}t|t�r8t|t�r8|jd�}t|t�rXt|t�rX|jd�}|jt|j��|j��dS)a�
        Compares whether the code blocks are equal. If not, raises an
        exception so the test fails. Ignores any trailing whitespace like
        blank lines.

        If ignore_imports is True, passes the code blocks into the
        strip_future_imports method.

        If one code block is a unicode string and the other a
        byte-string, it assumes the byte-string is encoded as utf-8.
        zutf-8N)�strip_future_imports�
isinstance�bytes�decodeZassertEqualr)�rstrip)r/r.�expected�ignore_importsrrr�compare�s



zCodeHandler.comparecCsdg}xT|jd�D]F}|jd�pJ|jd�pJ|jd�pJd|kpJd|kpJ|jd�s|j|�qWdj|�S)a
        Strips any of these import lines:

            from __future__ import <anything>
            from future <anything>
            from future.<anything>
            from builtins <anything>

        or any line containing:
            install_hooks()
        or:
            install_aliases()

        Limitation: doesn't handle imports split across multiple lines like
        this:

            from __future__ import (absolute_import, division, print_function,
                                    unicode_literals)
        r
zfrom __future__ import zfrom future zfrom builtins zinstall_hooks()zinstall_aliases()zfrom future.)r!rr'r()r/rr.rrrrrV�s



z CodeHandler.strip_future_importsc	Cs`|j||||||d�}	|r0d|kr(|jn|j}
nd}
t|�}|
|krHd}
|j|	|
||d�dS)a<
        Convenience method that calls convert() and compare().

        Reformats the code blocks automatically using the reformat_code()
        function.

        If all_imports is passed, we add the appropriate import headers
        for the stage(s) selected to the ``expected`` code-block, so they
        needn't appear repeatedly in the test code.

        If ignore_imports is True, ignores the presence of any lines
        beginning:

            from __future__ import ...
            from future import ...

        for the purpose of the comparison.
        )rJrKrLrSrMrI�)r\N)rUr;r:rr])r/Zbeforer[rJrKr\rLrSrMr.ZheadersZreformattedrrr�
convert_check�s
zCodeHandler.convert_checkcKs|j||f|�dS)ze
        Convenience method to ensure the code is unchanged by the
        futurize process.
        N)r_)r/r�kwargsrrr�	unchangedszCodeHandler.unchanged�mytestscript.pyc
CsHt|t�r|jd�}tj|j|ddd��}|jt|��WdQRXdS)z�
        Dedents the given code (a multiline string) and writes it out to
        a file in a temporary folder like /tmp/tmpUDCn7x/mytestscript.py.
        zutf-8Zwt)�encodingN)rWrXrY�io�openrC�writer)r/r�filename�frrrrO!s

zCodeHandler._write_test_scriptc	Cs.tj|j|ddd��}|j�}WdQRX|S)NZrtzutf-8)rc)rdrerC�read)r/rgrhZ	newsourcerrrrQ,szCodeHandler._read_test_scriptcCs0g}t|�}|r|jd�|r$d}n>d}|dgkr>|jd�n|dgkrT|jd�n|rb|jd�|j|}tj|g|d	|g}	yt|	t|jd
�}
Wn�tk
�r*}zvt	|��*}ddj
|	�d
|j|d|j�f}
WdQRXd|kr�tnt
}t|d��sd|_||
|j|j|jd��WYdd}~XnX|
S)Nz
--all-importsz
pasteurize.pyzfuturize.pyrz--stage1rIz--stage2z--conservativez-w)�stderrrGz8Error running the command %s
%s
Contents of file %s:

%s� zenv=%sz----
%s
----Zfuturizer.)r.)�listr'rCr<r=r
rrGrrer(rir6r7�hasattrr.r,r-)r/rgrJrKrLrMZparamsZscript�fn�	call_argsr.�erhr+Z
ErrorClassrrrrP1s:





(z!CodeHandler._futurize_test_scriptcCs�|j|}yt||g|jtd�}Wn�tk
r�}zht|��.}ddj||g�d|j|d|j�f}WdQRXt|d�s�d|_	t
||j|j|j	d��WYdd}~XnX|S)N)rGrjz8Error running the command %s
%s
Contents of file %s:

%srkzenv=%sz----
%s
----r.)r.)
rCr
rGrrrer(rirmr.r*r,r-)r/rgrNrnr.rprhr+rrrrR`s


(zCodeHandler._run_test_scriptN�rrI)rqFFTTF)T�rrI)rrFTFTF)rb)rb�rrI)rbrsFFF)r2r3r4r5rHrUr]rVr_rarOrQrPr<r=rRrrrrr8qs"+

"
!


-r8z#this test is known to fail on Py2.6cCsts|Stj|�S)N)r�unittest�expectedFailure)�funcrrr�expectedFailurePY3srwcCsts|Stj|�S)N)rrtru)rvrrr�expectedFailurePY26�srxcCsts|Stj|�S)N)r	rtru)rvrrr�expectedFailurePY27�srycCsts|Stj|�S)N)rrtru)rvrrr�expectedFailurePY2�srz�assertRaisesRegexcCsHt|ttf�rtj|�}|j|�sD|p(d}d||j|f}|j|��dS)z=Fail the test unless the text matches the regular expression.zRegex didn't matchz%s: %r not found in %rN)rW�strZunicode�re�compile�search�pattern�failureException)r/�text�expected_regexr+rrr�assertRegex�s

r�c@s&eZdZddd�Zdd�Zdd�ZdS)	�_AssertRaisesBaseContextNcCsp||_||_|dk	rBy|j|_WqHtk
r>t|�|_YqHXnd|_t|ttf�r`tj	|�}||_
d|_dS)N)r[�	test_caser2�obj_name�AttributeErrorr|rWrXr}r~r�r+)r/r[r��callable_objr�rrrr0�s
z!_AssertRaisesBaseContext.__init__cCs |jj|j|�}|jj|��dS)N)r�Z_formatMessager+r�)r/ZstandardMsgr+rrr�
_raiseFailure�sz&_AssertRaisesBaseContext._raiseFailurec
Cs8|dkr|jdd�|_|S|�|||�WdQRXdS)z�
        If callable_obj is None, assertRaises/Warns is being used as a
        context manager, so check for a 'msg' kwarg and return self.
        If callable_obj is not None, call it passing args and kwargs.
        Nr+)�popr+)r/�namer��argsr`rrr�handle�s
z_AssertRaisesBaseContext.handle)NN)r2r3r4r0r�r�rrrrr��s
r�c@s eZdZdZdd�Zdd�ZdS)�_AssertWarnsContextzBA context manager used to implement TestCase.assertWarns* methods.cCsRx$tjj�D]}t|dd�ri|_qWtjdd�|_|jj�|_tj	d|j
�|S)N�__warningregistry__T)�record�always)r<�modules�values�getattrr��warnings�catch_warnings�warnings_manager�	__enter__�simplefilterr[)r/�vrrrr��s
z_AssertWarnsContext.__enter__c
Cs|jj|||�|dk	rdSy|jj}Wntk
rFt|j�}YnXd}xd|jD]Z}|j}t||j�slqT|dkrx|}|j	dk	r�|j	j
t|��r�qT||_|j|_|j
|_
dSW|dk	r�|jdj|j	jt|���|jr�|jdj||j��n|jdj|��dS)Nz"{}" does not match "{}"z{} not triggered by {}z{} not triggered)r��__exit__r[r2r�r|r��messagerWr�rZwarningrg�linenor��formatr�r�)r/�exc_type�	exc_value�tbZexc_nameZfirst_matching�m�wrrrr��s8

z_AssertWarnsContext.__exit__N)r2r3r4r5r�r�rrrrr��sr�cOst|||�}|jd|||�S)a�Fail unless a warning of class warnClass is triggered
       by callable_obj when invoked with arguments args and keyword
       arguments kwargs.  If a different type of warning is
       triggered, it will not be handled: depending on the other
       warning filtering rules in effect, it might be silenced, printed
       out, or raised as an exception.

       If called with callable_obj omitted or None, will return a
       context object used like this::

            with self.assertWarns(SomeWarning):
                do_something()

       An optional keyword argument 'msg' can be provided when assertWarns
       is used as a context object.

       The context manager keeps a reference to the first matching
       warning as the 'warning' attribute; similarly, the 'filename'
       and 'lineno' attributes give you information about the line
       of Python code from which the warning was triggered.
       This allows you to inspect the warning after the assertion::

           with self.assertWarns(SomeWarning) as cm:
               do_something()
           the_warning = cm.warning
           self.assertEqual(the_warning.some_attribute, 147)
    �assertWarns)r�r�)r/Zexpected_warningr�r�r`�contextrrrr��sr�)N)N),Z
__future__rrr@r?rtr<r}r�rd�textwraprZfuture.utilsrrrrr	Zfuture.moves.subprocessr
rrZ	unittest2rr)r*r6r7ZTestCaser8ZskipIfZskip26rwrxryrzrmZassertRaisesRegexpr{r��objectr�r�r�rrrr�<module>sF	@


"1