[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / regrtest.py

#! /usr/bin/env python\r
\r
"""\r
Usage:\r
\r
python -m test.regrtest [options] [test_name1 [test_name2 ...]]\r
python path/to/Lib/test/regrtest.py [options] [test_name1 [test_name2 ...]]\r
\r
\r
If no arguments or options are provided, finds all files matching\r
the pattern "test_*" in the Lib/test subdirectory and runs\r
them in alphabetical order (but see -M and -u, below, for exceptions).\r
\r
For more rigorous testing, it is useful to use the following\r
command line:\r
\r
python -E -tt -Wd -3 -m test.regrtest [options] [test_name1 ...]\r
\r
\r
Options:\r
\r
-h/--help       -- print this text and exit\r
\r
Verbosity\r
\r
-v/--verbose    -- run tests in verbose mode with output to stdout\r
-w/--verbose2   -- re-run failed tests in verbose mode\r
-W/--verbose3   -- re-run failed tests in verbose mode immediately\r
-q/--quiet      -- no output unless one or more tests fail\r
-S/--slow       -- print the slowest 10 tests\r
   --header     -- print header with interpreter info\r
\r
Selecting tests\r
\r
-r/--random     -- randomize test execution order (see below)\r
   --randseed   -- pass a random seed to reproduce a previous random run\r
-f/--fromfile   -- read names of tests to run from a file (see below)\r
-x/--exclude    -- arguments are tests to *exclude*\r
-s/--single     -- single step through a set of tests (see below)\r
-u/--use RES1,RES2,...\r
                -- specify which special resource intensive tests to run\r
-M/--memlimit LIMIT\r
                -- run very large memory-consuming tests\r
\r
Special runs\r
\r
-l/--findleaks  -- if GC is available detect tests that leak memory\r
-L/--runleaks   -- run the leaks(1) command just before exit\r
-R/--huntrleaks RUNCOUNTS\r
                -- search for reference leaks (needs debug build, v. slow)\r
-j/--multiprocess PROCESSES\r
                -- run PROCESSES processes at once\r
-T/--coverage   -- turn on code coverage tracing using the trace module\r
-D/--coverdir DIRECTORY\r
                -- Directory where coverage files are put\r
-N/--nocoverdir -- Put coverage files alongside modules\r
-t/--threshold THRESHOLD\r
                -- call gc.set_threshold(THRESHOLD)\r
-F/--forever    -- run the specified tests in a loop, until an error happens\r
\r
\r
Additional Option Details:\r
\r
-r randomizes test execution order. You can use --randseed=int to provide a\r
int seed value for the randomizer; this is useful for reproducing troublesome\r
test orders.\r
\r
-s On the first invocation of regrtest using -s, the first test file found\r
or the first test file given on the command line is run, and the name of\r
the next test is recorded in a file named pynexttest.  If run from the\r
Python build directory, pynexttest is located in the 'build' subdirectory,\r
otherwise it is located in tempfile.gettempdir().  On subsequent runs,\r
the test in pynexttest is run, and the next test is written to pynexttest.\r
When the last test has been run, pynexttest is deleted.  In this way it\r
is possible to single step through the test files.  This is useful when\r
doing memory analysis on the Python interpreter, which process tends to\r
consume too many resources to run the full regression test non-stop.\r
\r
-f reads the names of tests from the file given as f's argument, one\r
or more test names per line.  Whitespace is ignored.  Blank lines and\r
lines beginning with '#' are ignored.  This is especially useful for\r
whittling down failures involving interactions among tests.\r
\r
-L causes the leaks(1) command to be run just before exit if it exists.\r
leaks(1) is available on Mac OS X and presumably on some other\r
FreeBSD-derived systems.\r
\r
-R runs each test several times and examines sys.gettotalrefcount() to\r
see if the test appears to be leaking references.  The argument should\r
be of the form stab:run:fname where 'stab' is the number of times the\r
test is run to let gettotalrefcount settle down, 'run' is the number\r
of times further it is run and 'fname' is the name of the file the\r
reports are written to.  These parameters all have defaults (5, 4 and\r
"reflog.txt" respectively), and the minimal invocation is '-R :'.\r
\r
-M runs tests that require an exorbitant amount of memory. These tests\r
typically try to ascertain containers keep working when containing more than\r
2 billion objects, which only works on 64-bit systems. There are also some\r
tests that try to exhaust the address space of the process, which only makes\r
sense on 32-bit systems with at least 2Gb of memory. The passed-in memlimit,\r
which is a string in the form of '2.5Gb', determines howmuch memory the\r
tests will limit themselves to (but they may go slightly over.) The number\r
shouldn't be more memory than the machine has (including swap memory). You\r
should also keep in mind that swap memory is generally much, much slower\r
than RAM, and setting memlimit to all available RAM or higher will heavily\r
tax the machine. On the other hand, it is no use running these tests with a\r
limit of less than 2.5Gb, and many require more than 20Gb. Tests that expect\r
to use more than memlimit memory will be skipped. The big-memory tests\r
generally run very, very long.\r
\r
-u is used to specify which special resource intensive tests to run,\r
such as those requiring large file support or network connectivity.\r
The argument is a comma-separated list of words indicating the\r
resources to test.  Currently only the following are defined:\r
\r
    all -       Enable all special resources.\r
\r
    audio -     Tests that use the audio device.  (There are known\r
                cases of broken audio drivers that can crash Python or\r
                even the Linux kernel.)\r
\r
    curses -    Tests that use curses and will modify the terminal's\r
                state and output modes.\r
\r
    largefile - It is okay to run some test that may create huge\r
                files.  These tests can take a long time and may\r
                consume >2GB of disk space temporarily.\r
\r
    network -   It is okay to run tests that use external network\r
                resource, e.g. testing SSL support for sockets.\r
\r
    bsddb -     It is okay to run the bsddb testsuite, which takes\r
                a long time to complete.\r
\r
    decimal -   Test the decimal module against a large suite that\r
                verifies compliance with standards.\r
\r
    cpu -       Used for certain CPU-heavy tests.\r
\r
    subprocess  Run all tests for the subprocess module.\r
\r
    urlfetch -  It is okay to download files required on testing.\r
\r
    gui -       Run tests that require a running GUI.\r
\r
    xpickle -   Test pickle and cPickle against Python 2.4, 2.5 and 2.6 to\r
                test backwards compatibility. These tests take a long time\r
                to run.\r
\r
To enable all resources except one, use '-uall,-<resource>'.  For\r
example, to run all the tests except for the bsddb tests, give the\r
option '-uall,-bsddb'.\r
"""\r
\r
import StringIO\r
import getopt\r
import json\r
import os\r
import random\r
import re\r
import sys\r
import time\r
import traceback\r
import warnings\r
import unittest\r
import tempfile\r
import imp\r
import platform\r
import sysconfig\r
\r
\r
# Some times __path__ and __file__ are not absolute (e.g. while running from\r
# Lib/) and, if we change the CWD to run the tests in a temporary dir, some\r
# imports might fail.  This affects only the modules imported before os.chdir().\r
# These modules are searched first in sys.path[0] (so '' -- the CWD) and if\r
# they are found in the CWD their __file__ and __path__ will be relative (this\r
# happens before the chdir).  All the modules imported after the chdir, are\r
# not found in the CWD, and since the other paths in sys.path[1:] are absolute\r
# (site.py absolutize them), the __file__ and __path__ will be absolute too.\r
# Therefore it is necessary to absolutize manually the __file__ and __path__ of\r
# the packages to prevent later imports to fail when the CWD is different.\r
for module in sys.modules.itervalues():\r
    if hasattr(module, '__path__'):\r
        module.__path__ = [os.path.abspath(path) for path in module.__path__]\r
    if hasattr(module, '__file__'):\r
        module.__file__ = os.path.abspath(module.__file__)\r
\r
\r
# MacOSX (a.k.a. Darwin) has a default stack size that is too small\r
# for deeply recursive regular expressions.  We see this as crashes in\r
# the Python test suite when running test_re.py and test_sre.py.  The\r
# fix is to set the stack limit to 2048.\r
# This approach may also be useful for other Unixy platforms that\r
# suffer from small default stack limits.\r
if sys.platform == 'darwin':\r
    try:\r
        import resource\r
    except ImportError:\r
        pass\r
    else:\r
        soft, hard = resource.getrlimit(resource.RLIMIT_STACK)\r
        newsoft = min(hard, max(soft, 1024*2048))\r
        resource.setrlimit(resource.RLIMIT_STACK, (newsoft, hard))\r
\r
# Test result constants.\r
PASSED = 1\r
FAILED = 0\r
ENV_CHANGED = -1\r
SKIPPED = -2\r
RESOURCE_DENIED = -3\r
INTERRUPTED = -4\r
\r
from test import test_support\r
\r
RESOURCE_NAMES = ('audio', 'curses', 'largefile', 'network', 'bsddb',\r
                  'decimal', 'cpu', 'subprocess', 'urlfetch', 'gui',\r
                  'xpickle')\r
\r
TEMPDIR = os.path.abspath(tempfile.gettempdir())\r
\r
\r
def usage(code, msg=''):\r
    print __doc__\r
    if msg: print msg\r
    sys.exit(code)\r
\r
\r
def main(tests=None, testdir=None, verbose=0, quiet=False,\r
         exclude=False, single=False, randomize=False, fromfile=None,\r
         findleaks=False, use_resources=None, trace=False, coverdir='coverage',\r
         runleaks=False, huntrleaks=False, verbose2=False, print_slow=False,\r
         random_seed=None, use_mp=None, verbose3=False, forever=False,\r
         header=False):\r
    """Execute a test suite.\r
\r
    This also parses command-line options and modifies its behavior\r
    accordingly.\r
\r
    tests -- a list of strings containing test names (optional)\r
    testdir -- the directory in which to look for tests (optional)\r
\r
    Users other than the Python test suite will certainly want to\r
    specify testdir; if it's omitted, the directory containing the\r
    Python test suite is searched for.\r
\r
    If the tests argument is omitted, the tests listed on the\r
    command-line will be used.  If that's empty, too, then all *.py\r
    files beginning with test_ will be used.\r
\r
    The other default arguments (verbose, quiet, exclude,\r
    single, randomize, findleaks, use_resources, trace, coverdir,\r
    print_slow, and random_seed) allow programmers calling main()\r
    directly to set the values that would normally be set by flags\r
    on the command line.\r
    """\r
\r
    test_support.record_original_stdout(sys.stdout)\r
    try:\r
        opts, args = getopt.getopt(sys.argv[1:], 'hvqxsSrf:lu:t:TD:NLR:FwWM:j:',\r
            ['help', 'verbose', 'verbose2', 'verbose3', 'quiet',\r
             'exclude', 'single', 'slow', 'random', 'fromfile', 'findleaks',\r
             'use=', 'threshold=', 'trace', 'coverdir=', 'nocoverdir',\r
             'runleaks', 'huntrleaks=', 'memlimit=', 'randseed=',\r
             'multiprocess=', 'slaveargs=', 'forever', 'header'])\r
    except getopt.error, msg:\r
        usage(2, msg)\r
\r
    # Defaults\r
    if random_seed is None:\r
        random_seed = random.randrange(10000000)\r
    if use_resources is None:\r
        use_resources = []\r
    for o, a in opts:\r
        if o in ('-h', '--help'):\r
            usage(0)\r
        elif o in ('-v', '--verbose'):\r
            verbose += 1\r
        elif o in ('-w', '--verbose2'):\r
            verbose2 = True\r
        elif o in ('-W', '--verbose3'):\r
            verbose3 = True\r
        elif o in ('-q', '--quiet'):\r
            quiet = True;\r
            verbose = 0\r
        elif o in ('-x', '--exclude'):\r
            exclude = True\r
        elif o in ('-s', '--single'):\r
            single = True\r
        elif o in ('-S', '--slow'):\r
            print_slow = True\r
        elif o in ('-r', '--randomize'):\r
            randomize = True\r
        elif o == '--randseed':\r
            random_seed = int(a)\r
        elif o in ('-f', '--fromfile'):\r
            fromfile = a\r
        elif o in ('-l', '--findleaks'):\r
            findleaks = True\r
        elif o in ('-L', '--runleaks'):\r
            runleaks = True\r
        elif o in ('-t', '--threshold'):\r
            import gc\r
            gc.set_threshold(int(a))\r
        elif o in ('-T', '--coverage'):\r
            trace = True\r
        elif o in ('-D', '--coverdir'):\r
            coverdir = os.path.join(os.getcwd(), a)\r
        elif o in ('-N', '--nocoverdir'):\r
            coverdir = None\r
        elif o in ('-R', '--huntrleaks'):\r
            huntrleaks = a.split(':')\r
            if len(huntrleaks) not in (2, 3):\r
                print a, huntrleaks\r
                usage(2, '-R takes 2 or 3 colon-separated arguments')\r
            if not huntrleaks[0]:\r
                huntrleaks[0] = 5\r
            else:\r
                huntrleaks[0] = int(huntrleaks[0])\r
            if not huntrleaks[1]:\r
                huntrleaks[1] = 4\r
            else:\r
                huntrleaks[1] = int(huntrleaks[1])\r
            if len(huntrleaks) == 2 or not huntrleaks[2]:\r
                huntrleaks[2:] = ["reflog.txt"]\r
        elif o in ('-M', '--memlimit'):\r
            test_support.set_memlimit(a)\r
        elif o in ('-u', '--use'):\r
            u = [x.lower() for x in a.split(',')]\r
            for r in u:\r
                if r == 'all':\r
                    use_resources[:] = RESOURCE_NAMES\r
                    continue\r
                remove = False\r
                if r[0] == '-':\r
                    remove = True\r
                    r = r[1:]\r
                if r not in RESOURCE_NAMES:\r
                    usage(1, 'Invalid -u/--use option: ' + a)\r
                if remove:\r
                    if r in use_resources:\r
                        use_resources.remove(r)\r
                elif r not in use_resources:\r
                    use_resources.append(r)\r
        elif o in ('-F', '--forever'):\r
            forever = True\r
        elif o in ('-j', '--multiprocess'):\r
            use_mp = int(a)\r
        elif o == '--header':\r
            header = True\r
        elif o == '--slaveargs':\r
            args, kwargs = json.loads(a)\r
            try:\r
                result = runtest(*args, **kwargs)\r
            except BaseException, e:\r
                result = INTERRUPTED, e.__class__.__name__\r
            print   # Force a newline (just in case)\r
            print json.dumps(result)\r
            sys.exit(0)\r
        else:\r
            print >>sys.stderr, ("No handler for option {}.  Please "\r
                "report this as a bug at http://bugs.python.org.").format(o)\r
            sys.exit(1)\r
    if single and fromfile:\r
        usage(2, "-s and -f don't go together!")\r
    if use_mp and trace:\r
        usage(2, "-T and -j don't go together!")\r
    if use_mp and findleaks:\r
        usage(2, "-l and -j don't go together!")\r
\r
    good = []\r
    bad = []\r
    skipped = []\r
    resource_denieds = []\r
    environment_changed = []\r
    interrupted = False\r
\r
    if findleaks:\r
        try:\r
            import gc\r
        except ImportError:\r
            print 'No GC available, disabling findleaks.'\r
            findleaks = False\r
        else:\r
            # Uncomment the line below to report garbage that is not\r
            # freeable by reference counting alone.  By default only\r
            # garbage that is not collectable by the GC is reported.\r
            #gc.set_debug(gc.DEBUG_SAVEALL)\r
            found_garbage = []\r
\r
    if single:\r
        filename = os.path.join(TEMPDIR, 'pynexttest')\r
        try:\r
            fp = open(filename, 'r')\r
            next_test = fp.read().strip()\r
            tests = [next_test]\r
            fp.close()\r
        except IOError:\r
            pass\r
\r
    if fromfile:\r
        tests = []\r
        fp = open(os.path.join(test_support.SAVEDCWD, fromfile))\r
        for line in fp:\r
            guts = line.split() # assuming no test has whitespace in its name\r
            if guts and not guts[0].startswith('#'):\r
                tests.extend(guts)\r
        fp.close()\r
\r
    # Strip .py extensions.\r
    removepy(args)\r
    removepy(tests)\r
\r
    stdtests = STDTESTS[:]\r
    nottests = NOTTESTS.copy()\r
    if exclude:\r
        for arg in args:\r
            if arg in stdtests:\r
                stdtests.remove(arg)\r
            nottests.add(arg)\r
        args = []\r
\r
    # For a partial run, we do not need to clutter the output.\r
    if verbose or header or not (quiet or single or tests or args):\r
        # Print basic platform information\r
        print "==", platform.python_implementation(), \\r
                    " ".join(sys.version.split())\r
        print "==  ", platform.platform(aliased=True), \\r
                      "%s-endian" % sys.byteorder\r
        print "==  ", os.getcwd()\r
        print "Testing with flags:", sys.flags\r
\r
    alltests = findtests(testdir, stdtests, nottests)\r
    selected = tests or args or alltests\r
    if single:\r
        selected = selected[:1]\r
        try:\r
            next_single_test = alltests[alltests.index(selected[0])+1]\r
        except IndexError:\r
            next_single_test = None\r
    if randomize:\r
        random.seed(random_seed)\r
        print "Using random seed", random_seed\r
        random.shuffle(selected)\r
    if trace:\r
        import trace\r
        tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix],\r
                             trace=False, count=True)\r
