✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

3

��2a���@s�dd
lZdd
l
Z
dd
lZdd
lZdd
lZdd
lZddlmZ
ddlm	Z	
Gdd�dej
�ZGdd�dej
�ZGdd	�d	ej
�Z
Gd
d�dej
�ZGdd
�d
ej
�ZGdd�dej
�Zedkr�ej�
d
S)�N)
�support)
�assert_python_failurec@s
eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�Z d=d>�Z!d?d@�Z"dAS)B�RoundtripLegalSyntaxTestCasecCsl|
|�
}|j�}yt
j|�
}Wn6t
jk
rT
}
z|jd
||f�

WYdd}~XnX|j||j�d�
dS)Nzcould not roundtrip %r: %sz!could not re-generate syntax tree)�totuple�parser�sequence2st�ParserError�fail�assertEqual)�self�
f�
s�st1�
t�st2Zwhy�r�0/opt/alt/python36/lib64/python3.6/test_parser.py�	roundtrips





$
z&RoundtripLegalSyntaxTestCase.roundtripcCs|jt
j|
�
dS)
N)rr�expr)rr
rrr�
check_exprs
z'RoundtripLegalSyntaxTestCase.check_exprc
Cs6tj
d
�
}
|
j�}i}t|i|�
|j|dt�
dS)Nz/from __future__ import unicode_literals; x = ''�
x)r�suite�compile�execZassertIsInstance�str)rr�codeZscoperrr�test_flags_passed s





z.RoundtripLegalSyntaxTestCase.test_flags_passedcCs|jt
j|
�
dS)
N)rrr)rr
rrr�check_suite)s
z(RoundtripLegalSyntaxTestCase.check_suitec

Cs�|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd	�

|jd
�

|jd�

|jd�

|jd
�

|jd�

|jd�

|jd�

|jd�

dS)Nzdef f(): yield 1zdef f(): yieldzdef f(): x += yieldzdef f(): x = yield 1zdef f(): x = y = yield 1zdef f(): x = yieldzdef f(): x = y = yieldzdef f(): 1 + (yield)*2zdef f(): (yield 1)*2zdef f(): return; yield 1zdef f(): yield 1; returnzdef f(): yield from 1zdef f(): x = yield from 1zdef f(): f((yield from 1))zdef f(): yield 1; return 1z1def f():
    for x in range(30):
        yield x
z)def f():
    if (yield):
        yield x
)
r)
rrrr�test_yield_statement,s"































z1RoundtripLegalSyntaxTestCase.test_yield_statementc

Cs@|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

dS)Nzasync def f():
 await smth()z"async def f():
 foo = await smth()z'async def f():
 foo, bar = await smth()zasync def f():
 (await smth())z#async def f():
 foo((await smth()))z&async def f():
 await foo(); return 42)
r)
rrrr�test_await_statementCs










z1RoundtripLegalSyntaxTestCase.test_await_statementc

Cs|jd
�

|jd�

dS)Nz"async def f():
 async with 1: passz/async def f():
 async with a as b, c as d: pass)
r)
rrrr�test_async_with_statementKs


z6RoundtripLegalSyntaxTestCase.test_async_with_statementc

Cs|jd
�

|jd�

dS)Nz'async def f():
 async for i in (): passz*async def f():
 async for i, b in (): pass)
r)
rrrr�test_async_for_statementOs


z5RoundtripLegalSyntaxTestCase.test_async_for_statementc

Cs|jd
�

|jd�

dS)Nz3def f():
    x = 0
    def g():
        nonlocal x
z:def f():
    x = y = 0
    def g():
        nonlocal x, y
)
r)
rrrr�test_nonlocal_statementSs

z4RoundtripLegalSyntaxTestCase.test_nonlocal_statementc

Cs�
|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd	�

|jd
�

|jd�

|jd�

|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd �

|jd!�

|jd"�

|jd#�

|jd$�

|jd%�

|jd&�

|jd'�

|jd(�

dS))Nzfoo(1)z	[1, 2, 3]z[x**3 for x in range(20)]z"[x**3 for x in range(20) if x % 3]z+[x**3 for x in range(20) if x % 2 if x % 3]zlist(x**3 for x in range(20))z&list(x**3 for x in range(20) if x % 3)z/list(x**3 for x in range(20) if x % 2 if x % 3)z
foo(*args)zfoo(*args, **kw)z	foo(**kw)zfoo(key=value)zfoo(key=value, *args)zfoo(key=value, *args, **kw)zfoo(key=value, **kw)zfoo(a, b, c, *args)zfoo(a, b, c, *args, **kw)zfoo(a, b, c, **kw)zfoo(a, *args, keyword=23)z	foo + barz	foo - barz	foo * barz	foo / barz
foo // barz	lambda: 0zlambda x: 0zlambda *y: 0zlambda *y, **z: 0z
lambda **z: 0zlambda x, y: 0zlambda foo=bar: 0z"lambda foo=bar, spaz=nifty+spit: 0zlambda foo=bar, **z: 0z#lambda foo=bar, blaz=blat+2, **z: 0z'lambda foo=bar, blaz=blat+2, *y, **z: 0zlambda x, *y, **z: 0z(x for x in range(10))zfoo(x for x in range(10))z...za[...])
r)
rrrr�test_expressions]sP














































































z-RoundtripLegalSyntaxTestCase.test_expressionsc

Cs|jd
�

dS)N�
a)
r)
rrrr�test_simple_expression�sz3RoundtripLegalSyntaxTestCase.test_simple_expressionc

Cs|jd
�

|jd�

dS)Nza = bza = b = c = d = e)
r)
rrrr�test_simple_assignments�s


z4RoundtripLegalSyntaxTestCase.test_simple_assignmentsc

JCs�
|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd	�

|jd
�

|j
t�
�
tdii�
WdQRX|j
t�
�
tdii�
WdQRX|j
t�
�
td
ii�
WdQRX|j
t�
�
tdii�
WdQRX|j
t�
�
tdii�
WdQRX|j
t�
�
tdii�
WdQRX|j
t�
�
tdii�
WdQRX|j
t�
�
tdii�
WdQRX|j
t�
�
tdii�
WdQRX|j
t�
�
tdii�
WdQRXdS)Nz
x: int = 5z"y: List[T] = []; z: [list] = fun()zx: tuple = (1, 2)zd[f()]: int = 42zf(d[x]): str = 'abc'zx.y.z.w: complex = 42jzx: intz#def f():
    x: str
    y: int = 5
z#class C:
    x: str
    y: int = 5
zIclass C:
    def __init__(self, x: int) -> None:
        self.x: int = x
z2+2: intz[]: int = 5zx, *y, z: int = range(5)zt: tuple = 1, 2z
u = v: intz
False: intzx.False: intz	x.y,: intz[0]: intzf(): int)r�assertRaises�SyntaxErrorr)
rrrr�test_var_annot�s<




































z+RoundtripLegalSyntaxTestCase.test_var_annotc

Cs||jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd	�

|jd
�

|jd�

|jd�

dS)
Nza += bza -= bza *= bza /= bza //= bza %= bza &= bza |= bza ^= bza <<= bza >>= bza **= b)
r)
rrrr�!test_simple_augmented_assignments�s






















z>RoundtripLegalSyntaxTestCase.test_simple_augmented_assignmentsc

Csl
|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd	�

|jd
�

|jd�

|jd�

|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd �

|jd!�

|jd"�

|jd#�

|jd$�

dS)%Nz
def f(): passzdef f(*args): passzdef f(*args, **kw): passzdef f(**kw): passzdef f(foo=bar): passzdef f(foo=bar, *args): passz!def f(foo=bar, *args, **kw): passzdef f(foo=bar, **kw): passzdef f(a, b): passzdef f(a, b, *args): passzdef f(a, b, *args, **kw): passzdef f(a, b, **kw): passzdef f(a, b, foo=bar): passz!def f(a, b, foo=bar, *args): passz'def f(a, b, foo=bar, *args, **kw): passz def f(a, b, foo=bar, **kw): passz@staticmethod
def f(): passz,@staticmethod
@funcattrs(x, y)
def f(): passz@funcattrs()
def f(): passzdef f(*, a): passzdef f(*, a = 5): passzdef f(*, a = 5, b): passzdef f(*, a, b = 5): passz def f(*, a, b = 5, **kwds): passzdef f(*args, a): passzdef f(*args, a = 5): passzdef f(*args, a = 5, b): passzdef f(*args, a, b = 5): passz$def f(*args, a, b = 5, **kwds): passzdef f(a: int): passzdef f(a: int = 5): passzdef f(*args: list): passzdef f(**kwds: dict): passzdef f(*, a: int): passzdef f(*, a: int = 5): passzdef f() -> int: pass)
r)
rrrr�test_function_defs�sH
































































z/RoundtripLegalSyntaxTestCase.test_function_defsc

Cs6|jd
�

|jd�

|jd�

|jd�

|jd�

dS)Nzclass foo():passzclass foo(object):passz!@class_decorator
class foo():passz&@class_decorator(arg)
class foo():passz(@decorator1
@decorator2
class foo():pass)
r)
rrrr�test_class_defs�s







z,RoundtripLegalSyntaxTestCase.test_class_defsc

Cs�|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd	�

|jd
�

|jd�

|jd�

|jd
�

|jd�

|jd�

|jd�

|jd�

dS)Nzfrom sys.path import *zfrom sys.path import dirnamezfrom sys.path import (dirname)zfrom sys.path import (dirname,)z*from sys.path import dirname as my_dirnamez,from sys.path import (dirname as my_dirname)z-from sys.path import (dirname as my_dirname,)z&from sys.path import dirname, basenamez(from sys.path import (dirname, basename)z)from sys.path import (dirname, basename,)z4from sys.path import dirname as my_dirname, basenamez6from sys.path import (dirname as my_dirname, basename)z7from sys.path import (dirname as my_dirname, basename,)z5from sys.path import dirname, basename as my_basenamez7from sys.path import (dirname, basename as my_basename)z8from sys.path import (dirname, basename as my_basename,)zfrom .bogus import x)
r)
rrrr�test_import_from_statement�s.
































z7RoundtripLegalSyntaxTestCase.test_import_from_statementc

Cs6|jd
�

|jd�

|jd�

|jd�

|jd�

dS)Nz
import syszimport sys as systemzimport sys, mathzimport sys as system, mathzimport sys, math as my_math)
r)
rrrr�test_basic_import_statement
s









z8RoundtripLegalSyntaxTestCase.test_basic_import_statementc

CsT|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

dS)	Nzfrom . import namezfrom .. import namezfrom ... import namezfrom .... import namezfrom .pkg import namezfrom ..pkg import namezfrom ...pkg import namezfrom ....pkg import name)
r)
rrrr�test_relative_imports
s













z2RoundtripLegalSyntaxTestCase.test_relative_importsc

Cs|jd
�

dS)Nz"# -*- coding: iso-8859-1 -*-
pass
)
r)
rrrr�test_pep263+
s
z(RoundtripLegalSyntaxTestCase.test_pep263c

Cs|jd
�

dS)Nzassert alo < ahi and blo < bhi
)
r)
rrrr�test_assert/
s
z(RoundtripLegalSyntaxTestCase.test_assertc

Cs"|jd
�

|jd�

|jd�

dS)Nzwith open('x'): pass
zwith open('x') as f: pass
z*with open('x') as f, open('y') as g: pass
)
r)
rrrr�	test_with2
s




z&RoundtripLegalSyntaxTestCase.test_withc

Cs@|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

