Example #1
0
def main(argv=sys.argv[1:]):
    logging.basicConfig(format='->%(asctime)s;%(levelname)s;%(message)s')
    top_dir = __file__[:__file__.find('/modules/core/')]
    build_dir = os.path.join(top_dir, '.build/modules/core/rwvx/src/core_rwvx-build')

    if 'MESSAGE_BROKER_DIR' not in os.environ:
        os.environ['MESSAGE_BROKER_DIR'] = os.path.join(build_dir, 'rwmsg/plugins/rwmsgbroker-c')

    if 'ROUTER_DIR' not in os.environ:
        os.environ['ROUTER_DIR'] = os.path.join(build_dir, 'rwdts/plugins/rwdtsrouter-c')

    parser = argparse.ArgumentParser()
    parser.add_argument('-t', '--test')
    parser.add_argument('-v', '--verbose', action='store_true')
    args = parser.parse_args(argv)

    # Set the global logging level
    logging.getLogger().setLevel(logging.DEBUG if args.verbose else logging.INFO)
    testname = args.test
    logging.info(testname)

    # The unittest framework requires a program name, so use the name of this
    # file instead (we do not want to have to pass a fake program name to main
    # when this is called from the interpreter).
    unittest.main(argv=[__file__], defaultTest=testname,
            testRunner=xmlrunner.XMLTestRunner(
                output=os.environ["RIFT_MODULE_TEST"]))
Example #2
0
 def main():        
     import sys
     sys.path.insert(0, "C:/Program Files/Southpaw/Tactic1.9/src/client")
     try:
         unittest.main()
     except SystemExit:
         pass
Example #3
0
    def run_tests(self):
        import sys, os

        if sys.version_info[0] == 3:
            rootdir =  os.path.dirname(os.path.abspath(__file__))
            if rootdir in sys.path:
                sys.path.remove(rootdir)

        ei_cmd = self.get_finalized_command('egg_info')
        egg_name = ei_cmd.egg_name.replace('-', '_')

        to_remove = []
        for dirname in sys.path:
            bn = os.path.basename(dirname)
            if bn.startswith(egg_name + "-"):
                to_remove.append(dirname)

        for dirname in to_remove:
            log.info("removing installed %r from sys.path before testing"%(dirname,))
            sys.path.remove(dirname)

        from PyObjCTest.loader import makeTestSuite
        import unittest

        #import pprint; pprint.pprint(sys.path)
       
        unittest.main(None, None, [unittest.__file__]+self.test_args)
Example #4
0
def test_main():
    global _do_pause

    o = optparse.OptionParser()
    o.add_option("-v", "--verbose", action="store_true",
                 help="Verbose output")
    o.add_option("-q", "--quiet", action="store_true",
                 help="Minimal output")
    o.add_option("-l", "--list_tests", action="store_true")
    o.add_option("-p", "--pause", action="store_true")

    conf, args = o.parse_args()


    if conf.list_tests:
        list_tests(1)
        return

    if conf.pause:
        _do_pause = True


    # process unittest arguments
    argv = [sys.argv[0]]

    if conf.verbose:
        argv.append("-v")
    if conf.quiet:
        argv.append("-q")

    argv.extend(args)

    # run unittest
    unittest.main(argv=argv)
Example #5
0
def main():
    unittest.main()

    def test_gauges(self):
        pkt = 'foo:50|g'
        self.svc._process(pkt, None)
        self.assertEquals(self.stats.gauges, {'foo': '50'})
def main():

  # create logger
  logger = logging.getLogger("decorationplan.detail3")
  logger.setLevel(logging.DEBUG)

  # create console handler and set level to debug
  ch = logging.StreamHandler( sys.__stdout__ ) # Add this
  ch.setLevel(logging.DEBUG)

  # create formatter
  formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

  # add formatter to ch
  ch.setFormatter(formatter)

  # add ch to logger
  logger.addHandler(ch)

  # 'application' code
  #logger.debug('debug message')
  #logger.info('info message')
  #logger.warn('warn message')
  #logger.error('error message')
  #logger.critical('critical message')
  
  unittest.main()
