def test_2():
    d = globals().copy()
    def testfunc():
        global x
        x = 1
    d['testfunc'] = testfunc
    profile.runctx("testfunc()", d, d, TESTFN)
    vereq (x, 1)
    os.unlink (TESTFN)

def test_anon():
    print "  anonymous mmap.mmap(-1, PAGESIZE)..."
    m = mmap.mmap(-1, PAGESIZE)
    for x in xrange(PAGESIZE):
        verify(m[x] == '\0', "anonymously mmap'ed contents should be zero")

    for x in xrange(PAGESIZE):
        m[x] = ch = chr(x & 255)
        vereq(m[x], ch)

def test_3():
    result = []
    def testfunc1():
        try: len(None)
        except: pass
        try: len(None)
        except: pass
        result.append(True)
    def testfunc2():
        testfunc1()
        testfunc1()
    profile.runctx("testfunc2()", locals(), locals(), TESTFN)
    vereq(result, [True, True])
    os.unlink(TESTFN)

def test_pack_into():
    test_string = 'Reykjavik rocks, eow!'
    writable_buf = array.array('c', ' '*100)
    fmt = '21s'
    s = struct.Struct(fmt)

    # Test without offset
    s.pack_into(writable_buf, 0, test_string)
    from_buf = writable_buf.tostring()[:len(test_string)]
    vereq(from_buf, test_string)

    # Test with offset.
    s.pack_into(writable_buf, 10, test_string)
    from_buf = writable_buf.tostring()[:len(test_string)+10]
    vereq(from_buf, test_string[:10] + test_string)

    # Go beyond boundaries.
    small_buf = array.array('c', ' '*10)
    assertRaises(struct.error, s.pack_into, small_buf, 0, test_string)
    assertRaises(struct.error, s.pack_into, small_buf, 2, test_string)

def test_pack_into_fn():
    test_string = 'Reykjavik rocks, eow!'
    writable_buf = array.array('c', ' '*100)
    fmt = '21s'
    pack_into = lambda *args: struct.pack_into(fmt, *args)

    # Test without offset.
    pack_into(writable_buf, 0, test_string)
    from_buf = writable_buf.tostring()[:len(test_string)]
    vereq(from_buf, test_string)

    # Test with offset.
    pack_into(writable_buf, 10, test_string)
    from_buf = writable_buf.tostring()[:len(test_string)+10]
    vereq(from_buf, test_string[:10] + test_string)

    # Go beyond boundaries.
    small_buf = array.array('c', ' '*10)
    assertRaises((struct.error, ValueError), pack_into, small_buf, 0, test_string)
    assertRaises((struct.error, ValueError), pack_into, small_buf, 2, test_string)

def test_saveall():
    # Verify that cyclic garbage like lists show up in gc.garbage if the
    # SAVEALL option is enabled.

    # First make sure we don't save away other stuff that just happens to
    # be waiting for collection.
    gc.collect()
    vereq(gc.garbage, []) # if this fails, someone else created immortal trash

    L = []
    L.append(L)
    id_L = id(L)

    debug = gc.get_debug()
    gc.set_debug(debug | gc.DEBUG_SAVEALL)
    del L
    gc.collect()
    gc.set_debug(debug)

    vereq(len(gc.garbage), 1)
    obj = gc.garbage.pop()
    vereq(id(obj), id_L)

warnings.filterwarnings("ignore", r"import \*", SyntaxWarning, "<string>")

print "1. simple nesting"


def make_adder(x):
    def adder(y):
        return x + y

    return adder


inc = make_adder(1)
plus10 = make_adder(10)

vereq(inc(1), 2)
vereq(plus10(-2), 8)

print "2. extra nesting"


def make_adder2(x):
    def extra():  # check freevars passing through non-use scopes
        def adder(y):
            return x + y

        return adder

    return extra()

def checkfilename(brokencode):
    try:
        _symtable.symtable(brokencode, "spam", "exec")
    except SyntaxError, e:
        vereq(e.filename, "spam")

def test_unpack_from():
    test_string = 'abcd01234'
    fmt = '4s'
    s = struct.Struct(fmt)
    for cls in (str, buffer):
        data = cls(test_string)
        vereq(s.unpack_from(data), ('abcd',))
        vereq(s.unpack_from(data, 2), ('cd01',))
        vereq(s.unpack_from(data, 4), ('0123',))
        for i in xrange(6):
            vereq(s.unpack_from(data, i), (data[i:i+4],))
        for i in xrange(6, len(test_string) + 1):
            simple_err(s.unpack_from, data, i)
    for cls in (str, buffer):
        data = cls(test_string)
        vereq(struct.unpack_from(fmt, data), ('abcd',))
        vereq(struct.unpack_from(fmt, data, 2), ('cd01',))
        vereq(struct.unpack_from(fmt, data, 4), ('0123',))
        for i in xrange(6):
            vereq(struct.unpack_from(fmt, data, i), (data[i:i+4],))
        for i in xrange(6, len(test_string) + 1):
            simple_err(struct.unpack_from, fmt, data, i)

