def main(filepath, profile=False, lineProfile=False, numProcs=1):
    """Run tests defined in the given Python file.

    :param profile: whether to enable profiling of the test execution using cProfile.
    :param lineProfile: whether to enable profiling of the test execution using line_profiler.
    :param numProcs: maximum number of processes to use, if a test supports running in parallel.
    """
    if not os.path.isfile(filepath):
        raise ValueError(filepath + ' is not a file')
    base, ext = os.path.splitext(os.path.basename(filepath))
    if ext != '.py':
        raise ValueError(filepath + ' is not a Python source file')
    # Load Python file
    dirpath = os.path.dirname(filepath)
    (file, pathname, desc) = imp.find_module(base, [dirpath])
    try:
        module = imp.load_module(base, file, pathname, desc)
    except ImportError:
        print "Python module search path:", sys.path, os.environ.get('PYTHONPATH')
        raise
    finally:
        file.close()
    # Extract and run its tests
    SetTestOutput(module)
    module.CHASTE_NUM_PROCS = numProcs
    runner = ChasteTestRunner(profile=profile, lineProfile=lineProfile)
    if hasattr(module, 'MakeTestSuite') and callable(module.MakeTestSuite):
        suite = module.MakeTestSuite()
        result = runner.run(suite)
        sys.exit(not result.wasSuccessful())
    else:
        unittest.main(module=module, argv=[sys.argv[0]], testRunner=runner, testLoader=ChasteTestLoader())

def run_suite(remove=None, folder=None, suite=None):
    """Runs a particular test suite or simply unittest.main.

    Takes care that all temporary data in `folder` is removed if `remove=True`.

    """
    if remove is not None:
        testParams['remove'] = remove

    testParams['user_tempdir'] = folder

    prepare_log_config()

    # Just signal if make_temp_dir works
    make_temp_dir('tmp.txt', signal=True)

    success = False
    try:
        if suite is None:
            unittest.main(verbosity=2)
        else:
            runner = unittest.TextTestRunner(verbosity=2)
            result = runner.run(suite)
            success = result.wasSuccessful()
    finally:
        remove_data()

    if not success:
        # Exit with 1 if tests were not successful
        sys.exit(1)