dS)Nztry: pass
except: pass
ztry: pass
finally: pass
z'try: pass
except A: pass
finally: pass
z4try: pass
except A: pass
except: pass
finally: pass
z"try: pass
except: pass
else: pass
z0try: pass
except: pass
else: pass
finally: pass
)
r)
rrrr�
test_try_stmt7
s









z*RoundtripLegalSyntaxTestCase.test_try_stmtc
s@
d
}
tj
|
�
}�f
dd��d&d'd(d)d*d+d,d.d/d0d1d2d3d5d7d9g}|jt�|jddd��
�
|�
|jt�|j��
�
dd�|D�
�
|jt�|jdd �
�
�
d!d�|D�
�
|jt�|jdd"�
�
�
d#d�|D�
�
|jt�|jddd��
�
d$d�|D�
�
|jt�tj|ddd��
�
|�
|jt�tj|ddd��
�
d%d�|D�
�
dS):Nzdef f(x):
    return x + 1c
3sX|d
}
|d}t|t
tf�rNx4|dd�D]}x�|�
D]
}|V
q:Wq,Wn|V
dS)Nr
�
)�
isinstance�tuple�list)�treeZ	node_type�nextZeltr)
�walkrrr:G
s





z8RoundtripLegalSyntaxTestCase.test_position.<locals>.walkr4�defr
r���
(�r���
)��
:��	��return��
+�
�
1��T)�	line_info�col_infoc
Ssg|]\}
}}}|
|f�qSrr)�.0r�
n�
l�
crrr�
<listcomp>g
sz>RoundtripLegalSyntaxTestCase.test_position.<locals>.<listcomp>)
rOc
Ssg|]\}
}}}|
||f�qSrr)rQrrRrSrTrrrrUi
s)
rPc
Ssg|]\}
}}}|
||f�qSrr)rQrrRrSrTrrrrUk
sc
Ssg|]}
t|
�
�qSr)
r7)rQrrrrrUm
sc
Ssg|]}
t|
�
�qSr)
r7)rQrrrrrUs
s)r4r;r4r
)r4rr4r<)r=r>r4r?)r4rr4r@)rArBr4r=)rCrDr4rA)r<rEr4rF���)r?rErGrV)r4rHrGr<)r4rrGrC)rIrJrGrK)rGrLrGrM)r<rErGrNrV)r@rErGrVrV)r<rErGrVrV)r
rErGrV)rrr
r7r�tolistZst2tupleZst2list)rr�stZexpectedr)
r:r�
test_positionA
sF

































z*RoundtripLegalSyntaxTestCase.test_positionc

Cs,|jd
�

|jd�

|jd�

|jd�

dS)Nz*a = yz
x, *b, = mz[*a, *b] = yzfor [*x, b] in x: pass)
r)
rrrr�test_extended_unpackingu
s






z4RoundtripLegalSyntaxTestCase.test_extended_unpackingc

Cs"|jd
�

|jd�

|jd�

dS)Nzraise
zraise e
zBtry:
    suite
except Exception as e:
    raise ValueError from e
)
r)
rrrr�test_raise_statement{
s




z1RoundtripLegalSyntaxTestCase.test_raise_statementc

Cs|jd
�

|jd�

dS)Nz[]z[*{2}, 3, *[4]])
r)
rrrr�test_list_displays�
s


z/RoundtripLegalSyntaxTestCase.test_list_displaysc

Cs6|jd
�

|jd�

|jd�

|jd�

|jd�

dS)Nz{*{2}, 3, *[4]}z{2}z{2,}z{2, 3}z{2, 3,})
r)
rrrr�test_set_displays�
s









z.RoundtripLegalSyntaxTestCase.test_set_displaysc

CsJ|jd
�

|jd�

|jd�

|jd�

|jd�

|jd�

|jd�

dS)Nz{}z{a:b}z{a:b,}z
{a:b, c:d}z{a:b, c:d,}z{**{}}z{**{}, 3:4, **{5:6, 7:8}})
r)
rrrr�test_dict_displays�
s