from test import test_support
import StringIO

# SF bug 480215:  softspace confused in nested print
f = StringIO.StringIO()
class C:
    def __str__(self):
        print >> f, 'a'
        return 'b'

print >> f, C(), 'c ', 'd\t', 'e'
print >> f, 'f', 'g'
# In 2.2 & earlier, this printed ' a\nbc  d\te\nf g\n'
test_support.vereq(f.getvalue(), 'a\nb c  d\te\nf g\n')

from test.test_support import vereq, TestFailed

import _symtable

symbols = _symtable.symtable("def f(x): return x", "?", "exec")

vereq(symbols[0].name, "global")
vereq(len([ste for ste in symbols.values() if ste.name == "f"]), 1)

# Bug tickler: SyntaxError file name correct whether error raised
# while parsing or building symbol table.
def checkfilename(brokencode):
    try:
        _symtable.symtable(brokencode, "spam", "exec")
    except SyntaxError, e:
        vereq(e.filename, "spam")
    else:
        raise TestFailed("no SyntaxError for %r" % (brokencode,))


checkfilename("def f(x): foo)(")  # parse-time
checkfilename("def f(x): global x")  # symtable-build-time

    pass


def f3(two, arguments):
    pass


def f4(two, (compound, (argument, list))):
    pass


def f5((compound, first), two):
    pass


vereq(f2.func_code.co_varnames, ("one_argument",))
vereq(f3.func_code.co_varnames, ("two", "arguments"))
if check_impl_detail(jython=True):
    vereq(f4.func_code.co_varnames, ("two", "(compound, (argument, list))", "compound", "argument", "list"))
    vereq(f5.func_code.co_varnames, ("(compound, first)", "two", "compound", "first"))
elif check_impl_detail(pypy=True):
    vereq(f4.func_code.co_varnames, ("two", ".2", "compound", "argument", "list"))
    vereq(f5.func_code.co_varnames, (".0", "two", "compound", "first"))
elif check_impl_detail(cpython=True):
    vereq(f4.func_code.co_varnames, ("two", ".1", "compound", "argument", "list"))
    vereq(f5.func_code.co_varnames, (".0", "two", "compound", "first"))


def a1(one_arg,):
    pass

### varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME]
###            | ('**'|'*' '*') NAME)
###            | fpdef ['=' test] (',' fpdef ['=' test])* [',']
### fpdef: NAME | '(' fplist ')'
### fplist: fpdef (',' fpdef)* [',']
### arglist: (argument ',')* (argument | *' test [',' '**' test] | '**' test)
### argument: [test '='] test   # Really [keyword '='] test
def f1(): pass
f1()
f1(*())
f1(*(), **{})
def f2(one_argument): pass
def f3(two, arguments): pass
def f4(two, (compound, (argument, list))): pass
def f5((compound, first), two): pass
vereq(f2.func_code.co_varnames, ('one_argument',))
vereq(f3.func_code.co_varnames, ('two', 'arguments'))
if sys.platform.startswith('java'):
    vereq(f4.func_code.co_varnames,
           ('two', '(compound, (argument, list))', 'compound', 'argument',
                        'list',))
    vereq(f5.func_code.co_varnames,
           ('(compound, first)', 'two', 'compound', 'first'))
else:
    vereq(f4.func_code.co_varnames,
          ('two', '.1', 'compound', 'argument',  'list'))
    vereq(f5.func_code.co_varnames,
          ('.0', 'two', 'compound', 'first'))
def a1(one_arg,): pass
def a2(two, args,): pass
def v0(*rest): pass

atexit.register(handler1)
atexit.register(handler2)
atexit.register(handler2, 7, kw="abc")
"""

fname = TESTFN + ".py"
f = file(fname, "w")
f.write(input)
f.close()

p = popen('"%s" %s' % (executable, fname))
output = p.read()
p.close()
vereq(output, """\
handler2 (7,) {'kw': 'abc'}
handler2 () {}
handler1
""")

input = """\
def direct():
    print "direct exit"

import sys
sys.exitfunc = direct