\r
    test_times = []\r
    test_support.use_resources = use_resources\r
    save_modules = sys.modules.keys()\r
\r
    def accumulate_result(test, result):\r
        ok, test_time = result\r
        test_times.append((test_time, test))\r
        if ok == PASSED:\r
            good.append(test)\r
        elif ok == FAILED:\r
            bad.append(test)\r
        elif ok == ENV_CHANGED:\r
            bad.append(test)\r
            environment_changed.append(test)\r
        elif ok == SKIPPED:\r
            skipped.append(test)\r
        elif ok == RESOURCE_DENIED:\r
            skipped.append(test)\r
            resource_denieds.append(test)\r
\r
    if forever:\r
        def test_forever(tests=list(selected)):\r
            while True:\r
                for test in tests:\r
                    yield test\r
                    if bad:\r
                        return\r
        tests = test_forever()\r
    else:\r
        tests = iter(selected)\r
\r
    if use_mp:\r
        try:\r
            from threading import Thread\r
        except ImportError:\r
            print "Multiprocess option requires thread support"\r
            sys.exit(2)\r
        from Queue import Queue\r
        from subprocess import Popen, PIPE\r
        debug_output_pat = re.compile(r"\[\d+ refs\]$")\r
        output = Queue()\r
        def tests_and_args():\r
            for test in tests:\r
                args_tuple = (\r
                    (test, verbose, quiet),\r
                    dict(huntrleaks=huntrleaks, use_resources=use_resources)\r
                )\r
                yield (test, args_tuple)\r
        pending = tests_and_args()\r
        opt_args = test_support.args_from_interpreter_flags()\r
        base_cmd = [sys.executable] + opt_args + ['-m', 'test.regrtest']\r
        def work():\r
            # A worker thread.\r
            try:\r
                while True:\r
                    try:\r
                        test, args_tuple = next(pending)\r
                    except StopIteration:\r
                        output.put((None, None, None, None))\r
                        return\r
                    # -E is needed by some tests, e.g. test_import\r
                    popen = Popen(base_cmd + ['--slaveargs', json.dumps(args_tuple)],\r
                                   stdout=PIPE, stderr=PIPE,\r
                                   universal_newlines=True,\r
                                   close_fds=(os.name != 'nt'))\r
                    stdout, stderr = popen.communicate()\r
                    # Strip last refcount output line if it exists, since it\r
                    # comes from the shutdown of the interpreter in the subcommand.\r
                    stderr = debug_output_pat.sub("", stderr)\r
                    stdout, _, result = stdout.strip().rpartition("\n")\r
                    if not result:\r
                        output.put((None, None, None, None))\r
                        return\r
                    result = json.loads(result)\r
                    if not quiet:\r
                        stdout = test+'\n'+stdout\r
                    output.put((test, stdout.rstrip(), stderr.rstrip(), result))\r
            except BaseException:\r
                output.put((None, None, None, None))\r
                raise\r
        workers = [Thread(target=work) for i in range(use_mp)]\r
        for worker in workers:\r
            worker.start()\r
        finished = 0\r
        try:\r
            while finished < use_mp:\r
                test, stdout, stderr, result = output.get()\r
                if test is None:\r
                    finished += 1\r
                    continue\r
                if stdout:\r
                    print stdout\r
                if stderr:\r
                    print >>sys.stderr, stderr\r
                if result[0] == INTERRUPTED:\r
                    assert result[1] == 'KeyboardInterrupt'\r
                    raise KeyboardInterrupt   # What else?\r
                accumulate_result(test, result)\r
        except KeyboardInterrupt:\r
            interrupted = True\r
            pending.close()\r
        for worker in workers:\r
            worker.join()\r
    else:\r
        for test in tests:\r
            if not quiet:\r
                print test\r
                sys.stdout.flush()\r
            if trace:\r
                # If we're tracing code coverage, then we don't exit with status\r
                # if on a false return value from main.\r
                tracer.runctx('runtest(test, verbose, quiet)',\r
                              globals=globals(), locals=vars())\r
            else:\r
                try:\r
                    result = runtest(test, verbose, quiet, huntrleaks)\r
                    accumulate_result(test, result)\r
                    if verbose3 and result[0] == FAILED:\r
                        print "Re-running test %r in verbose mode" % test\r
                        runtest(test, True, quiet, huntrleaks)\r
                except KeyboardInterrupt:\r
                    interrupted = True\r
                    break\r
                except:\r
                    raise\r
            if findleaks:\r
                gc.collect()\r
                if gc.garbage:\r
                    print "Warning: test created", len(gc.garbage),\r
                    print "uncollectable object(s)."\r
                    # move the uncollectable objects somewhere so we don't see\r
                    # them again\r
                    found_garbage.extend(gc.garbage)\r
                    del gc.garbage[:]\r
            # Unload the newly imported modules (best effort finalization)\r
            for module in sys.modules.keys():\r
                if module not in save_modules and module.startswith("test."):\r
                    test_support.unload(module)\r
