Remove third_party/twisted_8_1

third_party/twisted_8_1/twisted/scripts/trial.py

Index: third_party/twisted_8_1/twisted/scripts/trial.py
diff --git a/third_party/twisted_8_1/twisted/scripts/trial.py b/third_party/twisted_8_1/twisted/scripts/trial.py
deleted file mode 100644
index 4476f4aa12ef2651c0c5cc062d3384cad13d6c4d..0000000000000000000000000000000000000000
--- a/third_party/twisted_8_1/twisted/scripts/trial.py
+++ /dev/null
@@ -1,368 +0,0 @@
-# -*- test-case-name: twisted.trial.test.test_script -*-
-
-# Copyright (c) 2001-2007 Twisted Matrix Laboratories.
-# See LICENSE for details.
-
-
-import sys, os, random, gc, time, warnings
-
-from twisted.internet import defer
-from twisted.application import app
-from twisted.python import usage, reflect, failure
-from twisted import plugin
-from twisted.python.util import spewer
-from twisted.python.compat import set
-from twisted.trial import runner, itrial, reporter
-
-
-# Yea, this is stupid.  Leave it for for command-line compatibility for a
-# while, though.
-TBFORMAT_MAP = {
-    'plain': 'default',
-    'default': 'default',
-    'emacs': 'brief',
-    'brief': 'brief',
-    'cgitb': 'verbose',
-    'verbose': 'verbose'
-    }
-
-
-def _parseLocalVariables(line):
-    """Accepts a single line in Emacs local variable declaration format and
-    returns a dict of all the variables {name: value}.
-    Raises ValueError if 'line' is in the wrong format.
-
-    See http://www.gnu.org/software/emacs/manual/html_node/File-Variables.html
-    """
-    paren = '-*-'
-    start = line.find(paren) + len(paren)
-    end = line.rfind(paren)
-    if start == -1 or end == -1:
-        raise ValueError("%r not a valid local variable declaration" % (line,))
-    items = line[start:end].split(';')
-    localVars = {}
-    for item in items:
-        if len(item.strip()) == 0:
-            continue
-        split = item.split(':')
-        if len(split) != 2:
-            raise ValueError("%r contains invalid declaration %r"
-                             % (line, item))
-        localVars[split[0].strip()] = split[1].strip()
-    return localVars
-
-
-def loadLocalVariables(filename):
-    """Accepts a filename and attempts to load the Emacs variable declarations
-    from that file, simulating what Emacs does.
-
-    See http://www.gnu.org/software/emacs/manual/html_node/File-Variables.html
-    """
-    f = file(filename, "r")
-    lines = [f.readline(), f.readline()]
-    f.close()
-    for line in lines:
-        try:
-            return _parseLocalVariables(line)
-        except ValueError:
-            pass
-    return {}
-
-
-def getTestModules(filename):
-    testCaseVar = loadLocalVariables(filename).get('test-case-name', None)
-    if testCaseVar is None:
-        return []
-    return testCaseVar.split(',')
-
-
-def isTestFile(filename):
-    """Returns true if 'filename' looks like a file containing unit tests.
-    False otherwise.  Doesn't care whether filename exists.
-    """
-    basename = os.path.basename(filename)
-    return (basename.startswith('test_')
-            and os.path.splitext(basename)[1] == ('.py'))
-
-
-def _zshReporterAction():
-    return "(%s)" % (" ".join([p.longOpt for p in plugin.getPlugins(itrial.IReporter)]),)
-
-class Options(usage.Options, app.ReactorSelectionMixin):
-    synopsis = """%s [options] [[file|package|module|TestCase|testmethod]...]
-    """ % (os.path.basename(sys.argv[0]),)
-
-    optFlags = [["help", "h"],
-                ["rterrors", "e", "realtime errors, print out tracebacks as "
-                 "soon as they occur"],
-                ["debug", "b", "Run tests in the Python debugger. Will load "
-                 "'.pdbrc' from current directory if it exists."],
-                ["debug-stacktraces", "B", "Report Deferred creation and "
-                 "callback stack traces"],
-                ["nopm", None, "don't automatically jump into debugger for "
-                 "postmorteming of exceptions"],
-                ["dry-run", 'n', "do everything but run the tests"],
-                ["force-gc", None, "Have Trial run gc.collect() before and "
-                 "after each test case."],
-                ["profile", None, "Run tests under the Python profiler"],
-                ["unclean-warnings", None,
-                 "Turn dirty reactor errors into warnings"],
-                ["until-failure", "u", "Repeat test until it fails"],
-                ["no-recurse", "N", "Don't recurse into packages"],
-                ['help-reporters', None,
-                 "Help on available output plugins (reporters)"]
-                ]
-
-    optParameters = [
-        ["logfile", "l", "test.log", "log file name"],
-        ["random", "z", None,
-         "Run tests in random order using the specified seed"],
-        ['temp-directory', None, '_trial_temp',
-         'Path to use as working directory for tests.'],
-        ['reporter', None, 'verbose',
-         'The reporter to use for this test run.  See --help-reporters for '
-         'more info.']]
-
-    zsh_actions = {"tbformat":"(plain emacs cgitb)",
-                   "reporter":_zshReporterAction}
-    zsh_actionDescr = {"logfile":"log file name",
-                       "random":"random seed"}
-    zsh_extras = ["*:file|module|package|TestCase|testMethod:_files -g '*.py'"]
-
-    fallbackReporter = reporter.TreeReporter
-    extra = None
-    tracer = None
-
-    def __init__(self):
-        self['tests'] = set()
-        usage.Options.__init__(self)
-
-    def opt_coverage(self):
-        """
-        Generate coverage information in the _trial_temp/coverage. Requires
-        Python 2.3.3.
-        """
-        coverdir = 'coverage'
-        print "Setting coverage directory to %s." % (coverdir,)
-        import trace
-
-        # begin monkey patch ---------------------------
-        #   Before Python 2.4, this function asserted that 'filename' had
-        #   to end with '.py'  This is wrong for at least two reasons:
-        #   1.  We might be wanting to find executable line nos in a script
-        #   2.  The implementation should use os.splitext
-        #   This monkey patch is the same function as in the stdlib (v2.3)
-        #   but with the assertion removed.
-        def find_executable_linenos(filename):
-            """Return dict where keys are line numbers in the line number
-            table.
-            """
-            #assert filename.endswith('.py') # YOU BASTARDS
-            try:
-                prog = open(filename).read()
-                prog = '\n'.join(prog.splitlines()) + '\n'
-            except IOError, err:
-                sys.stderr.write("Not printing coverage data for %r: %s\n"
-                                 % (filename, err))
-                sys.stderr.flush()
-                return {}
-            code = compile(prog, filename, "exec")
-            strs = trace.find_strings(filename)
-            return trace.find_lines(code, strs)
-
-        trace.find_executable_linenos = find_executable_linenos
-        # end monkey patch ------------------------------
-
-        self.coverdir = os.path.abspath(os.path.join(self['temp-directory'], coverdir))
-        self.tracer = trace.Trace(count=1, trace=0)
-        sys.settrace(self.tracer.globaltrace)
-
-    def opt_testmodule(self, filename):
-        "Filename to grep for test cases (-*- test-case-name)"
-        # If the filename passed to this parameter looks like a test module
-        # we just add that to the test suite.
-        #
-        # If not, we inspect it for an Emacs buffer local variable called
-        # 'test-case-name'.  If that variable is declared, we try to add its
-        # value to the test suite as a module.
-        #
-        # This parameter allows automated processes (like Buildbot) to pass
-        # a list of files to Trial with the general expectation of "these files,
-        # whatever they are, will get tested"
-        if not os.path.isfile(filename):
-            sys.stderr.write("File %r doesn't exist\n" % (filename,))
-            return
-        filename = os.path.abspath(filename)
-        if isTestFile(filename):
-            self['tests'].add(filename)
-        else:
-            self['tests'].update(getTestModules(filename))
-
-    def opt_spew(self):
-        """Print an insanely verbose log of everything that happens.  Useful
-        when debugging freezes or locks in complex code."""
-        sys.settrace(spewer)
-
-
-    def opt_help_reporters(self):
-        synopsis = ("Trial's output can be customized using plugins called "
-                    "Reporters. You can\nselect any of the following "
-                    "reporters using --reporter=<foo>\n")
-        print synopsis
-        for p in plugin.getPlugins(itrial.IReporter):
-            print '   ', p.longOpt, '\t', p.description
-        print
-        sys.exit(0)
-
-    def opt_disablegc(self):
-        """Disable the garbage collector"""
-        gc.disable()
-
-    def opt_tbformat(self, opt):
-        """Specify the format to display tracebacks with. Valid formats are
-        'plain', 'emacs', and 'cgitb' which uses the nicely verbose stdlib
-        cgitb.text function"""
-        try:
-            self['tbformat'] = TBFORMAT_MAP[opt]
-        except KeyError:
-            raise usage.UsageError(
-                "tbformat must be 'plain', 'emacs', or 'cgitb'.")
-
-    def opt_extra(self, arg):
-        """
-        Add an extra argument.  (This is a hack necessary for interfacing with
-        emacs's `gud'.)
-        """
-        if self.extra is None:
-            self.extra = []
-        self.extra.append(arg)
-    opt_x = opt_extra
-
-    def opt_recursionlimit(self, arg):
-        """see sys.setrecursionlimit()"""
-        try:
-            sys.setrecursionlimit(int(arg))
-        except (TypeError, ValueError):
-            raise usage.UsageError(
-                "argument to recursionlimit must be an integer")
-
-    def opt_random(self, option):
-        try:
-            self['random'] = long(option)
-        except ValueError:
-            raise usage.UsageError(
-                "Argument to --random must be a positive integer")
-        else:
-            if self['random'] < 0:
-                raise usage.UsageError(
-                    "Argument to --random must be a positive integer")
-            elif self['random'] == 0:
-                self['random'] = long(time.time() * 100)
-
-    def opt_without_module(self, option):
-        """
-        Fake the lack of the specified modules, separated with commas.
-        """
-        for module in option.split(","):
-            if module in sys.modules:
-                warnings.warn("Module '%s' already imported, "
-                              "disabling anyway." % (module,),
-                              category=RuntimeWarning)
-            sys.modules[module] = None
-
-    def parseArgs(self, *args):
-        self['tests'].update(args)
-        if self.extra is not None:
-            self['tests'].update(self.extra)
-
-    def _loadReporterByName(self, name):
-        for p in plugin.getPlugins(itrial.IReporter):
-            qual = "%s.%s" % (p.module, p.klass)
-            if p.longOpt == name:
-                return reflect.namedAny(qual)
-        raise usage.UsageError("Only pass names of Reporter plugins to "
-                               "--reporter. See --help-reporters for "
-                               "more info.")
-
-
-    def postOptions(self):
-
-        # Only load reporters now, as opposed to any earlier, to avoid letting
-        # application-defined plugins muck up reactor selecting by importing
-        # t.i.reactor and causing the default to be installed.
-        self['reporter'] = self._loadReporterByName(self['reporter'])
-
-        if 'tbformat' not in self:
-            self['tbformat'] = 'default'
-        if self['nopm']:
-            if not self['debug']:
-                raise usage.UsageError("you must specify --debug when using "
-                                       "--nopm ")
-            failure.DO_POST_MORTEM = False
-
-
-def _initialDebugSetup(config):
-    # do this part of debug setup first for easy debugging of import failures
-    if config['debug']:
-        failure.startDebugMode()
-    if config['debug'] or config['debug-stacktraces']:
-        defer.setDebugging(True)
-
-
-def _getSuite(config):
-    loader = _getLoader(config)
-    recurse = not config['no-recurse']
-    return loader.loadByNames(config['tests'], recurse)
-
-
-def _getLoader(config):
-    loader = runner.TestLoader()
-    if config['random']:
-        randomer = random.Random()
-        randomer.seed(config['random'])
-        loader.sorter = lambda x : randomer.random()
-        print 'Running tests shuffled with seed %d\n' % config['random']
-    if not config['until-failure']:
-        loader.suiteFactory = runner.DestructiveTestSuite
-    return loader
-
-
-def _makeRunner(config):
-    mode = None
-    if config['debug']:
-        mode = runner.TrialRunner.DEBUG
-    if config['dry-run']:
-        mode = runner.TrialRunner.DRY_RUN
-    return runner.TrialRunner(config['reporter'],
-                              mode=mode,
-                              profile=config['profile'],
-                              logfile=config['logfile'],
-                              tracebackFormat=config['tbformat'],
-                              realTimeErrors=config['rterrors'],
-                              uncleanWarnings=config['unclean-warnings'],
-                              workingDirectory=config['temp-directory'],
-                              forceGarbageCollection=config['force-gc'])
-
-
-def run():
-    if len(sys.argv) == 1:
-        sys.argv.append("--help")
-    config = Options()
-    try:
-        config.parseOptions()
-    except usage.error, ue:
-        raise SystemExit, "%s: %s" % (sys.argv[0], ue)
-    _initialDebugSetup(config)
-    trialRunner = _makeRunner(config)
-    suite = _getSuite(config)
-    if config['until-failure']:
-        test_result = trialRunner.runUntilFailure(suite)
-    else:
-        test_result = trialRunner.run(suite)
-    if config.tracer:
-        sys.settrace(None)
-        results = config.tracer.results()
-        results.write_results(show_missing=1, summary=False,
-                              coverdir=config.coverdir)
-    sys.exit(not test_result.wasSuccessful())
-