# Make sure atexit doesn't drop
def indirect():
    print "indirect exit"

import atexit

def test_unpack_with_buffer():
    # SF bug 1563759: struct.unpack doens't support buffer protocol objects
    data = array.array('B', '\x12\x34\x56\x78')
    value, = struct.unpack('>I', data)
    vereq(value, 0x12345678)

from test.test_support import verify, vereq, verbose, TestFailed

import sys
module = type(sys)

# An uninitialized module has no __dict__ or __name__, and __doc__ is None
foo = module.__new__(module)
verify(foo.__dict__ is None)
try:
    s = foo.__name__
except AttributeError:
    pass
else:
    raise TestFailed, "__name__ = %s" % repr(s)
vereq(foo.__doc__, module.__doc__)

# Regularly initialized module, no docstring
foo = module("foo")
vereq(foo.__name__, "foo")
vereq(foo.__doc__, None)
vereq(foo.__dict__, {"__name__": "foo", "__doc__": None})

# ASCII docstring
foo = module("foo", "foodoc")
vereq(foo.__name__, "foo")
vereq(foo.__doc__, "foodoc")
vereq(foo.__dict__, {"__name__": "foo", "__doc__": "foodoc"})

# Unicode docstring
foo = module("foo", u"foodoc\u1234")

def test_both():
    "Test mmap module on Unix systems and Windows"

    # Create a file to be mmap'ed.
    if os.path.exists(TESTFN):
        os.unlink(TESTFN)
    f = open(TESTFN, 'w+')

    try:    # unlink TESTFN no matter what
        # Write 2 pages worth of data to the file
        f.write('\0'* PAGESIZE)
        f.write('foo')
        f.write('\0'* (PAGESIZE-3) )
        f.flush()
        m = mmap.mmap(f.fileno(), 2 * PAGESIZE)
        f.close()

        # Simple sanity checks

        print type(m)  # SF bug 128713:  segfaulted on Linux
        print '  Position of foo:', m.find('foo') / float(PAGESIZE), 'pages'
        vereq(m.find('foo'), PAGESIZE)

        print '  Length of file:', len(m) / float(PAGESIZE), 'pages'
        vereq(len(m), 2*PAGESIZE)

        print '  Contents of byte 0:', repr(m[0])
        vereq(m[0], '\0')
        print '  Contents of first 3 bytes:', repr(m[0:3])
        vereq(m[0:3], '\0\0\0')

        # Modify the file's content
        print "\n  Modifying file's content..."
        m[0] = '3'
        m[PAGESIZE +3: PAGESIZE +3+3] = 'bar'

        # Check that the modification worked
        print '  Contents of byte 0:', repr(m[0])
        vereq(m[0], '3')
        print '  Contents of first 3 bytes:', repr(m[0:3])
        vereq(m[0:3], '3\0\0')
        print '  Contents of second page:',  repr(m[PAGESIZE-1 : PAGESIZE + 7])
        vereq(m[PAGESIZE-1 : PAGESIZE + 7], '\0foobar\0')

        m.flush()

        # Test doing a regular expression match in an mmap'ed file
        match = re.search('[A-Za-z]+', m)
        if match is None:
            print '  ERROR: regex match on mmap failed!'
        else:
            start, end = match.span(0)
            length = end - start

            print '  Regex match on mmap (page start, length of match):',
            print start / float(PAGESIZE), length

            vereq(start, PAGESIZE)
            vereq(end, PAGESIZE + 6)

        # test seeking around (try to overflow the seek implementation)
        m.seek(0,0)
        print '  Seek to zeroth byte'
        vereq(m.tell(), 0)
        m.seek(42,1)
        print '  Seek to 42nd byte'
        vereq(m.tell(), 42)
        m.seek(0,2)
        print '  Seek to last byte'
        vereq(m.tell(), len(m))

        print '  Try to seek to negative position...'
        try:
            m.seek(-1)
        except ValueError:
            pass
        else:
            verify(0, 'expected a ValueError but did not get it')

        print '  Try to seek beyond end of mmap...'
        try:
            m.seek(1,2)
        except ValueError:
            pass
        else:
            verify(0, 'expected a ValueError but did not get it')

        print '  Try to seek to negative position...'
        try:
            m.seek(-len(m)-1,2)
        except ValueError:
            pass
        else:
            verify(0, 'expected a ValueError but did not get it')

        # Try resizing map
        print '  Attempting resize()'
        try:
            m.resize(512)
        except SystemError:
#.........这里部分代码省略.........

