home *** CD-ROM | disk | FTP | other *** search
# Source Generated with Decompyle++ # File: in.pyc (Python 2.5) '''Regression test. This will find all modules whose name is "test_*" in the test directory, and run them. Various command line options provide additional facilities. Command line options: -v: verbose -- run tests in verbose mode with output to stdout -w: verbose2 -- re-run failed tests in verbose mode -q: quiet -- don\'t print anything except if a test fails -g: generate -- write the output file for a test instead of comparing it -x: exclude -- arguments are tests to *exclude* -s: single -- run only a single test (see below) -r: random -- randomize test execution order -f: fromfile -- read names of tests to run from a file (see below) -l: findleaks -- if GC is available detect tests that leak memory -u: use -- specify which special resource intensive tests to run -h: help -- print this text and exit -t: threshold -- call gc.set_threshold(N) -T: coverage -- turn on code coverage using the trace module -D: coverdir -- Directory where coverage files are put -N: nocoverdir -- Put coverage files alongside modules -L: runleaks -- run the leaks(1) command just before exit -R: huntrleaks -- search for reference leaks (needs debug build, v. slow) -M: memlimit -- run very large memory-consuming tests If non-option arguments are present, they are names for tests to run, unless -x is given, in which case they are names for tests not to run. If no test names are given, all tests are run. -v is incompatible with -g and does not compare test output files. -T turns on code coverage tracing with the trace module. -D specifies the directory where coverage files are put. -N Put coverage files alongside modules. -s means to run only a single test and exit. This is useful when doing memory analysis on the Python interpreter (which tend to consume too many resources to run the full regression test non-stop). The file /tmp/pynexttest is read to find the next test to run. If this file is missing, the first test_*.py file in testdir or on the command line is used. (actually tempfile.gettempdir() is used instead of /tmp). -f reads the names of tests from the file given as f\'s argument, one or more test names per line. Whitespace is ignored. Blank lines and lines beginning with \'#\' are ignored. This is especially useful for whittling down failures involving interactions among tests. -L causes the leaks(1) command to be run just before exit if it exists. leaks(1) is available on Mac OS X and presumably on some other FreeBSD-derived systems. -R runs each test several times and examines sys.gettotalrefcount() to see if the test appears to be leaking references. The argument should be of the form stab:run:fname where \'stab\' is the number of times the test is run to let gettotalrefcount settle down, \'run\' is the number of times further it is run and \'fname\' is the name of the file the reports are written to. These parameters all have defaults (5, 4 and "reflog.txt" respectively), so the minimal invocation is \'-R ::\'. -M runs tests that require an exorbitant amount of memory. These tests typically try to ascertain containers keep working when containing more than 2 billion objects, which only works on 64-bit systems. There are also some tests that try to exhaust the address space of the process, which only makes sense on 32-bit systems with at least 2Gb of memory. The passed-in memlimit, which is a string in the form of \'2.5Gb\', determines howmuch memory the tests will limit themselves to (but they may go slightly over.) The number shouldn\'t be more memory than the machine has (including swap memory). You should also keep in mind that swap memory is generally much, much slower than RAM, and setting memlimit to all available RAM or higher will heavily tax the machine. On the other hand, it is no use running these tests with a limit of less than 2.5Gb, and many require more than 20Gb. Tests that expect to use more than memlimit memory will be skipped. The big-memory tests generally run very, very long. -u is used to specify which special resource intensive tests to run, such as those requiring large file support or network connectivity. The argument is a comma-separated list of words indicating the resources to test. Currently only the following are defined: all - Enable all special resources. audio - Tests that use the audio device. (There are known cases of broken audio drivers that can crash Python or even the Linux kernel.) curses - Tests that use curses and will modify the terminal\'s state and output modes. largefile - It is okay to run some test that may create huge files. These tests can take a long time and may consume >2GB of disk space temporarily. network - It is okay to run tests that use external network resource, e.g. testing SSL support for sockets. bsddb - It is okay to run the bsddb testsuite, which takes a long time to complete. decimal - Test the decimal module against a large suite that verifies compliance with standards. compiler - Test the compiler package by compiling all the source in the standard library and test suite. This takes a long time. Enabling this resource also allows test_tokenize to verify round-trip lexing on every file in the test library. subprocess Run all tests for the subprocess module. urlfetch - It is okay to download files required on testing. To enable all resources except one, use \'-uall,-<resource>\'. For example, to run all the tests except for the bsddb tests, give the option \'-uall,-bsddb\'. ''' import os import sys import getopt import random import warnings import re import cStringIO import traceback warnings.filterwarnings('ignore', 'hex/oct constants', FutureWarning, '.*test.test_grammar$') if sys.maxint > 2147483647: warnings.filterwarnings('ignore', 'hex/oct constants', FutureWarning, '<string>') for mod in ('ctypes', 'gzip', 'zipfile', 'tarfile', 'encodings.zlib_codec', 'test.test_zipimport', 'test.test_zlib', 'test.test_zipfile', 'test.test_codecs', 'test.string_tests'): warnings.filterwarnings(module = '.*%s$' % (mod,), action = 'ignore', category = ImportWarning) if sys.platform == 'darwin': try: import resource except ImportError: pass (soft, hard) = resource.getrlimit(resource.RLIMIT_STACK) newsoft = min(hard, max(soft, 1024 * 2048)) resource.setrlimit(resource.RLIMIT_STACK, (newsoft, hard)) from test import test_support RESOURCE_NAMES = ('audio', 'curses', 'largefile', 'network', 'bsddb', 'decimal', 'compiler', 'subprocess', 'urlfetch') def usage(code, msg = ''): print __doc__ if msg: print msg sys.exit(code) def main(tests = None, testdir = None, verbose = 0, quiet = False, generate = False, exclude = False, single = False, randomize = False, fromfile = None, findleaks = False, use_resources = None, trace = False, coverdir = 'coverage', runleaks = False, huntrleaks = False, verbose2 = False): """Execute a test suite. This also parses command-line options and modifies its behavior accordingly. tests -- a list of strings containing test names (optional) testdir -- the directory in which to look for tests (optional) Users other than the Python test suite will certainly want to specify testdir; if it's omitted, the directory containing the Python test suite is searched for. If the tests argument is omitted, the tests listed on the command-line will be used. If that's empty, too, then all *.py files beginning with test_ will be used. The other default arguments (verbose, quiet, generate, exclude, single, randomize, findleaks, use_resources, trace and coverdir) allow programmers calling main() directly to set the values that would normally be set by flags on the command line. """ test_support.record_original_stdout(sys.stdout) try: (opts, args) = getopt.getopt(sys.argv[1:], 'hvgqxsrf:lu:t:TD:NLR:wM:', [ 'help', 'verbose', 'quiet', 'generate', 'exclude', 'single', 'random', 'fromfile', 'findleaks', 'use=', 'threshold=', 'trace', 'coverdir=', 'nocoverdir', 'runleaks', 'huntrleaks=', 'verbose2', 'memlimit=']) except getopt.error: msg = None usage(2, msg) if use_resources is None: use_resources = [] for o, a in opts: if o in ('-h', '--help'): usage(0) continue if o in ('-v', '--verbose'): verbose += 1 continue if o in ('-w', '--verbose2'): verbose2 = True continue if o in ('-q', '--quiet'): quiet = True verbose = 0 continue if o in ('-g', '--generate'): generate = True continue if o in ('-x', '--exclude'): exclude = True continue if o in ('-s', '--single'): single = True continue if o in ('-r', '--randomize'): randomize = True continue if o in ('-f', '--fromfile'): fromfile = a continue if o in ('-l', '--findleaks'): findleaks = True continue if o in ('-L', '--runleaks'): runleaks = True continue if o in ('-t', '--threshold'): import gc gc.set_threshold(int(a)) continue if o in ('-T', '--coverage'): trace = True continue if o in ('-D', '--coverdir'): coverdir = os.path.join(os.getcwd(), a) continue if o in ('-N', '--nocoverdir'): coverdir = None continue if o in ('-R', '--huntrleaks'): huntrleaks = a.split(':') if len(huntrleaks) != 3: print a, huntrleaks usage(2, '-R takes three colon-separated arguments') if len(huntrleaks[0]) == 0: huntrleaks[0] = 5 else: huntrleaks[0] = int(huntrleaks[0]) if len(huntrleaks[1]) == 0: huntrleaks[1] = 4 else: huntrleaks[1] = int(huntrleaks[1]) if len(huntrleaks[2]) == 0: huntrleaks[2] = 'reflog.txt' len(huntrleaks[2]) == 0 if o in ('-M', '--memlimit'): test_support.set_memlimit(a) continue if o in ('-u', '--use'): u = [ x.lower() for x in a.split(',') ] for r in u: remove = False if r[0] == '-': remove = True r = r[1:] if r not in RESOURCE_NAMES: usage(1, 'Invalid -u/--use option: ' + a) if remove: if r in use_resources: use_resources.remove(r) r in use_resources if r not in use_resources: use_resources.append(r) continue if generate and verbose: usage(2, "-g and -v don't go together!") if single and fromfile: usage(2, "-s and -f don't go together!") good = [] bad = [] skipped = [] resource_denieds = [] if findleaks: try: import gc except ImportError: print 'No GC available, disabling findleaks.' findleaks = False found_garbage = [] if single: gettempdir = gettempdir import tempfile filename = os.path.join(gettempdir(), 'pynexttest') try: fp = open(filename, 'r') next = fp.read().strip() tests = [ next] fp.close() except IOError: pass except: None<EXCEPTION MATCH>IOError None<EXCEPTION MATCH>IOError if fromfile: tests = [] fp = open(fromfile) for line in fp: guts = line.split() if guts and not guts[0].startswith('#'): tests.extend(guts) continue fp.close() if args: args = map(removepy, args) if tests: tests = map(removepy, tests) stdtests = STDTESTS[:] nottests = NOTTESTS[:] if exclude: for arg in args: if arg in stdtests: stdtests.remove(arg) continue nottests[:0] = args args = [] if not tests and args: pass tests = findtests(testdir, stdtests, nottests) if single: tests = tests[:1] if randomize: random.shuffle(tests) if trace: import trace tracer = trace.Trace(ignoredirs = [ sys.prefix, sys.exec_prefix], trace = False, count = True) test_support.verbose = verbose test_support.use_resources = use_resources save_modules = sys.modules.keys() for test in tests: if not quiet: print test sys.stdout.flush() if trace: tracer.runctx('runtest(test, generate, verbose, quiet, testdir)', globals = globals(), locals = vars()) else: try: ok = runtest(test, generate, verbose, quiet, testdir, huntrleaks) except KeyboardInterrupt: print break except: raise if ok > 0: good.append(test) elif ok == 0: bad.append(test) else: skipped.append(test) if ok == -2: resource_denieds.append(test) if findleaks: gc.collect() if gc.garbage: print 'Warning: test created', len(gc.garbage), 'uncollectable object(s).' found_garbage.extend(gc.garbage) del gc.garbage[:] for module in sys.modules.keys(): if module not in save_modules and module.startswith('test.'): test_support.unload(module) continue good.sort() bad.sort() skipped.sort() if good and not quiet: if not bad and not skipped and len(good) > 1: print 'All', print count(len(good), 'test'), 'OK.' if verbose: print "CAUTION: stdout isn't compared in verbose mode:" print 'a test that passes in verbose mode may fail without it.' if bad: print count(len(bad), 'test'), 'failed:' printlist(bad) if skipped and not quiet: print count(len(skipped), 'test'), 'skipped:' printlist(skipped) e = _ExpectedSkips() plat = sys.platform if e.isvalid(): surprise = set(skipped) - e.getexpected() - set(resource_denieds) if surprise: print count(len(surprise), 'skip'), 'unexpected on', plat + ':' printlist(surprise) else: print 'Those skips are all expected on', plat + '.' else: print 'Ask someone to teach regrtest.py about which tests are' print 'expected to get skipped on', plat + '.' if verbose2 and bad: print 'Re-running failed tests in verbose mode' for test in bad: print 'Re-running test %r in verbose mode' % test sys.stdout.flush() try: test_support.verbose = 1 ok = runtest(test, generate, 1, quiet, testdir, huntrleaks) continue except KeyboardInterrupt: print break continue raise continue if single: alltests = findtests(testdir, stdtests, nottests) for i in range(len(alltests)): if tests[0] == alltests[i]: if i == len(alltests) - 1: os.unlink(filename) else: fp = open(filename, 'w') fp.write(alltests[i + 1] + '\n') fp.close() break continue if trace: r = tracer.results() r.write_results(show_missing = True, summary = True, coverdir = coverdir) if runleaks: os.system('leaks %d' % os.getpid()) sys.exit(len(bad) > 0) STDTESTS = [ 'test_grammar', 'test_opcodes', 'test_operations', 'test_builtin', 'test_exceptions', 'test_types', 'test_unittest', 'test_doctest', 'test_doctest2'] NOTTESTS = [ 'test_support', 'test_future1', 'test_future2', 'test_future3'] def findtests(testdir = None, stdtests = STDTESTS, nottests = NOTTESTS): '''Return a list of all applicable test modules.''' if not testdir: testdir = findtestdir() names = os.listdir(testdir) tests = [] for name in names: if name[:5] == 'test_' and name[-3:] == os.extsep + 'py': modname = name[:-3] if modname not in stdtests and modname not in nottests: tests.append(modname) modname not in nottests tests.sort() return stdtests + tests def runtest(test, generate, verbose, quiet, testdir = None, huntrleaks = False): """Run a single test. test -- the name of the test generate -- if true, generate output, instead of running the test and comparing it to a previously created output file verbose -- if true, print more messages quiet -- if true, don't print 'skipped' messages (probably redundant) testdir -- test directory huntrleaks -- run multiple times to test for leaks; requires a debug build; a triple corresponding to -R's three arguments Return: -2 test skipped because resource denied -1 test skipped for some other reason 0 test failed 1 test passed """ try: return runtest_inner(test, generate, verbose, quiet, testdir, huntrleaks) finally: cleanup_test_droppings(test, verbose) def runtest_inner(test, generate, verbose, quiet, testdir = None, huntrleaks = False): test_support.unload(test) if not testdir: testdir = findtestdir() outputdir = os.path.join(testdir, 'output') outputfile = os.path.join(outputdir, test) if verbose: cfp = None else: cfp = cStringIO.StringIO() try: save_stdout = sys.stdout try: if cfp: sys.stdout = cfp print test if test.startswith('test.'): abstest = test else: abstest = 'test.' + test the_package = __import__(abstest, globals(), locals(), []) the_module = getattr(the_package, test) indirect_test = getattr(the_module, 'test_main', None) if indirect_test is not None: indirect_test() if huntrleaks: dash_R(the_module, test, indirect_test, huntrleaks) finally: sys.stdout = save_stdout except test_support.ResourceDenied: msg = None if not quiet: print test, 'skipped --', msg sys.stdout.flush() return -2 except (ImportError, test_support.TestSkipped): msg = None if not quiet: print test, 'skipped --', msg sys.stdout.flush() return -1 except KeyboardInterrupt: raise except test_support.TestFailed: msg = None print 'test', test, 'failed --', msg sys.stdout.flush() return 0 except: (type, value) = sys.exc_info()[:2] print 'test', test, 'crashed --', str(type) + ':', value sys.stdout.flush() if verbose: traceback.print_exc(file = sys.stdout) sys.stdout.flush() return 0 if not cfp: return 1 output = cfp.getvalue() if generate: if output == test + '\n': if os.path.exists(outputfile): print 'output file', outputfile, 'is no longer needed; consider removing it' else: return 1 fp = open(outputfile, 'w') fp.write(output) fp.close() return 1 if os.path.exists(outputfile): fp = open(outputfile, 'r') expected = fp.read() fp.close() else: expected = test + '\n' if output == expected or huntrleaks: return 1 print 'test', test, 'produced unexpected output:' sys.stdout.flush() reportdiff(expected, output) sys.stdout.flush() return 0 def cleanup_test_droppings(testname, verbose): import shutil for name in (test_support.TESTFN, 'db_home'): if not os.path.exists(name): continue if os.path.isdir(name): kind = 'directory' nuker = shutil.rmtree elif os.path.isfile(name): kind = 'file' nuker = os.unlink else: raise SystemError('os.path says %r exists but is neither directory nor file' % name) if verbose: print '%r left behind %s %r' % (testname, kind, name) try: nuker(name) continue except Exception: msg = None print >>sys.stderr, "%r left behind %s %r and it couldn't be removed: %s" % (testname, kind, name, msg) continue def dash_R(the_module, test, indirect_test, huntrleaks): import copy_reg if not hasattr(sys, 'gettotalrefcount'): raise Exception('Tracking reference leaks requires a debug build of Python') fs = warnings.filters[:] ps = copy_reg.dispatch_table.copy() pic = sys.path_importer_cache.copy() deltas = [] (nwarmup, ntracked, fname) = huntrleaks repcount = nwarmup + ntracked print >>sys.stderr, 'beginning', repcount, 'repetitions' print >>sys.stderr, '1234567890' * (repcount // 10 + 1)[:repcount] dash_R_cleanup(fs, ps, pic) for i in range(repcount): rc = sys.gettotalrefcount() run_the_test() sys.stderr.write('.') dash_R_cleanup(fs, ps, pic) if i >= nwarmup: deltas.append(sys.gettotalrefcount() - rc - 2) continue print >>sys.stderr if any(deltas): print >>sys.stderr, test, 'leaked', deltas, 'references' refrep = open(fname, 'a') print >>refrep, test, 'leaked', deltas, 'references' refrep.close() def dash_R_cleanup(fs, ps, pic): import gc import copy_reg import _strptime import linecache import dircache import urlparse import urllib import urllib2 import mimetypes import doctest import struct import filecmp _path_created = _path_created import distutils.dir_util warnings.filters[:] = fs copy_reg.dispatch_table.clear() copy_reg.dispatch_table.update(ps) sys.path_importer_cache.clear() sys.path_importer_cache.update(pic) _path_created.clear() re.purge() _strptime._regex_cache.clear() urlparse.clear_cache() urllib.urlcleanup() urllib2.install_opener(None) dircache.reset() linecache.clearcache() mimetypes._default_mime_types() struct._cache.clear() filecmp._cache.clear() doctest.master = None gc.collect() def reportdiff(expected, output): import difflib print '*' * 70 a = expected.splitlines(1) b = output.splitlines(1) sm = difflib.SequenceMatcher(a = a, b = b) tuples = sm.get_opcodes() def pair(x0, x1): x0 += 1 if x0 >= x1: return 'line ' + str(x0) else: return 'lines %d-%d' % (x0, x1) for op, a0, a1, b0, b1 in tuples: if op == 'equal': continue if op == 'delete': print '***', pair(a0, a1), 'of expected output missing:' for line in a[a0:a1]: print '-', line, if op == 'replace': print '*** mismatch between', pair(a0, a1), 'of expected', 'output and', pair(b0, b1), 'of actual output:' for line in difflib.ndiff(a[a0:a1], b[b0:b1]): print line, if op == 'insert': print '***', pair(b0, b1), "of actual output doesn't appear", 'in expected output after line', str(a1) + ':' for line in b[b0:b1]: print '+', line, print 'get_opcodes() returned bad tuple?!?!', (op, a0, a1, b0, b1) print '*' * 70 def findtestdir(): if __name__ == '__main__': file = sys.argv[0] else: file = __file__ if not os.path.dirname(file): pass testdir = os.curdir return testdir def removepy(name): if name.endswith(os.extsep + 'py'): name = name[:-3] return name def count(n, word): if n == 1: return '%d %s' % (n, word) else: return '%d %ss' % (n, word) def printlist(x, width = 70, indent = 4): '''Print the elements of iterable x to stdout. Optional arg width (default 70) is the maximum line length. Optional arg indent (default 4) is the number of blanks with which to begin each line. ''' fill = fill import textwrap blanks = ' ' * indent print fill(' '.join(map(str, x)), width, initial_indent = blanks, subsequent_indent = blanks) _expectations = { 'win32': '\n test__locale\n test_applesingle\n test_al\n test_bsddb185\n test_bsddb3\n test_cd\n test_cl\n test_commands\n test_crypt\n test_curses\n test_dbm\n test_dl\n test_fcntl\n test_fork1\n test_gdbm\n test_gl\n test_grp\n test_imgfile\n test_ioctl\n test_largefile\n test_linuxaudiodev\n test_mhlib\n test_nis\n test_openpty\n test_ossaudiodev\n test_poll\n test_posix\n test_pty\n test_pwd\n test_resource\n test_signal\n test_sunaudiodev\n test_threadsignals\n test_timing\n test_wait3\n test_wait4\n ', 'linux2': '\n test_al\n test_applesingle\n test_bsddb185\n test_cd\n test_cl\n test_curses\n test_dl\n test_gl\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_nis\n test_ntpath\n test_ossaudiodev\n test_sqlite\n test_startfile\n test_sunaudiodev\n ', 'mac': '\n test_al\n test_atexit\n test_bsddb\n test_bsddb185\n test_bsddb3\n test_bz2\n test_cd\n test_cl\n test_commands\n test_crypt\n test_curses\n test_dbm\n test_dl\n test_fcntl\n test_fork1\n test_gl\n test_grp\n test_ioctl\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_locale\n test_mmap\n test_nis\n test_ntpath\n test_openpty\n test_ossaudiodev\n test_poll\n test_popen\n test_popen2\n test_posix\n test_pty\n test_pwd\n test_resource\n test_signal\n test_sqlite\n test_startfile\n test_sunaudiodev\n test_sundry\n test_tarfile\n test_timing\n ', 'unixware7': '\n test_al\n test_applesingle\n test_bsddb\n test_bsddb185\n test_cd\n test_cl\n test_dl\n test_gl\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_minidom\n test_nis\n test_ntpath\n test_openpty\n test_pyexpat\n test_sax\n test_startfile\n test_sqlite\n test_sunaudiodev\n test_sundry\n ', 'openunix8': '\n test_al\n test_applesingle\n test_bsddb\n test_bsddb185\n test_cd\n test_cl\n test_dl\n test_gl\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_minidom\n test_nis\n test_ntpath\n test_openpty\n test_pyexpat\n test_sax\n test_sqlite\n test_startfile\n test_sunaudiodev\n test_sundry\n ', 'sco_sv3': '\n test_al\n test_applesingle\n test_asynchat\n test_bsddb\n test_bsddb185\n test_cd\n test_cl\n test_dl\n test_fork1\n test_gettext\n test_gl\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_locale\n test_minidom\n test_nis\n test_ntpath\n test_openpty\n test_pyexpat\n test_queue\n test_sax\n test_sqlite\n test_startfile\n test_sunaudiodev\n test_sundry\n test_thread\n test_threaded_import\n test_threadedtempfile\n test_threading\n ', 'riscos': '\n test_al\n test_applesingle\n test_asynchat\n test_atexit\n test_bsddb\n test_bsddb185\n test_bsddb3\n test_cd\n test_cl\n test_commands\n test_crypt\n test_dbm\n test_dl\n test_fcntl\n test_fork1\n test_gdbm\n test_gl\n test_grp\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_locale\n test_mmap\n test_nis\n test_ntpath\n test_openpty\n test_poll\n test_popen2\n test_pty\n test_pwd\n test_strop\n test_sqlite\n test_startfile\n test_sunaudiodev\n test_sundry\n test_thread\n test_threaded_import\n test_threadedtempfile\n test_threading\n test_timing\n ', 'darwin': '\n test__locale\n test_al\n test_bsddb\n test_bsddb3\n test_cd\n test_cl\n test_curses\n test_gdbm\n test_gl\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_locale\n test_minidom\n test_nis\n test_ntpath\n test_ossaudiodev\n test_poll\n test_sqlite\n test_startfile\n test_sunaudiodev\n ', 'sunos5': '\n test_al\n test_applesingle\n test_bsddb\n test_bsddb185\n test_cd\n test_cl\n test_curses\n test_dbm\n test_gdbm\n test_gl\n test_gzip\n test_imgfile\n test_linuxaudiodev\n test_openpty\n test_sqlite\n test_startfile\n test_zipfile\n test_zlib\n ', 'hp-ux11': '\n test_al\n test_applesingle\n test_bsddb\n test_bsddb185\n test_cd\n test_cl\n test_curses\n test_dl\n test_gdbm\n test_gl\n test_gzip\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_locale\n test_minidom\n test_nis\n test_ntpath\n test_openpty\n test_pyexpat\n test_sax\n test_sqlite\n test_startfile\n test_sunaudiodev\n test_zipfile\n test_zlib\n ', 'atheos': '\n test_al\n test_applesingle\n test_bsddb185\n test_cd\n test_cl\n test_curses\n test_dl\n test_gdbm\n test_gl\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_locale\n test_mhlib\n test_mmap\n test_nis\n test_poll\n test_popen2\n test_resource\n test_sqlite\n test_startfile\n test_sunaudiodev\n ', 'cygwin': '\n test_al\n test_applesingle\n test_bsddb185\n test_bsddb3\n test_cd\n test_cl\n test_curses\n test_dbm\n test_gl\n test_imgfile\n test_ioctl\n test_largefile\n test_linuxaudiodev\n test_locale\n test_nis\n test_ossaudiodev\n test_socketserver\n test_sqlite\n test_sunaudiodev\n ', 'os2emx': '\n test_al\n test_applesingle\n test_audioop\n test_bsddb185\n test_bsddb3\n test_cd\n test_cl\n test_commands\n test_curses\n test_dl\n test_gl\n test_imgfile\n test_largefile\n test_linuxaudiodev\n test_mhlib\n test_mmap\n test_nis\n test_openpty\n test_ossaudiodev\n test_pty\n test_resource\n test_signal\n test_sqlite\n test_startfile\n test_sunaudiodev\n ', 'freebsd4': '\n test_aepack\n test_al\n test_applesingle\n test_bsddb\n test_bsddb3\n test_cd\n test_cl\n test_gdbm\n test_gl\n test_imgfile\n test_linuxaudiodev\n test_locale\n test_macfs\n test_macostools\n test_nis\n test_ossaudiodev\n test_pep277\n test_plistlib\n test_pty\n test_scriptpackages\n test_socket_ssl\n test_socketserver\n test_sqlite\n test_startfile\n test_sunaudiodev\n test_tcl\n test_timeout\n test_unicode_file\n test_urllibnet\n test_winreg\n test_winsound\n ', 'aix5': '\n test_aepack\n test_al\n test_applesingle\n test_bsddb\n test_bsddb185\n test_bsddb3\n test_bz2\n test_cd\n test_cl\n test_dl\n test_gdbm\n test_gl\n test_gzip\n test_imgfile\n test_linuxaudiodev\n test_macfs\n test_macostools\n test_nis\n test_ossaudiodev\n test_sqlite\n test_startfile\n test_sunaudiodev\n test_tcl\n test_winreg\n test_winsound\n test_zipimport\n test_zlib\n ', 'openbsd3': '\n test_aepack\n test_al\n test_applesingle\n test_bsddb\n test_bsddb3\n test_cd\n test_cl\n test_ctypes\n test_dl\n test_gdbm\n test_gl\n test_imgfile\n test_linuxaudiodev\n test_locale\n test_macfs\n test_macostools\n test_nis\n test_normalization\n test_ossaudiodev\n test_pep277\n test_plistlib\n test_scriptpackages\n test_tcl\n test_sqlite\n test_startfile\n test_sunaudiodev\n test_unicode_file\n test_winreg\n test_winsound\n ', 'netbsd3': '\n test_aepack\n test_al\n test_applesingle\n test_bsddb\n test_bsddb185\n test_bsddb3\n test_cd\n test_cl\n test_ctypes\n test_curses\n test_dl\n test_gdbm\n test_gl\n test_imgfile\n test_linuxaudiodev\n test_locale\n test_macfs\n test_macostools\n test_nis\n test_ossaudiodev\n test_pep277\n test_sqlite\n test_startfile\n test_sunaudiodev\n test_tcl\n test_unicode_file\n test_winreg\n test_winsound\n ' } _expectations['linux2-alpha'] = _expectations['linux2'] _expectations['linux2-hppa'] = _expectations['linux2'] _expectations['linux2-mips'] = _expectations['linux2'] _expectations['linux2-sparc'] = _expectations['linux2'] _expectations['freebsd5'] = _expectations['freebsd4'] _expectations['freebsd6'] = _expectations['freebsd4'] _expectations['freebsd7'] = _expectations['freebsd4'] class _ExpectedSkips: def __init__(self): import os.path as os test_socket_ssl = test_socket_ssl import test test_timeout = test_timeout import test self.valid = False if sys.platform in _expectations: s = _expectations[sys.platform] self.expected = set(s.split()) if not os.path.supports_unicode_filenames: self.expected.add('test_pep277') if test_socket_ssl.skip_expected: self.expected.add('test_socket_ssl') if test_timeout.skip_expected: self.expected.add('test_timeout') if sys.maxint == 0x7FFFFFFFFFFFFFFFL: self.expected.add('test_rgbimg') self.expected.add('test_imageop') if sys.platform not in ('mac', 'darwin'): MAC_ONLY = [ 'test_macostools', 'test_macfs', 'test_aepack', 'test_plistlib', 'test_scriptpackages'] for skip in MAC_ONLY: self.expected.add(skip) if sys.platform != 'win32': WIN_ONLY = [ 'test_unicode_file', 'test_winreg', 'test_winsound'] for skip in WIN_ONLY: self.expected.add(skip) self.valid = True def isvalid(self): '''Return true iff _ExpectedSkips knows about the current platform.''' return self.valid def getexpected(self): '''Return set of test names we expect to skip on current platform. self.isvalid() must be true. ''' if not self.isvalid(): raise AssertionError return self.expected if __name__ == '__main__': mydir = os.path.abspath(os.path.normpath(os.path.dirname(sys.argv[0]))) i = pathlen = len(sys.path) while i >= 0: i -= 1 if os.path.abspath(os.path.normpath(sys.path[i])) == mydir: del sys.path[i] if len(sys.path) == pathlen: print 'Could not find %r in sys.path to remove it' % mydir main() 
(.txt)