????
Your IP : 18.116.60.124
3
�c�M � @ s� d dl mZmZ d dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
m Z d dl m
Z
mZmZmZmZ d dlmZmZmZ er�d dlZdd� Zdd � ZG d
d � d e�ZG d d
� d
e�ZG dd� de�ZG dd� dej �Z ej ed�Z dd� Z dd� Z!dd� Z"dd� Z#e$ej d��s(ej j%ej _&d$d d �Z'e$ej d ��sNe
ej d e'� G d d � d e(�Z)G d d!� d!e)�Z*d%d"d#�Z+e$ej d#��s�e
ej d#e+� dS )&� )�print_function�absolute_importN)�dedent)� bind_method�PY26�PY3�PY2�PY27)� check_output�STDOUT�CalledProcessErrorc C s | j d�r| dd� } t| �S )z,
Removes any leading
and dedents.
�
� N)�
startswithr )�code� r �/usr/lib/python3.6/base.py�
reformat_code s
r c sh | j d�� dd� t� �D �}dd� t� �D �}dd� t� �D �}| j� | 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| j ||
� q�|
|k�r2| j | |
� q�|
|k�rL| j | |
� q�| j � |
� q�W dj
| �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 S s g | ]\}}|j d �r|�qS )zfrom __future__ import )r )�.0�i�liner r r �
<listcomp>* s z&order_future_lines.<locals>.<listcomp>c S s( g | ] \}}|j d �s |j d�r|�qS )z from futurez from past)r )r r r r r r r - s
c S s g | ]\}}|j d �r|�qS )z
from builtins)r )r r r r r r r 1 s zIinternal usage error: dedent the code before calling order_future_lines()c S s t | �dkrt| �S dS )Nr )�len�max)�numbersr r r �mymax7 s z!order_future_lines.<locals>.mymaxc S s t | �dkrt| �S td�S )Nr �inf)r �min�float)r r r r �mymin: s z!order_future_lines.<locals>.myminz2the __future__ and future imports are out of orderc s g | ] }� | �qS r r )r r )�linesr r r C s c s g | ] }� | �qS r r )r r )r r r r F s c s g | ] }� | �qS r r )r r )r r r r I s ) �split� enumerate�lstrip�AssertionError�sorted�dict�zip�ranger �append�join)r Zuufuture_line_numbersZfuture_line_numbersZbuiltins_line_numbersr r ZuulZsorted_uufuture_linesZflZsorted_future_linesZblZsorted_builtins_linesZ new_linesr r )r r �order_future_lines s2
r+ c @ s" e Zd ZdZddd�Zdd� ZdS )�VerboseCalledProcessErrorz�
Like CalledProcessError, but it displays more information (message and
script output) for diagnosing test failures etc.
Nc C s || _ || _|| _|| _d S )N)�msg�
returncode�cmd�output)�selfr- r. r/ r0 r r r �__init__` s z"VerboseCalledProcessError.__init__c C s d| j | j| j| jf S )Nz>Command '%s' failed with exit status %d
Message: %s
Output: %s)r/ r. r- r0 )r1 r r r �__str__f s z!VerboseCalledProcessError.__str__)N)�__name__�
__module__� __qualname__�__doc__r2 r3 r r r r r, [ s
r, c @ s e Zd ZdS )�
FuturizeErrorN)r4 r5 r6 r r r r r8 j s r8 c @ s e Zd ZdS )�PasteurizeErrorN)r4 r5 r6 r r r r r9 m s r9 c @ st e Zd ZdZdd� Zd dd �Zd d
d �Zd d
� Zd dd�Zdd� Z d!dd�Z
d"dd�Z d$dd�Z de
jfdd�ZdS )%� CodeHandlerzt
Handy mixin for test classes for writing / reading / futurizing /
running .py files in the test suite.
c C sj t d�| _t d�| _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)r1 Zpypathr r r �setUpv s
zCodeHandler.setUpr � FTc C sT |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) r1 r rL rM rN Zreformat�runrO r0 rP �_r r r �convert� s
zCodeHandler.convertc C st |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�decodeZ assertEqualr+ �rstrip)r1 r0 �expected�ignore_importsr r r �compare� s
zCodeHandler.comparec C sd g }xT|j d�D ]F}|jd�pJ|jd�pJ|jd�pJd|kpJd|kpJ|jd�s|j|� qW dj|�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! r r) r* )r1 r r0 r r r r rX � s
z CodeHandler.strip_future_importsc C s` | 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.
)rL rM rN rU rO rK � )r^ N)rW r= r< r r_ ) r1 Zbeforer] rL rM r^ rN rU rO r0 ZheadersZ reformattedr r r �
convert_check� s
zCodeHandler.convert_checkc K s | j ||f|� dS )ze
Convenience method to ensure the code is unchanged by the
futurize process.
N)ra )r1 r �kwargsr r r � unchanged s zCodeHandler.unchanged�mytestscript.pyc
C sH t |t�r|jd�}tj| j| ddd��}|jt|�� W dQ R X dS )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)rY rZ r[ �io�openrE �writer )r1 r �filename�fr r r rQ ! s
z CodeHandler._write_test_scriptc C s. t j| j| ddd��}|j� }W d Q R X |S )NZrtzutf-8)re )rf rg rE �read)r1 ri rj Z newsourcer r r rS , s z CodeHandler._read_test_scriptc C s@ g }t |�}|r|jd� |r$d}nNd}|dgkr>|jd� n&|dgkrT|jd� n|ddgksdt�|rr|jd� | j| }tj|g| d |g } yt| t| jd
�}
W n� t k
�r: } zvt
|��*} d d j | �d
| j |d| j � f }
W d Q R X d|kr�t
nt}t| d��sd | _||
| j| j| jd��W Y d d } ~ X nX |
S )Nz
--all-importsz
pasteurize.pyz futurize.pyr z--stage1rK z--stage2z--conservativez-w)�stderrrI z8Error running the command %s
%s
Contents of file %s:
%s� zenv=%sz ----
%s
----Zfuturizer0 )r0 )�listr) r$ rE r> r? r
r rI r rg r* rk r8 r9 �hasattrr0 r. r/ )r1 ri rL rM rN rO ZparamsZscript�fn� call_argsr0 �erj r- Z
ErrorClassr r r rR 1 s<
(z!CodeHandler._futurize_test_scriptc C s� | j | }yt||g| jtd�}W n� tk
r� } zht|��.}ddj||g�d| j |d|j� f }W d Q R X t|d�s�d |_ t
||j |j |j d��W Y d d }~X nX |S )N)rI rl z8Error running the command %s
%s
Contents of file %s:
%srm zenv=%sz ----
%s
----r0 )r0 )
rE r
rI r r rg r* rk ro r0 r, r. r/ )r1 ri rP rp r0 rr rj r- r r r rT ` s
(z CodeHandler._run_test_scriptN�r rK )rs FFTTF)T�r rK )rt FTFTF)rd )rd �r rK )rd ru FFF)r4 r5 r6 r7 rJ rW r_ rX ra rc rQ rS rR r> r? rT r r r r r: q s" +
"
!
-r: z#this test is known to fail on Py2.6c C s t s| S tj| �S )N)r �unittest�expectedFailure)�funcr r r �expectedFailurePY3 s ry c C s t s| S tj| �S )N)r rv rw )rx r r r �expectedFailurePY26� s rz c C s t s| S tj| �S )N)r rv rw )rx r r r �expectedFailurePY27� s r{ c C s t s| S tj| �S )N)r rv rw )rx r r r �expectedFailurePY2� s r| �assertRaisesRegexc C sT t |ttf�r$|std��tj|�}|j|�sP|p4d}d||j|f }| j|��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) rY �strZunicoder$ �re�compile�search�pattern�failureException)r1 �text�expected_regexr- r r r � assertRegex� s
r� c @ s& e Zd Zddd�Zdd� Zdd� ZdS ) �_AssertRaisesBaseContextNc C sp || _ || _|d k rBy |j| _W qH tk
r> t|�| _Y qHX nd | _t|ttf�r`tj |�}|| _
d | _ d S )N) r] � test_caser4 �obj_name�AttributeErrorr~ rY rZ r r� r� r- )r1 r] r� � callable_objr� r r r r2 � s
z!_AssertRaisesBaseContext.__init__c C s | j j| j|�}| j j|��d S )N)r� Z_formatMessager- r� )r1 Z standardMsgr- r r r �
_raiseFailure� s z&_AssertRaisesBaseContext._raiseFailurec
C s8 |dkr|j dd�| _| S | � |||� W dQ R X dS )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� �argsrb r r r �handle� s
z _AssertRaisesBaseContext.handle)NN)r4 r5 r6 r2 r� r� r r r r r� � s
r� c @ s e Zd ZdZdd� Zdd� ZdS )�_AssertWarnsContextzBA context manager used to implement TestCase.assertWarns* methods.c C sR x$t jj� D ]}t|dd �r i |_q W tjdd�| _| jj� | _tj d| j
� | S )N�__warningregistry__T)�record�always) r> �modules�values�getattrr� �warnings�catch_warnings�warnings_manager� __enter__� simplefilterr] )r1 �vr r r r� � s
z _AssertWarnsContext.__enter__c
C s | j j|||� |d k r d S y | jj}W n tk
rF t| j�}Y nX d }xd| jD ]Z}|j}t|| j�slqT|d krx|}| j d k r�| j j
t|�� r�qT|| _ |j | _ |j
| _
d S W |d k r�| jdj| j jt|��� | jr�| jdj|| j�� n| jdj|�� d S )Nz"{}" does not match "{}"z{} not triggered by {}z{} not triggered)r� �__exit__r] r4 r� r~ r� �messagerY r� r� Zwarningri �linenor� �formatr� r� )r1 �exc_type� exc_value�tbZexc_nameZfirst_matching�m�wr r r r� � s8
z _AssertWarnsContext.__exit__N)r4 r5 r6 r7 r� r� r r r r r� � s r� c O s t || |�}|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� )r1 Zexpected_warningr� r� rb �contextr r r r� � s r� )N)N),Z
__future__r r rB rA rv r> r r� rf �textwrapr Z future.utilsr r r r r Zfuture.moves.subprocessr
r r Z unittest2r r+ r, r8 r9 ZTestCaser: ZskipIfZskip26ry rz r{ r| ro ZassertRaisesRegexpr} r� �objectr� r� r� r r r r �<module> sF @
"1