Example #7
0
    def run(self):
        os.setpgrp()

        unittest_args = [sys.argv[0]]
        if ARGS.verbose:
            unittest_args += ["-v"]
        unittest.main(argv=unittest_args)
Example #8
0
def run_unittest(tester):
    """run unittest"""
    import unittest
    unittest.main(
        None, None, [unittest.__file__, tester.test_suite],
        testLoader = unittest.TestLoader()
    )
Example #9
0
def main():
    try:
        opts, args = getopt.getopt(sys.argv[1:], "h:p:u:w:")
    except getopt.GetoptError as err:
        print str(err) 
        usage()
        sys.exit(2)
    global host
    host = "127.0.0.1"
    global port
    port = 8000
    global username
    username = None
    global password
    password = None
    for o, a in opts:
        if o == "-h":
            host = a
        elif o == "-p":
            port = int(a)
        elif o == "-u":
            username = a
        elif o == "-w":
            password = a
        else:   
            assert False, "unhandled option"
    unittest.main(argv=[sys.argv[0]])
def main():
    global DELETE, OUTPUT
    parser = OptionParser()
    parser.add_option("--list", action="store", dest="listTests")
    parser.add_option("--nodelete", action="store_true")
    parser.add_option("--output", action="store_true")
    # The following options are passed to unittest.
    parser.add_option("-e", "--explain", action="store_true")
    parser.add_option("-v", "--verbose", action="store_true")
    parser.add_option("-q", "--quiet", action="store_true")
    opts, files = parser.parse_args()
    if opts.nodelete:
        DELETE = False
    if opts.output:
        OUTPUT = True
    if opts.listTests:
        listTests(opts.listTests)
    else:
        # Eliminate script-specific command-line arguments to prevent
        # errors in unittest.
        del sys.argv[1:]
        for opt in ("explain", "verbose", "quiet"):
            if getattr(opts, opt):
                sys.argv.append("--" + opt)
        sys.argv.extend(files)
        unittest.main()
    def test_register_and_login(self):
        # register a new account
        response = self.client.post(url_for('auth.register'), data={
            'email': 'test@test.com',
            'username': 'test',
            'password': 'secret',
            'password_confirm': 'secret'
        })
        self.assertEqual(response.status_code, 302)

        # login with new account
        response = self.client.post(url_for('auth.login'), data={'email': 'test@test.com', 'password': 'secret'},
                                    follow_redirects=True)
        data = response.get_data(as_text=True)
        self.assertRegex(data, 'Hello,\s+test!')
        self.assertIn('You have not confirmed your account', data)

        # send a confirmation token
        user = User.query.filter_by(email='test@test.com').first()
        token = user.generate_confirmation_token()

        response = self.client.get(url_for('auth.confirm', token=token), follow_redirects=True)
        data = response.get_data(as_text=True)
        self.assertIn('You have confirmed your account', data)

        # log out
        response = self.client.get(url_for('auth.logout'), follow_redirects=True)
        data = response.get_data(as_text=True)
        self.assertIn('You have been logged out', data)

        if __name__ == '__main__':
            unittest.main()
Example #12
0
def run_tests():
    if not os.path.isdir(test_repo):
        sys.stderr.write("Error: Test repository not found.\n"
            "Create test repository first using ./create_test_repo.sh script.\n")
        sys.exit(1)

    unittest.main()
Example #13
0
def main():
  if '-v' in sys.argv:
    unittest.TestCase.maxDiff = None
    logging.basicConfig(level=logging.DEBUG)
  else:
    logging.basicConfig(level=logging.FATAL)
  unittest.main()
Example #14
0
def main(argv=sys.argv[1:]):
    logging.basicConfig(format="TEST %(message)s")

    # The unittest framework requires a program name, so use the name of this
    # file instead (we do not want to have to pass a fake program name to main
    # when this is called from the interpreter).
    unittest.main(argv=[__file__] + argv, testRunner=xmlrunner.XMLTestRunner(output=os.environ["RIFT_MODULE_TEST"]))
