Lib/test/regrtest.py

   1 #! /usr/bin/env python
   2
   3 """Regression test.
   4
   5 This will find all modules whose name is "test_*" in the test
   6 directory, and run them.  Various command line options provide
   7 additional facilities.
   8
   9 Command line options:
  10
  11 -v: verbose    -- run tests in verbose mode with output to stdout
  12 -q: quiet      -- don't print anything except if a test fails
  13 -g: generate   -- write the output file for a test instead of comparing it
  14 -x: exclude    -- arguments are tests to *exclude*
  15 -s: single     -- run only a single test (see below)
  16 -r: random     -- randomize test execution order
  17 -f: fromfile   -- read names of tests to run from a file (see below)
  18 -l: findleaks  -- if GC is available detect tests that leak memory
  19 -u: use        -- specify which special resource intensive tests to run
  20 -h: help       -- print this text and exit
  21 -t: threshold  -- call gc.set_threshold(N)
  22 -T: coverage   -- turn on code coverage using the trace module
  23 -D: coverdir   -- Directory where coverage files are put
  24 -N: nocoverdir -- Put coverage files alongside modules
  25 -L: runleaks   -- run the leaks(1) command just before exit
  26 -R: huntrleaks -- search for reference leaks (needs debug build, v. slow)
  27
  28 If non-option arguments are present, they are names for tests to run,
  29 unless -x is given, in which case they are names for tests not to run.
  30 If no test names are given, all tests are run.
  31
  32 -v is incompatible with -g and does not compare test output files.
  33
  34 -T turns on code coverage tracing with the trace module.
  35
  36 -D specifies the directory where coverage files are put.
  37
  38 -N Put coverage files alongside modules.
  39
  40 -s means to run only a single test and exit.  This is useful when
  41 doing memory analysis on the Python interpreter (which tend to consume
  42 too many resources to run the full regression test non-stop).  The
  43 file /tmp/pynexttest is read to find the next test to run.  If this
  44 file is missing, the first test_*.py file in testdir or on the command
  45 line is used.  (actually tempfile.gettempdir() is used instead of
  46 /tmp).
  47
  48 -f reads the names of tests from the file given as f's argument, one
  49 or more test names per line.  Whitespace is ignored.  Blank lines and
  50 lines beginning with '#' are ignored.  This is especially useful for
  51 whittling down failures involving interactions among tests.
  52
  53 -L causes the leaks(1) command to be run just before exit if it exists.
  54 leaks(1) is available on Mac OS X and presumably on some other
  55 FreeBSD-derived systems.
  56
  57 -R runs each test several times and examines sys.gettotalrefcount() to
  58 see if the test appears to be leaking references.  The argument should
  59 be of the form stab:run:fname where 'stab' is the number of times the
  60 test is run to let gettotalrefcount settle down, 'run' is the number
  61 of times further it is run and 'fname' is the name of the file the
  62 reports are written to.  These parameters all have defaults (5, 4 and
  63 "reflog.txt" respectively), so the minimal invocation is '-R ::'.
  64
  65 -u is used to specify which special resource intensive tests to run,
  66 such as those requiring large file support or network connectivity.
  67 The argument is a comma-separated list of words indicating the
  68 resources to test.  Currently only the following are defined:
  69
  70     all -       Enable all special resources.
  71
  72     audio -     Tests that use the audio device.  (There are known
  73                 cases of broken audio drivers that can crash Python or
  74                 even the Linux kernel.)
  75
  76     curses -    Tests that use curses and will modify the terminal's
  77                 state and output modes.
  78
  79     largefile - It is okay to run some test that may create huge
  80                 files.  These tests can take a long time and may
  81                 consume >2GB of disk space temporarily.
  82
  83     network -   It is okay to run tests that use external network
  84                 resource, e.g. testing SSL support for sockets.
  85
  86     bsddb -     It is okay to run the bsddb testsuite, which takes
  87                 a long time to complete.
  88
  89     decimal -   Test the decimal module against a large suite that
  90                 verifies compliance with standards.
  91
  92     compiler -  Test the compiler package by compiling all the source
  93                 in the standard library and test suite.  This takes
  94                 a long time.  Enabling this resource also allows
  95                 test_tokenize to verify round-trip lexing on every
  96                 file in the test library.
  97
  98     subprocess  Run all tests for the subprocess module.
  99
 100     urlfetch -  It is okay to download files required on testing.
 101
 102 To enable all resources except one, use '-uall,-<resource>'.  For
 103 example, to run all the tests except for the bsddb tests, give the
 104 option '-uall,-bsddb'.
 105 """
 106
 107 import os
 108 import sys
 109 import getopt
 110 import random
 111 import warnings
 112 import sre
 113 import cStringIO
 114 import traceback
 115
 116 # I see no other way to suppress these warnings;
 117 # putting them in test_grammar.py has no effect:
 118 warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning,
 119                         ".*test.test_grammar$")
 120 if sys.maxint > 0x7fffffff:
 121     # Also suppress them in <string>, because for 64-bit platforms,
 122     # that's where test_grammar.py hides them.
 123     warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning,
 124                             "<string>")
 125
 126 # MacOSX (a.k.a. Darwin) has a default stack size that is too small
 127 # for deeply recursive regular expressions.  We see this as crashes in
 128 # the Python test suite when running test_re.py and test_sre.py.  The
 129 # fix is to set the stack limit to 2048.
 130 # This approach may also be useful for other Unixy platforms that
 131 # suffer from small default stack limits.
 132 if sys.platform == 'darwin':
 133     try:
 134         import resource
 135     except ImportError:
 136         pass
 137     else:
 138         soft, hard = resource.getrlimit(resource.RLIMIT_STACK)
 139         newsoft = min(hard, max(soft, 1024*2048))
 140         resource.setrlimit(resource.RLIMIT_STACK, (newsoft, hard))
 141
 142 from test import test_support
 143
 144 RESOURCE_NAMES = ('audio', 'curses', 'largefile', 'network', 'bsddb',
 145                   'decimal', 'compiler', 'subprocess', 'urlfetch')
 146
 147
 148 def usage(code, msg=''):
 149     print __doc__
 150     if msg: print msg
 151     sys.exit(code)
 152
 153
 154 def main(tests=None, testdir=None, verbose=0, quiet=False, generate=False,
 155          exclude=False, single=False, randomize=False, fromfile=None,
 156          findleaks=False, use_resources=None, trace=False, coverdir='coverage',
 157          runleaks=False, huntrleaks=False):
 158     """Execute a test suite.
 159
 160     This also parses command-line options and modifies its behavior
 161     accordingly.
 162
 163     tests -- a list of strings containing test names (optional)
 164     testdir -- the directory in which to look for tests (optional)
 165
 166     Users other than the Python test suite will certainly want to
 167     specify testdir; if it's omitted, the directory containing the
 168     Python test suite is searched for.
 169
 170     If the tests argument is omitted, the tests listed on the
 171     command-line will be used.  If that's empty, too, then all *.py
 172     files beginning with test_ will be used.
 173
 174     The other default arguments (verbose, quiet, generate, exclude, single,
 175     randomize, findleaks, use_resources, trace and coverdir) allow programmers
 176     calling main() directly to set the values that would normally be set by
 177     flags on the command line.
 178     """
 179
 180     test_support.record_original_stdout(sys.stdout)
 181     try:
 182         opts, args = getopt.getopt(sys.argv[1:], 'hvgqxsrf:lu:t:TD:NLR:',
 183                                    ['help', 'verbose', 'quiet', 'generate',
 184                                     'exclude', 'single', 'random', 'fromfile',
 185                                     'findleaks', 'use=', 'threshold=', 'trace',
 186                                     'coverdir=', 'nocoverdir', 'runleaks',
 187                                     'huntrleaks='
 188                                     ])
 189     except getopt.error, msg:
 190         usage(2, msg)
 191
 192     # Defaults
 193     if use_resources is None:
 194         use_resources = []
 195     for o, a in opts:
 196         if o in ('-h', '--help'):
 197             usage(0)
 198         elif o in ('-v', '--verbose'):
 199             verbose += 1
 200         elif o in ('-q', '--quiet'):
 201             quiet = True;
 202             verbose = 0
 203         elif o in ('-g', '--generate'):
 204             generate = True
 205         elif o in ('-x', '--exclude'):
 206             exclude = True
 207         elif o in ('-s', '--single'):
 208             single = True
 209         elif o in ('-r', '--randomize'):
 210             randomize = True
 211         elif o in ('-f', '--fromfile'):
 212             fromfile = a
 213         elif o in ('-l', '--findleaks'):
 214             findleaks = True
 215         elif o in ('-L', '--runleaks'):
 216             runleaks = True
 217         elif o in ('-t', '--threshold'):
 218             import gc
 219             gc.set_threshold(int(a))
 220         elif o in ('-T', '--coverage'):
 221             trace = True
 222         elif o in ('-D', '--coverdir'):
 223             coverdir = os.path.join(os.getcwd(), a)
 224         elif o in ('-N', '--nocoverdir'):
 225             coverdir = None
 226         elif o in ('-R', '--huntrleaks'):
 227             huntrleaks = a.split(':')
 228             if len(huntrleaks) != 3:
 229                 print a, huntrleaks
 230                 usage(2, '-R takes three colon-separated arguments')
 231             if len(huntrleaks[0]) == 0:
 232                 huntrleaks[0] = 5
 233             else:
 234                 huntrleaks[0] = int(huntrleaks[0])
 235             if len(huntrleaks[1]) == 0:
 236                 huntrleaks[1] = 4
 237             else:
 238                 huntrleaks[1] = int(huntrleaks[1])
 239             if len(huntrleaks[2]) == 0:
 240                 huntrleaks[2] = "reflog.txt"
 241         elif o in ('-u', '--use'):
 242             u = [x.lower() for x in a.split(',')]
 243             for r in u:
 244                 if r == 'all':
 245                     use_resources[:] = RESOURCE_NAMES
 246                     continue
 247                 remove = False
 248                 if r[0] == '-':
 249                     remove = True
 250                     r = r[1:]
 251                 if r not in RESOURCE_NAMES:
 252                     usage(1, 'Invalid -u/--use option: ' + a)
 253                 if remove:
 254                     if r in use_resources:
 255                         use_resources.remove(r)
 256                 elif r not in use_resources:
 257                     use_resources.append(r)
 258     if generate and verbose:
 259         usage(2, "-g and -v don't go together!")
 260     if single and fromfile:
 261         usage(2, "-s and -f don't go together!")
 262
 263     good = []
 264     bad = []
 265     skipped = []
 266     resource_denieds = []
 267
 268     if findleaks:
 269         try:
 270             import gc
 271         except ImportError:
 272             print 'No GC available, disabling findleaks.'
 273             findleaks = False
 274         else:
 275             # Uncomment the line below to report garbage that is not
 276             # freeable by reference counting alone.  By default only
 277             # garbage that is not collectable by the GC is reported.
 278             #gc.set_debug(gc.DEBUG_SAVEALL)
 279             found_garbage = []
 280
 281     if single:
 282         from tempfile import gettempdir
 283         filename = os.path.join(gettempdir(), 'pynexttest')
 284         try:
 285             fp = open(filename, 'r')
 286             next = fp.read().strip()
 287             tests = [next]
 288             fp.close()
 289         except IOError:
 290             pass
 291
 292     if fromfile:
 293         tests = []
 294         fp = open(fromfile)
 295         for line in fp:
 296             guts = line.split() # assuming no test has whitespace in its name
 297             if guts and not guts[0].startswith('#'):
 298                 tests.extend(guts)
 299         fp.close()
 300
 301     # Strip .py extensions.
 302     if args:
 303         args = map(removepy, args)
 304     if tests:
 305         tests = map(removepy, tests)
 306
 307     stdtests = STDTESTS[:]
 308     nottests = NOTTESTS[:]
 309     if exclude:
 310         for arg in args:
 311             if arg in stdtests:
 312                 stdtests.remove(arg)
 313         nottests[:0] = args
 314         args = []
 315     tests = tests or args or findtests(testdir, stdtests, nottests)
 316     if single:
 317         tests = tests[:1]
 318     if randomize:
 319         random.shuffle(tests)
 320     if trace:
 321         import trace
 322         tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix],
 323                              trace=False, count=True)
 324     test_support.verbose = verbose      # Tell tests to be moderately quiet
 325     test_support.use_resources = use_resources
 326     save_modules = sys.modules.keys()
 327     for test in tests:
 328         if not quiet:
 329             print test
 330             sys.stdout.flush()
 331         if trace:
 332             # If we're tracing code coverage, then we don't exit with status
 333             # if on a false return value from main.
 334             tracer.runctx('runtest(test, generate, verbose, quiet, testdir)',
 335                           globals=globals(), locals=vars())
 336         else:
 337             ok = runtest(test, generate, verbose, quiet, testdir, huntrleaks)
 338             if ok > 0:
 339                 good.append(test)
 340             elif ok == 0:
 341                 bad.append(test)
 342             else:
 343                 skipped.append(test)
 344                 if ok == -2:
 345                     resource_denieds.append(test)
 346         if findleaks:
 347             gc.collect()
 348             if gc.garbage:
 349                 print "Warning: test created", len(gc.garbage),
 350                 print "uncollectable object(s)."
 351                 # move the uncollectable objects somewhere so we don't see
 352                 # them again
 353                 found_garbage.extend(gc.garbage)
 354                 del gc.garbage[:]
 355         # Unload the newly imported modules (best effort finalization)
 356         for module in sys.modules.keys():
 357             if module not in save_modules and module.startswith("test."):
 358                 test_support.unload(module)
 359
 360     # The lists won't be sorted if running with -r
 361     good.sort()
 362     bad.sort()
 363     skipped.sort()
 364
 365     if good and not quiet:
 366         if not bad and not skipped and len(good) > 1:
 367             print "All",
 368         print count(len(good), "test"), "OK."
 369         if verbose:
 370             print "CAUTION:  stdout isn't compared in verbose mode:"
 371             print "a test that passes in verbose mode may fail without it."
 372     if bad:
 373         print count(len(bad), "test"), "failed:"
 374         printlist(bad)
 375     if skipped and not quiet:
 376         print count(len(skipped), "test"), "skipped:"
 377         printlist(skipped)
 378
 379         e = _ExpectedSkips()
 380         plat = sys.platform
 381         if e.isvalid():
 382             surprise = set(skipped) - e.getexpected() - set(resource_denieds)
 383             if surprise:
 384                 print count(len(surprise), "skip"), \
 385                       "unexpected on", plat + ":"
 386                 printlist(surprise)
 387             else:
 388                 print "Those skips are all expected on", plat + "."
 389         else:
 390             print "Ask someone to teach regrtest.py about which tests are"
 391             print "expected to get skipped on", plat + "."
 392
 393     if single:
 394         alltests = findtests(testdir, stdtests, nottests)
 395         for i in range(len(alltests)):
 396             if tests[0] == alltests[i]:
 397                 if i == len(alltests) - 1:
 398                     os.unlink(filename)
 399                 else:
 400                     fp = open(filename, 'w')
 401                     fp.write(alltests[i+1] + '\n')
 402                     fp.close()
 403                 break
 404         else:
 405             os.unlink(filename)
 406
 407     if trace:
 408         r = tracer.results()
 409         r.write_results(show_missing=True, summary=True, coverdir=coverdir)
 410
 411     if runleaks:
 412         os.system("leaks %d" % os.getpid())
 413
 414     sys.exit(len(bad) > 0)
 415
 416
 417 STDTESTS = [
 418     'test_grammar',
 419     'test_opcodes',
 420     'test_operations',
 421     'test_builtin',
 422     'test_exceptions',
 423     'test_types',
 424    ]
 425
 426 NOTTESTS = [
 427     'test_support',
 428     'test_future1',
 429     'test_future2',
 430     'test_future3',
 431     ]
 432
 433 def findtests(testdir=None, stdtests=STDTESTS, nottests=NOTTESTS):
 434     """Return a list of all applicable test modules."""
 435     if not testdir: testdir = findtestdir()
 436     names = os.listdir(testdir)
 437     tests = []
 438     for name in names:
 439         if name[:5] == "test_" and name[-3:] == os.extsep+"py":
 440             modname = name[:-3]
 441             if modname not in stdtests and modname not in nottests:
 442                 tests.append(modname)
 443     tests.sort()
 444     return stdtests + tests
 445
 446 def runtest(test, generate, verbose, quiet, testdir=None, huntrleaks=False):
 447     """Run a single test.
 448     test -- the name of the test
 449     generate -- if true, generate output, instead of running the test
 450     and comparing it to a previously created output file
 451     verbose -- if true, print more messages
 452     quiet -- if true, don't print 'skipped' messages (probably redundant)
 453     testdir -- test directory
 454     """
 455     test_support.unload(test)
 456     if not testdir:
 457         testdir = findtestdir()
 458     outputdir = os.path.join(testdir, "output")
 459     outputfile = os.path.join(outputdir, test)
 460     if verbose:
 461         cfp = None
 462     else:
 463         cfp = cStringIO.StringIO()
 464     if huntrleaks:
 465         refrep = open(huntrleaks[2], "a")
 466     try:
 467         save_stdout = sys.stdout
 468         try:
 469             if cfp:
 470                 sys.stdout = cfp
 471                 print test              # Output file starts with test name
 472             if test.startswith('test.'):
 473                 abstest = test
 474             else:
 475                 # Always import it from the test package
 476                 abstest = 'test.' + test
 477             the_package = __import__(abstest, globals(), locals(), [])
 478             the_module = getattr(the_package, test)
 479             # Most tests run to completion simply as a side-effect of
 480             # being imported.  For the benefit of tests that can't run
 481             # that way (like test_threaded_import), explicitly invoke
 482             # their test_main() function (if it exists).
 483             indirect_test = getattr(the_module, "test_main", None)
 484             if indirect_test is not None:
 485                 indirect_test()
 486             if huntrleaks:
 487                 # This code *is* hackish and inelegant, yes.
 488                 # But it seems to do the job.
 489                 import copy_reg
 490                 fs = warnings.filters[:]
 491                 ps = copy_reg.dispatch_table.copy()
 492                 pic = sys.path_importer_cache.copy()
 493                 import gc
 494                 def cleanup():
 495                     import _strptime, linecache, warnings, dircache
 496                     import urlparse, urllib, urllib2
 497                     from distutils.dir_util import _path_created
 498                     _path_created.clear()
 499                     warnings.filters[:] = fs
 500                     gc.collect()
 501                     sre.purge()
 502                     _strptime._regex_cache.clear()
 503                     urlparse.clear_cache()
 504                     urllib.urlcleanup()
 505                     urllib2.install_opener(None)
 506                     copy_reg.dispatch_table.clear()
 507                     copy_reg.dispatch_table.update(ps)
 508                     sys.path_importer_cache.clear()
 509                     sys.path_importer_cache.update(pic)
 510                     dircache.reset()
 511                     linecache.clearcache()
 512                 if indirect_test:
 513                     def run_the_test():
 514                         indirect_test()
 515                 else:
 516                     def run_the_test():
 517                         reload(the_module)
 518                 deltas = []
 519                 repcount = huntrleaks[0] + huntrleaks[1]
 520                 print >> sys.stderr, "beginning", repcount, "repetitions"
 521                 print >> sys.stderr, \
 522                       ("1234567890"*(repcount//10 + 1))[:repcount]
 523                 for i in range(repcount):
 524                     rc = sys.gettotalrefcount()
 525                     run_the_test()
 526                     sys.stderr.write('.')
 527                     cleanup()
 528                     deltas.append(sys.gettotalrefcount() - rc - 2)
 529                 print >>sys.stderr
 530                 if max(map(abs, deltas[-huntrleaks[1]:])) > 0:
 531                     print >>sys.stderr, test, 'leaked', \
 532                           deltas[-huntrleaks[1]:], 'references'
 533                     print >>refrep, test, 'leaked', \
 534                           deltas[-huntrleaks[1]:], 'references'
 535                 # The end of the huntrleaks hackishness.
 536         finally:
 537             sys.stdout = save_stdout
 538     except test_support.ResourceDenied, msg:
 539         if not quiet:
 540             print test, "skipped --", msg
 541             sys.stdout.flush()
 542         return -2
 543     except (ImportError, test_support.TestSkipped), msg:
 544         if not quiet:
 545             print test, "skipped --", msg
 546             sys.stdout.flush()
 547         return -1
 548     except KeyboardInterrupt:
 549         raise
 550     except test_support.TestFailed, msg:
 551         print "test", test, "failed --", msg
 552         sys.stdout.flush()
 553         return 0
 554     except:
 555         type, value = sys.exc_info()[:2]
 556         print "test", test, "crashed --", str(type) + ":", value
 557         sys.stdout.flush()
 558         if verbose:
 559             traceback.print_exc(file=sys.stdout)
 560             sys.stdout.flush()
 561         return 0
 562     else:
 563         if not cfp:
 564             return 1
 565         output = cfp.getvalue()
 566         if generate:
 567             if output == test + "\n":
 568                 if os.path.exists(outputfile):
 569                     # Write it since it already exists (and the contents
 570                     # may have changed), but let the user know it isn't
 571                     # needed:
 572                     print "output file", outputfile, \
 573                           "is no longer needed; consider removing it"
 574                 else:
 575                     # We don't need it, so don't create it.
 576                     return 1
 577             fp = open(outputfile, "w")
 578             fp.write(output)
 579             fp.close()
 580             return 1
 581         if os.path.exists(outputfile):
 582             fp = open(outputfile, "r")
 583             expected = fp.read()
 584             fp.close()
 585         else:
 586             expected = test + "\n"
 587         if output == expected or huntrleaks:
 588             return 1
 589         print "test", test, "produced unexpected output:"
 590         sys.stdout.flush()
 591         reportdiff(expected, output)
 592         sys.stdout.flush()
 593         return 0
 594
 595 def reportdiff(expected, output):
 596     import difflib
 597     print "*" * 70
 598     a = expected.splitlines(1)
 599     b = output.splitlines(1)
 600     sm = difflib.SequenceMatcher(a=a, b=b)
 601     tuples = sm.get_opcodes()
 602
 603     def pair(x0, x1):
 604         # x0:x1 are 0-based slice indices; convert to 1-based line indices.
 605         x0 += 1
 606         if x0 >= x1:
 607             return "line " + str(x0)
 608         else:
 609             return "lines %d-%d" % (x0, x1)
 610
 611     for op, a0, a1, b0, b1 in tuples:
 612         if op == 'equal':
 613             pass
 614
 615         elif op == 'delete':
 616             print "***", pair(a0, a1), "of expected output missing:"
 617             for line in a[a0:a1]:
 618                 print "-", line,
 619
 620         elif op == 'replace':
 621             print "*** mismatch between", pair(a0, a1), "of expected", \
 622                   "output and", pair(b0, b1), "of actual output:"
 623             for line in difflib.ndiff(a[a0:a1], b[b0:b1]):
 624                 print line,
 625
 626         elif op == 'insert':
 627             print "***", pair(b0, b1), "of actual output doesn't appear", \
 628                   "in expected output after line", str(a1)+":"
 629             for line in b[b0:b1]:
 630                 print "+", line,
 631
 632         else:
 633             print "get_opcodes() returned bad tuple?!?!", (op, a0, a1, b0, b1)
 634
 635     print "*" * 70
 636
 637 def findtestdir():
 638     if __name__ == '__main__':
 639         file = sys.argv[0]
 640     else:
 641         file = __file__
 642     testdir = os.path.dirname(file) or os.curdir
 643     return testdir
 644
 645 def removepy(name):
 646     if name.endswith(os.extsep + "py"):
 647         name = name[:-3]
 648     return name
 649
 650 def count(n, word):
 651     if n == 1:
 652         return "%d %s" % (n, word)
 653     else:
 654         return "%d %ss" % (n, word)
 655
 656 def printlist(x, width=70, indent=4):
 657     """Print the elements of iterable x to stdout.
 658
 659     Optional arg width (default 70) is the maximum line length.
 660     Optional arg indent (default 4) is the number of blanks with which to
 661     begin each line.
 662     """
 663
 664     from textwrap import fill
 665     blanks = ' ' * indent
 666     print fill(' '.join(map(str, x)), width,
 667                initial_indent=blanks, subsequent_indent=blanks)
 668
 669 # Map sys.platform to a string containing the basenames of tests
 670 # expected to be skipped on that platform.
 671 #
 672 # Special cases:
 673 #     test_pep277
 674 #         The _ExpectedSkips constructor adds this to the set of expected
 675 #         skips if not os.path.supports_unicode_filenames.
 676 #     test_socket_ssl
 677 #         Controlled by test_socket_ssl.skip_expected.  Requires the network
 678 #         resource, and a socket module with ssl support.
 679 #     test_timeout
 680 #         Controlled by test_timeout.skip_expected.  Requires the network
 681 #         resource and a socket module.
 682
 683 _expectations = {
 684     'win32':
 685         """
 686         test__locale
 687         test_applesingle
 688         test_al
 689         test_bsddb185
 690         test_bsddb3
 691         test_cd
 692         test_cl
 693         test_commands
 694         test_crypt
 695         test_curses
 696         test_dbm
 697         test_dl
 698         test_fcntl
 699         test_fork1
 700         test_gdbm
 701         test_gl
 702         test_grp
 703         test_imgfile
 704         test_ioctl
 705         test_largefile
 706         test_linuxaudiodev
 707         test_mhlib
 708         test_nis
 709         test_openpty
 710         test_ossaudiodev
 711         test_poll
 712         test_posix
 713         test_pty
 714         test_pwd
 715         test_resource
 716         test_signal
 717         test_sunaudiodev
 718         test_threadsignals
 719         test_timing
 720         """,
 721     'linux2':
 722         """
 723         test_al
 724         test_applesingle
 725         test_bsddb185
 726         test_cd
 727         test_cl
 728         test_curses
 729         test_dl
 730         test_gl
 731         test_imgfile
 732         test_largefile
 733         test_linuxaudiodev
 734         test_nis
 735         test_ntpath
 736         test_ossaudiodev
 737         test_sunaudiodev
 738         """,
 739    'mac':
 740         """
 741         test_al
 742         test_atexit
 743         test_bsddb
 744         test_bsddb185
 745         test_bsddb3
 746         test_bz2
 747         test_cd
 748         test_cl
 749         test_commands
 750         test_crypt
 751         test_curses
 752         test_dbm
 753         test_dl
 754         test_fcntl
 755         test_fork1
 756         test_gl
 757         test_grp
 758         test_ioctl
 759         test_imgfile
 760         test_largefile
 761         test_linuxaudiodev
 762         test_locale
 763         test_mmap
 764         test_nis
 765         test_ntpath
 766         test_openpty
 767         test_ossaudiodev
 768         test_poll
 769         test_popen
 770         test_popen2
 771         test_posix
 772         test_pty
 773         test_pwd
 774         test_resource
 775         test_signal
 776         test_sunaudiodev
 777         test_sundry
 778         test_tarfile
 779         test_timing
 780         """,
 781     'unixware7':
 782         """
 783         test_al
 784         test_applesingle
 785         test_bsddb
 786         test_bsddb185
 787         test_cd
 788         test_cl
 789         test_dl
 790         test_gl
 791         test_imgfile
 792         test_largefile
 793         test_linuxaudiodev
 794         test_minidom
 795         test_nis
 796         test_ntpath
 797         test_openpty
 798         test_pyexpat
 799         test_sax
 800         test_sunaudiodev
 801         test_sundry
 802         """,
 803     'openunix8':
 804         """
 805         test_al
 806         test_applesingle
 807         test_bsddb
 808         test_bsddb185
 809         test_cd
 810         test_cl
 811         test_dl
 812         test_gl
 813         test_imgfile
 814         test_largefile
 815         test_linuxaudiodev
 816         test_minidom
 817         test_nis
 818         test_ntpath
 819         test_openpty
 820         test_pyexpat
 821         test_sax
 822         test_sunaudiodev
 823         test_sundry
 824         """,
 825     'sco_sv3':
 826         """
 827         test_al
 828         test_applesingle
 829         test_asynchat
 830         test_bsddb
 831         test_bsddb185
 832         test_cd
 833         test_cl
 834         test_dl
 835         test_fork1
 836         test_gettext
 837         test_gl
 838         test_imgfile
 839         test_largefile
 840         test_linuxaudiodev
 841         test_locale
 842         test_minidom
 843         test_nis
 844         test_ntpath
 845         test_openpty
 846         test_pyexpat
 847         test_queue
 848         test_sax
 849         test_sunaudiodev
 850         test_sundry
 851         test_thread
 852         test_threaded_import
 853         test_threadedtempfile
 854         test_threading
 855         """,
 856     'riscos':
 857         """
 858         test_al
 859         test_applesingle
 860         test_asynchat
 861         test_atexit
 862         test_bsddb
 863         test_bsddb185
 864         test_bsddb3
 865         test_cd
 866         test_cl
 867         test_commands
 868         test_crypt
 869         test_dbm
 870         test_dl
 871         test_fcntl
 872         test_fork1
 873         test_gdbm
 874         test_gl
 875         test_grp
 876         test_imgfile
 877         test_largefile
 878         test_linuxaudiodev
 879         test_locale
 880         test_mmap
 881         test_nis
 882         test_ntpath
 883         test_openpty
 884         test_poll
 885         test_popen2
 886         test_pty
 887         test_pwd
 888         test_strop
 889         test_sunaudiodev
 890         test_sundry
 891         test_thread
 892         test_threaded_import
 893         test_threadedtempfile
 894         test_threading
 895         test_timing
 896         """,
 897     'darwin':
 898         """
 899         test__locale
 900         test_al
 901         test_bsddb
 902         test_bsddb3
 903         test_cd
 904         test_cl
 905         test_curses
 906         test_dl
 907         test_gdbm
 908         test_gl
 909         test_imgfile
 910         test_largefile
 911         test_linuxaudiodev
 912         test_locale
 913         test_minidom
 914         test_nis
 915         test_ntpath
 916         test_ossaudiodev
 917         test_poll
 918         test_sunaudiodev
 919         """,
 920     'sunos5':
 921         """
 922         test_al
 923         test_applesingle
 924         test_bsddb
 925         test_bsddb185
 926         test_cd
 927         test_cl
 928         test_curses
 929         test_dbm
 930         test_gdbm
 931         test_gl
 932         test_gzip
 933         test_imgfile
 934         test_linuxaudiodev
 935         test_openpty
 936         test_zipfile
 937         test_zlib
 938         """,
 939     'hp-ux11':
 940         """
 941         test_al
 942         test_applesingle
 943         test_bsddb
 944         test_bsddb185
 945         test_cd
 946         test_cl
 947         test_curses
 948         test_dl
 949         test_gdbm
 950         test_gl
 951         test_gzip
 952         test_imgfile
 953         test_largefile
 954         test_linuxaudiodev
 955         test_locale
 956         test_minidom
 957         test_nis
 958         test_ntpath
 959         test_openpty
 960         test_pyexpat
 961         test_sax
 962         test_sunaudiodev
 963         test_zipfile
 964         test_zlib
 965         """,
 966     'atheos':
 967         """
 968         test_al
 969         test_applesingle
 970         test_bsddb185
 971         test_cd
 972         test_cl
 973         test_curses
 974         test_dl
 975         test_gdbm
 976         test_gl
 977         test_imgfile
 978         test_largefile
 979         test_linuxaudiodev
 980         test_locale
 981         test_mhlib
 982         test_mmap
 983         test_nis
 984         test_poll
 985         test_popen2
 986         test_resource
 987         test_sunaudiodev
 988         """,
 989     'cygwin':
 990         """
 991         test_al
 992         test_applesingle
 993         test_bsddb185
 994         test_bsddb3
 995         test_cd
 996         test_cl
 997         test_curses
 998         test_dbm
 999         test_gl
1000         test_imgfile
1001         test_ioctl
1002         test_largefile
1003         test_linuxaudiodev
1004         test_locale
1005         test_nis
1006         test_ossaudiodev
1007         test_socketserver
1008         test_sunaudiodev
1009         """,
1010     'os2emx':
1011         """
1012         test_al
1013         test_applesingle
1014         test_audioop
1015         test_bsddb185
1016         test_bsddb3
1017         test_cd
1018         test_cl
1019         test_commands
1020         test_curses
1021         test_dl
1022         test_gl
1023         test_imgfile
1024         test_largefile
1025         test_linuxaudiodev
1026         test_mhlib
1027         test_mmap
1028         test_nis
1029         test_openpty
1030         test_ossaudiodev
1031         test_pty
1032         test_resource
1033         test_signal
1034         test_sunaudiodev
1035         """,
1036     'freebsd4':
1037         """
1038         test_aepack
1039         test_al
1040         test_applesingle
1041         test_bsddb
1042         test_bsddb3
1043         test_cd
1044         test_cl
1045         test_gdbm
1046         test_gl
1047         test_imgfile
1048         test_linuxaudiodev
1049         test_locale
1050         test_macfs
1051         test_macostools
1052         test_nis
1053         test_ossaudiodev
1054         test_pep277
1055         test_plistlib
1056         test_pty
1057         test_scriptpackages
1058         test_socket_ssl
1059         test_socketserver
1060         test_sunaudiodev
1061         test_tcl
1062         test_timeout
1063         test_unicode_file
1064         test_urllibnet
1065         test_winreg
1066         test_winsound
1067         """,
1068     'aix5':
1069         """
1070         test_aepack
1071         test_al
1072         test_applesingle
1073         test_bsddb
1074         test_bsddb185
1075         test_bsddb3
1076         test_bz2
1077         test_cd
1078         test_cl
1079         test_dl
1080         test_gdbm
1081         test_gl
1082         test_gzip
1083         test_imgfile
1084         test_linuxaudiodev
1085         test_macfs
1086         test_macostools
1087         test_nis
1088         test_ossaudiodev
1089         test_sunaudiodev
1090         test_tcl
1091         test_winreg
1092         test_winsound
1093         test_zipimport
1094         test_zlib
1095         """,
1096 }
1097 _expectations['freebsd5'] = _expectations['freebsd4']
1098 _expectations['freebsd6'] = _expectations['freebsd4']
1099 _expectations['freebsd7'] = _expectations['freebsd4']
1100
1101 class _ExpectedSkips:
1102     def __init__(self):
1103         import os.path
1104         from test import test_socket_ssl
1105         from test import test_timeout
1106
1107         self.valid = False
1108         if sys.platform in _expectations:
1109             s = _expectations[sys.platform]
1110             self.expected = set(s.split())
1111
1112             # this isn't a regularly run unit test, it is always skipped
1113             self.expected.add('test_hashlib_speed')
1114
1115             if not os.path.supports_unicode_filenames:
1116                 self.expected.add('test_pep277')
1117
1118             if test_socket_ssl.skip_expected:
1119                 self.expected.add('test_socket_ssl')
1120
1121             if test_timeout.skip_expected:
1122                 self.expected.add('test_timeout')
1123
1124             if sys.maxint == 9223372036854775807L:
1125                 self.expected.add('test_rgbimg')
1126                 self.expected.add('test_imageop')
1127
1128             if not sys.platform in ("mac", "darwin"):
1129                 MAC_ONLY = ["test_macostools", "test_macfs", "test_aepack",
1130                             "test_plistlib", "test_scriptpackages"]
1131                 for skip in MAC_ONLY:
1132                     self.expected.add(skip)
1133
1134             if sys.platform != "win32":
1135                 WIN_ONLY = ["test_unicode_file", "test_winreg",
1136                             "test_winsound"]
1137                 for skip in WIN_ONLY:
1138                     self.expected.add(skip)
1139
1140             self.valid = True
1141
1142     def isvalid(self):
1143         "Return true iff _ExpectedSkips knows about the current platform."
1144         return self.valid
1145
1146     def getexpected(self):
1147         """Return set of test names we expect to skip on current platform.
1148
1149         self.isvalid() must be true.
1150         """
1151
1152         assert self.isvalid()
1153         return self.expected
1154
1155 if __name__ == '__main__':
1156     # Remove regrtest.py's own directory from the module search path.  This
1157     # prevents relative imports from working, and relative imports will screw
1158     # up the testing framework.  E.g. if both test.test_support and
1159     # test_support are imported, they will not contain the same globals, and
1160     # much of the testing framework relies on the globals in the
1161     # test.test_support module.
1162     mydir = os.path.abspath(os.path.normpath(os.path.dirname(sys.argv[0])))
1163     i = pathlen = len(sys.path)
1164     while i >= 0:
1165         i -= 1
1166         if os.path.abspath(os.path.normpath(sys.path[i])) == mydir:
1167             del sys.path[i]
1168     if len(sys.path) == pathlen:
1169         print 'Could not find %r in sys.path to remove it' % mydir
1170     main()