run_tests.py

   1 #! /usr/bin/env python
   2 ##############################################################################
   3 #
   4 # Copyright (c) 2001, 2002 Zope Corporation and Contributors.
   5 # All Rights Reserved.
   6 #
   7 # This software is subject to the provisions of the Zope Public License,
   8 # Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
   9 # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
  10 # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  11 # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
  12 # FOR A PARTICULAR PURPOSE.
  13 #
  14 ##############################################################################
  15 """
  16 test.py [-aBbcdDfgGhLmprtTuv] [modfilter [testfilter]]
  17
  18 Test harness.
  19
  20 -a level
  21 --all
  22     Run the tests at the given level.  Any test at a level at or below this is
  23     run, any test at a level above this is not run.  Level 0 runs all tests.
  24     The default is to run tests at level 1.  --all is a shortcut for -a 0.
  25
  26 -b
  27 --build
  28     Run "python setup.py build" before running tests, where "python"
  29     is the version of python used to run test.py.  Highly recommended.
  30     Tests will be run from the build directory.  (Note: In Python < 2.3
  31     the -q flag is added to the setup.py command line.)
  32
  33 -B
  34     Run "python setup.py build_ext -i" before running tests.  Tests will be
  35     run from the source directory.
  36
  37 -c  use pychecker
  38
  39 -d
  40     Instead of the normal test harness, run a debug version which
  41     doesn't catch any exceptions.  This is occasionally handy when the
  42     unittest code catching the exception doesn't work right.
  43     Unfortunately, the debug harness doesn't print the name of the
  44     test, so Use With Care.
  45
  46 --dir directory
  47     Option to limit where tests are searched for. This is
  48     important when you *really* want to limit the code that gets run.
  49     For example, if refactoring interfaces, you don't want to see the way
  50     you have broken setups for tests in other packages. You *just* want to
  51     run the interface tests.
  52
  53 -D
  54     Works like -d, except that it loads pdb when an exception occurs.
  55
  56 -f
  57     Run functional tests instead of unit tests.
  58
  59 -g threshold
  60     Set the garbage collector generation0 threshold.  This can be used to
  61     stress memory and gc correctness.  Some crashes are only reproducible when
  62     the threshold is set to 1 (agressive garbage collection).  Do "-g 0" to
  63     disable garbage collection altogether.
  64
  65 -G gc_option
  66     Set the garbage collection debugging flags.  The argument must be one
  67     of the DEBUG_ flags defined bythe Python gc module.  Multiple options
  68     can be specified by using "-G OPTION1 -G OPTION2."
  69
  70 --libdir test_root
  71     Search for tests starting in the specified start directory
  72     (useful for testing components being developed outside the main
  73     "src" or "build" trees).
  74
  75 --keepbytecode
  76     Do not delete all stale bytecode before running tests
  77
  78 -L
  79     Keep running the selected tests in a loop.  You may experience
  80     memory leakage.
  81
  82 -t
  83     Time the individual tests and print a list of the top 50, sorted from
  84     longest to shortest.
  85
  86 -p
  87     Show running progress.  It can be combined with -v or -vv.
  88
  89 -r
  90     Look for refcount problems.
  91     This requires that Python was built --with-pydebug.
  92
  93 -T
  94     Use the trace module from Python for code coverage.  XXX This only works
  95     if trace.py is explicitly added to PYTHONPATH.  The current utility writes
  96     coverage files to a directory named `coverage' that is parallel to
  97     `build'.  It also prints a summary to stdout.
  98
  99 -v
 100     Verbose output.  With one -v, unittest prints a dot (".") for each test
 101     run.  With -vv, unittest prints the name of each test (for some definition
 102     of "name" ...).  With no -v, unittest is silent until the end of the run,
 103     except when errors occur.
 104
 105     When -p is also specified, the meaning of -v is sligtly changed.  With
 106     -p and no -v only the percent indicator is displayed.  With -p and -v
 107     the test name of the current test is shown to the right of the percent
 108     indicator.  With -p and -vv the test name is not truncated to fit into
 109     80 columns and it is not cleared after the test finishes.
 110
 111 -u
 112 -m
 113     Use the PyUnit GUI instead of output to the command line.  The GUI imports
 114     tests on its own, taking care to reload all dependencies on each run.  The
 115     debug (-d), verbose (-v), progress (-p), and Loop (-L) options will be
 116     ignored.  The testfilter filter is also not applied.
 117
 118     -m starts the gui minimized.  Double-clicking the progress bar will start
 119     the import and run all tests.
 120
 121
 122 modfilter
 123 testfilter
 124     Case-sensitive regexps to limit which tests are run, used in search
 125     (not match) mode.
 126     In an extension of Python regexp notation, a leading "!" is stripped
 127     and causes the sense of the remaining regexp to be negated (so "!bc"
 128     matches any string that does not match "bc", and vice versa).
 129     By default these act like ".", i.e. nothing is excluded.
 130
 131     modfilter is applied to a test file's path, starting at "build" and
 132     including (OS-dependent) path separators.
 133
 134     testfilter is applied to the (method) name of the unittest methods
 135     contained in the test files whose paths modfilter matched.
 136
 137 Extreme (yet useful) examples:
 138
 139     test.py -vvb . "^testWriteClient$"
 140
 141     Builds the project silently, then runs unittest in verbose mode on all
 142     tests whose names are precisely "testWriteClient".  Useful when
 143     debugging a specific test.
 144
 145     test.py -vvb . "!^testWriteClient$"
 146
 147     As before, but runs all tests whose names aren't precisely
 148     "testWriteClient".  Useful to avoid a specific failing test you don't
 149     want to deal with just yet.
 150
 151     test.py -m . "!^testWriteClient$"
 152
 153     As before, but now opens up a minimized PyUnit GUI window (only showing
 154     the progress bar).  Useful for refactoring runs where you continually want
 155     to make sure all tests still pass.
 156 """
 157
 158 import gc
 159 import os
 160 import re
 161 import pdb
 162 import sys
 163 import threading    # just to get at Thread objects created by tests
 164 import time
 165 import traceback
 166 import unittest
 167 import warnings
 168
 169 from distutils.util import get_platform
 170
 171 PLAT_SPEC = "%s-%s" % (get_platform(), sys.version[0:3])
 172
 173 class ImmediateTestResult(unittest._TextTestResult):
 174
 175     __super_init = unittest._TextTestResult.__init__
 176     __super_startTest = unittest._TextTestResult.startTest
 177     __super_printErrors = unittest._TextTestResult.printErrors
 178
 179     def __init__(self, stream, descriptions, verbosity, debug=0,
 180                  count=None, progress=0):
 181         self.__super_init(stream, descriptions, verbosity)
 182         self._debug = debug
 183         self._progress = progress
 184         self._progressWithNames = 0
 185         self._count = count
 186         self._testtimes = {}
 187         # docstrings for tests don't override test-descriptions:
 188         self.descriptions = False
 189         if progress and verbosity == 1:
 190             self.dots = 0
 191             self._progressWithNames = 1
 192             self._lastWidth = 0
 193             self._maxWidth = 80
 194             try:
 195                 import curses
 196             except ImportError:
 197                 pass
 198             else:
 199                 curses.setupterm()
 200                 self._maxWidth = curses.tigetnum('cols')
 201             self._maxWidth -= len("xxxx/xxxx (xxx.x%): ") + 1
 202
 203     def stopTest(self, test):
 204         self._testtimes[test] = time.time() - self._testtimes[test]
 205         if gc.garbage:
 206             print "The following test left garbage:"
 207             print test
 208             print gc.garbage
 209             # eat the garbage here, so that the garbage isn't
 210             # printed for every subsequent test.
 211             gc.garbage[:] = []
 212
 213         # Did the test leave any new threads behind?
 214         new_threads = [t for t in threading.enumerate()
 215                          if (t.isAlive()
 216                              and
 217                              t not in self._threads)]
 218         if new_threads:
 219             print "The following test left new threads behind:"
 220             print test
 221             print "New thread(s):", new_threads
 222
 223     def print_times(self, stream, count=None):
 224         results = self._testtimes.items()
 225         results.sort(lambda x, y: cmp(y[1], x[1]))
 226         if count:
 227             n = min(count, len(results))
 228             if n:
 229                 print >>stream, "Top %d longest tests:" % n
 230         else:
 231             n = len(results)
 232         if not n:
 233             return
 234         for i in range(n):
 235             print >>stream, "%6dms" % int(results[i][1] * 1000), results[i][0]
 236
 237     def _print_traceback(self, msg, err, test, errlist):
 238         if self.showAll or self.dots or self._progress:
 239             self.stream.writeln("\n")
 240             self._lastWidth = 0
 241
 242         tb = "".join(traceback.format_exception(*err))
 243         self.stream.writeln(msg)
 244         self.stream.writeln(tb)
 245         errlist.append((test, tb))
 246
 247     def startTest(self, test):
 248         if self._progress:
 249             self.stream.write("\r%4d" % (self.testsRun + 1))
 250             if self._count:
 251                 self.stream.write("/%d (%5.1f%%)" % (self._count,
 252                                   (self.testsRun + 1) * 100.0 / self._count))
 253             if self.showAll:
 254                 self.stream.write(": ")
 255             elif self._progressWithNames:
 256                 # XXX will break with multibyte strings
 257                 name = self.getShortDescription(test)
 258                 width = len(name)
 259                 if width < self._lastWidth:
 260                     name += " " * (self._lastWidth - width)
 261                 self.stream.write(": %s" % name)
 262                 self._lastWidth = width
 263             self.stream.flush()
 264         self._threads = threading.enumerate()
 265         self.__super_startTest(test)
 266         self._testtimes[test] = time.time()
 267
 268     def getShortDescription(self, test):
 269         s = self.getDescription(test)
 270         if len(s) > self._maxWidth:
 271             pos = s.find(" (")
 272             if pos >= 0:
 273                 w = self._maxWidth - (pos + 5)
 274                 if w < 1:
 275                     # first portion (test method name) is too long
 276                     s = s[:self._maxWidth-3] + "..."
 277                 else:
 278                     pre = s[:pos+2]
 279                     post = s[-w:]
 280                     s = "%s...%s" % (pre, post)
 281         return s[:self._maxWidth]
 282
 283     def addError(self, test, err):
 284         if self._progress:
 285             self.stream.write("\r")
 286         if self._debug:
 287             raise err[0], err[1], err[2]
 288         self._print_traceback("Error in test %s" % test, err,
 289                               test, self.errors)
 290
 291     def addFailure(self, test, err):
 292         if self._progress:
 293             self.stream.write("\r")
 294         if self._debug:
 295             raise err[0], err[1], err[2]
 296         self._print_traceback("Failure in test %s" % test, err,
 297                               test, self.failures)
 298
 299     def printErrors(self):
 300         if self._progress and not (self.dots or self.showAll):
 301             self.stream.writeln()
 302         self.__super_printErrors()
 303
 304     def printErrorList(self, flavor, errors):
 305         for test, err in errors:
 306             self.stream.writeln(self.separator1)
 307             self.stream.writeln("%s: %s" % (flavor, self.getDescription(test)))
 308             self.stream.writeln(self.separator2)
 309             self.stream.writeln(err)
 310
 311
 312 class ImmediateTestRunner(unittest.TextTestRunner):
 313
 314     __super_init = unittest.TextTestRunner.__init__
 315
 316     def __init__(self, **kwarg):
 317         debug = kwarg.get("debug")
 318         if debug is not None:
 319             del kwarg["debug"]
 320         progress = kwarg.get("progress")
 321         if progress is not None:
 322             del kwarg["progress"]
 323         self.__super_init(**kwarg)
 324         self._debug = debug
 325         self._progress = progress
 326
 327     def _makeResult(self):
 328         return ImmediateTestResult(self.stream, self.descriptions,
 329                                    self.verbosity, debug=self._debug,
 330                                    count=self._count, progress=self._progress)
 331
 332     def run(self, test):
 333         self._count = test.countTestCases()
 334         return unittest.TextTestRunner.run(self, test)
 335
 336 # setup list of directories to put on the path
 337 class PathInit:
 338     def __init__(self, build, build_inplace, libdir=None):
 339         self.inplace = None
 340         # Figure out if we should test in-place or test in-build.  If the -b
 341         # or -B option was given, test in the place we were told to build in.
 342         # Otherwise, we'll look for a build directory and if we find one,
 343         # we'll test there, otherwise we'll test in-place.
 344         if build:
 345             self.inplace = build_inplace
 346         if self.inplace is None:
 347             # Need to figure it out
 348             if os.path.isdir(os.path.join("build", "lib.%s" % PLAT_SPEC)):
 349                 self.inplace = 0
 350             else:
 351                 self.inplace = 1
 352         # Calculate which directories we're going to add to sys.path, and cd
 353         # to the appropriate working directory
 354         org_cwd = os.getcwd()
 355         if self.inplace:
 356             self.libdir = "src"
 357         else:
 358             self.libdir = "lib.%s" % PLAT_SPEC
 359             os.chdir("build")
 360         # Hack sys.path
 361         self.cwd = os.getcwd()
 362         sys.path.insert(0, os.path.join(self.cwd, self.libdir))
 363         # Hack again for external products.
 364         global functional
 365         kind = functional and "functional" or "unit"
 366         if libdir:
 367             extra = os.path.join(org_cwd, libdir)
 368             print "Running %s tests from %s" % (kind, extra)
 369             self.libdir = extra
 370             sys.path.insert(0, extra)
 371         else:
 372             print "Running %s tests from %s" % (kind, self.cwd)
 373         # Make sure functional tests find ftesting.zcml
 374         if functional:
 375             config_file = 'ftesting.zcml'
 376             if not self.inplace:
 377                 # We chdired into build, so ftesting.zcml is in the
 378                 # parent directory
 379                 config_file = os.path.join('..', 'ftesting.zcml')
 380             print "Parsing %s" % config_file
 381             from zope.testing.functional import FunctionalTestSetup
 382             FunctionalTestSetup(config_file)
 383
 384 def match(rx, s):
 385     if not rx:
 386         return 1
 387     if rx[0] == "!":
 388         return re.search(rx[1:], s) is None
 389     else:
 390         return re.search(rx, s) is not None
 391
 392 class TestFileFinder:
 393     def __init__(self, prefix):
 394         self.files = []
 395         self._plen = len(prefix)
 396         if not prefix.endswith(os.sep):
 397             self._plen += 1
 398         global functional
 399         if functional:
 400             self.dirname = "ftest"
 401         else:
 402             self.dirname = "test"
 403
 404     def visit(self, rx, dir, files):
 405         if os.path.split(dir)[1] != self.dirname:
 406             return
 407         # ignore tests that aren't in packages
 408         if not "__init__.py" in files:
 409             if not files or files == ["CVS"]:
 410                 return
 411             print "not a package", dir
 412             return
 413
 414         # Put matching files in matches.  If matches is non-empty,
 415         # then make sure that the package is importable.
 416         matches = []
 417         for file in files:
 418             if file.startswith('test') and os.path.splitext(file)[-1] == '.py':
 419                 path = os.path.join(dir, file)
 420                 if match(rx, path):
 421                     matches.append(path)
 422
 423         # ignore tests when the package can't be imported, possibly due to
 424         # dependency failures.
 425         pkg = dir[self._plen:].replace(os.sep, '.')
 426         try:
 427             __import__(pkg)
 428         # We specifically do not want to catch ImportError since that's useful
 429         # information to know when running the tests.
 430         except RuntimeError, e:
 431             if VERBOSE:
 432                 print "skipping %s because: %s" % (pkg, e)
 433             return
 434         else:
 435             self.files.extend(matches)
 436
 437     def module_from_path(self, path):
 438         """Return the Python package name indicated by the filesystem path."""
 439         assert path.endswith(".py")
 440         path = path[self._plen:-3]
 441         mod = path.replace(os.sep, ".")
 442         return mod
 443
 444 def walk_with_symlinks(top, func, arg):
 445     """Like os.path.walk, but follows symlinks on POSIX systems.
 446
 447     This could theoreticaly result in an infinite loop, if you create symlink
 448     cycles in your Zope sandbox, so don't do that.
 449     """
 450     try:
 451         # Prevent 'hidden' files (those starting with '.') from being considered.
 452         names = [f for f in os.listdir(top) if not f.startswith('.')]
 453     except os.error:
 454         return
 455     func(arg, top, names)
 456     exceptions = ('.', '..')
 457     for name in names:
 458         if name not in exceptions:
 459             name = os.path.join(top, name)
 460             if os.path.isdir(name):
 461                 walk_with_symlinks(name, func, arg)
 462
 463
 464 def check_test_dir():
 465     global test_dir
 466     if test_dir and not os.path.exists(test_dir):
 467         d = pathinit.libdir
 468         d = os.path.join(d, test_dir)
 469         if os.path.exists(d):
 470             if not os.path.isdir(d):
 471                 raise ValueError(
 472                     "%s does not exist and %s is not a directory"
 473                     % (test_dir, d)
 474                     )
 475             test_dir = d
 476         else:
 477             raise ValueError("%s does not exist!" % test_dir)
 478
 479
 480 def find_tests(rx):
 481     global finder
 482     finder = TestFileFinder(pathinit.libdir)
 483
 484     check_test_dir()
 485     walkdir = test_dir or pathinit.libdir
 486     walk_with_symlinks(walkdir, finder.visit, rx)
 487     return finder.files
 488
 489 def package_import(modname):
 490     mod = __import__(modname)
 491     for part in modname.split(".")[1:]:
 492         mod = getattr(mod, part)
 493     return mod
 494
 495 def get_suite(file):
 496     modname = finder.module_from_path(file)
 497     try:
 498         mod = package_import(modname)
 499     except ImportError, err:
 500         # print traceback
 501         print "Error importing %s\n%s" % (modname, err)
 502         traceback.print_exc()
 503         if debug:
 504             raise
 505         return None
 506     try:
 507         suite_func = mod.test_suite
 508     except AttributeError:
 509         print "No test_suite() in %s" % file
 510         return None
 511     return suite_func()
 512
 513 def filter_testcases(s, rx):
 514     new = unittest.TestSuite()
 515     for test in s._tests:
 516         # See if the levels match
 517         dolevel = (level == 0) or level >= getattr(test, "level", 0)
 518         if not dolevel:
 519             continue
 520         if isinstance(test, unittest.TestCase):
 521             name = test.id() # Full test name: package.module.class.method
 522             name = name[1 + name.rfind("."):] # extract method name
 523             if not rx or match(rx, name):
 524                 new.addTest(test)
 525         else:
 526             filtered = filter_testcases(test, rx)
 527             if filtered:
 528                 new.addTest(filtered)
 529     return new
 530
 531 def gui_runner(files, test_filter):
 532     if build_inplace:
 533         utildir = os.path.join(os.getcwd(), "utilities")
 534     else:
 535         utildir = os.path.join(os.getcwd(), "..", "utilities")
 536     sys.path.append(utildir)
 537     import unittestgui
 538     suites = []
 539     for file in files:
 540         suites.append(finder.module_from_path(file) + ".test_suite")
 541
 542     suites = ", ".join(suites)
 543     minimal = (GUI == "minimal")
 544     # unittestgui apparently doesn't take the minimal flag anymore
 545     unittestgui.main(suites)
 546
 547 class TrackRefs:
 548     """Object to track reference counts across test runs."""
 549
 550     def __init__(self):
 551         self.type2count = {}
 552         self.type2all = {}
 553
 554     def update(self):
 555         obs = sys.getobjects(0)
 556         type2count = {}
 557         type2all = {}
 558         for o in obs:
 559             all = sys.getrefcount(o)
 560             t = type(o)
 561             if t in type2count:
 562                 type2count[t] += 1
 563                 type2all[t] += all
 564             else:
 565                 type2count[t] = 1
 566                 type2all[t] = all
 567
 568         ct = [(type2count[t] - self.type2count.get(t, 0),
 569                type2all[t] - self.type2all.get(t, 0),
 570                t)
 571               for t in type2count.iterkeys()]
 572         ct.sort()
 573         ct.reverse()
 574         for delta1, delta2, t in ct:
 575             if delta1 or delta2:
 576                 print "%-55s %8d %8d" % (t, delta1, delta2)
 577
 578         self.type2count = type2count
 579         self.type2all = type2all
 580
 581 def runner(files, test_filter, debug):
 582     runner = ImmediateTestRunner(verbosity=VERBOSE, debug=debug,
 583         progress=progress)
 584     suite = unittest.TestSuite()
 585     for file in files:
 586         s = get_suite(file)
 587         # See if the levels match
 588         dolevel = (level == 0) or level >= getattr(s, "level", 0)
 589         if s is not None and dolevel:
 590             s = filter_testcases(s, test_filter)
 591             suite.addTest(s)
 592     try:
 593         r = runner.run(suite)
 594         if timesfn:
 595             r.print_times(open(timesfn, "w"))
 596             if VERBOSE:
 597                 print "Wrote timing data to", timesfn
 598         if timetests:
 599             r.print_times(sys.stdout, timetests)
 600     except:
 601         if debugger:
 602             print "%s:" % (sys.exc_info()[0], )
 603             print sys.exc_info()[1]
 604             pdb.post_mortem(sys.exc_info()[2])
 605         else:
 606             raise
 607
 608 def remove_stale_bytecode(arg, dirname, names):
 609     names = map(os.path.normcase, names)
 610     for name in names:
 611         if name.endswith(".pyc") or name.endswith(".pyo"):
 612             srcname = name[:-1]
 613             if srcname not in names:
 614                 fullname = os.path.join(dirname, name)
 615                 print "Removing stale bytecode file", fullname
 616                 os.unlink(fullname)
 617
 618 def main(module_filter, test_filter, libdir):
 619     if not keepStaleBytecode:
 620         os.path.walk(os.curdir, remove_stale_bytecode, None)
 621
 622     # Get the log.ini file from the current directory instead of possibly
 623     # buried in the build directory.  XXX This isn't perfect because if
 624     # log.ini specifies a log file, it'll be relative to the build directory.
 625     # Hmm...
 626     logini = os.path.abspath("log.ini")
 627
 628     # Initialize the path and cwd
 629     global pathinit
 630     pathinit = PathInit(build, build_inplace, libdir)
 631
 632     # Initialize the logging module.
 633
 634     import logging.config
 635     logging.basicConfig()
 636
 637     level = os.getenv("LOGGING")
 638     if level:
 639         level = int(level)
 640     else:
 641         level = logging.CRITICAL
 642     logging.root.setLevel(level)
 643
 644     if os.path.exists(logini):
 645         logging.config.fileConfig(logini)
 646
 647     files = find_tests(module_filter)
 648     files.sort()
 649
 650     if GUI:
 651         gui_runner(files, test_filter)
 652     elif LOOP:
 653         if REFCOUNT:
 654             rc = sys.gettotalrefcount()
 655             track = TrackRefs()
 656         while 1:
 657             runner(files, test_filter, debug)
 658             gc.collect()
 659             if gc.garbage:
 660                 print "GARBAGE:", len(gc.garbage), gc.garbage
 661                 return
 662             if REFCOUNT:
 663                 prev = rc
 664                 rc = sys.gettotalrefcount()
 665                 print "totalrefcount=%-8d change=%-6d" % (rc, rc - prev)
 666                 track.update()
 667     else:
 668         runner(files, test_filter, debug)
 669
 670
 671 def process_args(argv=None):
 672     import getopt
 673     global module_filter
 674     global test_filter
 675     global VERBOSE
 676     global LOOP
 677     global GUI
 678     global TRACE
 679     global REFCOUNT
 680     global debug
 681     global debugger
 682     global build
 683     global level
 684     global libdir
 685     global timesfn
 686     global timetests
 687     global progress
 688     global build_inplace
 689     global keepStaleBytecode
 690     global functional
 691     global test_dir
 692
 693     if argv is None:
 694         argv = sys.argv
 695
 696     module_filter = None
 697     test_filter = None
 698     VERBOSE = 2
 699     LOOP = 0
 700     GUI = 0
 701     TRACE = 0
 702     REFCOUNT = 0
 703     debug = 0 # Don't collect test results; simply let tests crash
 704     debugger = 0
 705     build = 0
 706     build_inplace = 0
 707     gcthresh = None
 708     gcdebug = 0
 709     gcflags = []
 710     level = 1
 711     libdir = '.'
 712     progress = 0
 713     timesfn = None
 714     timetests = 0
 715     keepStaleBytecode = 0
 716     functional = 0
 717     test_dir = None
 718
 719     try:
 720         opts, args = getopt.getopt(argv[1:], "a:bBcdDfg:G:hLmprtTuv",
 721                                    ["all", "help", "libdir=", "times=",
 722                                     "keepbytecode", "dir=", "build"])
 723     except getopt.error, msg:
 724         print msg
 725         print "Try `python %s -h' for more information." % argv[0]
 726         sys.exit(2)
 727
 728     for k, v in opts:
 729         if k == "-a":
 730             level = int(v)
 731         elif k == "--all":
 732             level = 0
 733             os.environ["COMPLAIN_IF_TESTS_MISSED"]='1'
 734         elif k in ("-b", "--build"):
 735             build = 1
 736         elif k == "-B":
 737              build = build_inplace = 1
 738         elif k == "-c":
 739             # make sure you have a recent version of pychecker
 740             if not os.environ.get("PYCHECKER"):
 741                 os.environ["PYCHECKER"] = "-q"
 742             import pychecker.checker
 743         elif k == "-d":
 744             debug = 1
 745         elif k == "-D":
 746             debug = 1
 747             debugger = 1
 748         elif k == "-f":
 749             functional = 1
 750         elif k in ("-h", "--help"):
 751             print __doc__
 752             sys.exit(0)
 753         elif k == "-g":
 754             gcthresh = int(v)
 755         elif k == "-G":
 756             if not v.startswith("DEBUG_"):
 757                 print "-G argument must be DEBUG_ flag, not", repr(v)
 758                 sys.exit(1)
 759             gcflags.append(v)
 760         elif k == '--keepbytecode':
 761             keepStaleBytecode = 1
 762         elif k == '--libdir':
 763             libdir = v
 764         elif k == "-L":
 765             LOOP = 1
 766         elif k == "-m":
 767             GUI = "minimal"
 768         elif k == "-p":
 769             progress = 1
 770         elif k == "-r":
 771             if hasattr(sys, "gettotalrefcount"):
 772                 REFCOUNT = 1
 773             else:
 774                 print "-r ignored, because it needs a debug build of Python"
 775         elif k == "-T":
 776             TRACE = 1
 777         elif k == "-t":
 778             if not timetests:
 779                 timetests = 50
 780         elif k == "-u":
 781             GUI = 1
 782         elif k == "-v":
 783             VERBOSE += 1
 784         elif k == "--times":
 785             try:
 786                 timetests = int(v)
 787             except ValueError:
 788                 # must be a filename to write
 789                 timesfn = v
 790         elif k == '--dir':
 791             test_dir = v
 792
 793     if gcthresh is not None:
 794         if gcthresh == 0:
 795             gc.disable()
 796             print "gc disabled"
 797         else:
 798             gc.set_threshold(gcthresh)
 799             print "gc threshold:", gc.get_threshold()
 800
 801     if gcflags:
 802         val = 0
 803         for flag in gcflags:
 804             v = getattr(gc, flag, None)
 805             if v is None:
 806                 print "Unknown gc flag", repr(flag)
 807                 print gc.set_debug.__doc__
 808                 sys.exit(1)
 809             val |= v
 810         gcdebug |= v
 811
 812     if gcdebug:
 813         gc.set_debug(gcdebug)
 814
 815     if build:
 816         # Python 2.3 is more sane in its non -q output
 817         if sys.hexversion >= 0x02030000:
 818             qflag = ""
 819         else:
 820             qflag = "-q"
 821         cmd = sys.executable + " setup.py " + qflag + " build"
 822         if build_inplace:
 823             cmd += "_ext -i"
 824         if VERBOSE:
 825             print cmd
 826         sts = os.system(cmd)
 827         if sts:
 828             print "Build failed", hex(sts)
 829             sys.exit(1)
 830
 831     if VERBOSE:
 832         kind = functional and "functional" or "unit"
 833         if level == 0:
 834             print "Running %s tests at all levels" % kind
 835         else:
 836             print "Running %s tests at level %d" % (kind, level)
 837
 838     # XXX We want to change *visible* warnings into errors.  The next
 839     # line changes all warnings into errors, including warnings we
 840     # normally never see.  In particular, test_datetime does some
 841     # short-integer arithmetic that overflows to long ints, and, by
 842     # default, Python doesn't display the overflow warning that can
 843     # be enabled when this happens.  The next line turns that into an
 844     # error instead.  Guido suggests that a better to get what we're
 845     # after is to replace warnings.showwarning() with our own thing
 846     # that raises an error.
 847 ##    warnings.filterwarnings("error")
 848     warnings.filterwarnings("ignore", module="logging")
 849
 850     if args:
 851         if len(args) > 1:
 852             test_filter = args[1]
 853         module_filter = args[0]
 854     try:
 855         if TRACE:
 856             # if the trace module is used, then we don't exit with
 857             # status if on a false return value from main.
 858             coverdir = os.path.join(os.getcwd(), "coverage")
 859             import trace
 860             ignoremods = ["os", "posixpath", "stat"]
 861             tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix],
 862                                  ignoremods=ignoremods,
 863                                  trace=0, count=1)
 864
 865             tracer.runctx("main(module_filter, test_filter, libdir)",
 866                           globals=globals(), locals=vars())
 867             r = tracer.results()
 868             path = "/tmp/trace.%s" % os.getpid()
 869             import cPickle
 870             f = open(path, "wb")
 871             cPickle.dump(r, f)
 872             f.close()
 873             print path
 874             r.write_results(show_missing=1, summary=1, coverdir=coverdir)
 875         else:
 876             bad = main(module_filter, test_filter, libdir)
 877             if bad:
 878                 sys.exit(1)
 879     except ImportError, err:
 880         print err
 881         print sys.path
 882         raise
 883
 884
 885 if __name__ == "__main__":
 886     process_args()