Example #15
0
 def run(self):
     '''
     Finds all the tests modules in tests/, and runs them.
     '''
     from firebirdsql import tests
     import unittest
     unittest.main(tests, argv=sys.argv[:1])
Example #16
0
    def test_2Not500or404andLoginIsVisible(self):
        assert "500" not in driver.title  # проверка на 500/404 ошибку
        assert "404" not in driver.title
        _ = wait.until(EC.element_to_be_clickable((By.CLASS_NAME, 'hidden-xs')))

        if __name__ == '__main__':
            unittest.main()
Example #17
0
def iMain(lCmdLine):

    if '--test' in lCmdLine:
        # legacy - unused
        sys.argv = [sys.argv[0]]  # the --test argument upsets unittest.main()
        unittest.main()
        return 0

    oApp = None
    try:
        oArgParser = oParseOptions()
        oOptions = oArgParser.parse_args(lCmdLine)

        sConfigFile = oOptions.sConfigFile
        oConfig = oParseConfig(sConfigFile)
        oConfig = oMergeConfig(oConfig, oOptions)

        oApp = CmdLineApp(oConfig, oOptions.lArgs)

        if oOptions.lArgs:
            oApp.onecmd_plus_hooks(' '.join(oOptions.lArgs) +'\n')
        else:
            oApp._cmdloop()
    except KeyboardInterrupt:
        pass
    except Exception as e:
        print traceback.format_exc(10)
    # always reached
    if oApp:
        oApp.vAtexit()

        l = threading.enumerate()
        if len(l) > 1:
            print "WARN: Threads still running: %r" % (l,)
def main(argv=sys.argv[1:]):
    logging.basicConfig(format='TEST %(message)s')

    parser = argparse.ArgumentParser()
    parser.add_argument('-v', '--verbose', action='store_true')
    parser.add_argument('-w', '--wait', action='store_true',
                help="Wait after the tests are done, to inspect the system.")
    parser.add_argument('unittest_args', nargs='*')

    args = parser.parse_args(argv)

    if args.wait: TestRestconf.wait_forever = True

    # Set the global logging level
    logging.getLogger(__name__).setLevel(logging.DEBUG if args.verbose else logging.ERROR)

    try:
        # The unittest framework requires a program name, so use the name of this
        # file instead (we do not want to have to pass a fake program name to main
        # when this is called from the interpreter).
        unittest.main(argv=[__file__] + args.unittest_args,
            testRunner=xmlrunner.XMLTestRunner(
                output=os.environ["RIFT_MODULE_TEST"]))
    except Exception as exp:
        print("Exception thrown", exp)
        if TestRestconf.testware is not None:
            os.system("stty sane")
            TestRestconf.testware.stop_testware()
def main():
    log.basicConfig(
        format='%(asctime)s %(name)s %(levelname)s: %(message)s',
        datefmt='%m/%d/%Y %I:%M:%S',
        level=log.DEBUG)

    unittest.main()
Example #20
0
def main(supported_fmts=[], supported_oses=['linux']):
    '''Run tests'''

    debug = '-d' in sys.argv
    verbosity = 1
    if supported_fmts and (imgfmt not in supported_fmts):
        notrun('not suitable for this image format: %s' % imgfmt)

    if True not in [sys.platform.startswith(x) for x in supported_oses]:
        notrun('not suitable for this OS: %s' % sys.platform)

    # We need to filter out the time taken from the output so that qemu-iotest
    # can reliably diff the results against master output.
    import StringIO
    if debug:
        output = sys.stdout
        verbosity = 2
        sys.argv.remove('-d')
    else:
        output = StringIO.StringIO()

    class MyTestRunner(unittest.TextTestRunner):
        def __init__(self, stream=output, descriptions=True, verbosity=verbosity):
            unittest.TextTestRunner.__init__(self, stream, descriptions, verbosity)

    # unittest.main() will use sys.exit() so expect a SystemExit exception
    try:
        unittest.main(testRunner=MyTestRunner)
    finally:
        if not debug:
            sys.stderr.write(re.sub(r'Ran (\d+) tests? in [\d.]+s', r'Ran \1 tests', output.getvalue()))