def test_issue4228():
    # Packing a long may yield either 32 or 64 bits
    x = struct.pack('L', -1)[:4]
    vereq(x, '\xff'*4)

            os.kill(pid, getattr(signal, signame))
            print >> sys.__stdout__, "    child sent", signame, "to", pid
            time.sleep(1)
    finally:
        os._exit(0)

# Install handlers.
hup = signal.signal(signal.SIGHUP, handlerA)
usr1 = signal.signal(signal.SIGUSR1, handlerB)
usr2 = signal.signal(signal.SIGUSR2, signal.SIG_IGN)
alrm = signal.signal(signal.SIGALRM, signal.default_int_handler)

try:

    signal.alarm(MAX_DURATION)
    vereq(signal.getsignal(signal.SIGHUP), handlerA)
    vereq(signal.getsignal(signal.SIGUSR1), handlerB)
    vereq(signal.getsignal(signal.SIGUSR2), signal.SIG_IGN)
    vereq(signal.getsignal(signal.SIGALRM), signal.default_int_handler)

    # Try to ensure this test exits even if there is some problem with alarm.
    # Tru64/Alpha often hangs and is ultimately killed by the buildbot.
    fork_pid = force_test_exit()

    try:
        signal.getsignal(4242)
        raise TestFailed('expected ValueError for invalid signal # to '
                         'getsignal()')
    except ValueError:
        pass

def test_both():
    "Test mmap module on Unix systems and Windows"

    # Create a file to be mmap'ed.
    if os.path.exists(TESTFN):
        os.unlink(TESTFN)
    f = open(TESTFN, "w+")

    try:  # unlink TESTFN no matter what
        # Write 2 pages worth of data to the file
        f.write("\0" * PAGESIZE)
        f.write("foo")
        f.write("\0" * (PAGESIZE - 3))
        f.flush()
        m = mmap.mmap(f.fileno(), 2 * PAGESIZE)
        f.close()

        # Simple sanity checks

        print type(m)  # SF bug 128713:  segfaulted on Linux
        print "  Position of foo:", m.find("foo") / float(PAGESIZE), "pages"
        vereq(m.find("foo"), PAGESIZE)

        print "  Length of file:", len(m) / float(PAGESIZE), "pages"
        vereq(len(m), 2 * PAGESIZE)

        print "  Contents of byte 0:", repr(m[0])
        vereq(m[0], "\0")
        print "  Contents of first 3 bytes:", repr(m[0:3])
        vereq(m[0:3], "\0\0\0")

        # Modify the file's content
        print "\n  Modifying file's content..."
        m[0] = "3"
        m[PAGESIZE + 3 : PAGESIZE + 3 + 3] = "bar"

        # Check that the modification worked
        print "  Contents of byte 0:", repr(m[0])
        vereq(m[0], "3")
        print "  Contents of first 3 bytes:", repr(m[0:3])
        vereq(m[0:3], "3\0\0")
        print "  Contents of second page:", repr(m[PAGESIZE - 1 : PAGESIZE + 7])
        vereq(m[PAGESIZE - 1 : PAGESIZE + 7], "\0foobar\0")

        m.flush()

        # Test doing a regular expression match in an mmap'ed file
        match = re.search("[A-Za-z]+", m)
        if match is None:
            print "  ERROR: regex match on mmap failed!"
        else:
            start, end = match.span(0)
            length = end - start

            print "  Regex match on mmap (page start, length of match):",
            print start / float(PAGESIZE), length

            vereq(start, PAGESIZE)
            vereq(end, PAGESIZE + 6)

        # test seeking around (try to overflow the seek implementation)
        m.seek(0, 0)
        print "  Seek to zeroth byte"
        vereq(m.tell(), 0)
        m.seek(42, 1)
        print "  Seek to 42nd byte"
        vereq(m.tell(), 42)
        m.seek(0, 2)
        print "  Seek to last byte"
        vereq(m.tell(), len(m))

        print "  Try to seek to negative position..."
        try:
            m.seek(-1)
        except ValueError:
            pass
        else:
            verify(0, "expected a ValueError but did not get it")

        print "  Try to seek beyond end of mmap..."
        try:
            m.seek(1, 2)
        except ValueError:
            pass
        else:
            verify(0, "expected a ValueError but did not get it")

        print "  Try to seek to negative position..."
        try:
            m.seek(-len(m) - 1, 2)
        except ValueError:
            pass
        else:
            verify(0, "expected a ValueError but did not get it")

        # Try resizing map
        print "  Attempting resize()"
        try:
            m.resize(512)
        except SystemError:
#.........这里部分代码省略.........