✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

�
f ff�@s
dd
lZdd
l
Z
dd
lZdd
lZdd
lZddlmZ
ddlmZ
Gdd�de
j	�Z
Gdd�de
j	�ZGdd	�d	e
j	�ZGd
d�de
j	�Z
Gdd
�d
e
j	�ZGdd�de
j	�Zdd�Zedkr
e�
nd
S)�N)
�support)
�assert_python_failurec@sH
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�Zd5S)6�RoundtripLegalSyntaxTestCasecCs�|
|�
}|j�}yt
j|�
}Wn?t
jk
rl
}
z|jd
||f�

WYdd}~Xn
X|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�5/opt/alt/python34/lib64/python3.4/test/test_parser.py�	roundtrips





*
z&RoundtripLegalSyntaxTestCase.roundtripcCs|jt
j|
�
dS)
N)rr�expr)rr
rrr�
check_exprs
z'RoundtripLegalSyntaxTestCase.check_exprc
CsItj
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_passeds




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�

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

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_expressionsLsP














































































z-RoundtripLegalSyntaxTestCase.test_expressionsc

Cs|jd
�

dS)N�
a)
r)
rrrr�test_simple_expressionvsz3RoundtripLegalSyntaxTestCase.test_simple_expressionc

Cs|jd
�

|jd�

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


z4RoundtripLegalSyntaxTestCase.test_simple_assignmentsc

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

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

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

CsE|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

CsE|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

Csl|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_with�s




z&RoundtripLegalSyntaxTestCase.test_withc

CsR|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_stmt�s









z*RoundtripLegalSyntaxTestCase.test_try_stmtc
s�d
}
tj
|
�
}|jdddd�}�f
dd��t�|�
�
}|jddd d!d"d#d$d&d'd(d)d*d+d-d/d1g|�
dS)2Nzdef f(x):
    return x + 1Z	line_info�
Zcol_infoc
3sf|d
}
|d}t|t
�r]x<|dd�D]"}x�|�
D]}|V
qGWq4Wn|V
dS)Nr
r.)�
isinstance�tuple)�treeZ	node_type�nextZeltr)
�walkrrr3
s







z8RoundtripLegalSyntaxTestCase.test_position.<locals>.walk�defr
r���
(�r���
)��
:��	��return��
+�
�
1��)r.zdefr.r
)r.rr.r5)r6r7r.r8)r.rr.r9)r:r;r.r6)r<r=r.r:)r5r>r.r?���)r8r>r@rH)r.zreturnr@r5)r.rr@r<)rBrCr@rD)r@rEr@rF)r5r>r@rGrH)r9r>r@rHrH)r5r>r@rHrH)r
r>r@rH)rrr�listr
)rrrrZ	terminalsr)
r3r�
test_position	
s.




















z*RoundtripLegalSyntaxTestCase.test_positionc

Cs8|jd
�

|jd�

|jd�

|jd�

dS)Nz*a = yz
x, *b, = mz[*a, *b] = yzfor [*x, b] in x: pass)
r)
rrrr�test_extended_unpacking.
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_statement4
s




z1RoundtripLegalSyntaxTestCase.test_raise_statementc

Cs8|jd
�

|jd�

|jd�

|jd�

dS)Nz{2}z{2,}z{2, 3}z{2, 3,})
r)
rrrr�test_set_displays<
s






z.RoundtripLegalSyntaxTestCase.test_set_displaysc

CsE|jd
�

|jd�

|jd�

|jd�

|jd�

dS)Nz{}z{a:b}z{a:b,}z
{a:b, c:d}z{a:b, c:d,})
r)
rrrr�test_dict_displaysB
s









z/RoundtripLegalSyntaxTestCase.test_dict_displaysc

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_comprehensionsI
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_comprehensionsN
s




z5RoundtripLegalSyntaxTestCase.test_dict_comprehensionsN)�__name__�
__module__�__qualname__rrrrrrr r"r#r$r%r&r'r(r)r*r+r,r-rJrKrLrMrNrOrPrrrrrs4	
*0
%rc@speZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dS)�IllegalSyntaxTestCasecCs>ytj
|
�

Wntjk
r(


YnX|jd
|�

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




z$IllegalSyntaxTestCase.check_bad_treec

Cs|jdd�
dS)Nr.r@�z<junk>)r.r@rV)
rU)
rrrr�	test_junkc
szIllegalSyntaxTestCase.test_junkc
$Csdg}
|j|
d,�
dS)hN�

�
�
�
r.r4r�
r6r7r:r;r<r=�#
r5r>r8�	
�

�
�
rA�9
�$
�%
�&
�'
�)
�*
�+
�,
�-
�.
�/
�0
�1
r@rE�
�yieldr9r
zdef f():
  return 1
  yield 1�r.zdef�r.r�r6r7�r:r;�r\rtru�r<r=�r5r>�r8r>�r.zreturn�r@rE�ror{�rnr|�rmr}�rlr~�rkr�rjr��rir��rhr��rgr��rfr��rer��rdr��rcr��rbr��rarzr��r`r��r_r��r.zyield�r@rE�ror��rnr��rmr��rlr��rkr��rjr��rir��rhr��rgr��rfr��rer��rdr��rcr��rbr��rpr�r��r`r��r_r��r5r>�r^r�r��rYr��r9r>�r^r�r�r��rYr��r]rxryr��r[rrrsrvrwr��r5r>�r
r>�rZr�r�r��rYr�)rXr�)
rU)rr1rrr�test_illegal_yield_1g
sf

















































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

�
�	
�

�
r.�from�
�
__future__�import�
�
generatorsr5r>�
�
r4r�
r6r7r:r;r<r=�#
r8�
�
rA�9
�$
�%
�&
�'
�)
�*
�+
�,
�-
�.
�/
�0
�1
r@rE�
rqr9r
zdef f():
  return 1
  yield 1�r.zfrom�r.r��r�r��r.zimport�r.r��r�r��r�r�r�r�r��r�r��r5r>�r�r�r��r�r��r.zdef�r.r�r6r7�r:r;�r�r�r��r<r=�r5r>�r8r>�r.zreturn�r@rE�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.zyield�r@rE�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
�r5r>�r�r
r
�r�r
�r9r>�r�r�r
r	
�r�r

�r�r�r�r
�r�r�r�r�r�r
�r5r>�r
r>�r�r

r
r
�r�r
)r�r�r
)
rU)rr1rrr�test_illegal_yield_2�
sx


























































z*IllegalSyntaxTestCase.test_illegal_yield_2c
Csd:}
|j|
d�
dS);N�
�7
�"
�#
�$
�%
�'
�(
�)
�*
�+
�,
�-
�.
�/
r.r!��
,�
cr5r>r
za,,c�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
r0
�r
r1
�r"
r#
�r"
r#
�r.r$
�r!
r5
�r 
r6
�r
r7
�r
r8
�r
r9
�r
r:
�r
r;
�r
r<
�r
r=
�r
r>
�r
r?
�r
r@
�r
rA
�r
r2
r3
r4
rB
�r5r>�r
r>)r
rC
rD
rE
)
rU)rr1rrr�test_a_comma_comma_c�
s.





















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

�
�	
�

�
�8
�#
�$
�%
�&
�(
�)
�*
�+
�,
�-
�.
�/
�0
r.r!�
�%�$=�
br5r>r
za $= b�r.r!�rY
r^
�rX
r_
�rW
r`
�rV
ra
�rU
rb
�rT
rc
�rS
rd
�rR
re
�rQ
rf
�rP
rg
�rO
rh
�rN
ri
�rM
rj
�rL
rk
�r[
r\
�rZ
rm
�r.r]
�rY
ro
�rX
rp
�rW
rq
�rV
rr
�rU
rs
�rT
rt
�rS
ru
�rR
rv
�rQ
rw
�rP
rx
�rO
ry
�rN
rz
�rM
r{
�rL
r|
�rK
rl
rn
r}
�rJ
r~
�r5r>�rI
r
r�
�rH
r�
�r
r>)rG
r�
r�
)
rU)rr1rrr�test_illegal_operator�
s:



























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

�
�	
�

�
r.�foor5r>r
zmalformed global ast�r.r�
�r�
r�
�r�
r�
�r5r>�r�
r�
r�
�r�
r�
�r5r>�r
r>)r�
r�
r�
r�
)
rU)rr1rrr�test_malformed_globals






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

�
�

�
�
�
r.r�r��
�
�fredr5r>r
zfrom import fred�r.zfrom�r.zimport�r.r�
�r�
r�
�r�
r�
�r�
r�
r�
r�
�r�
r�
�r�
r�
�r5r>�r�
r�
r�
�r�
r�
�r5r>�r
r>)r�
r�
r�
r�
)
rU)rr1rrr�test_missing_import_source%s








z0IllegalSyntaxTestCase.test_missing_import_sourceN)rQrRrSrUrWr�r
rF
r�
r�
r�
rrrrrTY
s7@!rTc@sLeZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�ZdS)�CompileTestCasec
Cs8tj
d
�
}
tj|
�
}|jt|�
d�
dS)Nz2 + 3r8)rr�	compilestr
�eval)r�strrrr�test_compile_expr8s


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






z"CompileTestCase.test_compile_suitec
Cs)tj
d
�
}
|jttj|
�
dS)Nz	1 = 3 + 4)rr�assertRaises�SyntaxErrorr�
)rr�
rrr�test_compile_errorDs

z"CompileTestCase.test_compile_errorc
CsNtj
d
�
}
|jttj|
�
tj
d�
}
|jttj|
�
dS)Nza = "\U12345678"z	a = "\u1")rrr�
r�
r�
)rr�
rrr�test_compile_badunicodeHs



z'CompileTestCase.test_compile_badunicodec
Cs]tj
d
�
}
tj|
�
}|jt|�
d�
tj|
�
}|jt|�
d�
dS)Nz-3rV���r�
)rrr�
r
r�
)rr�
�code1�code2rrr�test_issue_9011Ns




zCompileTestCase.test_issue_9011N)rQrRrSr�
r�
r�
r�
r�
rrrrr�
4s
r�
c@s:eZ
dZd
Zdd�Zdd�Zdd�ZdS)	�ParserStackLimitTestCasezitry to push the parser to/over its limits.
    see http://bugs.python.org/issue1881 for a discussion
    cCsd
|
d|
S)N�
[�
]r)r�levelrrr�_nested_expression\s
z+ParserStackLimitTestCase._nested_expressionc
Cs,|jd
�
}
t
j|
�
}|j�
dS)N�])r�
rrr)r�
er�
rrr�test_deeply_nested_list_s

z0ParserStackLimitTestCase.test_deeply_nested_listc
CsK|jd
�
}
t
d|
�\}}}|jd|�
|jd|�
dS)N�dz-css_push: parser stack overflowsMemoryError)r�
rZassertIn)rr�
�rc�out�errrrr�test_trigger_memory_errores


z2ParserStackLimitTestCase.test_trigger_memory_errorN)rQrRrS�__doc__r�
r�
r�
rrrrr�
Xs
r�
c@s@eZ
dZd
Zdd�ZejZejdd��
ZdS)�STObjectTestCasez(Test operations on ST objects themselvesc

CsOtj
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))TFr.g��hҘ@zspanish armadaiswaterloo)rrrr
�min�max�sortedZ
assertTruer�
�	TypeError�operator�ge�le�lt�gt)
rrrZst3Zst1_copyZst2_copyZst3_copyZbottom�topZmidrrr�test_comparisonspsf












































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

|
tjd
�
�

|
tjd�
�

|
tjd�
�

|
tjd
�
�

|
tjdddd�
�

dS)Nc

Ss:|d
k
r|S|dk
r(|dd@Sd
|d
j�>S)Nr.�rV���)
�
bit_length)
�
nrrr�
XXXROUNDUP�s





z0STObjectTestCase.test_sizeof.<locals>.XXXROUNDUPZPiiZhP3iP0hc
s�|dkrd
Sd
}
t|�
dko8t
|dt�}|r\|
t|d�
d7}
n|rr|dd�n
|dd�}|r�|
�t|�
�
�
7}
x!|D]}|
�|�
7}
q�Wn|
S)Nr
r.rHrHrH)�lenr/r)Znode�resZhasstrZchildrenZchild)r�
�nodesize�sizeofchildrenrrr�
�s



%


&





z4STObjectTestCase.test_sizeof.<locals>.sizeofchildrenc

s(�j|��
�|j
��
�
dS)
N)�check_sizeofr)
r�
)�basesizer�
rr�
rr�check_st_sizeof�s

z5STObjectTestCase.test_sizeof.<locals>.check_st_sizeofz2 + 3z	2 + 3 + 4z	x = 2 + 3r>z# -*- coding: utf-8 -*-r�
z2,i�r�
)rZcalcobjsize�structZcalcsizerrr)rr�
r)r�
r�
r�
rr�
r�test_sizeof�s






zSTObjectTestCase.test_sizeofN)	rQrRrSr�
r�
rr�
Zcpython_onlyr�
rrrrr�
ms
=	r�
c@seZ
dZd
d�ZdS)�OtherParserCasec


Cs*|jt
�
�
tjd
d�
WdQXdS)Nr!r]
)r�
r�
rr)
rrrr�test_two_args_to_expr�s
z%OtherParserCase.test_two_args_to_exprN)rQrRrSr�
rrrrr�
�sr�
cCs tj
tttttt�
dS)
N)rZrun_unittestrrTr�
r�
r�
r�
rrrr�	test_main�s






r�
�__main__)rZunittest�sysr�
r�
ZtestrZtest.script_helperrZTestCaserrTr�
r�
r�
r�
r�
rQrrrr�<module>
s 





�K�$i