def main():
    if len(sys.argv) == 1:
        unittest.main()
        return

    waagent.LoggerInit('/var/log/waagent.log', '/dev/stdout')
    waagent.Log("%s started to handle." %(ExtensionShortName))

    global hutil
    hutil = Util.HandlerUtility(waagent.Log, waagent.Error,
                                ExtensionShortName)
    hutil.do_parse_context('TEST')
    global MyPatching
    MyPatching = FakePatching(hutil)

    if MyPatching == None:
        sys.exit(1)

    for a in sys.argv[1:]:
        if re.match("^([-/]*)(disable)", a):
            disable()
        elif re.match("^([-/]*)(uninstall)", a):
            uninstall()
        elif re.match("^([-/]*)(install)", a):
            install()
        elif re.match("^([-/]*)(enable)", a):
            enable()
        elif re.match("^([-/]*)(update)", a):
            update()
        elif re.match("^([-/]*)(download)", a):
            download()
        elif re.match("^([-/]*)(patch)", a):
            patch()
        elif re.match("^([-/]*)(oneoff)", a):
            oneoff()
Example #22
0
def q1():
    '''
    How can I handle errors, like the Zero Division Error,
    while testing?
    '''
    if __name__ == "__main__":
        unittest.main()
Example #23
0
def main(suite=None):
    if not suite:
        unittest.main()
    else:
        unittest.TestSuite(suite)
        runner = unittest.TextTestRunner()
        runner.run(suite)
Example #24
0
    def test_add(self):
    self.assertEqual(2 + 3, 5)
    def test_sub(self):
    self.assertEqual(5 - 3, 2)
    
if __name__ == '__main__':
    unittest.main()
    
python python/tests/test.py
    
# Asercje w testach

self.assertEqual(2 + 3, 5)
self.assertAlmostEqual(0.1 + 0.2, 0.3, delta=1e-6)
self.assertNotEqual('żółw', u'Żółw')
self.assertTrue([0])
self.assertFalse([])
x = []
y = x
self.assertIs(x, y)
self.assertIn('x', ['x'])
self.assertIsInstance([], list)
self.assertIsNone(None)
self.assertItemsEqual((2, 3), [2, 3])


# Code coverage

sudo pip install coverage
coverage run python/hello.py
coverage report -m
coverage html
    def test_generate_teams(self):
        data_struct = generate_data_structure(
            'a2|'
            ' **qg** [](#qg) |'
            'vs.|'
            ' [](#dig) **dig** |'
            ' [picks & bans](http://www.twitch.tv/esl_lol/v/30574431?t=1h47m41s) |'
            ' [game start](http://www.twitch.tv/esl_lol/v/30574431?t=1h57m05s) |'
            ' [picks & bans](https://www.youtube.com/watch?v=ytsjecr73nk) |'
            ' [game start](https://www.youtube.com/watch?v=ytsjecr73nk&t=7m45s) |'
            ' [highlights](https://www.youtube.com/watch?v=j67z3z9gnsc) |',
            'title')
        self.assertTrue('qg' in data_struct['blue_team'])
        self.assertTrue('dig' in data_struct['red_team'])
        self.assertTrue('a2' in data_struct['local_id'])
        self.assertIsNotNone(data_struct['pick_ban'])
        self.assertIsNotNone(data_struct['pick_ban']['twitch'])
        self.assertIsNotNone(data_struct['pick_ban']['youtube'])
        self.assertIsNotNone(data_struct['game_start'])
        self.assertIsNotNone(data_struct['game_start']['youtube'])
        self.assertEqual(data_struct['game_start']['youtube'],
                         ' [game start](https://www.youtube.com/watch?v=ytsjecr73nk&t=7m45s) ')
        self.assertIsNotNone(data_struct['highlights'])

        if __name__ == '__main__':
            unittest.main()
