def testRunner(self): # Creating a TextTestRunner with the appropriate argument should # register the TextTestResult it creates runner = unittest.TextTestRunner(stream=StringIO()) result = runner.run(unittest.TestSuite()) self.assertIn(result, unittest.signals._results)
def testFailFastSetByRunner(self): runner = unittest.TextTestRunner(stream=StringIO(), failfast=True) def test(result): self.assertTrue(result.failfast) runner.run(test)
def testRunnerRegistersResult(self): class Test(unittest.TestCase): def testFoo(self): pass originalRegisterResult = unittest.runner.registerResult def cleanup(): unittest.runner.registerResult = originalRegisterResult self.addCleanup(cleanup) result = unittest.TestResult() runner = unittest.TextTestRunner(stream=StringIO()) # Use our result object runner._makeResult = lambda: result self.wasRegistered = 0 def fakeRegisterResult(thisResult): self.wasRegistered += 1 self.assertEqual(thisResult, result) unittest.runner.registerResult = fakeRegisterResult runner.run(unittest.TestSuite()) self.assertEqual(self.wasRegistered, 1)
def test_init(self): runner = unittest.TextTestRunner() self.assertFalse(runner.failfast) self.assertFalse(runner.buffer) self.assertEqual(runner.verbosity, 1) self.assertTrue(runner.descriptions) self.assertEqual(runner.resultclass, unittest.TextTestResult)
def test_ExitAsDefault(self): self.assertRaises( SystemExit, unittest.main, argv=["foobar"], testRunner=unittest.TextTestRunner(stream=StringIO()), testLoader=self.FooBarLoader())
def test_NonExit(self): program = unittest.main( exit=False, argv=["foobar"], testRunner=unittest.TextTestRunner(stream=StringIO()), testLoader=self.FooBarLoader()) self.assertTrue(hasattr(program, 'result'))
def testOldResultWithRunner(self): class Test(unittest.TestCase): def testFoo(self): pass runner = unittest.TextTestRunner(resultclass=OldResult, stream=StringIO()) # This will raise an exception if TextTestRunner can't handle old # test result objects runner.run(Test('testFoo'))
def test_pickle_unpickle(self): # Issue #7197: a TextTestRunner should be (un)pickleable. This is # required by test_multiprocessing under Windows (in verbose mode). from StringIO import StringIO as PickleableIO # cStringIO objects are not pickleable, but StringIO objects are. stream = PickleableIO("foo") runner = unittest.TextTestRunner(stream) for protocol in range(pickle.HIGHEST_PROTOCOL + 1): s = pickle.dumps(runner, protocol=protocol) obj = pickle.loads(s) # StringIO objects never compare equal, a cheap test instead. self.assertEqual(obj.stream.getvalue(), stream.getvalue())
def test_resultclass(self): def MockResultClass(*args): return args STREAM = object() DESCRIPTIONS = object() VERBOSITY = object() runner = unittest.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY, resultclass=MockResultClass) self.assertEqual(runner.resultclass, MockResultClass) expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY) self.assertEqual(runner._makeResult(), expectedresult)
def testBufferAndFailfast(self): class Test(unittest.TestCase): def testFoo(self): pass result = unittest.TestResult() runner = unittest.TextTestRunner(stream=StringIO(), failfast=True, buffer=True) # Use our result object runner._makeResult = lambda: result runner.run(Test('testFoo')) self.assertTrue(result.failfast) self.assertTrue(result.buffer)
def getRunner(self): return unittest.TextTestRunner(resultclass=resultFactory, stream=StringIO())
def run_suite(self, suite, **kwargs): return redgreenunittest.TextTestRunner( verbosity=self.verbosity, failfast=self.failfast).run(suite)
import redgreenunittest as unittest import calculator.calc class CalculatorTests(unittest.TestCase): def setUp(self): print 'setup...' def tearDown(self): print 'tear down...' def test_runs(self): calcClass = calculator.calc.Calculator() self.assertEqual(2, calcClass.add(1, 1)) if __name__ == '__main__': # all test run # unittest.main() runner = unittest.TextTestRunner() runner.run(unittest.makeSuite(CalculatorTests, 'test'))
#!/usr/bin/env python # -*- coding: utf-8 -*- """ This file is part of Uxie. Uxie - Pokemon Showdown's usage stats database builder Copyright (C) 2016 Kewin Dousse (Protectator) Licensed under the MIT License. See file LICENSE in the project root for license information. """ import sys import redgreenunittest as unittest from tests.testparsers import UsageTest, MetagameTest, MovesetTest, LeadsTest, ChaosTest from tests.testdatabases import MysqlTest from tests.testfeeder import FeederTest def suite(): return unittest.TestSuite( (unittest.makeSuite(MysqlTest), unittest.makeSuite(UsageTest), unittest.makeSuite(MetagameTest), unittest.makeSuite(MovesetTest), unittest.makeSuite(LeadsTest), unittest.makeSuite(ChaosTest), unittest.makeSuite(FeederTest))) if __name__ == '__main__': ret = not unittest.TextTestRunner(verbosity=2).run(suite()).wasSuccessful() sys.exit(ret)
suite.addTest(TestMetaxEtsin("testDeleteDataset")) suite.addTest(TestIDAMetax("testFreezeFile")) suite.addTest(TestIDAMetax("testUnFreezeFile")) suite.addTest(TestIDAMetax("testDeleteFile")) #suite.addTest(TestMetaxQuvain("testCreateDataset")) #suite.addTest(TestMetaxQuvain("testUpdateDateset")) #suite.addTest(TestMetaxQuvain("testDeleteDataset")) suite.addTest(TestMetaxDPress("testPreserveDataset")) suite.addTest(TestMetaxDPress("testRejectDataset")) suite.addTest(TestMetaxDPress("testRemoveDataset")) suite.addTest(TestMetaxDPress("testResetDataset")) runner = unittest.TextTestRunner(verbosity=2) runner.resultclass = JsonTestResult result = runner.run(suite) elapsed_time = time.time() - start_time # print json output result_dict = result.jsonify() count, total = result_count(result_dict) print("-----" * 20) print("\t\t\tSUMMARY ") print("-----" * 20) print("\n\t\t\tTotal == ", total)