def run():

    parser = argparse.ArgumentParser()
    parser.add_argument('--print-log', action='store_true',
                        help='Print the log.')
    parser.add_argument('--port-base', help='The port number to start looking '
                        'for open ports. The default is %i.' % narwhal.port_base,
                        default=narwhal.port_base, type=int)
    args = parser.parse_args()

    if args.print_log:
        logging.basicConfig(level=logging.DEBUG,
                            format=('%(asctime)s %(levelname)s:%(name)s:'
                                    '%(funcName)s:'
                                    '%(filename)s(%(lineno)d):'
                                    '%(threadName)s(%(thread)d):%(message)s'))

    narwhal.port_base = args.port_base

    test_runner = xmlrunner.XMLTestRunner(output='test-reports')

    try:
        setUpModule()
        unittest.main(argv=[''], testRunner=test_runner)
    finally:
        tearDownModule()

    def run_tests(self):

        # Add test modules
        sys.path.insert(0, os.path.join(basedir, 'tests'))
        import unittest2 as unittest
        import _common
        from s3ql.common import (setup_excepthook, add_stdout_logging, LoggerFilter)

        # Initialize logging if not yet initialized
        root_logger = logging.getLogger()
        if not root_logger.handlers:
            add_stdout_logging(quiet=True)
            handler = logging.handlers.RotatingFileHandler("setup.log",
                                                           maxBytes=10*1024**2, backupCount=0)
            formatter = logging.Formatter('%(asctime)s.%(msecs)03d [%(process)s] %(threadName)s: '
                                          '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S")
            handler.setFormatter(formatter)                                                
            root_logger.addHandler(handler)
            setup_excepthook()  
            if self.debug:
                root_logger.setLevel(logging.DEBUG)
                if 'all' not in self.debug:
                    root_logger.addFilter(LoggerFilter(self.debug, logging.INFO))
            else:
                root_logger.setLevel(logging.INFO) 
        else:
            root_logger.debug("Logging already initialized.")

        # Define our own test loader to order modules alphabetically
        from pkg_resources import resource_listdir, resource_exists
        class ScanningLoader(unittest.TestLoader):
            # Yes, this is a nasty hack
            # pylint: disable=W0232,W0221,W0622
            def loadTestsFromModule(self, module):
                """Return a suite of all tests cases contained in the given module"""
                tests = []
                if module.__name__!='setuptools.tests.doctest':  # ugh
                    tests.append(unittest.TestLoader.loadTestsFromModule(self,module))
                if hasattr(module, "additional_tests"):
                    tests.append(module.additional_tests())
                if hasattr(module, '__path__'):
                    for file in sorted(resource_listdir(module.__name__, '')):
                        if file.endswith('.py') and file!='__init__.py':
                            submodule = module.__name__+'.'+file[:-3]
                        else:
                            if resource_exists(
                                module.__name__, file+'/__init__.py'
                            ):
                                submodule = module.__name__+'.'+file
                            else:
                                continue
                        tests.append(self.loadTestsFromName(submodule))
                if len(tests)!=1:
                    return self.suiteClass(tests)
                else:
                    return tests[0] # don't create a nested suite for only one return
                
        unittest.main(
            None, None, [unittest.__file__]+self.test_args,
            testLoader = ScanningLoader())

def main():
    """Runs the testsuite as command line application."""
    try:
        unittest.main(testLoader=BetterLoader(), defaultTest='suite')
    except Exception:
        import traceback
        traceback.print_exc()
        sys.exit(1)

	def agentMain(cls, level=logging.DEBUG):
		hdlr = logging.StreamHandler()
		hdlr.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s', '%m-%d %H:%M:%S'))
		root = logging.getLogger()
		root.handlers = []
		root.addHandler(hdlr)
		root.setLevel(level)
		unittest2.main(verbosity=2)

def test_main():
    verbosity = os.getenv('SILENT') and 1 or 2
    try:
        unittest.main(verbosity=verbosity)
    finally:
        cleanup()
        # force interpreter exit in case the FTP server thread is hanging
        os._exit(0)

def run_tests(self):
    try:
        import unittest2 as unittest
    except ImportError:
        import unittest
    unittest.main(
        None, None, [unittest.__file__]+self.test_args,
        testLoader=unittest.loader.defaultTestLoader,
        buffer = True
    )

def test_given(tests):
    module = sys.modules[__name__]
    if tests == None:
        defaultTest = None
    else:
        loader = TestLoader()
        defaultTest = TestSuite()
        tests = loader.loadTestsFromNames(tests, module)
        defaultTest.addTests(tests)
    main(defaultTest=defaultTest)

def run():
    parser = argparse.ArgumentParser()
    parser.add_argument('--print-log', help="Print the log to STDERR.",
                        action='store_true')
    args = parser.parse_args()

    if args.print_log:
        logging.basicConfig(level=logging.DEBUG,
                            format=('%(asctime)s %(levelname)s:%(name)s:'
                                    '%(funcName)s:'
                                    '%(filename)s(%(lineno)d):'
                                    '%(threadName)s(%(thread)d):%(message)s'))

    unittest.main(argv=[''])

def make_run(remove=None, folder=None):

    if remove is None:
        remove = REMOVE

    global user_tempdir
    user_tempdir=folder

    global actual_tempdir
    try:
        unittest.main()
    finally:
        if remove:
            shutil.rmtree(actual_tempdir,True)

 def run(self):
     """ 
         Invokes all tests this runner knows about or the default unittest 
         main to discover other tests if this runner is empty.
     """
     
     count  = self._suite.countTestCases()
     runner = unittest.TextTestRunner(verbosity=self._verbosity)
     
     if 0 == count:
         unittest.main(testRunner=runner)
     else:
         print
         print "----------------------------------------------------------------------"
         runner.run(self._suite)

def test_main():
    """
    Counts errors and successes from tests.
    """ 
    try:
        test = unittest.main(verbosity=2, exit=False)
    except:
        test = unittest.main()
    # Retrieve errors
    #test_passed = test.result.wasSuccessful()
    #test_total = test.result.testsRun
    test_errors = len(test.result.errors)
    test_failures = len(test.result.failures)
    # Return code for exiting program with it
    test_result = True if test_errors + test_failures == 0 else False
    return test_result

def run():
    parser = argparse.ArgumentParser()
    parser.add_argument('--print-log', action='store_true',
                        help='Print the log.')
    args = parser.parse_args()

    if args.print_log:
        logging.basicConfig(level=logging.DEBUG,
                            format=('%(asctime)s %(levelname)s:%(name)s:'
                                    '%(funcName)s:'
                                    '%(filename)s(%(lineno)d):'
                                    '%(threadName)s(%(thread)d):%(message)s'))

    test_runner = xmlrunner.XMLTestRunner(output='test-reports')

    unittest.main(argv=[''], testRunner=test_runner, verbosity=2)

 def test_NonExit(self):
     program = unittest2.main(
         exit=False,
         argv=["foobar"],
         testRunner=unittest2.TextTestRunner(
             stream=StringIO()),
         testLoader=self.FooBarLoader())
     self.assertTrue(hasattr(program, 'result'))

def run():
    global deproxy_port
    global stop_port
    global repose_port

    parser = argparse.ArgumentParser()
    parser.add_argument('--repose-port', help='The port Repose will listen on '
                        'for requests. The default is %i.' % repose_port,
                        default=repose_port, type=int)
    parser.add_argument('--stop-port', help='The port Repose will listen on '
                        'for the stop command. The default is %i.' % stop_port,
                        default=stop_port, type=int)
    parser.add_argument('--deproxy-port', help='The port Deproxy will listen '
                        'on for requests forwarded from Repose. The default '
                        'is %i.' % deproxy_port, default=deproxy_port,
                        type=int)
    parser.add_argument('--print-log', action='store_true',
                        help='Print the log.')
    args = parser.parse_args()

    if args.print_log:
        logging.basicConfig(level=logging.DEBUG,
                            format=('%(asctime)s %(levelname)s:%(name)s:'
                                    '%(funcName)s:'
                                    '%(filename)s(%(lineno)d):'
                                    '%(threadName)s(%(thread)d):%(message)s'))

    deproxy_port = args.deproxy_port
    repose_port = args.repose_port
    stop_port = args.stop_port

    test_runner = xmlrunner.XMLTestRunner(output='test-reports')

    try:
        setUpModule()
        unittest.main(argv=[''], testRunner=test_runner)
    finally:
        tearDownModule()

def run():
    global port_base

    parser = argparse.ArgumentParser()
    parser.add_argument('--print-log', help="Print the log to STDERR.",
                        action='store_true')
    parser.add_argument('--port-base', help='The port number to start looking '
                        'for open ports. The default is %i.' % port_base,
                        default=port_base, type=int)
    args = parser.parse_args()

    if args.print_log:
        logging.basicConfig(level=logging.DEBUG,
                            format=('%(asctime)s %(levelname)s:%(name)s:'
                                    '%(funcName)s:'
                                    '%(filename)s(%(lineno)d):'
                                    '%(threadName)s(%(thread)d):%(message)s'))

    port_base = args.port_base

    test_runner = _xmlrunner.XMLTestRunner(output='test-reports')

    unittest.main(argv=[''], testRunner=test_runner)

def _main(argv):
    parser = argparse.ArgumentParser(prog='conveyor-test')
    parser.add_argument(
        '--logging',
        default=None,
        metavar='FILE')
    parser.add_argument(
        '--xml',
        action='store_true',
        default=False)
    parser.add_argument('args', nargs=argparse.REMAINDER)
    args = parser.parse_args(argv[1:])
    testrunner = None
    if None is not args.logging:
        logging.config.fileConfig(args.logging)
    if args.xml:
        import xmlrunner
        testrunner = xmlrunner.XMLTestRunner(output=str('obj/'))
    if 0 != len(args.args) and '--' == args.args[0]:
        args.args = args.args[1:]
    sys.argv[1:] = args.args
    code = unittest.main(module=None, testRunner=testrunner)
    return code

        new_template = NestedNamespace('joe')
        self.assertTrue(new_template.__class__ in
                        [t.__class__ for t in stack], "%s" % stack)

        errmsg = "%s does not appear to be a subclass of %s"
        for c in [t.__class__ for t in stack]:
            self.assertTrue(isinstance(new_template, c),
                            errmsg % (new_template, c))

    def test_should_print_subcommands(self):
        """ Subcommands should be printed after the template runs
        """
        b_template = BasicNamespace('tom')
        n_template = NestedNamespace('bob')
        # pretend the nested_namespace template provides localcommands (it
        # doesn't have to actually provide them, just claim that it does)
        n_template.use_local_commands = True

        self.assertFalse(b_template.should_print_subcommands(self.command))
        self.assertTrue(n_template.should_print_subcommands(self.command))


def test_suite():
    suite = unittest.TestSuite([
        unittest.makeSuite(test_base_template),
    ])
    return suite

if __name__ == '__main__':
    unittest.main(defaultTest='test_suite')

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import sys
from unittest2 import main

if __name__ == '__main__':
    current_dir = os.path.dirname(os.path.abspath(__file__))
    tests_dir = os.path.join(current_dir, 'tests')
    sys.path += [current_dir, tests_dir]
    os.environ['DJANGO_SETTINGS_MODULE'] = 'project.settings'
    main(argv=[sys.argv[0]] + ['discover', '-s', tests_dir, '-t',
                               current_dir] + \
              sys.argv[1:])