\r
    if interrupted:\r
        # print a newline after ^C\r
        print\r
        print "Test suite interrupted by signal SIGINT."\r
        omitted = set(selected) - set(good) - set(bad) - set(skipped)\r
        print count(len(omitted), "test"), "omitted:"\r
        printlist(omitted)\r
    if good and not quiet:\r
        if not bad and not skipped and not interrupted and len(good) > 1:\r
            print "All",\r
        print count(len(good), "test"), "OK."\r
    if print_slow:\r
        test_times.sort(reverse=True)\r
        print "10 slowest tests:"\r
        for time, test in test_times[:10]:\r
            print "%s: %.1fs" % (test, time)\r
    if bad:\r
        bad = set(bad) - set(environment_changed)\r
        if bad:\r
            print count(len(bad), "test"), "failed:"\r
            printlist(bad)\r
        if environment_changed:\r
            print "{} altered the execution environment:".format(\r
                count(len(environment_changed), "test"))\r
            printlist(environment_changed)\r
    if skipped and not quiet:\r
        print count(len(skipped), "test"), "skipped:"\r
        printlist(skipped)\r
\r
        e = _ExpectedSkips()\r
        plat = sys.platform\r
        if e.isvalid():\r
            surprise = set(skipped) - e.getexpected() - set(resource_denieds)\r
            if surprise:\r
                print count(len(surprise), "skip"), \\r
                      "unexpected on", plat + ":"\r
                printlist(surprise)\r
            else:\r
                print "Those skips are all expected on", plat + "."\r
        else:\r
            print "Ask someone to teach regrtest.py about which tests are"\r
            print "expected to get skipped on", plat + "."\r
