def suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.findTestCases(test_util))
    suite.addTest(unittest.findTestCases(test_mythdb))
    suite.addTest(unittest.findTestCases(test_mythtv))
    suite.addTest(unittest.findTestCases(test_domain))
    suite.addTest(unittest.findTestCases(test_player))
    return suite

def unitTestSuite():
    test_suite = unittest.TestSuite()
    test_suite.addTest(unittest.findTestCases(test_achievements))
    test_suite.addTest(unittest.findTestCases(test_game_store))
    test_suite.addTest(unittest.findTestCases(test_ladder))
    test_suite.addTest(unittest.findTestCases(test_pundit))
    test_suite.addTest(unittest.findTestCases(transforms))
    return test_suite

def test_suite():
    from node.ext.ugm.tests import test_api
    from node.ext.ugm.tests import test_file

    suite = unittest.TestSuite()

    suite.addTest(unittest.findTestCases(test_api))
    suite.addTest(unittest.findTestCases(test_file))

    return suite

def test_suite():
    from cone.zodb.tests import test_common
    from cone.zodb.tests import test_entry
    from cone.zodb.tests import test_indexing
    from cone.zodb.tests import test_catalog

    suite = unittest.TestSuite()

    suite.addTest(unittest.findTestCases(test_common))
    suite.addTest(unittest.findTestCases(test_entry))
    suite.addTest(unittest.findTestCases(test_indexing))
    suite.addTest(unittest.findTestCases(test_catalog))

    return suite

def suite():
    modules_to_test = map( lambda x: x[:-3], glob.glob("tests/*.py" ))
    
    alltests = unittest.TestSuite()
    for module in map(__import__, modules_to_test):
        alltests.addTest(unittest.findTestCases(module))
    return alltests

def buildSuite():
    suite = unittest.TestSuite()
    for mod in map(__import__,
        [ os.path.basename(os.path.splitext(file)[0])
            for file in glob(testdir + '/*_test.py') ]):
        suite.addTest(unittest.findTestCases(mod)) 
    return suite

def suite():
	modules = ['testConnection', 'testConnectionManager', 'testPool', 'testQuery', 'testTransaction', 'testLogging']
	alltests = unittest.TestSuite()
	for module in map(__import__, modules):
		alltests.addTest(unittest.findTestCases(module))
		
	return alltests

def main(options=None):
    op = options or optparse.OptionParser()
    op.add_option('-b', '--browser', dest='browser', default='ie', 
        help='Specify the browser to use [ie/firefox]')
    op.add_option('-u', '--url', dest='url', help='Specify the URL to load in the browser')
    op.add_option('-v', '--verbose', dest='verbose', action='store_true')
    op.add_option('-q', '--quiet', dest='quiet', action='store_true')

    # Blacklist of members of optparse.Values to ignore
    blacklist = dir(optparse.Values)

    opts, args = op.parse_args()
    kwargs = dict([(k, getattr(opts, k)) for k in dir(opts) if not k in blacklist])
    kwargs.pop('quiet')
    kwargs.pop('verbose')

    kwargs['verbosity'] = 1
    if opts.quiet:
        kwargs['verbosity'] = 0
    if opts.verbose:
        kwargs['verbosity'] = 2

    tests = unittest.findTestCases(sys.modules['__main__'])
    runner = WatinTestRunner(**kwargs)
    rc = runner.run(tests)
    if not rc.wasSuccessful():
        sys.exit(1)

def suite():
    modules_to_test = (
        'sql.testtypes',
        'sql.columns',
        'sql.constraints',

        'sql.generative',

        # SQL syntax
        'sql.select',
        'sql.selectable',
        'sql.case_statement',
        'sql.labels',
        'sql.unicode',

        # assorted round-trip tests
        'sql.functions',
        'sql.query',
        'sql.quote',
        'sql.rowcount',

        # defaults, sequences (postgres/oracle)
        'sql.defaults',
        )
    alltests = unittest.TestSuite()
    for name in modules_to_test:
        mod = __import__(name)
        for token in name.split('.')[1:]:
            mod = getattr(mod, token)
        alltests.addTest(unittest.findTestCases(mod, suiteClass=None))
    return alltests

def main(verbose):

    basenames = [
        "test_template",
        "test_engine",
        "test_preprocess",
        "test_htmlhelper",
        "test_main",
        "test_encoding",
        "test_users_guide",
        "test_faq",
        "test_examples",
    ]
    if python3:
        basenames.remove("test_encoding")

    if verbose:

        import os
        for basename in basenames:
            print('')
            print("************************************************* " + basename)
            os.system("python %s.py" % basename)

    else:

        import unittest
        suite = unittest.TestSuite()
        for basename in basenames:
            test_module = __import__(basename)
            suite.addTest(unittest.findTestCases(test_module))

        unittest.TextTestRunner(verbosity=1).run(suite)

def suite():
    """ Create a test suite for this module. """
    
    # We need to do some magic stuff here.  We want to load up all the test
    # cases twice: once for each setting of the bDomlette flag.  So we need
    # to get an explicit module reference, and load the cases manually.
    mod = sys.modules[__name__]
    suite = unittest.TestSuite()

    global bDomlette
    bDomlette = False
    suite.addTest(unittest.findTestCases(mod))

    bDomlette = True
    suite.addTest(unittest.findTestCases(mod))
    return suite

def suite():
    modules = ["testConnection", "testPool", "testQuery", "testTransaction", "testLogging"]
    alltests = unittest.TestSuite()
    for module in map(__import__, modules):
        alltests.addTest(unittest.findTestCases(module))

    return alltests