Example #26
0
def ez_launch(modname,
              main=None,
              setup=None,
              cleanup=None,
              test=None,
              logfile=''):
    """
    For a simple (non-tool-style) program, figure out what needs to happen and
    call the invoker's 'main' callback.
    """
    if len(sys.argv) == 1 and sys.argv[0] == '':
        return
    if modname != '__main__':
        return
    sname = sys.argv[0]
    pname = re.sub('.py$', '', sname)
    if (sname.endswith('.py') and
            not os.path.exists(pname) and '-L' in sys.argv):
        print("creating symlink: %s -> %s" % (pname, sname))
        os.symlink(sname, pname)
    elif sys._getframe(1).f_code.co_name in ['?', '<module>']:
        if sname.endswith('.py'):
            if '-d' in sys.argv:
                sys.argv.remove('-d')
                pdb.set_trace()
            if test is None:
                unittest.main()
            else:
                if setup is not None:
                    setup()
                keep = testhelp.main(sys.argv, test, logfile=logfile)
                if not keep and cleanup is not None:
                    cleanup()
        elif main is not None:
            main(sys.argv)
Example #27
0
def main():
    """ Starts Home Assistant. Will create demo config if no config found. """

    # Do we want to run the tests?
    if ARG_RUN_TESTS in sys.argv:
        sys.argv.remove(ARG_RUN_TESTS)

        import unittest

        unittest.main(module='homeassistant.test')

    # Within Docker we load the config from a different path
    if ARG_DOCKER in sys.argv:
        config_path = '/config/home-assistant.conf'
    else:
        config_path = 'config/home-assistant.conf'

    # Ensure a config file exists to make first time usage easier
    if not os.path.isfile(config_path):
        with open(config_path, 'w') as conf:
            conf.write("[http]\n")
            conf.write("api_password=password\n\n")
            conf.write("[demo]\n")

    hass = bootstrap.from_config_file(config_path)
    hass.start()
    hass.block_till_stopped()
Example #28
0
def resolve():
s = input()
n = int(input()) - 1
print(s[int(n/5)] + s[int(n%5)])

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例1(self):
        input = """abcde
1"""
        output = """ab"""
        self.assertIO(input, output)
    def test_入力例2(self):
        input = """aeiou
22"""
        output = """ue"""
        self.assertIO(input, output)
    def test_入力例3(self):
        input = """vwxyz
25"""
        output = """zz"""
        self.assertIO(input, output)

if __name__ == "__main__":
    unittest.main()
Example #29
0
def main():
    """Runs the testsuite as command line application.
    """
    try:
        unittest.main()
    except Exception as e:
        print('Error: %s' % e)
Example #30
0
def main(argv):
    """
    Runs the test files through the xml runner
    :param argv: List of command line arguments
    """
    if len(argv) != 2:
        raise ValueError("Usage: testrunner <path-to-test-file>")

    pathname = argv[1]
    if not os.path.exists(pathname):
        raise ValueError("Test file not found '{}'".format(pathname))
    if not os.path.isfile(pathname):
        raise ValueError("Test path '{}' is not a file".format(pathname))

    # Load the test and copy over any module variables so that we have
    # the same environment defined here
    test_module = imp.load_source(module_name(pathname), pathname)
    test_module_globals = dir(test_module)
    this_globals = globals()
    for key in test_module_globals:
        this_globals[key] = getattr(test_module, key)

    # create runner & execute
    unittest.main(
        module=test_module,
        # We've processed the test source so don't let unittest try to reparse it
        # This forces it to load the tests from the supplied module
        argv=(argv[0],),
        # these make sure that some options that are not applicable
        # remain hidden from the help menu.
        failfast=False, buffer=False, catchbreak=False
    )