\r
    if verbose2 and bad:\r
        print "Re-running failed tests in verbose mode"\r
        for test in bad:\r
            print "Re-running test %r in verbose mode" % test\r
            sys.stdout.flush()\r
            try:\r
                test_support.verbose = True\r
                ok = runtest(test, True, quiet, huntrleaks)\r
            except KeyboardInterrupt:\r
                # print a newline separate from the ^C\r
                print\r
                break\r
            except:\r
                raise\r
\r
    if single:\r
        if next_single_test:\r
            with open(filename, 'w') as fp:\r
                fp.write(next_single_test + '\n')\r
        else:\r
            os.unlink(filename)\r
\r
    if trace:\r
        r = tracer.results()\r
        r.write_results(show_missing=True, summary=True, coverdir=coverdir)\r
\r
    if runleaks:\r
        os.system("leaks %d" % os.getpid())\r
\r
    sys.exit(len(bad) > 0 or interrupted)\r
\r
\r
STDTESTS = [\r
    'test_grammar',\r
    'test_opcodes',\r
    'test_dict',\r
    'test_builtin',\r
    'test_exceptions',\r
    'test_types',\r
    'test_unittest',\r
    'test_doctest',\r
    'test_doctest2',\r
]\r
\r
NOTTESTS = {\r
    'test_support',\r
    'test_future1',\r
    'test_future2',\r
}\r
\r
def findtests(testdir=None, stdtests=STDTESTS, nottests=NOTTESTS):\r
    """Return a list of all applicable test modules."""\r
    testdir = findtestdir(testdir)\r
    names = os.listdir(testdir)\r
    tests = []\r
    others = set(stdtests) | nottests\r
    for name in names:\r
        modname, ext = os.path.splitext(name)\r
        if modname[:5] == "test_" and ext == ".py" and modname not in others:\r
            tests.append(modname)\r
    return stdtests + sorted(tests)\r
\r
def runtest(test, verbose, quiet,\r
            huntrleaks=False, use_resources=None):\r
    """Run a single test.\r
\r
    test -- the name of the test\r
    verbose -- if true, print more messages\r
    quiet -- if true, don't print 'skipped' messages (probably redundant)\r
    test_times -- a list of (time, test_name) pairs\r
    huntrleaks -- run multiple times to test for leaks; requires a debug\r
                  build; a triple corresponding to -R's three arguments\r
    Returns one of the test result constants:\r
        INTERRUPTED      KeyboardInterrupt when run under -j\r
        RESOURCE_DENIED  test skipped because resource denied\r
        SKIPPED          test skipped for some other reason\r
        ENV_CHANGED      test failed because it changed the execution environment\r
        FAILED           test failed\r
        PASSED           test passed\r
    """\r
