AlkantarClanX12

Your IP : 18.227.52.248

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

B

�A�[�L�@s�ddlmZmZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZddlm
Z
mZmZmZmZddlmZmZmZer�ddlZdd�Zdd	�ZGd
d�de�ZGdd
�d
e�ZGdd�de�ZGdd�dej�Ze�ed�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|�d�r|dd�}t|�S)z,
    Removes any leading 
 and dedents.
    �
�N)�
startswithr)�code�r�B/opt/alt/python37/lib/python3.7/site-packages/future/tests/base.py�
reformat_codes
rcsh|�d��dd�t��D�}dd�t��D�}dd�t��D�}|��|ksTtd��dd�}d	d
�}||�||�ks|td��t�fdd�|D��}tt||��}t�fd
d�|D��}tt||��}	t�fdd�|D��}
tt||
��}g}xptt���D]`}
|
|k�r|�	||
�q�|
|k�r2|�	|	|
�q�|
|k�rL|�	||
�q�|�	�|
�q�Wd�
|�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|]\}}|�d�r|�qS)zfrom __future__ import )r)�.0�i�linerrr�
<listcomp>*sz&order_future_lines.<locals>.<listcomp>cSs(g|] \}}|�d�s |�d�r|�qS)zfrom futurez	from past)r)rrrrrrr-s
cSsg|]\}}|�d�r|�qS)z
from builtins)r)rrrrrrr1szIinternal usage error: dedent the code before calling order_future_lines()cSst|�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>.myminz2the __future__ and future imports are out of ordercsg|]}�|�qSrr)rr)�linesrrrCscsg|]}�|�qSrr)rr)r rrrFscsg|]}�|�qSrr)rr)r rrrIs)�split�	enumerate�lstrip�AssertionError�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_liness2



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/r0rrr�__init__`sz"VerboseCalledProcessError.__init__cCsd|j|j|j|jfS)Nz>Command '%s' failed with exit status %d
Message: %s
Output: %s)r/r.r-r0)r1rrr�__str__fsz!VerboseCalledProcessError.__str__)N)�__name__�
__module__�__qualname__�__doc__r2r3rrrrr,[s
r,c@seZdZdS)�
FuturizeErrorN)r4r5r6rrrrr8jsr8c@seZdZdS)�PasteurizeErrorN)r4r5r6rrrrr9msr9c@steZdZdZdd�Zddd�Zdd	d
�Zdd�Zdd
d�Zdd�Z	ddd�Z
ddd�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|_t��tj	j
|_t�d�}|rXdt�
�tj|i|_ndt�
�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�tempfile�mkdtemp�os�path�sep�tempdir�getenv�getcwd�pathsep�env)r1Zpypathrrr�setUpvs

zCodeHandler.setUp�r�FTcCsT|rt|�}|�|�|j||||d�|��}|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)r1rrNrOrPZreformat�runrQr0rR�_rrr�convert�s

zCodeHandler.convertcCsp|r|�|�}|�|�}t|t�r6t|t�s6|�d�}t|t�rTt|t�sT|�d�}|�t|���|���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)r1r0�expected�ignore_importsrrr�compare�s



zCodeHandler.comparecCsdg}xT|�d�D]F}|�d�s|�d�s|�d�sd|ksd|ks|�d�s|�|�qWd�|�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*)r1rr0rrrrrZ�s



z CodeHandler.strip_future_importsc	CsP|j||||||d�}	|r0d|kr(|jn|j}
nd}
|j|	|
t|�|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.
        )rNrOrPrWrQrM�)r`N)rYr=r<rar)r1�beforer_rNrOr`rPrWrQr0�headersrrr�
convert_check�s
zCodeHandler.convert_checkcKs|j||f|�dS)ze
        Convenience method to ensure the code is unchanged by the
        futurize process.
        N)re)r1r�kwargsrrr�	unchangedszCodeHandler.unchanged�mytestscript.pyc	CsHt|t�r|�d�}tj|j|ddd��}|�t|��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-8�wt)�encodingN)r[r\r]�io�openrF�writer)r1r�filename�frrrrSs

zCodeHandler._write_test_scriptc	Cs.tj|j|ddd��}|��}WdQRX|S)N�rtzutf-8)rj)rkrlrF�read)r1rnroZ	newsourcerrrrU(szCodeHandler._read_test_scriptcCs.g}t|�}|r|�d�|r$d}nNd}|dgkr>|�d�n&|dgkrT|�d�n|ddgksdt�|rr|�d�|j|}tj|g|d	|g}	yt|	t|jd
�}
Wn�t	k
�r(}zbt
|��*}dd�|	�d
|j|d|��f}
WdQRXd|kr�t
nt}||
|j|j|jd��Wdd}~XYnX|
S)Nz
--all-importsz
pasteurize.pyzfuturize.pyrz--stage1rMz--stage2z--conservativez-w)�stderrrJz8Error running the command %s
%s
Contents of file %s:

%s� zenv=%sz----
%s
----Zfuturize)r0)�listr)r$rFr>r?r
rrJrrlr*rqr8r9r.r/r0)r1rnrNrOrPrQ�params�script�fn�	call_argsr0�eror-Z
ErrorClassrrrrT-s8





(z!CodeHandler._futurize_test_scriptcCs�|j|}yt||g|jtd�}Wn�tk
r�}zft|��.}dd�||g�d|j|d|��f}WdQRXt|d�s�d|_	t
||j|j|j	d��Wdd}~XYnX|S)N)rJrrz8Error running the command %s
%s
Contents of file %s:

%srszenv=%sz----
%s
----r0)r0)
rFr
rJrrrlr*rq�hasattrr0r,r.r/)r1rnrRrwr0ryror-rrrrVXs


(zCodeHandler._run_test_scriptN)rLFFTTF)T)rLFTFTF)rh)rh)rhrLFFF)r4r5r6r7rKrYrarZrergrSrUrTr>r?rVrrrrr:qs"+

"



)r:z#this test is known to fail on Py2.6cCsts|St�|�S)N)r�unittest�expectedFailure)�funcrrr�expectedFailurePY3wsr~cCsts|St�|�S)N)rr{r|)r}rrr�expectedFailurePY26|srcCsts|St�|�S)N)r	r{r|)r}rrr�expectedFailurePY27�sr�cCsts|St�|�S)N)rr{r|)r}rrr�expectedFailurePY2�sr��assertRaisesRegexcCsTt|ttf�r$|std��t�|�}|�|�sP|p4d}d||j|f}|�|��dS)z=Fail the test unless the text matches the regular expression.z!expected_regex must not be empty.zRegex didn't matchz%s: %r not found in %rN)	r[�str�unicoder$�re�compile�search�pattern�failureException)r1�text�expected_regexr-rrr�assertRegex�s

r�c@s&eZdZddd�Zdd�Zdd�ZdS)	�_AssertRaisesBaseContextNcCsp||_||_|dk	rBy|j|_WqHtk
r>t|�|_YqHXnd|_t|ttf�r`t�	|�}||_
d|_dS)N)r_�	test_caser4�obj_name�AttributeErrorr�r[r\r�r�r�r-)r1r_r��callable_objr�rrrr2�s
z!_AssertRaisesBaseContext.__init__cCs |j�|j|�}|j�|��dS)N)r�Z_formatMessager-r�)r1ZstandardMsgr-rrr�
_raiseFailure�sz&_AssertRaisesBaseContext._raiseFailurec	Cs8|dkr|�dd�|_|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-)r1�namer��argsrfrrr�handle�s
z_AssertRaisesBaseContext.handle)NN)r4r5r6r2r�r�rrrrr��s
r�c@s eZdZdZdd�Zdd�ZdS)�_AssertWarnsContextzBA context manager used to implement TestCase.assertWarns* methods.cCsRx$tj��D]}t|dd�ri|_qWtjdd�|_|j��|_t�	d|j
�|S)N�__warningregistry__T)�record�always)r>�modules�values�getattrr��warnings�catch_warnings�warnings_manager�	__enter__�simplefilterr_)r1�vrrrr��s
z_AssertWarnsContext.__enter__cCs|j�|||�|dk	rdSy|jj}Wntk
rFt|j�}YnXd}xb|jD]X}|j}t||j�slqT|dkrx|}|j	dk	r�|j	�
t|��s�qT||_|j|_|j
|_
dSW|dk	r�|�d�|j	jt|���|jr�|�d�||j��n|�d�|��dS)Nz"{}" does not match "{}"z{} not triggered by {}z{} not triggered)r��__exit__r_r4r�r�r��messager[r�r��warningrn�linenor��formatr�r�)r1�exc_type�	exc_value�tbZexc_nameZfirst_matching�m�wrrrr��s8

z_AssertWarnsContext.__exit__N)r4r5r6r7r�r�rrrrr��sr�cOst|||�}|�d|||�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�)r1Zexpected_warningr�r�rf�contextrrrr��sr�)N)N),�
__future__rrrCrAr{r>r�r�rk�textwraprZfuture.utilsrrrrr	Zfuture.moves.subprocessr
rrZ	unittest2rr+r,r8r9ZTestCaser:ZskipIfZskip26r~rr�r�rzZassertRaisesRegexpr�r��objectr�r�r�rrrr�<module>sF	@

"1