✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

�
��f$Wc@s�
dd
lZdd
l
Z
dd
lZdd
lZdd
lZdd
lZdd
lZddlmZ
ddl	m
Z

Gdd�de�Zdd�Z
dd	�Zd
d�Zdd
�Zdd�Zdd�Zdd�Zdd�Ze
jd�
Zedej�
dd�Zdd�Zdd�Zdd�Zd d!�ZGd"d#�d#ej�Zd$d%�Z e!d&kr�
ej"�
nd
S('iN(
usupport(
u
_FakeInputc

Bs>|EeZ
dZd
Zdd�Zdd�Zdd�ZdS(	uPdbTestInputu:Context manager that makes testing Pdb in doctests easier.cCs
|
|_dS(
N(
uinput(uselfuinput((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu__init__s
uPdbTestInput.__init__c

CsFtj
|_t|j�
t_
ttd
�r9tj�nd|_dS(Nugettrace(	usysustdinu
real_stdinu
_FakeInputuinputuhasattrugettraceuNoneu
orig_trace(
uself((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu	__enter__s


uPdbTestInput.__enter__c
Gs,|jt
_|jr(t
j|j�

ndS(
N(u
real_stdinusysustdinu
orig_traceusettrace(uselfuexc((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu__exit__s

	
uPdbTestInput.__exit__N(u__name__u
__module__u__qualname__u__doc__u__init__u	__enter__u__exit__(
u
__locals__((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyuPdbTestInputs
uPdbTestInputc
Csd
S(u#This tests the custom displayhook for pdb.

    >>> def test_function(foo, bar):
    ...     import pdb; pdb.Pdb(nosigint=True).set_trace()
    ...     pass

    >>> with PdbTestInput([
    ...     'foo',
    ...     'bar',
    ...     'for i in range(5): print(i)',
    ...     'continue',
    ... ]):
    ...     test_function(1, None)
    > <doctest test.test_pdb.test_pdb_displayhook[0]>(3)test_function()
    -> pass
    (Pdb) foo
    1
    (Pdb) bar
    (Pdb) for i in range(5): print(i)
    0
    1
    2
    3
    4
    (Pdb) continue
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_pdb_displayhook!sutest_pdb_displayhookc
Csd
S(uVTest the basic commands of pdb.

    >>> def test_function_2(foo, bar='default'):
    ...     print(foo)
    ...     for i in range(5):
    ...         print(i)
    ...     print(bar)
    ...     for i in range(10):
    ...         never_executed
    ...     print('after for')
    ...     print('...')
    ...     return foo.upper()

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True).set_trace()
    ...     ret = test_function_2('baz')
    ...     print(ret)

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...     'step',       # entering the function call
    ...     'args',       # display function args
    ...     'list',       # list function source
    ...     'bt',         # display backtrace
    ...     'up',         # step up to test_function()
    ...     'down',       # step down to test_function_2() again
    ...     'next',       # stepping to print(foo)
    ...     'next',       # stepping to the for loop
    ...     'step',       # stepping into the for loop
    ...     'until',      # continuing until out of the for loop
    ...     'next',       # executing the print(bar)
    ...     'jump 8',     # jump over second for loop
    ...     'return',     # return out of function
    ...     'retval',     # display return value
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_basic_commands[1]>(3)test_function()
    -> ret = test_function_2('baz')
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
    -> def test_function_2(foo, bar='default'):
    (Pdb) args
    foo = 'baz'
    bar = 'default'
    (Pdb) list
      1  ->     def test_function_2(foo, bar='default'):
      2             print(foo)
      3             for i in range(5):
      4                 print(i)
      5             print(bar)
      6             for i in range(10):
      7                 never_executed
      8             print('after for')
      9             print('...')
     10             return foo.upper()
    [EOF]
    (Pdb) bt
    ...
      <doctest test.test_pdb.test_pdb_basic_commands[2]>(18)<module>()
    -> test_function()
      <doctest test.test_pdb.test_pdb_basic_commands[1]>(3)test_function()
    -> ret = test_function_2('baz')
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
    -> def test_function_2(foo, bar='default'):
    (Pdb) up
    > <doctest test.test_pdb.test_pdb_basic_commands[1]>(3)test_function()
    -> ret = test_function_2('baz')
    (Pdb) down
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(1)test_function_2()
    -> def test_function_2(foo, bar='default'):
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(2)test_function_2()
    -> print(foo)
    (Pdb) next
    baz
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(3)test_function_2()
    -> for i in range(5):
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(4)test_function_2()
    -> print(i)
    (Pdb) until
    0
    1
    2
    3
    4
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(5)test_function_2()
    -> print(bar)
    (Pdb) next
    default
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(6)test_function_2()
    -> for i in range(10):
    (Pdb) jump 8
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(8)test_function_2()
    -> print('after for')
    (Pdb) return
    after for
    ...
    --Return--
    > <doctest test.test_pdb.test_pdb_basic_commands[0]>(10)test_function_2()->'BAZ'
    -> return foo.upper()
    (Pdb) retval
    'BAZ'
    (Pdb) continue
    BAZ
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_pdb_basic_commands>sutest_pdb_basic_commandsc
Csd
S(u�Test basic commands related to breakpoints.

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True).set_trace()
    ...     print(1)
    ...     print(2)
    ...     print(3)
    ...     print(4)

    First, need to clear bdb state that might be left over from previous tests.
    Otherwise, the new breakpoints might get assigned different numbers.

    >>> from bdb import Breakpoint
    >>> Breakpoint.next = 1
    >>> Breakpoint.bplist = {}
    >>> Breakpoint.bpbynumber = [None]

    Now test the breakpoint commands.  NORMALIZE_WHITESPACE is needed because
    the breakpoint list outputs a tab for the "stop only" and "ignore next"
    lines, which we don't want to put in here.

    >>> with PdbTestInput([  # doctest: +NORMALIZE_WHITESPACE
    ...     'break 3',
    ...     'disable 1',
    ...     'ignore 1 10',
    ...     'condition 1 1 < 2',
    ...     'break 4',
    ...     'break 4',
    ...     'break',
    ...     'clear 3',
    ...     'break',
    ...     'condition 1',
    ...     'enable 1',
    ...     'clear 1',
    ...     'commands 2',
    ...     'print 42',
    ...     'end',
    ...     'continue',  # will stop at breakpoint 2 (line 4)
    ...     'clear',     # clear all!
    ...     'y',
    ...     'tbreak 5',
    ...     'continue',  # will stop at temporary breakpoint
    ...     'break',     # make sure breakpoint is gone
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(3)test_function()
    -> print(1)
    (Pdb) break 3
    Breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) disable 1
    Disabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) ignore 1 10
    Will ignore next 10 crossings of breakpoint 1.
    (Pdb) condition 1 1 < 2
    New condition set for breakpoint 1.
    (Pdb) break 4
    Breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break 4
    Breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
            stop only if 1 < 2
            ignore next 10 hits
    2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    3   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) clear 3
    Deleted breakpoint 3 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) break
    Num Type         Disp Enb   Where
    1   breakpoint   keep no    at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
            stop only if 1 < 2
            ignore next 10 hits
    2   breakpoint   keep yes   at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) condition 1
    Breakpoint 1 is now unconditional.
    (Pdb) enable 1
    Enabled breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) clear 1
    Deleted breakpoint 1 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:3
    (Pdb) commands 2
    (com) print 42
    (com) end
    (Pdb) continue
    1
    42
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(4)test_function()
    -> print(2)
    (Pdb) clear
    Clear all breaks? y
    Deleted breakpoint 2 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:4
    (Pdb) tbreak 5
    Breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
    (Pdb) continue
    2
    Deleted breakpoint 4 at <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>:5
    > <doctest test.test_pdb.test_pdb_breakpoint_commands[0]>(5)test_function()
    -> print(3)
    (Pdb) break
    (Pdb) continue
    3
    4
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_pdb_breakpoint_commands�sutest_pdb_breakpoint_commandsc
CsdS(
N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu
do_nothing
s
u
do_nothingcCstd
�

dS(Ni*(
uprint(((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyudo_something
s
udo_somethingc
Csd
S(u�Test the list and source commands of pdb.

    >>> def test_function_2(foo):
    ...     import test.test_pdb
    ...     test.test_pdb.do_nothing()
    ...     'some...'
    ...     'more...'
    ...     'code...'
    ...     'to...'
    ...     'make...'
    ...     'a...'
    ...     'long...'
    ...     'listing...'
    ...     'useful...'
    ...     '...'
    ...     '...'
    ...     return foo

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True).set_trace()
    ...     ret = test_function_2('baz')

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...     'list',      # list first function
    ...     'step',      # step into second function
    ...     'list',      # list second function
    ...     'list',      # continue listing to EOF
    ...     'list 1,3',  # list specific lines
    ...     'list x',    # invalid argument
    ...     'next',      # step to import
    ...     'next',      # step over import
    ...     'step',      # step into do_nothing
    ...     'longlist',  # list all lines
    ...     'source do_something',  # list all lines of function
    ...     'source fooxxx',        # something that doesn't exit
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_list_commands[1]>(3)test_function()
    -> ret = test_function_2('baz')
    (Pdb) list
      1         def test_function():
      2             import pdb; pdb.Pdb(nosigint=True).set_trace()
      3  ->         ret = test_function_2('baz')
    [EOF]
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_list_commands[0]>(1)test_function_2()
    -> def test_function_2(foo):
    (Pdb) list
      1  ->     def test_function_2(foo):
      2             import test.test_pdb
      3             test.test_pdb.do_nothing()
      4             'some...'
      5             'more...'
      6             'code...'
      7             'to...'
      8             'make...'
      9             'a...'
     10             'long...'
     11             'listing...'
    (Pdb) list
     12             'useful...'
     13             '...'
     14             '...'
     15             return foo
    [EOF]
    (Pdb) list 1,3
      1  ->     def test_function_2(foo):
      2             import test.test_pdb
      3             test.test_pdb.do_nothing()
    (Pdb) list x
    *** ...
    (Pdb) next
    > <doctest test.test_pdb.test_list_commands[0]>(2)test_function_2()
    -> import test.test_pdb
    (Pdb) next
    > <doctest test.test_pdb.test_list_commands[0]>(3)test_function_2()
    -> test.test_pdb.do_nothing()
    (Pdb) step
    --Call--
    > ...test_pdb.py(...)do_nothing()
    -> def do_nothing():
    (Pdb) longlist
    ...  ->     def do_nothing():
    ...             pass
    (Pdb) source do_something
    ...         def do_something():
    ...             print(42)
    (Pdb) source fooxxx
    *** ...
    (Pdb) continue
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_list_commands
sutest_list_commandsc
Csd
S(usTest post mortem traceback debugging.

    >>> def test_function_2():
    ...     try:
    ...         1/0
    ...     finally:
    ...         print('Exception!')

    >>> def test_function():
    ...     import pdb; pdb.Pdb(nosigint=True).set_trace()
    ...     test_function_2()
    ...     print('Not reached.')

    >>> with PdbTestInput([  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
    ...     'next',      # step over exception-raising call
    ...     'bt',        # get a backtrace
    ...     'list',      # list code of test_function()
    ...     'down',      # step into test_function_2()
    ...     'list',      # list code of test_function_2()
    ...     'continue',
    ... ]):
    ...    try:
    ...        test_function()
    ...    except ZeroDivisionError:
    ...        print('Correctly reraised.')
    > <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
    -> test_function_2()
    (Pdb) next
    Exception!
    ZeroDivisionError: division by zero
    > <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
    -> test_function_2()
    (Pdb) bt
    ...
      <doctest test.test_pdb.test_post_mortem[2]>(10)<module>()
    -> test_function()
    > <doctest test.test_pdb.test_post_mortem[1]>(3)test_function()
    -> test_function_2()
      <doctest test.test_pdb.test_post_mortem[0]>(3)test_function_2()
    -> 1/0
    (Pdb) list
      1         def test_function():
      2             import pdb; pdb.Pdb(nosigint=True).set_trace()
      3  ->         test_function_2()
      4             print('Not reached.')
    [EOF]
    (Pdb) down
    > <doctest test.test_pdb.test_post_mortem[0]>(3)test_function_2()
    -> 1/0
    (Pdb) list
      1         def test_function_2():
      2             try:
      3  >>             1/0
      4             finally:
      5  ->             print('Exception!')
    [EOF]
    (Pdb) continue
    Correctly reraised.
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_post_mortem}
sutest_post_mortemc
Csd
S(uMThis illustrates the simple case of module skipping.

    >>> def skip_module():
    ...     import string
    ...     import pdb; pdb.Pdb(skip=['stri*'], nosigint=True).set_trace()
    ...     string.capwords('FOO')

    >>> with PdbTestInput([
    ...     'step',
    ...     'continue',
    ... ]):
    ...     skip_module()
    > <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module()
    -> string.capwords('FOO')
    (Pdb) step
    --Return--
    > <doctest test.test_pdb.test_pdb_skip_modules[0]>(4)skip_module()->None
    -> string.capwords('FOO')
    (Pdb) continue
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_pdb_skip_modules�
sutest_pdb_skip_modulesumodule_to_skipu6def foo_pony(callback): x = 1; callback(); return Nonec
Csd
S(u3This illustrates skipping of modules that call into other code.

    >>> def skip_module():
    ...     def callback():
    ...         return None
    ...     import pdb; pdb.Pdb(skip=['module_to_skip*'], nosigint=True).set_trace()
    ...     mod.foo_pony(callback)

    >>> with PdbTestInput([
    ...     'step',
    ...     'step',
    ...     'step',
    ...     'step',
    ...     'step',
    ...     'continue',
    ... ]):
    ...     skip_module()
    ...     pass  # provides something to "step" to
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(5)skip_module()
    -> mod.foo_pony(callback)
    (Pdb) step
    --Call--
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(2)callback()
    -> def callback():
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(3)callback()
    -> return None
    (Pdb) step
    --Return--
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(3)callback()->None
    -> return None
    (Pdb) step
    --Return--
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[0]>(5)skip_module()->None
    -> mod.foo_pony(callback)
    (Pdb) step
    > <doctest test.test_pdb.test_pdb_skip_modules_with_callback[1]>(10)<module>()
    -> pass  # provides something to "step" to
    (Pdb) continue
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu#test_pdb_skip_modules_with_callback�
su#test_pdb_skip_modules_with_callbackc
Csd
S(u�Test that "continue" and "next" work properly in bottom frame (issue #5294).

    >>> def test_function():
    ...     import pdb, sys; inst = pdb.Pdb(nosigint=True)
    ...     inst.set_trace()
    ...     inst.botframe = sys._getframe()  # hackery to get the right botframe
    ...     print(1)
    ...     print(2)
    ...     print(3)
    ...     print(4)

    >>> with PdbTestInput([  # doctest: +ELLIPSIS
    ...     'next',
    ...     'break 7',
    ...     'continue',
    ...     'next',
    ...     'continue',
    ...     'continue',
    ... ]):
    ...    test_function()
    > <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(4)test_function()
    -> inst.botframe = sys._getframe()  # hackery to get the right botframe
    (Pdb) next
    > <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(5)test_function()
    -> print(1)
    (Pdb) break 7
    Breakpoint ... at <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>:7
    (Pdb) continue
    1
    2
    > <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(7)test_function()
    -> print(3)
    (Pdb) next
    3
    > <doctest test.test_pdb.test_pdb_continue_in_bottomframe[0]>(8)test_function()
    -> print(4)
    (Pdb) continue
    4
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu test_pdb_continue_in_bottomframesu test_pdb_continue_in_bottomframecCs/d
dl}t
|jdd�
|�|
�

dS(uRun pdb.method(arg).iNunosigintT(updbugetattruPdbuTrue(umethoduargupdb((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu
pdb_invoke,s
u
pdb_invokec
Csd
S(u�
Testing run and runeval with incorrect first argument.

    >>> pti = PdbTestInput(['continue',])
    >>> with pti:
    ...     pdb_invoke('run', lambda x: x)
    Traceback (most recent call last):
    TypeError: exec() arg 1 must be a string, bytes or code object

    >>> with pti:
    ...     pdb_invoke('runeval', lambda x: x)
    Traceback (most recent call last):
    TypeError: eval() arg 1 must be a string, bytes or code object
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu$test_pdb_run_with_incorrect_argument2su$test_pdb_run_with_incorrect_argumentc
Csd
S(u Testing run and runeval with code object as a first argument.

    >>> with PdbTestInput(['step','x', 'continue']):  # doctest: +ELLIPSIS
    ...     pdb_invoke('run', compile('x=1', '<string>', 'exec'))
    > <string>(1)<module>()...
    (Pdb) step
    --Return--
    > <string>(1)<module>()->None
    (Pdb) x
    1
    (Pdb) continue

    >>> with PdbTestInput(['x', 'continue']):
    ...     x=0
    ...     pdb_invoke('runeval', compile('x+1', '<string>', 'eval'))
    > <string>(1)<module>()->None
    (Pdb) x
    1
    (Pdb) continue
    N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_pdb_run_with_code_objectBsutest_pdb_run_with_code_objectc

BsP|EeZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�ZdS(uPdbTestCasec	Cs�d
}t|d��}|j
tj|
�
�

WdQX|jtj|�
tjdd|g}d}}t
j|dt
jdt
jdt
j
�
�%}|jtj|�
�
\}}WdQX|o�tj|�
}|o�tj|�
}||fS(	u3Run 'script' lines with pdb and the pdb 'commands'.umain.pyu
wNu-mupdbustdoutustdinustderr(uopenuwriteutextwrapudedentu
addCleanupusupportuunlinkusysu
executableuNoneu
subprocessuPopenuPIPEuSTDOUTucommunicateustruencodeubytesudecode(	uselfuscriptucommandsufilenameu
fucmdustdoutustderruproc((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyurun_pdb[s







	


$


uPdbTestCase.run_pdbc
Cs�tt
jd
��}
|
jd�

WdQXtjddt
jg}tj|dtjdtjdtj	�
}|j
|jj�

|j
d�
\}}|jd	|d
�
dS(Nuwbsprint("testing my pdb")
u-mupdbustdoutustdinustderrsquit
sSyntaxErroru0Got a syntax error running test script under PDB(uopenusupportuTESTFNuwriteusysu
executableu
subprocessuPopenuPIPEuSTDOUTu
addCleanupustdoutucloseucommunicateuassertNotIn(uselfu
fucmduprocustdoutustderr((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_issue7964ls



	
	



uPdbTestCase.test_issue7964c

Cs�d
}
d}d}tdd��}|j
tj|�
�

WdQX|jtjd�
|j|
|�\}}|jt	dd�|j
�D�
�
d�
dS(	Nu�
            from bar import bar

            def foo():
                bar()

            def nope():
                pass

            def foobar():
                foo()
                nope()

            foobar()
        u�
            from bar import bar
            break bar
            continue
            step
            step
            quit
        u5
            def bar():
                pass
        ubar.pyu
wc
ss|]}
d|
kV
qd
S(umain.py(5)foo()->NoneN((u.0u
l((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu	<genexpr>�su.PdbTestCase.test_issue13183.<locals>.<genexpr>u+Fail to step into the caller after a return(uopenuwriteutextwrapudedentu
addCleanupusupportuunlinkurun_pdbu
assertTrueuanyu
splitlines(uselfuscriptucommandsubaru
fustdoutustderr((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_issue13183{s






uPdbTestCase.test_issue13183c
Cs�tj
d
�

ttjd��&}
|
jtjd�
jd�
�

WdQXtj	dtjg}t
j|dt
jdt
jdt
j
�
}|j|jj�

|jd	�
\}}|jd
|j�d�
dS(Nu	threadinguwbu

                import threading
                import pdb

                def start_pdb():
                    pdb.Pdb().set_trace()
                    x = 1
                    y = 1

                t = threading.Thread(target=start_pdb)
                t.start()uasciiu-uustdoutustdinustderrscont
uErroru*Got an error running test script under PDB(usupportu
import_moduleuopenuTESTFNuwriteutextwrapudedentuencodeusysu
executableu
subprocessuPopenuPIPEuSTDOUTu
addCleanupustdoutucloseucommunicateuassertNotInudecode(uselfu
fucmduprocustdoutustderr((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_issue13210�s





	
	



uPdbTestCase.test_issue13210c

Cstj
tj�

dS(
N(usupportuunlinkuTESTFN(
uself((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutearDown�s
uPdbTestCase.tearDownN(u__name__u
__module__u__qualname__urun_pdbutest_issue7964utest_issue13183utest_issue13210utearDown(
u
__locals__((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyuPdbTestCaseYs
$uPdbTestCasecGs;d
dlm
}

tjt�
tj|
�
g}tj|�
S(Ni(
utest_pdb(utestutest_pdbuunittestu	makeSuiteuPdbTestCaseudoctestuDocTestSuiteu	TestSuite(uargsutest_pdbusuites((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu
load_tests�s


u
load_testsu__main__(#udoctestuimpupdbusysuunittestu
subprocessutextwraputestusupportutest.test_doctestu
_FakeInputuobjectuPdbTestInpututest_pdb_displayhookutest_pdb_basic_commandsutest_pdb_breakpoint_commandsu
do_nothingudo_somethingutest_list_commandsutest_post_mortemutest_pdb_skip_modulesu
new_moduleumoduexecu__dict__u#test_pdb_skip_modules_with_callbacku test_pdb_continue_in_bottomframeu
pdb_invokeu$test_pdb_run_with_incorrect_argumentutest_pdb_run_with_code_objectuTestCaseuPdbTestCaseu
load_testsu__name__umain(((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu<module>s8





nk`>
+*h