\r
    test_support.verbose = verbose  # Tell tests to be moderately quiet\r
    if use_resources is not None:\r
        test_support.use_resources = use_resources\r
    try:\r
        return runtest_inner(test, verbose, quiet, huntrleaks)\r
    finally:\r
        cleanup_test_droppings(test, verbose)\r
\r
\r
# Unit tests are supposed to leave the execution environment unchanged\r
# once they complete.  But sometimes tests have bugs, especially when\r
# tests fail, and the changes to environment go on to mess up other\r
# tests.  This can cause issues with buildbot stability, since tests\r
# are run in random order and so problems may appear to come and go.\r
# There are a few things we can save and restore to mitigate this, and\r
# the following context manager handles this task.\r
\r
class saved_test_environment:\r
    """Save bits of the test environment and restore them at block exit.\r
\r
        with saved_test_environment(testname, verbose, quiet):\r
            #stuff\r
\r
    Unless quiet is True, a warning is printed to stderr if any of\r
    the saved items was changed by the test.  The attribute 'changed'\r
    is initially False, but is set to True if a change is detected.\r
\r
    If verbose is more than 1, the before and after state of changed\r
    items is also printed.\r
    """\r
\r
    changed = False\r
\r
    def __init__(self, testname, verbose=0, quiet=False):\r
        self.testname = testname\r
        self.verbose = verbose\r
        self.quiet = quiet\r
\r
    # To add things to save and restore, add a name XXX to the resources list\r
    # and add corresponding get_XXX/restore_XXX functions.  get_XXX should\r
    # return the value to be saved and compared against a second call to the\r
    # get function when test execution completes.  restore_XXX should accept\r
    # the saved value and restore the resource using it.  It will be called if\r
    # and only if a change in the value is detected.\r
    #\r
    # Note: XXX will have any '.' replaced with '_' characters when determining\r
    # the corresponding method names.\r
\r
    resources = ('sys.argv', 'cwd', 'sys.stdin', 'sys.stdout', 'sys.stderr',\r
                 'os.environ', 'sys.path', 'asyncore.socket_map')\r
\r
    def get_sys_argv(self):\r
        return id(sys.argv), sys.argv, sys.argv[:]\r
    def restore_sys_argv(self, saved_argv):\r
        sys.argv = saved_argv[1]\r
        sys.argv[:] = saved_argv[2]\r
\r
    def get_cwd(self):\r
        return os.getcwd()\r
    def restore_cwd(self, saved_cwd):\r
        os.chdir(saved_cwd)\r
\r
    def get_sys_stdout(self):\r
        return sys.stdout\r
    def restore_sys_stdout(self, saved_stdout):\r
        sys.stdout = saved_stdout\r
\r
    def get_sys_stderr(self):\r
        return sys.stderr\r
    def restore_sys_stderr(self, saved_stderr):\r
        sys.stderr = saved_stderr\r
\r
    def get_sys_stdin(self):\r
        return sys.stdin\r
    def restore_sys_stdin(self, saved_stdin):\r
        sys.stdin = saved_stdin\r
\r
    def get_os_environ(self):\r
        return id(os.environ), os.environ, dict(os.environ)\r
    def restore_os_environ(self, saved_environ):\r
        os.environ = saved_environ[1]\r
        os.environ.clear()\r
        os.environ.update(saved_environ[2])\r
\r
    def get_sys_path(self):\r
        return id(sys.path), sys.path, sys.path[:]\r
    def restore_sys_path(self, saved_path):\r
        sys.path = saved_path[1]\r
        sys.path[:] = saved_path[2]\r
\r
    def get_asyncore_socket_map(self):\r
        asyncore = sys.modules.get('asyncore')\r
        # XXX Making a copy keeps objects alive until __exit__ gets called.\r
        return asyncore and asyncore.socket_map.copy() or {}\r
    def restore_asyncore_socket_map(self, saved_map):\r
        asyncore = sys.modules.get('asyncore')\r
        if asyncore is not None:\r
            asyncore.close_all(ignore_all=True)\r
            asyncore.socket_map.update(saved_map)\r
\r
    def resource_info(self):\r
        for name in self.resources:\r
            method_suffix = name.replace('.', '_')\r
            get_name = 'get_' + method_suffix\r
            restore_name = 'restore_' + method_suffix\r
            yield name, getattr(self, get_name), getattr(self, restore_name)\r
\r
    def __enter__(self):\r
        self.saved_values = dict((name, get()) for name, get, restore\r
                                                   in self.resource_info())\r
        return self\r
\r
    def __exit__(self, exc_type, exc_val, exc_tb):\r
        saved_values = self.saved_values\r
        del self.saved_values\r
        for name, get, restore in self.resource_info():\r
            current = get()\r
            original = saved_values.pop(name)\r
            # Check for changes to the resource's value\r
            if current != original:\r
                self.changed = True\r
                restore(original)\r
                if not self.quiet:\r
                    print >>sys.stderr, (\r
                          "Warning -- {} was modified by {}".format(\r
                                                 name, self.testname))\r
                    if self.verbose > 1:\r
                        print >>sys.stderr, (\r
                              "  Before: {}\n  After:  {} ".format(\r
                                                  original, current))\r
            # XXX (ncoghlan): for most resources (e.g. sys.path) identity\r
            # matters at least as much as value. For others (e.g. cwd),\r
            # identity is irrelevant. Should we add a mechanism to check\r
            # for substitution in the cases where it matters?\r
        return False\r
\r
\r
def runtest_inner(test, verbose, quiet, huntrleaks=False):\r
    test_support.unload(test)\r
    if verbose:\r
        capture_stdout = None\r
    else:\r
        capture_stdout = StringIO.StringIO()\r
