B

�A�[�L�@s�
dd
lm
Z
mZ
ddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZ
ddlm
Z
mZmZmZmZ
ddlmZmZmZ
er�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�CalledProcessErrorc

Cs|�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


rc
s:
|�d
�
�dd�t
��
D�
}
dd�t
��
D�
}dd�t
��
D�
}dd�}dd	�}t�f
d
d�|
D�
�
}tt|
|��
}t�f
dd�|D�
�
}tt||��
}	t�f
dd�|D�
�
}
tt||
��
}g}xntt��
�
D]^}
|
|
kr�|�||
�

q�|
|k�
r|�|	|
�

q�|
|k�
r|�||
�

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
c
Ssg|]\}
}|�d�
r|
�qS)
zfrom __future__ import )
r)�.0�
i�linerrr�
<listcomp>*s
z&order_future_lines.<locals>.<listcomp>c
Ss(g|] \}
}|�d�
s |�d
�
r|
�qS)zfrom futurez	from past)
r)rrrrrrr-s


c
Ssg|]\}
}|�d�
r|
�qS)
z
from builtins)
r)rrrrrrr1s
c

Sst|�
d
krt
|�
Sd
S)Nr
)�len�max)
�numbersrrr�mymax7s
z!order_future_lines.<locals>.mymaxc

