Your IP : 216.73.216.213

Current Path : /proc/242857/root/opt/alt/python33/lib64/python3.3/test/__pycache__/
Upload File :
Current File : //proc/242857/root/opt/alt/python33/lib64/python3.3/test/__pycache__/test_pdb.cpython-33.pyc

�
��f$Wc@s�ddlZddlZddlZddlZddlZddlZddlZddlmZddl	m
Z
Gdd�de�Zdd�Z
dd	�Zd
d�Zdd
�Zdd�Zdd�Zdd�Zdd�Zejd�Zedej�dd�Zdd�Zdd�Zdd�Zd d!�ZGd"d#�d#ej�Zd$d%�Z e!d&kr�ej"�ndS('iN(usupport(u
_FakeInputcBs>|EeZdZdZdd�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__suPdbTestInput.__init__cCsFtj|_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__cGs,|jt_|jr(tj|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PdbTestInputcCsdS(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_displayhookcCsdS(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_commandscCsdS(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_commandscCsdS(N((((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyu
do_nothingsu
do_nothingcCstd�dS(Ni*(uprint(((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyudo_somethingsudo_somethingcCsdS(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_commandssutest_list_commandscCsdS(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_mortemcCsdS(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 NonecCsdS(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_callbackcCsdS(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/ddl}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_invokecCsdS(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_argumentcCsdS(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_objectcBsP|EeZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS(uPdbTestCasec	Cs�d}t|d��}|jtj|��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.pyuwNu-mupdbustdoutustdinustderr(uopenuwriteutextwrapudedentu
addCleanupusupportuunlinkusysu
executableuNoneu
subprocessuPopenuPIPEuSTDOUTucommunicateustruencodeubytesudecode(	uselfuscriptucommandsufilenameufucmdustdoutustderruproc((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyurun_pdb[s
	$uPdbTestCase.run_pdbcCs�ttjd��}|jd�WdQXtjddtjg}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(uselfufucmduprocustdoutustderr((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_issue7964ls		uPdbTestCase.test_issue7964c
Cs�d}d}d}tdd��}|jtj|��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.pyuwcss|]}d|kVqdS(umain.py(5)foo()->NoneN((u.0ul((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(uselfuscriptucommandsubarufustdoutustderr((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_issue13183{suPdbTestCase.test_issue13183cCs�tjd�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(uselfufucmduprocustdoutustderr((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutest_issue13210�s

		uPdbTestCase.test_issue13210cCstjtj�dS(N(usupportuunlinkuTESTFN(uself((u2/opt/alt/python33/lib64/python3.3/test/test_pdb.pyutearDown�suPdbTestCase.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;ddlm}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�su
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