~ubuntu-branches/ubuntu/vivid/python-gevent/vivid

 

The --db option, when provided, specifies sqlite3 database that holds the test results.

By default 'testresults.sqlite3' is used in the current directory.

 

The results are stored in the following 2 tables:

 

DEFAULT_TIMEOUT = 60

 

# the number of bytes of output that is recorded; the rest is thrown away

 

ignore_tracebacks = ['ExpectedException', 'test_support.TestSkipped', 'test.test_support.TestSkipped']

 

 

try:

    import sqlite3

    try:

        import pysqlite2.dbapi2 as sqlite3

        sqlite3 = None

 

_column_types = {'time': 'real'}

    return libevent_version

 

 

def get_tempnam():

    import warnings

    warnings.filterwarnings('ignore', 'tempnam is a potential security risk to your program')

 

 

def run_tests(options, args):

    arg = args[0]

    module_name = arg

    if module_name.endswith('.py'):

        module_name = module_name[:-3]

    class _runner(object):

        def __new__(cls, *args, **kawrgs):

            return DatabaseTestRunner(database_path=options.db, runid=options.runid, module_name=module_name, verbosity=options.verbosity)

    if options.db:

        import unittest

        unittest.TextTestRunner = _runner

        import test_support

        test_support.BasicTestRunner = _runner

    if os.path.exists(arg):

    else:

        test = defaultTestLoader.loadTestsFromName(arg)

        result = _runner().run(test)

        sys.exit(not result.wasSuccessful())

 

 

    from threading import Timer

    from mysubprocess import Popen, PIPE, STDOUT

 

                  '--verbosity', options.verbosity]

    if options.db:

        popen_args += ['--db', options.db]

    popen_args = [str(x) for x in popen_args]

    if options.capture:

        popen = Popen(popen_args, stdout=PIPE, stderr=STDOUT, shell=False)

 

    def killer():

        retcode.append('TIMEOUT')

        popen.kill()

 

    timeout = Timer(options.timeout, killer)

    finally:

        timeout.cancel()

    # QQQ compensating for run_tests' screw up

    if module_name.endswith('.py'):

        module_name = module_name[:-3]

    output = output.replace(' (__main__.', ' (' + module_name + '.')

    return retcode[0], output, output_printed

 

 

    success = False

    if options.db:

        if module_name.endswith('.py'):

            module_name = module_name[:-3]

        from datetime import datetime

                       'test': module_name})

        row_id = store_record(options.db, 'test', params)

        params['id'] = row_id

    if len(output) > OUTPUT_LIMIT:

    if retcode:

        if retcode == 1 and 'test_support.TestSkipped' in output:

            pass

        else:

            if not output_printed and options.verbosity >= -1:

                sys.stdout.write(output)

    elif retcode == 0:

        if not output_printed and options.verbosity >= 1:

            sys.stdout.write(output)

        if options.verbosity >= 0:

        success = True

    else:

    if options.db:

        params['output'] = output

        params['retcode'] = retcode

              'python': '%s.%s.%s' % sys.version_info[:3],

              'changeset': get_changeset(),

              'libevent_version': get_libevent_version(),

              'uname': platform.uname()[0],

              'retcode': 'TIMEOUT'}

    success = True

    if not args:

        args = glob.glob('test_*.py')

        args.remove('test_support.py')

    for arg in args:

        try:

            success = spawn_subprocess(arg, options, params) and success

        except Exception:

 

 

_warning_re = re.compile('\w*warning', re.I)

 

 

def get_warnings(output):

    ... ZeroDivisionError: integer division or modulo by zero''')

    ['ZeroDivisionError']

    """

 

 

def get_warning_stats(output):

        traceback_count -= 1

    items = counter.items()

    items.sort(key=lambda (a, b): -b)

        items.append(('other traceback', traceback_count))

    result = []

    for name, count in items:

 

 

def get_info(output, test):

    traceback_stats, ignored_list = get_traceback_stats(output, test)

    warning_stats = get_warning_stats(output)

    result = traceback_stats + warning_stats

    parser.add_option('-v', '--verbose', default=0, action='count')

    parser.add_option('-q', '--quiet', default=0, action='count')

    parser.add_option('--verbosity', default=0, type='int', help=optparse.SUPPRESS_HELP)

    parser.add_option('--runid')

    parser.add_option('--record', default=False, action='store_true')

    parser.add_option('--no-capture', dest='capture', default=True, action='store_false')

    options, args = parser.parse_args()

    options.verbosity += options.verbose - options.quiet

 

        else:

 

    if options.db:

        db = sqlite3.connect(options.db)