z/RoundtripLegalSyntaxTestCase.test_dict_displaysc

Cs6|jd
�

|jd�

|jd�

|jd�

|jd�

dS)Nz
f(*a, **b)zf(a, *b, *c, *d)zf(**a, **b)zf(2, *a, *b, **b, **c, **d)z0f(*b, *() or () and (), **{} and {}, **() or {}))
r)
rrrr�test_argument_unpacking�
s









z4RoundtripLegalSyntaxTestCase.test_argument_unpackingc

Cs"|jd
�

|jd�

|jd�

dS)Nz{x for x in seq}z{f(x) for x in seq}z#{f(x) for x in seq if condition(x)})
r)
rrrr�test_set_comprehensions�
s




z4RoundtripLegalSyntaxTestCase.test_set_comprehensionsc

Cs"|jd
�

|jd�

|jd�

dS)Nz{x:x for x in seq}z({x**2:x[3] for x in seq if condition(x)}z4{x:x for x in seq1 for y in seq2 if condition(x, y)})
r)
rrrr�test_dict_comprehensions�
s




z5RoundtripLegalSyntaxTestCase.test_dict_comprehensionsN)#�__name__�
__module__�__qualname__rrrrrrr r!r"r#r%r&r)r*r+r,r-r.r/r0r1r2r3rYrZr[r\r]r^r_r`rarrrrrs@	
*'0
4	rc@s\eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�ZdS)�IllegalSyntaxTestCasecCs8ytj
|
�

Wntjk
r$


YnX|jd
|�

dS)Nz"did not detect invalid tree for %r)rrrr	)rr8Zlabelrrr�check_bad_tree�
s




z$IllegalSyntaxTestCase.check_bad_treec

Cs|jdd�
dS)Nr4rG�z<junk>)r4rGrg)
rf)
rrrr�	test_junk�
szIllegalSyntaxTestCase.test_junkc
	CsDd}
|j|
d
�
d"}
|j|
d�
d+}
|j|
d�
d4}
|j|
d�
dS)5N�

�

�
�
�
r4r<rEr
z too small items in terminal node�passz'non-string second item in terminal node�pass�
0z'non-integer third item in terminal nodeztoo many items in terminal node�
r4�rmrq�rlrr�r<rE�rkrsrt�rjru�r<rE�r
rE)rirvrwrx�r4rn�rmry�rlrz�r<rE�rkr{r|�rjr}�r<rE�r
rE)rir~rr��r4rorpr
�rmr��rlr��r<rE�rkr�r��rjr��r<rE�r
rE)rir�r�r��r4ror
r
�rmr��rlr��r<rE�rkr�r��rjr��r<rE�r
rE)rir�r�r�)
rf)rr8rrr�test_illegal_terminal�
sP



































z+IllegalSyntaxTestCase.test_illegal_terminalc
$Csdg}
|j|
d,�
dS)hN�

�
�
�
r4r;r�
r=r>rArBrCrD�#
r<rEr?�	
�

�
�
rH�9
�$
�%
�&
�'
�)
�*
�+
�,
�-
�.
�/
�0
�1
rGrL�
�yieldr@r
zdef f():
  return 1
  yield 1�r4r;�r4r�r=r>�rArB�r�r�r��rCrD�r<rE�r?rE�r4rH�rGrL�r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r�r��r�r��r�r��r4r��rGrL�r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r�r��r�r��r�r��r<rE�r�r�r��r�r��r@rE�r�r�r�r��r�r��r�r�r�r��r�r�r�r�r�r��r<rE�r
rE�r�r�r�r��r�r�)r�r�)
rf)rr8rrr�test_illegal_yield_1�
sf

















































z*IllegalSyntaxTestCase.test_illegal_yield_1c
%Csdy}
|j|
d3�
dS)zN�

�
�	
�

�
r4�from�
�
__future__�import�
�
generatorsr<rE�
�
r;r�
r=r>rArBrCrD�#
r?�
�
rH�9
�$
�%
�&
�'
�)
�*
�+
�,
�-
�.
�/
�0
�1
rGrL�
r�r@r
zdef f():
  return 1
  yield 1�r4r��r4r��r�r
�r4r��r4r��r�r
�r�r
r	
r

r
�r�r

�r<rE�r�r
r
�r�r
�r4r;�r4r�r=r>�rArB�r�r
r
�rCrD�r<rE�r?rE�r4rH�rGrL�r
r
�r
r
�r
r
�r
r
�r

r
�r
r 
�r�r!
�r�r"
�r�r#
�r�r$
�r�r%
�r�r&
�r�r'
�r�r(
�r�r
r)
�r�r*
�r�r+
�r4r��rGrL�r
r.
�r
r/
�r
r0
�r
r1
�r

r2
�r
r3
�r�r4
�r�r5
�r�r6
�r�r7
�r�r8
�r�r9
�r�r:
�r�r;
�r
r-
r<
�r�r=
�r�r>
�r<rE�r�r?
r@
�r�rA
�r@rE�r�r,
rB
rC
�r�rD
�r�r
r
rE
�r�r
r
r
r
rF
�r<rE�r
rE�r�rG
rH
rI
�r�rJ
)r�r
rK
)
rf)rr8rrr�test_illegal_yield_2!sx


























