\r
    test_time = 0.0\r
    refleak = False  # True if the test leaked references.\r
    try:\r
        save_stdout = sys.stdout\r
        try:\r
            if capture_stdout:\r
                sys.stdout = capture_stdout\r
            if test.startswith('test.'):\r
                abstest = test\r
            else:\r
                # Always import it from the test package\r
                abstest = 'test.' + test\r
            with saved_test_environment(test, verbose, quiet) as environment:\r
                start_time = time.time()\r
                the_package = __import__(abstest, globals(), locals(), [])\r
                the_module = getattr(the_package, test)\r
                # Old tests run to completion simply as a side-effect of\r
                # being imported.  For tests based on unittest or doctest,\r
                # explicitly invoke their test_main() function (if it exists).\r
                indirect_test = getattr(the_module, "test_main", None)\r
                if indirect_test is not None:\r
                    indirect_test()\r
                if huntrleaks:\r
                    refleak = dash_R(the_module, test, indirect_test,\r
                        huntrleaks)\r
                test_time = time.time() - start_time\r
        finally:\r
            sys.stdout = save_stdout\r
    except test_support.ResourceDenied, msg:\r
        if not quiet:\r
            print test, "skipped --", msg\r
            sys.stdout.flush()\r
        return RESOURCE_DENIED, test_time\r
    except unittest.SkipTest, msg:\r
        if not quiet:\r
            print test, "skipped --", msg\r
            sys.stdout.flush()\r
        return SKIPPED, test_time\r
    except KeyboardInterrupt:\r
        raise\r
    except test_support.TestFailed, msg:\r
        print >>sys.stderr, "test", test, "failed --", msg\r
        sys.stderr.flush()\r
        return FAILED, test_time\r
    except:\r
        type, value = sys.exc_info()[:2]\r
        print >>sys.stderr, "test", test, "crashed --", str(type) + ":", value\r
        sys.stderr.flush()\r
        if verbose:\r
            traceback.print_exc(file=sys.stderr)\r
            sys.stderr.flush()\r
        return FAILED, test_time\r
    else:\r
        if refleak:\r
            return FAILED, test_time\r
        if environment.changed:\r
            return ENV_CHANGED, test_time\r
        # Except in verbose mode, tests should not print anything\r
        if verbose or huntrleaks:\r
            return PASSED, test_time\r
        output = capture_stdout.getvalue()\r
        if not output:\r
            return PASSED, test_time\r
        print "test", test, "produced unexpected output:"\r
        print "*" * 70\r
        print output\r
        print "*" * 70\r
        sys.stdout.flush()\r
        return FAILED, test_time\r
\r
def cleanup_test_droppings(testname, verbose):\r
    import shutil\r
    import stat\r
    import gc\r
\r
    # First kill any dangling references to open files etc.\r
    gc.collect()\r
\r
    # Try to clean up junk commonly left behind.  While tests shouldn't leave\r
    # any files or directories behind, when a test fails that can be tedious\r
    # for it to arrange.  The consequences can be especially nasty on Windows,\r
    # since if a test leaves a file open, it cannot be deleted by name (while\r
    # there's nothing we can do about that here either, we can display the\r
    # name of the offending test, which is a real help).\r
    for name in (test_support.TESTFN,\r
                 "db_home",\r
                ):\r
        if not os.path.exists(name):\r
            continue\r
\r
        if os.path.isdir(name):\r
            kind, nuker = "directory", shutil.rmtree\r
        elif os.path.isfile(name):\r
            kind, nuker = "file", os.unlink\r
        else:\r
            raise SystemError("os.path says %r exists but is neither "\r
                              "directory nor file" % name)\r
\r
        if verbose:\r
            print "%r left behind %s %r" % (testname, kind, name)\r
        try:\r
            # if we have chmod, fix possible permissions problems\r
            # that might prevent cleanup\r
            if (hasattr(os, 'chmod')):\r
                os.chmod(name, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)\r
            nuker(name)\r
        except Exception, msg:\r
            print >> sys.stderr, ("%r left behind %s %r and it couldn't be "\r
                "removed: %s" % (testname, kind, name, msg))\r
\r
def dash_R(the_module, test, indirect_test, huntrleaks):\r
    """Run a test multiple times, looking for reference leaks.\r
\r
    Returns:\r
        False if the test didn't leak references; True if we detected refleaks.\r
    """\r
    # This code is hackish and inelegant, but it seems to do the job.\r
    import copy_reg, _abcoll, _pyio\r
\r
    if not hasattr(sys, 'gettotalrefcount'):\r
        raise Exception("Tracking reference leaks requires a debug build "\r
                        "of Python")\r
\r
    # Save current values for dash_R_cleanup() to restore.\r
    fs = warnings.filters[:]\r
    ps = copy_reg.dispatch_table.copy()\r
    pic = sys.path_importer_cache.copy()\r
    try:\r
        import zipimport\r
    except ImportError:\r
        zdc = None # Run unmodified on platforms without zipimport support\r
    else:\r
        zdc = zipimport._zip_directory_cache.copy()\r
    abcs = {}\r
    modules = _abcoll, _pyio\r
    for abc in [getattr(mod, a) for mod in modules for a in mod.__all__]:\r
        # XXX isinstance(abc, ABCMeta) leads to infinite recursion\r
        if not hasattr(abc, '_abc_registry'):\r
            continue\r
        for obj in abc.__subclasses__() + [abc]:\r
            abcs[obj] = obj._abc_registry.copy()\r
\r
    if indirect_test:\r
        def run_the_test():\r
            indirect_test()\r
    else:\r
        def run_the_test():\r
            imp.reload(the_module)\r