Sst|�
d
krt
|�
Std�
S)Nr
�inf)r�min�float)
rrrr�mymin:s
z!order_future_lines.<locals>.myminc
sg|]}
�|
�qSrr)rr)
�linesrrrCsc
sg|]}
�|
�qSrr)rr)
r rrrFsc
sg|]}
�|
�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"eZ
dZd
Zddd�
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__`s



z"VerboseCalledProcessError.__init__c

Csd
|j|j
|j|jfS)Nz>Command '%s' failed with exit status %d
Message: %s
Output: %s)r-r,r+r.)
r/rrr�__str__fs

z!VerboseCalledProcessError.__str__)
N)�__name__�
__module__�__qualname__�__doc__r0r1rrrrr*[s

r*c
@seZ
dZd
S)�
FuturizeErrorN)r2r3r4rrrrr6js
r6c
@seZ
dZd
S)�PasteurizeErrorN)r2r3r4rrrrr7ms
r7c@steZ
dZd
Zdd�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.
    c
Csjtd
�
|_
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 *
        Z
PYTHONPATHN)r�headers1�headers2�sys�
executable�interpreters�tempfileZmkdtemp�os�path�sep�tempdir�getenv�getcwd�pathsep�env)r/Zpypathrrr�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)r/rrJrKrLZreformat�runrMr.rN�
_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)r/r.�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()r/rr.rrrrrV�s










z CodeHandler.strip_future_importsc	CsP|j|
|||||d
�}	|r0d|kr(|j
n|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.
        )rJrKrLrSrMrI�)
r\N)rUr:r9r]r)r/Zbeforer[rJrKr\rLrSrMr.Zheadersrrr�
convert_check�s




zCodeHandler.convert_checkcKs|j|
|
f|�

d
S)ze
        Convenience method to ensure the code is unchanged by the
        futurize process.
        N)
r_)r/r�kwargsrrr�	unchanged
szCodeHandler.unchanged�mytestscript.pyc	CsHt|
t
�r|
�d
�
}
tj|j|dd
d��}|�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-8Zwt)
�encodingN)rWrXrY�io�openrB�writer)r/r�filename�
frrrrO
s



zCodeHandler._write_test_scriptc	Cs.tj
|j|
d
dd��}|��}WdQRX|S)NZrtzutf-8)
rc)rdrerB�read)r/rgrhZ	newsourcerrrrQ(
s


zCodeHandler._read_test_scriptcCs
g}t|�
}|r|�
d
�

|r$d}n>d}|dg
kr>|�
d�

n|dg
krT|�
d�

n|rb|�
d�

|j|
}tj|g|d	|g}	yt|	t|jd
�}
Wn�tk
�
r
}
zbt	|�
�*}dd�
|	�
d
|j|d|��f}
WdQRXd|kr�tnt
}||
|j|j|jd��
Wdd}~XYnX|
S)Nz
--all-importsz
pasteurize.pyzfuturize.pyrz--stage1rIz--stage2z--conservativez-w)�stderrrFz8Error running the command %s
%s
Contents of file %s:

%s�
 zenv=%sz----
%s
----Zfuturize)
r.)�listr'rBr;r<r
rrFrrer(rir6r7r,r-r.)r/rgrJrKrLrMZparamsZscript�fn�	call_argsr.�
erhr+Z
ErrorClassrrrrP-
s6
























(
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)rFrjz8Error running the command %s
%s
Contents of file %s:

%srkzenv=%sz----
%s
----r.)
r.)
rBr
rFrrrer(ri�hasattrr.r*r,r-)r/rgrNrmr.rorhr+rrrrRX
s











(
zCodeHandler._run_test_scriptN)rHFFTTF)
T)rHFTFTF)
rb)
rb)rbrHFFF)r2r3r4r5rGrUr]rVr_rarOrQrPr;r<rRrrrrr8qs"
+


"







)
r8z#this test is known to fail on Py2.6c

Csts|St
�|�
S)
N)r�unittest�expectedFailure)
�funcrrr�expectedFailurePY3w
s


rtc

Csts|St
�|�
S)
N)rrqrr)
rsrrr�expectedFailurePY26|
s


ruc

Csts|St
�|�
S)
N)r	rqrr)
rsrrr�expectedFailurePY27�
s


rvc

Csts|St
�|�
S)
N)rrqrr)
rsrrr�expectedFailurePY2�
s


rw�assertRaisesRegexcCsHt|t
tf�rt�|�
}|�|
�
sD|p(d
}d||j|
f}|�|�
�
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&eZ
dZddd�
Zdd�Zdd�Zd
S)	�_AssertRaisesBaseContextNcCsp|
|_||_
|dk	rBy|j|_WqHtk
r>


t|�
|_YqHXnd|_t|ttf�r`t�	|�
}||_
d|_dS)
N)r[�	test_caser2�obj_name�AttributeErrorryrWrXrzr{r�r+)r/r[r��callable_objr�rrrr0�
s










z!_AssertRaisesBaseContext.__init__cCs |j�
|j|
�}|j�|�
�
dS)
N)r�Z_formatMessager+r~)r/ZstandardMsgr+rrr�
_raiseFailure�
s

z&_AssertRaisesBaseContext._raiseFailurec	Cs8|d
kr|�dd
�|_
|S|�
|||�

Wd
QRXd
S)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 eZ
dZd
Zdd�Zdd�ZdS)�_AssertWarnsContextzBA context manager used to implement TestCase.assertWarns* methods.c
CsRx$tj
��D]}
t|
d
d�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[)r/�
vrrrr��
s






z_AssertWarnsContext.__enter__cCs
|j�
|
||�
|
dk	rdSy|jj}Wntk
rF


t|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[r2r�ryr��messagerWr�r|Zwarningrg�linenor��formatr}r�)r/�exc_type�	exc_value�tbZexc_nameZfirst_matching�
m�
wrrrr��
s8

























z_AssertWarnsContext.__exit__N)r2r3r4r5r�r�rrrrr��
s
r�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�)r/Zexpected_warningr�r�r`�contextrrrr��
s
r�)
N)
N),Z
__future__rrr?r>rqr;rzr�rd�textwraprZfuture.utilsrrrrr	Zfuture.moves.subprocessr
rrZ	unittest2rr)r*r6r7ZTestCaser8ZskipIfZskip26rtrurvrwrpZassertRaisesRegexprxr��objectr�r�r�rrrr�<module>
sF









	@



"1