z*IllegalSyntaxTestCase.test_illegal_yield_2c
Csd:}
|j|
d�
dS);N�
�7
�"
�#
�$
�%
�'
�(
�)
�*
�+
�,
�-
�.
�/
r4r$��
,rTr<rEr
za,,c�r4r$�r[
r^
�rZ
r_
�rY
r`
�rX
ra
�rW
rb
�rV
rc
�rU
rd
�rT
re
�rS
rf
�rR
rg
�rQ
rh
�rP
ri
�rO
rj
�r\
r]
�r\
r]
�r4rT�r[
rn
�rZ
ro
�rY
rp
�rX
rq
�rW
rr
�rV
rs
�rU
rt
�rT
ru
�rS
rv
�rR
rw
�rQ
rx
�rP
ry
�rO
rz
�rN
rk
rl
rm
r{
�r<rE�r
rE)rM
r|
r}
r~
)
rf)rr8rrr�test_a_comma_comma_cas.





















z*IllegalSyntaxTestCase.test_a_comma_comma_cc
CsdD}
|j|
d�
dS)EN�

�
�	
�

�
�8
�#
�$
�%
�&
�(
�)
�*
�+
�,
�-
�.
�/
�0
r4r$�
�%�$=�
br<rEr
za $= b�r4r$�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r4r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
�r�
r�
r�
r�
�r�
r�
�r<rE�r�
r�
r�
�r�
r�
�r
rE)r�
r�
r�
)
rf)rr8rrr�test_illegal_operator|s:



























z+IllegalSyntaxTestCase.test_illegal_operatorc
Csd}
|j|
d�
dS)N�

�
�	
�

�
r4�foor<rEr
zmalformed global ast�r4r�
�r�
r�
�r�
r�
�r<rE�r�
r�
r�
�r�
r�
�r<rE�r
rE)r�
r�
r�
r�
)
rf)rr8rrr�test_malformed_global�s






z+IllegalSyntaxTestCase.test_malformed_globalc
Csd}
|j|
d�
dS)N�

�
�

�
�
�
r4r�r��
�
�fredr<rEr
zfrom import fred�r4r��r4r��r4r�
�r�
r�
�r�
r�
�r�
r�
r�
r�
�r�
r�
�r�
r�
�r<rE�r�
r�
r�
�r�
r�
�r<rE�r
rE)r�
r�
r�
r�
)
rf)rr8rrr�test_missing_import_source�s








z0IllegalSyntaxTestCase.test_missing_import_sourcec
	CsHd}
|j|
d�
d}
|j|
d�
d}
|j
t�
�
tj|
�

WdQRXdS)N�S
�

r
rEzmissed encoding�
iso-8859-1znon-string encoding���r
rE�r�
r�
)r�
r�
�r
rE�r�
r�
)r�
r�
r�
�r
rE�r�
r�
)r�
r�
r�
)rfr'�UnicodeEncodeErrorrr)rr8rrr�test_illegal_encoding�s








z+IllegalSyntaxTestCase.test_illegal_encodingN)
rbrcrdrfrhr�r�rL
r
r�
r�
r�
r�
rrrrre�
s.7@!rec@s<eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�CompileTestCasec
Cs(tj
d
�
}
tj|
�
}|jt|�
d�
dS)Nz2 + 3r?)rr�	compilestr
�eval)rrXrrrr�test_compile_expr�s




z!CompileTestCase.test_compile_exprc
Cs6tj
d
�
}
tj|
�
}i}t||�
|j|dd�
dS)Nzx = 2; y = x + 3�
yr?)rrr�
rr
)rrXrZglobsrrr�test_compile_suite�s








z"CompileTestCase.test_compile_suitec
Cstj
d
�
}
|jttj|
�
dS)Nz	1 = 3 + 4)rrr'r(r�
)rrXrrr�test_compile_error�s


z"CompileTestCase.test_compile_errorc
Cs8tj
d
�
}
|jttj|
�
tj
d�
}
|jttj|
�
dS)Nza = "\U12345678"z	a = "\u1")rrr'r(r�
)rrXrrr�test_compile_badunicode�s





z'CompileTestCase.test_compile_badunicodec
CsBtj
d
�
}
tj|
�
}|jt|�
d�
tj|
�
}|jt|�
d�
dS)Nz-3rg���r�
)rrr�
r
r�
)rrX�code1�code2rrr�test_issue_9011�s







zCompileTestCase.test_issue_9011c
Cs
tj
d
�
}
tj|
�
}|j|jd�
|
j�}|j|jd�
x>dD]6}tj|
|�}|j|jd�
|
j|�
}|j|jd�
q>Wxvtd�
td�
fD]b}|jt	�
�
tj|
|�}WdQRX|j|jd�
|jt	�
�
|
j|�
}WdQRX|j|jd�
q�W|j
ttj|
td�
�
|j
t|
jtd�
�
dS)Nza + 5z
<syntax-tree>�file.py�file.py)r�
r�
)
rrr�
r
�co_filenamer�	bytearray�
memoryviewZassertWarns�DeprecationWarningr'�	TypeErrorr7)rrXr�filenamerrr�test_compile_filename�s&






















z%CompileTestCase.test_compile_filenameN)	rbrcrdr�
r�
r�
r�
r�
rrrrrr�
�s
r�
c@s$eZ
dZd
d�Zdd�Zdd�ZdS)�ParserStackLimitTestCasecCsd
|
d|
S)N�
[�
]r)r�levelrrr�_nested_expressions
z+ParserStackLimitTestCase._nested_expressionc
Cs |jd
�
}
t
j|
�
}|j�
dS)N�])r	rrr)r�
erXrrr�test_deeply_nested_list
s



z0ParserStackLimitTestCase.test_deeply_nested_listc
Cs6|jd
�
}
t
d|
�\}}}|jd|�
|jd|�
dS)N�dz-css_push: parser stack overflowsMemoryError)r	rZassertIn)rrZrc�out�errrrr�test_trigger_memory_errors



z2ParserStackLimitTestCase.test_trigger_memory_errorN)rbrcrdr	rrrrrrrsrc@s0eZ
dZd
d�Zdd�ZejZejdd��
ZdS)�STObjectTestCasec

Cstj
d
�
}
tjd�
}tj
d�
}tj
d
�
}tjd�
}tj
d�
}|j|
|
kd�
|j||kd�
|j||kd�
|j|
|�
|j||�
|j||�
|j|
|kd�
|j|
|kd�
|j||kd�
|j|
|
kd�
|j||kd�
|j||kd�
|j|
|kd�
|j||kd�
|j||kd�
|j||
kd�
|j|
|kd�
|j||kd�
|j|
|k||
k
�
|j|
|k||
k
�
|j||k||k
�
|j|
|k||
k�
|j|
|k||
k�
|j||k||k�
|j|
|k
||
k�
|j||
k
|
|k�
|j||k
||k�
t|
||�}t|
||�}t|
||g�
d}	|j||	k�

|j||k�

|j|	|k�

|j||	k
�

|j||k
�

|j|	|k
�

|j||k
�

|j|	|	k
�

|j||k
�

|j|
dkd�
|jd|kd�
|jt	t
j|d�
|jt	t
jd|
�
|jt	t
j
|
d	�
|jt	t
jd
|�
dS)Nz2 + 3zx = 2; y = x + 3zlist(x**3 for x in range(20))TFr4g��hҘ@zspanish armadaiswaterloo)rrrr
�min�max�sortedZ
assertTruer'r�operator�ge�le�lt�gt)
rrrZst3Zst1_copyZst2_copyZst3_copyZbottom�topZmidrrr�test_comparisonssf


















































z!STObjectTestCase.test_comparisonsc
Cs�tj
d
�
tjd�
tj
d�
g}
x�|
D]~}tj|�
}|j|j�|j��
tj|�
}|j|j�|j��
x<ttj	d�
D]*}tj
tj||��
}|j|j�|j��
qrWq"WdS)Nz2 + 3zx = 2; y = x + 3zlist(x**3 for x in range(20))r4)rrr�copyr
r�deepcopy�range�pickleZHIGHEST_PROTOCOL�loads�dumps)r�stsrXZst_copy�protorrr�test_copy_pickleXs











z!STObjectTestCase.test_copy_picklec
s�d
d��tj
d�
�
tjd�
����fdd���
���fdd�}
|
tjd	�
�

|
tjd
�
�

|
tjd�
�

|
tjd�
�

|
tjd
�
�

|
tjdddd�
�

dS)Nc

Ss0|d
k
r|S|dk
r |dd@Sd
|d
j�>S)Nr4�rg���)
�
bit_length)
rRrrr�
XXXROUNDUPks





z0STObjectTestCase.test_sizeof.<locals>.XXXROUNDUPZPiiZhP3iP0hc
s�|dkrd
Sd
}
t|�
dko(t
|dt�}|rB|
t|d�
d7}
|rR|dd�n
|dd�}|r�|
�t|�
�
�
7}
x|D]}|
�|�
7}
q|W|
S)Nr
r4rVrVrV)�lenr5r)Znode�res�hasstrZchildrenZchild)r(�nodesize�sizeofchildrenrrr-ts












z4STObjectTestCase.test_sizeof.<locals>.sizeofchildrenc

s �j|��
�|j
��
�
dS)
N)�check_sizeofr)
rX)�basesizer,rr-rr�check_st_sizeof�s

z5STObjectTestCase.test_sizeof.<locals>.check_st_sizeofz2 + 3z	2 + 3 + 4z	x = 2 + 3rEz# -*- coding: utf-8 -*-rz2,i�r)rZcalcobjsize�struct�calcsizerrr)rr0r)r(r/r,rr-r�test_sizeofis








zSTObjectTestCase.test_sizeofN)	rbrcrdrr$rr.Zcpython_onlyr3rrrrrs=rc@seZ
dZd
d�ZdS)�OtherParserCasec


Cs&|jt
�
�
tjd
d�
WdQRXdS)Nr$r�
)r'rrr)
rrrr�test_two_args_to_expr�s
z%OtherParserCase.test_two_args_to_exprN)rbrcrdr5rrrrr4�sr4�__main__)rrrZunittestrr1ZtestrZtest.support.script_helperrZTestCaserrer�
rrr4rb�mainrrrr�<module>
s(






!:x