\r
    deltas = []\r
    nwarmup, ntracked, fname = huntrleaks\r
    fname = os.path.join(test_support.SAVEDCWD, fname)\r
    repcount = nwarmup + ntracked\r
    print >> sys.stderr, "beginning", repcount, "repetitions"\r
    print >> sys.stderr, ("1234567890"*(repcount//10 + 1))[:repcount]\r
    dash_R_cleanup(fs, ps, pic, zdc, abcs)\r
    for i in range(repcount):\r
        rc_before = sys.gettotalrefcount()\r
        run_the_test()\r
        sys.stderr.write('.')\r
        dash_R_cleanup(fs, ps, pic, zdc, abcs)\r
        rc_after = sys.gettotalrefcount()\r
        if i >= nwarmup:\r
            deltas.append(rc_after - rc_before)\r
    print >> sys.stderr\r
    if any(deltas):\r
        msg = '%s leaked %s references, sum=%s' % (test, deltas, sum(deltas))\r
        print >> sys.stderr, msg\r
        with open(fname, "a") as refrep:\r
            print >> refrep, msg\r
            refrep.flush()\r
        return True\r
    return False\r
\r
def dash_R_cleanup(fs, ps, pic, zdc, abcs):\r
    import gc, copy_reg\r
    import _strptime, linecache\r
    dircache = test_support.import_module('dircache', deprecated=True)\r
    import urlparse, urllib, urllib2, mimetypes, doctest\r
    import struct, filecmp\r
    from distutils.dir_util import _path_created\r
\r
    # Clear the warnings registry, so they can be displayed again\r
    for mod in sys.modules.values():\r
        if hasattr(mod, '__warningregistry__'):\r
            del mod.__warningregistry__\r
\r
    # Restore some original values.\r
    warnings.filters[:] = fs\r
    copy_reg.dispatch_table.clear()\r
    copy_reg.dispatch_table.update(ps)\r
    sys.path_importer_cache.clear()\r
    sys.path_importer_cache.update(pic)\r
    try:\r
        import zipimport\r
    except ImportError:\r
        pass # Run unmodified on platforms without zipimport support\r
    else:\r
        zipimport._zip_directory_cache.clear()\r
        zipimport._zip_directory_cache.update(zdc)\r
\r
    # clear type cache\r
    sys._clear_type_cache()\r
\r
    # Clear ABC registries, restoring previously saved ABC registries.\r
    for abc, registry in abcs.items():\r
        abc._abc_registry = registry.copy()\r
        abc._abc_cache.clear()\r
        abc._abc_negative_cache.clear()\r
\r
    # Clear assorted module caches.\r
    _path_created.clear()\r
    re.purge()\r
    _strptime._regex_cache.clear()\r
    urlparse.clear_cache()\r
    urllib.urlcleanup()\r
    urllib2.install_opener(None)\r
    dircache.reset()\r
    linecache.clearcache()\r
    mimetypes._default_mime_types()\r
    filecmp._cache.clear()\r
    struct._clearcache()\r
    doctest.master = None\r
\r
    # Collect cyclic trash.\r
    gc.collect()\r
\r
def findtestdir(path=None):\r
    return path or os.path.dirname(__file__) or os.curdir\r
\r
def removepy(names):\r
    if not names:\r
        return\r
    for idx, name in enumerate(names):\r
        basename, ext = os.path.splitext(name)\r
        if ext == '.py':\r
            names[idx] = basename\r
\r
def count(n, word):\r
    if n == 1:\r
        return "%d %s" % (n, word)\r
    else:\r
        return "%d %ss" % (n, word)\r
\r
def printlist(x, width=70, indent=4):\r
    """Print the elements of iterable x to stdout.\r
\r
    Optional arg width (default 70) is the maximum line length.\r
    Optional arg indent (default 4) is the number of blanks with which to\r
    begin each line.\r
    """\r
\r
    from textwrap import fill\r
    blanks = ' ' * indent\r
    # Print the sorted list: 'x' may be a '--random' list or a set()\r
    print fill(' '.join(str(elt) for elt in sorted(x)), width,\r
               initial_indent=blanks, subsequent_indent=blanks)\r
\r
# Map sys.platform to a string containing the basenames of tests\r
# expected to be skipped on that platform.\r
#\r
# Special cases:\r
#     test_pep277\r
#         The _ExpectedSkips constructor adds this to the set of expected\r
#         skips if not os.path.supports_unicode_filenames.\r
#     test_timeout\r
#         Controlled by test_timeout.skip_expected.  Requires the network\r
#         resource and a socket module.\r
#\r
# Tests that are expected to be skipped everywhere except on one platform\r
# are also handled separately.\r
\r
_expectations = {\r
    'win32':\r
        """\r
        test__locale\r
        test_bsddb185\r
        test_bsddb3\r
        test_commands\r
        test_crypt\r
        test_curses\r
        test_dbm\r
        test_dl\r
        test_fcntl\r
        test_fork1\r
        test_epoll\r
        test_gdbm\r
        test_grp\r
        test_ioctl\r
        test_largefile\r
        test_kqueue\r
        test_mhlib\r
        test_openpty\r
        test_ossaudiodev\r
        test_pipes\r
        test_poll\r
        test_posix\r
        test_pty\r
        test_pwd\r
        test_resource\r
        test_signal\r
        test_threadsignals\r
        test_timing\r
        test_wait3\r
        test_wait4\r
        """,\r
    'linux2':\r
        """\r
        test_bsddb185\r
        test_curses\r
        test_dl\r
        test_largefile\r
        test_kqueue\r
        test_ossaudiodev\r
        """,\r
    'unixware7':\r
        """\r
        test_bsddb\r
        test_bsddb185\r
        test_dl\r
        test_epoll\r
        test_largefile\r
        test_kqueue\r
        test_minidom\r
        test_openpty\r
        test_pyexpat\r
        test_sax\r
        test_sundry\r
        """,\r
    'openunix8':\r
        """\r
        test_bsddb\r
        test_bsddb185\r
        test_dl\r
        test_epoll\r
        test_largefile\r
        test_kqueue\r
        test_minidom\r
        test_openpty\r
        test_pyexpat\r
        test_sax\r
        test_sundry\r
        """,\r
    'sco_sv3':\r
        """\r
        test_asynchat\r
        test_bsddb\r
        test_bsddb185\r
        test_dl\r
        test_fork1\r
        test_epoll\r
        test_gettext\r
        test_largefile\r
        test_locale\r
        test_kqueue\r
        test_minidom\r
        test_openpty\r
        test_pyexpat\r
        test_queue\r
        test_sax\r
        test_sundry\r
        test_thread\r
        test_threaded_import\r
        test_threadedtempfile\r
        test_threading\r
        """,\r
    'riscos':\r
        """\r
        test_asynchat\r
        test_atexit\r
        test_bsddb\r
        test_bsddb185\r
        test_bsddb3\r
        test_commands\r
        test_crypt\r
        test_dbm\r
        test_dl\r
        test_fcntl\r
        test_fork1\r
        test_epoll\r
        test_gdbm\r
        test_grp\r
        test_largefile\r
        test_locale\r
        test_kqueue\r
        test_mmap\r
        test_openpty\r
        test_poll\r
        test_popen2\r
        test_pty\r
        test_pwd\r
        test_strop\r
        test_sundry\r
        test_thread\r
        test_threaded_import\r
        test_threadedtempfile\r
        test_threading\r
        test_timing\r
        """,\r
    'darwin':\r
        """\r
        test__locale\r
        test_bsddb\r
        test_bsddb3\r
        test_curses\r
        test_epoll\r
        test_gdb\r
        test_gdbm\r
        test_largefile\r
        test_locale\r
        test_kqueue\r
        test_minidom\r
        test_ossaudiodev\r
        test_poll\r
        """,\r
    'sunos5':\r
        """\r
        test_bsddb\r
        test_bsddb185\r
        test_curses\r
        test_dbm\r
        test_epoll\r
        test_kqueue\r
        test_gdbm\r
        test_gzip\r
        test_openpty\r
        test_zipfile\r
        test_zlib\r
        """,\r
    'hp-ux11':\r
        """\r
        test_bsddb\r
        test_bsddb185\r
        test_curses\r
        test_dl\r
        test_epoll\r
        test_gdbm\r
        test_gzip\r
        test_largefile\r
        test_locale\r
        test_kqueue\r
        test_minidom\r
        test_openpty\r
        test_pyexpat\r
        test_sax\r
        test_zipfile\r
        test_zlib\r
        """,\r
    'atheos':\r
        """\r
        test_bsddb185\r
        test_curses\r
        test_dl\r
        test_gdbm\r
        test_epoll\r
        test_largefile\r
        test_locale\r
        test_kqueue\r
        test_mhlib\r
        test_mmap\r
        test_poll\r
        test_popen2\r
        test_resource\r
        """,\r
    'cygwin':\r
        """\r
        test_bsddb185\r
        test_bsddb3\r
        test_curses\r
        test_dbm\r
        test_epoll\r
        test_ioctl\r
        test_kqueue\r
        test_largefile\r
        test_locale\r
        test_ossaudiodev\r
        test_socketserver\r
        """,\r
    'os2emx':\r
        """\r
        test_audioop\r
        test_bsddb185\r
        test_bsddb3\r
        test_commands\r
        test_curses\r
        test_dl\r
        test_epoll\r
        test_kqueue\r
        test_largefile\r
        test_mhlib\r
        test_mmap\r
        test_openpty\r
        test_ossaudiodev\r
        test_pty\r
        test_resource\r
        test_signal\r
        """,\r
    'freebsd4':\r
        """\r
        test_bsddb\r
        test_bsddb3\r
        test_epoll\r
        test_gdbm\r
        test_locale\r
        test_ossaudiodev\r
        test_pep277\r
        test_pty\r
        test_socketserver\r
        test_tcl\r
        test_tk\r
        test_ttk_guionly\r
        test_ttk_textonly\r
        test_timeout\r
        test_urllibnet\r
        test_multiprocessing\r
        """,\r
    'aix5':\r
        """\r
        test_bsddb\r
        test_bsddb185\r
        test_bsddb3\r
        test_bz2\r
        test_dl\r
        test_epoll\r
        test_gdbm\r
        test_gzip\r
        test_kqueue\r
        test_ossaudiodev\r
        test_tcl\r
        test_tk\r
        test_ttk_guionly\r
        test_ttk_textonly\r
        test_zipimport\r
        test_zlib\r
        """,\r
    'openbsd3':\r
        """\r
        test_ascii_formatd\r
        test_bsddb\r
        test_bsddb3\r
        test_ctypes\r
        test_dl\r
        test_epoll\r
        test_gdbm\r
        test_locale\r
        test_normalization\r
        test_ossaudiodev\r
        test_pep277\r
        test_tcl\r
        test_tk\r
        test_ttk_guionly\r
        test_ttk_textonly\r
        test_multiprocessing\r
        """,\r
    'netbsd3':\r
        """\r
        test_ascii_formatd\r
        test_bsddb\r
        test_bsddb185\r
        test_bsddb3\r
        test_ctypes\r
        test_curses\r
        test_dl\r
        test_epoll\r
        test_gdbm\r
        test_locale\r
        test_ossaudiodev\r
        test_pep277\r
        test_tcl\r
        test_tk\r
        test_ttk_guionly\r
        test_ttk_textonly\r
        test_multiprocessing\r
        """,\r
}\r
_expectations['freebsd5'] = _expectations['freebsd4']\r
_expectations['freebsd6'] = _expectations['freebsd4']\r
_expectations['freebsd7'] = _expectations['freebsd4']\r
_expectations['freebsd8'] = _expectations['freebsd4']\r
\r
class _ExpectedSkips:\r
    def __init__(self):\r
        import os.path\r
        from test import test_timeout\r
\r
        self.valid = False\r
        if sys.platform in _expectations:\r
            s = _expectations[sys.platform]\r
            self.expected = set(s.split())\r
\r
            # expected to be skipped on every platform, even Linux\r
            self.expected.add('test_linuxaudiodev')\r
\r
            if not os.path.supports_unicode_filenames:\r
                self.expected.add('test_pep277')\r
\r
            if test_timeout.skip_expected:\r
                self.expected.add('test_timeout')\r
\r
            if sys.maxint == 9223372036854775807L:\r
                self.expected.add('test_imageop')\r
\r
            if sys.platform != "darwin":\r
                MAC_ONLY = ["test_macos", "test_macostools", "test_aepack",\r
                            "test_plistlib", "test_scriptpackages",\r
                            "test_applesingle"]\r
                for skip in MAC_ONLY:\r
                    self.expected.add(skip)\r
            elif len(u'\0'.encode('unicode-internal')) == 4:\r
                self.expected.add("test_macostools")\r
\r
\r
            if sys.platform != "win32":\r
                # test_sqlite is only reliable on Windows where the library\r
                # is distributed with Python\r
                WIN_ONLY = ["test_unicode_file", "test_winreg",\r
                            "test_winsound", "test_startfile",\r
                            "test_sqlite", "test_msilib"]\r
                for skip in WIN_ONLY:\r
                    self.expected.add(skip)\r
\r
            if sys.platform != 'irix':\r
                IRIX_ONLY = ["test_imageop", "test_al", "test_cd", "test_cl",\r
                             "test_gl", "test_imgfile"]\r
                for skip in IRIX_ONLY:\r
                    self.expected.add(skip)\r
\r
            if sys.platform != 'sunos5':\r
                self.expected.add('test_sunaudiodev')\r
                self.expected.add('test_nis')\r
\r
            if not sys.py3kwarning:\r
                self.expected.add('test_py3kwarn')\r
\r
            self.valid = True\r
\r
    def isvalid(self):\r
        "Return true iff _ExpectedSkips knows about the current platform."\r
        return self.valid\r
\r
    def getexpected(self):\r
        """Return set of test names we expect to skip on current platform.\r
\r
        self.isvalid() must be true.\r
        """\r
\r
        assert self.isvalid()\r
        return self.expected\r
\r
if __name__ == '__main__':\r
    # findtestdir() gets the dirname out of __file__, so we have to make it\r
    # absolute before changing the working directory.\r
    # For example __file__ may be relative when running trace or profile.\r
    # See issue #9323.\r
    __file__ = os.path.abspath(__file__)\r
\r
    # sanity check\r
    assert __file__ == os.path.abspath(sys.argv[0])\r
\r
    # When tests are run from the Python build directory, it is best practice\r
    # to keep the test files in a subfolder.  It eases the cleanup of leftover\r
    # files using command "make distclean".\r
    if sysconfig.is_python_build():\r
        TEMPDIR = os.path.join(sysconfig.get_config_var('srcdir'), 'build')\r
        TEMPDIR = os.path.abspath(TEMPDIR)\r
        if not os.path.exists(TEMPDIR):\r
            os.mkdir(TEMPDIR)\r
\r
    # Define a writable temp dir that will be used as cwd while running\r
    # the tests. The name of the dir includes the pid to allow parallel\r
    # testing (see the -j option).\r
    TESTCWD = 'test_python_{}'.format(os.getpid())\r
\r
    TESTCWD = os.path.join(TEMPDIR, TESTCWD)\r
\r
    # Run the tests in a context manager that temporary changes the CWD to a\r
    # temporary and writable directory. If it's not possible to create or\r
    # change the CWD, the original CWD will be used. The original CWD is\r
    # available from test_support.SAVEDCWD.\r
    with test_support.temp_cwd(TESTCWD, quiet=True):\r
        main()\r