def suite():
    modules_to_test = ('LFSR_ut', 'Axis3_ut', 'Quaternion_ut', \
                       'Grid_ut', 'Map_ut', 'Ligand_ut', 'Dock_ut')
    alltests = unittest.TestSuite()
    for module in map(__import__, modules_to_test):
        alltests.addTest(unittest.findTestCases(module))
    return alltests

def suite():
    modules_to_test = (
        'test_codes',
        'test_dataele',
        'test_map_if',
        'test_map_index',
        'test_map_unique',
        'test_map_walker',
        'test_params',
        'test_path',
        'test_rawx12file',
        'test_segment',
        'test_syntax',
        'test_validation',
        'test_x12context',
        'test_x12file',
        'test_x12n_document',
        'test_xmlwriter',
        'test_x12n_document',
        'test_xmlx12_simple',
    )
    alltests = unittest.TestSuite()
    for module in map(__import__, modules_to_test):
        alltests.addTest(unittest.findTestCases(module))
    return alltests

def suite():
    alltests = unittest.TestSuite()

    for mod in get_testmods():
        alltests.addTest(unittest.findTestCases(mod))
    
    return alltests

def suite():
  modules_to_test = find_modules_and_add_paths(os.getcwd())
  alltests = unittest.TestSuite()
  for module in map(__import__, modules_to_test):
    alltests.addTest(unittest.findTestCases(module))

  return alltests

def run_test():
    import sys

    sys.path.extend(["/home/rinze/dev/lib/Pyro4/src/",
                     "/home/rinze/dev/odemis/src",
                     "/home/rinze/dev/odemis/src/gui",
                     "/home/rinze/dev/misc/"])

    import unittest
    import os
    import logging

    import odemis.gui.test as test

    print "\n** Gathering all Odemis GUI TestCases...\n"

    alltests = unittest.TestSuite()

    path = os.path.dirname(os.path.realpath(__file__))

    for _, _, files in os.walk(path):
        modules_to_test = [x[:-3] for x in files if x.endswith('test.py')]

        for file_name in sorted(modules_to_test):
            print " * Adding module %s" % file_name
            module = __import__(file_name)
            logging.getLogger().setLevel(logging.ERROR)

            module.INSPECT = False
            module.MANUAL = False
            module.SLEEP_TIME = 10

            alltests.addTest(unittest.findTestCases(module))

    result = unittest.TestResult()

    test.INSPECT = False
    test.MANUAL = False
    test.SLEEP_TIME = 10

    print "\n** Running..."
    alltests.run(result)

    num_errors = len(result.errors)
    print "\n** %d Errors occured" % num_errors

    for error in result.errors:
        print "  * %s" % error[0]
        for line in error[1].splitlines():
            print "  %s" % line

    num_failures = len(result.failures)
    print "\n** %d Failures occured\n" % num_failures

    for failure in result.failures:
        print " * %s" % failure[0]
        for line in failure[1].splitlines():
            print "  %s" % line

    print "** Done."

def main(port, tests, verbosity):
    if not tests:
        tests = os.listdir(os.path.dirname(__file__))
        tests = [os.path.splitext(t)[0] for t in tests]

    # find files and the tests in them
    mainsuite = unittest.TestSuite()
    for modulename in tests:
        try:
            module = __import__(modulename)
        except ImportError:
            print("skipping %s" % modulename)
        else:
            module.PORT = port
            testsuite = unittest.findTestCases(module)
            print(
                "found %s tests in %r" %
                (testsuite.countTestCases(), modulename))
            mainsuite.addTest(testsuite)

    # run the collected tests
    testRunner = unittest.TextTestRunner(verbosity=verbosity)
    result = testRunner.run(mainsuite)

    # set exit code according to test results
    return (0 if result.wasSuccessful() else 1)

def main():
    parser = OptionParser(usage="%prog [options] [files]")
    add = parser.add_option
    add("--conf", dest="conf", metavar="CONF",
        help="set the conf file")
    add("--profile", dest="profile", action="store_true", default=False,
        help="turn on hotshot profiling")
    add("--dump", dest="dump", action="store_true", default=False,
        help="dump this script")
    add("--unittest", dest="unittest", action="store_true", default=False,
        help="run the python unittests")
    add("--quiet", dest="verbosity", action="store_const", const=0,
        help="minimal output")
    add("--verbose", dest="verbosity", action="store_const", const=2,
        help="verbose output")
    add("--help:conf", dest="showdefaultconf", action="store_true", default=False,
        help="display the default configuration file")
    parser.set_defaults(verbosity=1)
    options, args = parser.parse_args()

    if len(sys.argv) == 1:
        parser.print_help()
        sys.exit()

    if options.showdefaultconf:
        print conf.DEFAULT_CONF
        sys.exit()

    conf_ = conf.Conf()
    if options.conf:
        conf_.loadfile(options.conf)

    profile_func = _profile_disabled
    if options.profile:
        profile_func = _profile_enabled

    if options.unittest:
        suite = unittest.TestSuite();
        for module in [conf, htmlparse, jsparse, lint, util]:
            suite.addTest(unittest.findTestCases(module))

        runner = unittest.TextTestRunner(verbosity=options.verbosity)
        runner.run(suite)

    paths = []
    for recurse, path in conf_['paths']:
        paths.extend(_resolve_paths(path, recurse))
    for arg in args:
        paths.extend(_resolve_paths(arg, False))
    if options.dump:
        profile_func(_dump, paths)
    else:
        profile_func(_lint, paths, conf_)

    if _lint_results['errors']:
        sys.exit(3)
    if _lint_results['warnings']:
        sys.exit(1)
    sys.exit(1)

def suite():
    modules_to_test = ('config_settings_test',
                       'document_manipulator_test',
                       'localization_test')
    alltests = unittest.TestSuite()
    for module in map(__import__, modules_to_test):
        alltests.addTest(unittest.findTestCases(module))
    return alltests