AppPkg/Applications/Python: Add Python 2.7.2 sources since the release of Python 2.7.3 made them unavailable from the python.org web site.
These files are a subset of the python-2.7.2.tgz distribution from python.org. Changed files from PyMod-2.7.2 have been copied into the corresponding directories of this tree, replacing the original files in the distribution. Signed-off-by: daryl.mcdaniel@intel.com git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@13197 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
darylm503
@@ -0,0 +1,21 @@
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
|
||||
here = os.path.dirname(__file__)
|
||||
loader = unittest.defaultTestLoader
|
||||
|
||||
def suite():
|
||||
suite = unittest.TestSuite()
|
||||
for fn in os.listdir(here):
|
||||
if fn.startswith("test") and fn.endswith(".py"):
|
||||
modname = "unittest.test." + fn[:-3]
|
||||
__import__(modname)
|
||||
module = sys.modules[modname]
|
||||
suite.addTest(loader.loadTestsFromModule(module))
|
||||
return suite
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main(defaultTest="suite")
|
||||
@@ -0,0 +1 @@
|
||||
# Empty module for testing the loading of modules
|
||||
@@ -0,0 +1,119 @@
|
||||
import unittest
|
||||
|
||||
|
||||
class TestHashing(object):
|
||||
"""Used as a mixin for TestCase"""
|
||||
|
||||
# Check for a valid __hash__ implementation
|
||||
def test_hash(self):
|
||||
for obj_1, obj_2 in self.eq_pairs:
|
||||
try:
|
||||
if not hash(obj_1) == hash(obj_2):
|
||||
self.fail("%r and %r do not hash equal" % (obj_1, obj_2))
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except Exception, e:
|
||||
self.fail("Problem hashing %r and %r: %s" % (obj_1, obj_2, e))
|
||||
|
||||
for obj_1, obj_2 in self.ne_pairs:
|
||||
try:
|
||||
if hash(obj_1) == hash(obj_2):
|
||||
self.fail("%s and %s hash equal, but shouldn't" %
|
||||
(obj_1, obj_2))
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except Exception, e:
|
||||
self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))
|
||||
|
||||
|
||||
class TestEquality(object):
|
||||
"""Used as a mixin for TestCase"""
|
||||
|
||||
# Check for a valid __eq__ implementation
|
||||
def test_eq(self):
|
||||
for obj_1, obj_2 in self.eq_pairs:
|
||||
self.assertEqual(obj_1, obj_2)
|
||||
self.assertEqual(obj_2, obj_1)
|
||||
|
||||
# Check for a valid __ne__ implementation
|
||||
def test_ne(self):
|
||||
for obj_1, obj_2 in self.ne_pairs:
|
||||
self.assertNotEqual(obj_1, obj_2)
|
||||
self.assertNotEqual(obj_2, obj_1)
|
||||
|
||||
|
||||
class LoggingResult(unittest.TestResult):
|
||||
def __init__(self, log):
|
||||
self._events = log
|
||||
super(LoggingResult, self).__init__()
|
||||
|
||||
def startTest(self, test):
|
||||
self._events.append('startTest')
|
||||
super(LoggingResult, self).startTest(test)
|
||||
|
||||
def startTestRun(self):
|
||||
self._events.append('startTestRun')
|
||||
super(LoggingResult, self).startTestRun()
|
||||
|
||||
def stopTest(self, test):
|
||||
self._events.append('stopTest')
|
||||
super(LoggingResult, self).stopTest(test)
|
||||
|
||||
def stopTestRun(self):
|
||||
self._events.append('stopTestRun')
|
||||
super(LoggingResult, self).stopTestRun()
|
||||
|
||||
def addFailure(self, *args):
|
||||
self._events.append('addFailure')
|
||||
super(LoggingResult, self).addFailure(*args)
|
||||
|
||||
def addSuccess(self, *args):
|
||||
self._events.append('addSuccess')
|
||||
super(LoggingResult, self).addSuccess(*args)
|
||||
|
||||
def addError(self, *args):
|
||||
self._events.append('addError')
|
||||
super(LoggingResult, self).addError(*args)
|
||||
|
||||
def addSkip(self, *args):
|
||||
self._events.append('addSkip')
|
||||
super(LoggingResult, self).addSkip(*args)
|
||||
|
||||
def addExpectedFailure(self, *args):
|
||||
self._events.append('addExpectedFailure')
|
||||
super(LoggingResult, self).addExpectedFailure(*args)
|
||||
|
||||
def addUnexpectedSuccess(self, *args):
|
||||
self._events.append('addUnexpectedSuccess')
|
||||
super(LoggingResult, self).addUnexpectedSuccess(*args)
|
||||
|
||||
|
||||
class ResultWithNoStartTestRunStopTestRun(object):
|
||||
"""An object honouring TestResult before startTestRun/stopTestRun."""
|
||||
|
||||
def __init__(self):
|
||||
self.failures = []
|
||||
self.errors = []
|
||||
self.testsRun = 0
|
||||
self.skipped = []
|
||||
self.expectedFailures = []
|
||||
self.unexpectedSuccesses = []
|
||||
self.shouldStop = False
|
||||
|
||||
def startTest(self, test):
|
||||
pass
|
||||
|
||||
def stopTest(self, test):
|
||||
pass
|
||||
|
||||
def addError(self, test):
|
||||
pass
|
||||
|
||||
def addFailure(self, test):
|
||||
pass
|
||||
|
||||
def addSuccess(self, test):
|
||||
pass
|
||||
|
||||
def wasSuccessful(self):
|
||||
return True
|
||||
@@ -0,0 +1,286 @@
|
||||
import datetime
|
||||
|
||||
import unittest
|
||||
|
||||
|
||||
class Test_Assertions(unittest.TestCase):
|
||||
def test_AlmostEqual(self):
|
||||
self.assertAlmostEqual(1.00000001, 1.0)
|
||||
self.assertNotAlmostEqual(1.0000001, 1.0)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertAlmostEqual, 1.0000001, 1.0)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertNotAlmostEqual, 1.00000001, 1.0)
|
||||
|
||||
self.assertAlmostEqual(1.1, 1.0, places=0)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertAlmostEqual, 1.1, 1.0, places=1)
|
||||
|
||||
self.assertAlmostEqual(0, .1+.1j, places=0)
|
||||
self.assertNotAlmostEqual(0, .1+.1j, places=1)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertAlmostEqual, 0, .1+.1j, places=1)
|
||||
self.assertRaises(self.failureException,
|
||||
self.assertNotAlmostEqual, 0, .1+.1j, places=0)
|
||||
|
||||
self.assertAlmostEqual(float('inf'), float('inf'))
|
||||
self.assertRaises(self.failureException, self.assertNotAlmostEqual,
|
||||
float('inf'), float('inf'))
|
||||
|
||||
def test_AmostEqualWithDelta(self):
|
||||
self.assertAlmostEqual(1.1, 1.0, delta=0.5)
|
||||
self.assertAlmostEqual(1.0, 1.1, delta=0.5)
|
||||
self.assertNotAlmostEqual(1.1, 1.0, delta=0.05)
|
||||
self.assertNotAlmostEqual(1.0, 1.1, delta=0.05)
|
||||
|
||||
self.assertRaises(self.failureException, self.assertAlmostEqual,
|
||||
1.1, 1.0, delta=0.05)
|
||||
self.assertRaises(self.failureException, self.assertNotAlmostEqual,
|
||||
1.1, 1.0, delta=0.5)
|
||||
|
||||
self.assertRaises(TypeError, self.assertAlmostEqual,
|
||||
1.1, 1.0, places=2, delta=2)
|
||||
self.assertRaises(TypeError, self.assertNotAlmostEqual,
|
||||
1.1, 1.0, places=2, delta=2)
|
||||
|
||||
first = datetime.datetime.now()
|
||||
second = first + datetime.timedelta(seconds=10)
|
||||
self.assertAlmostEqual(first, second,
|
||||
delta=datetime.timedelta(seconds=20))
|
||||
self.assertNotAlmostEqual(first, second,
|
||||
delta=datetime.timedelta(seconds=5))
|
||||
|
||||
def test_assertRaises(self):
|
||||
def _raise(e):
|
||||
raise e
|
||||
self.assertRaises(KeyError, _raise, KeyError)
|
||||
self.assertRaises(KeyError, _raise, KeyError("key"))
|
||||
try:
|
||||
self.assertRaises(KeyError, lambda: None)
|
||||
except self.failureException as e:
|
||||
self.assertIn("KeyError not raised", e.args)
|
||||
else:
|
||||
self.fail("assertRaises() didn't fail")
|
||||
try:
|
||||
self.assertRaises(KeyError, _raise, ValueError)
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
self.fail("assertRaises() didn't let exception pass through")
|
||||
with self.assertRaises(KeyError) as cm:
|
||||
try:
|
||||
raise KeyError
|
||||
except Exception, e:
|
||||
raise
|
||||
self.assertIs(cm.exception, e)
|
||||
|
||||
with self.assertRaises(KeyError):
|
||||
raise KeyError("key")
|
||||
try:
|
||||
with self.assertRaises(KeyError):
|
||||
pass
|
||||
except self.failureException as e:
|
||||
self.assertIn("KeyError not raised", e.args)
|
||||
else:
|
||||
self.fail("assertRaises() didn't fail")
|
||||
try:
|
||||
with self.assertRaises(KeyError):
|
||||
raise ValueError
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
self.fail("assertRaises() didn't let exception pass through")
|
||||
|
||||
def testAssertNotRegexpMatches(self):
|
||||
self.assertNotRegexpMatches('Ala ma kota', r'r+')
|
||||
try:
|
||||
self.assertNotRegexpMatches('Ala ma kota', r'k.t', 'Message')
|
||||
except self.failureException, e:
|
||||
self.assertIn("'kot'", e.args[0])
|
||||
self.assertIn('Message', e.args[0])
|
||||
else:
|
||||
self.fail('assertNotRegexpMatches should have failed.')
|
||||
|
||||
|
||||
class TestLongMessage(unittest.TestCase):
|
||||
"""Test that the individual asserts honour longMessage.
|
||||
This actually tests all the message behaviour for
|
||||
asserts that use longMessage."""
|
||||
|
||||
def setUp(self):
|
||||
class TestableTestFalse(unittest.TestCase):
|
||||
longMessage = False
|
||||
failureException = self.failureException
|
||||
|
||||
def testTest(self):
|
||||
pass
|
||||
|
||||
class TestableTestTrue(unittest.TestCase):
|
||||
longMessage = True
|
||||
failureException = self.failureException
|
||||
|
||||
def testTest(self):
|
||||
pass
|
||||
|
||||
self.testableTrue = TestableTestTrue('testTest')
|
||||
self.testableFalse = TestableTestFalse('testTest')
|
||||
|
||||
def testDefault(self):
|
||||
self.assertFalse(unittest.TestCase.longMessage)
|
||||
|
||||
def test_formatMsg(self):
|
||||
self.assertEqual(self.testableFalse._formatMessage(None, "foo"), "foo")
|
||||
self.assertEqual(self.testableFalse._formatMessage("foo", "bar"), "foo")
|
||||
|
||||
self.assertEqual(self.testableTrue._formatMessage(None, "foo"), "foo")
|
||||
self.assertEqual(self.testableTrue._formatMessage("foo", "bar"), "bar : foo")
|
||||
|
||||
# This blows up if _formatMessage uses string concatenation
|
||||
self.testableTrue._formatMessage(object(), 'foo')
|
||||
|
||||
def test_formatMessage_unicode_error(self):
|
||||
one = ''.join(chr(i) for i in range(255))
|
||||
# this used to cause a UnicodeDecodeError constructing msg
|
||||
self.testableTrue._formatMessage(one, u'\uFFFD')
|
||||
|
||||
def assertMessages(self, methodName, args, errors):
|
||||
def getMethod(i):
|
||||
useTestableFalse = i < 2
|
||||
if useTestableFalse:
|
||||
test = self.testableFalse
|
||||
else:
|
||||
test = self.testableTrue
|
||||
return getattr(test, methodName)
|
||||
|
||||
for i, expected_regexp in enumerate(errors):
|
||||
testMethod = getMethod(i)
|
||||
kwargs = {}
|
||||
withMsg = i % 2
|
||||
if withMsg:
|
||||
kwargs = {"msg": "oops"}
|
||||
|
||||
with self.assertRaisesRegexp(self.failureException,
|
||||
expected_regexp=expected_regexp):
|
||||
testMethod(*args, **kwargs)
|
||||
|
||||
def testAssertTrue(self):
|
||||
self.assertMessages('assertTrue', (False,),
|
||||
["^False is not true$", "^oops$", "^False is not true$",
|
||||
"^False is not true : oops$"])
|
||||
|
||||
def testAssertFalse(self):
|
||||
self.assertMessages('assertFalse', (True,),
|
||||
["^True is not false$", "^oops$", "^True is not false$",
|
||||
"^True is not false : oops$"])
|
||||
|
||||
def testNotEqual(self):
|
||||
self.assertMessages('assertNotEqual', (1, 1),
|
||||
["^1 == 1$", "^oops$", "^1 == 1$",
|
||||
"^1 == 1 : oops$"])
|
||||
|
||||
def testAlmostEqual(self):
|
||||
self.assertMessages('assertAlmostEqual', (1, 2),
|
||||
["^1 != 2 within 7 places$", "^oops$",
|
||||
"^1 != 2 within 7 places$", "^1 != 2 within 7 places : oops$"])
|
||||
|
||||
def testNotAlmostEqual(self):
|
||||
self.assertMessages('assertNotAlmostEqual', (1, 1),
|
||||
["^1 == 1 within 7 places$", "^oops$",
|
||||
"^1 == 1 within 7 places$", "^1 == 1 within 7 places : oops$"])
|
||||
|
||||
def test_baseAssertEqual(self):
|
||||
self.assertMessages('_baseAssertEqual', (1, 2),
|
||||
["^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"])
|
||||
|
||||
def testAssertSequenceEqual(self):
|
||||
# Error messages are multiline so not testing on full message
|
||||
# assertTupleEqual and assertListEqual delegate to this method
|
||||
self.assertMessages('assertSequenceEqual', ([], [None]),
|
||||
["\+ \[None\]$", "^oops$", r"\+ \[None\]$",
|
||||
r"\+ \[None\] : oops$"])
|
||||
|
||||
def testAssertSetEqual(self):
|
||||
self.assertMessages('assertSetEqual', (set(), set([None])),
|
||||
["None$", "^oops$", "None$",
|
||||
"None : oops$"])
|
||||
|
||||
def testAssertIn(self):
|
||||
self.assertMessages('assertIn', (None, []),
|
||||
['^None not found in \[\]$', "^oops$",
|
||||
'^None not found in \[\]$',
|
||||
'^None not found in \[\] : oops$'])
|
||||
|
||||
def testAssertNotIn(self):
|
||||
self.assertMessages('assertNotIn', (None, [None]),
|
||||
['^None unexpectedly found in \[None\]$', "^oops$",
|
||||
'^None unexpectedly found in \[None\]$',
|
||||
'^None unexpectedly found in \[None\] : oops$'])
|
||||
|
||||
def testAssertDictEqual(self):
|
||||
self.assertMessages('assertDictEqual', ({}, {'key': 'value'}),
|
||||
[r"\+ \{'key': 'value'\}$", "^oops$",
|
||||
"\+ \{'key': 'value'\}$",
|
||||
"\+ \{'key': 'value'\} : oops$"])
|
||||
|
||||
def testAssertDictContainsSubset(self):
|
||||
self.assertMessages('assertDictContainsSubset', ({'key': 'value'}, {}),
|
||||
["^Missing: 'key'$", "^oops$",
|
||||
"^Missing: 'key'$",
|
||||
"^Missing: 'key' : oops$"])
|
||||
|
||||
def testAssertMultiLineEqual(self):
|
||||
self.assertMessages('assertMultiLineEqual', ("", "foo"),
|
||||
[r"\+ foo$", "^oops$",
|
||||
r"\+ foo$",
|
||||
r"\+ foo : oops$"])
|
||||
|
||||
def testAssertLess(self):
|
||||
self.assertMessages('assertLess', (2, 1),
|
||||
["^2 not less than 1$", "^oops$",
|
||||
"^2 not less than 1$", "^2 not less than 1 : oops$"])
|
||||
|
||||
def testAssertLessEqual(self):
|
||||
self.assertMessages('assertLessEqual', (2, 1),
|
||||
["^2 not less than or equal to 1$", "^oops$",
|
||||
"^2 not less than or equal to 1$",
|
||||
"^2 not less than or equal to 1 : oops$"])
|
||||
|
||||
def testAssertGreater(self):
|
||||
self.assertMessages('assertGreater', (1, 2),
|
||||
["^1 not greater than 2$", "^oops$",
|
||||
"^1 not greater than 2$",
|
||||
"^1 not greater than 2 : oops$"])
|
||||
|
||||
def testAssertGreaterEqual(self):
|
||||
self.assertMessages('assertGreaterEqual', (1, 2),
|
||||
["^1 not greater than or equal to 2$", "^oops$",
|
||||
"^1 not greater than or equal to 2$",
|
||||
"^1 not greater than or equal to 2 : oops$"])
|
||||
|
||||
def testAssertIsNone(self):
|
||||
self.assertMessages('assertIsNone', ('not None',),
|
||||
["^'not None' is not None$", "^oops$",
|
||||
"^'not None' is not None$",
|
||||
"^'not None' is not None : oops$"])
|
||||
|
||||
def testAssertIsNotNone(self):
|
||||
self.assertMessages('assertIsNotNone', (None,),
|
||||
["^unexpectedly None$", "^oops$",
|
||||
"^unexpectedly None$",
|
||||
"^unexpectedly None : oops$"])
|
||||
|
||||
def testAssertIs(self):
|
||||
self.assertMessages('assertIs', (None, 'foo'),
|
||||
["^None is not 'foo'$", "^oops$",
|
||||
"^None is not 'foo'$",
|
||||
"^None is not 'foo' : oops$"])
|
||||
|
||||
def testAssertIsNot(self):
|
||||
self.assertMessages('assertIsNot', (None, None),
|
||||
["^unexpectedly identical: None$", "^oops$",
|
||||
"^unexpectedly identical: None$",
|
||||
"^unexpectedly identical: None : oops$"])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,252 @@
|
||||
import gc
|
||||
import os
|
||||
import sys
|
||||
import signal
|
||||
import weakref
|
||||
|
||||
from cStringIO import StringIO
|
||||
|
||||
|
||||
import unittest
|
||||
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'kill'), "Test requires os.kill")
|
||||
@unittest.skipIf(sys.platform =="win32", "Test cannot run on Windows")
|
||||
@unittest.skipIf(sys.platform == 'freebsd6', "Test kills regrtest on freebsd6 "
|
||||
"if threads have been used")
|
||||
class TestBreak(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self._default_handler = signal.getsignal(signal.SIGINT)
|
||||
|
||||
def tearDown(self):
|
||||
signal.signal(signal.SIGINT, self._default_handler)
|
||||
unittest.signals._results = weakref.WeakKeyDictionary()
|
||||
unittest.signals._interrupt_handler = None
|
||||
|
||||
|
||||
def testInstallHandler(self):
|
||||
default_handler = signal.getsignal(signal.SIGINT)
|
||||
unittest.installHandler()
|
||||
self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
|
||||
|
||||
try:
|
||||
pid = os.getpid()
|
||||
os.kill(pid, signal.SIGINT)
|
||||
except KeyboardInterrupt:
|
||||
self.fail("KeyboardInterrupt not handled")
|
||||
|
||||
self.assertTrue(unittest.signals._interrupt_handler.called)
|
||||
|
||||
def testRegisterResult(self):
|
||||
result = unittest.TestResult()
|
||||
unittest.registerResult(result)
|
||||
|
||||
for ref in unittest.signals._results:
|
||||
if ref is result:
|
||||
break
|
||||
elif ref is not result:
|
||||
self.fail("odd object in result set")
|
||||
else:
|
||||
self.fail("result not found")
|
||||
|
||||
|
||||
def testInterruptCaught(self):
|
||||
default_handler = signal.getsignal(signal.SIGINT)
|
||||
|
||||
result = unittest.TestResult()
|
||||
unittest.installHandler()
|
||||
unittest.registerResult(result)
|
||||
|
||||
self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
|
||||
|
||||
def test(result):
|
||||
pid = os.getpid()
|
||||
os.kill(pid, signal.SIGINT)
|
||||
result.breakCaught = True
|
||||
self.assertTrue(result.shouldStop)
|
||||
|
||||
try:
|
||||
test(result)
|
||||
except KeyboardInterrupt:
|
||||
self.fail("KeyboardInterrupt not handled")
|
||||
self.assertTrue(result.breakCaught)
|
||||
|
||||
|
||||
def testSecondInterrupt(self):
|
||||
result = unittest.TestResult()
|
||||
unittest.installHandler()
|
||||
unittest.registerResult(result)
|
||||
|
||||
def test(result):
|
||||
pid = os.getpid()
|
||||
os.kill(pid, signal.SIGINT)
|
||||
result.breakCaught = True
|
||||
self.assertTrue(result.shouldStop)
|
||||
os.kill(pid, signal.SIGINT)
|
||||
self.fail("Second KeyboardInterrupt not raised")
|
||||
|
||||
try:
|
||||
test(result)
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
else:
|
||||
self.fail("Second KeyboardInterrupt not raised")
|
||||
self.assertTrue(result.breakCaught)
|
||||
|
||||
|
||||
def testTwoResults(self):
|
||||
unittest.installHandler()
|
||||
|
||||
result = unittest.TestResult()
|
||||
unittest.registerResult(result)
|
||||
new_handler = signal.getsignal(signal.SIGINT)
|
||||
|
||||
result2 = unittest.TestResult()
|
||||
unittest.registerResult(result2)
|
||||
self.assertEqual(signal.getsignal(signal.SIGINT), new_handler)
|
||||
|
||||
result3 = unittest.TestResult()
|
||||
|
||||
def test(result):
|
||||
pid = os.getpid()
|
||||
os.kill(pid, signal.SIGINT)
|
||||
|
||||
try:
|
||||
test(result)
|
||||
except KeyboardInterrupt:
|
||||
self.fail("KeyboardInterrupt not handled")
|
||||
|
||||
self.assertTrue(result.shouldStop)
|
||||
self.assertTrue(result2.shouldStop)
|
||||
self.assertFalse(result3.shouldStop)
|
||||
|
||||
|
||||
def testHandlerReplacedButCalled(self):
|
||||
# If our handler has been replaced (is no longer installed) but is
|
||||
# called by the *new* handler, then it isn't safe to delay the
|
||||
# SIGINT and we should immediately delegate to the default handler
|
||||
unittest.installHandler()
|
||||
|
||||
handler = signal.getsignal(signal.SIGINT)
|
||||
def new_handler(frame, signum):
|
||||
handler(frame, signum)
|
||||
signal.signal(signal.SIGINT, new_handler)
|
||||
|
||||
try:
|
||||
pid = os.getpid()
|
||||
os.kill(pid, signal.SIGINT)
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
else:
|
||||
self.fail("replaced but delegated handler doesn't raise interrupt")
|
||||
|
||||
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 testWeakReferences(self):
|
||||
# Calling registerResult on a result should not keep it alive
|
||||
result = unittest.TestResult()
|
||||
unittest.registerResult(result)
|
||||
|
||||
ref = weakref.ref(result)
|
||||
del result
|
||||
|
||||
# For non-reference counting implementations
|
||||
gc.collect();gc.collect()
|
||||
self.assertIsNone(ref())
|
||||
|
||||
|
||||
def testRemoveResult(self):
|
||||
result = unittest.TestResult()
|
||||
unittest.registerResult(result)
|
||||
|
||||
unittest.installHandler()
|
||||
self.assertTrue(unittest.removeResult(result))
|
||||
|
||||
# Should this raise an error instead?
|
||||
self.assertFalse(unittest.removeResult(unittest.TestResult()))
|
||||
|
||||
try:
|
||||
pid = os.getpid()
|
||||
os.kill(pid, signal.SIGINT)
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
|
||||
self.assertFalse(result.shouldStop)
|
||||
|
||||
def testMainInstallsHandler(self):
|
||||
failfast = object()
|
||||
test = object()
|
||||
verbosity = object()
|
||||
result = object()
|
||||
default_handler = signal.getsignal(signal.SIGINT)
|
||||
|
||||
class FakeRunner(object):
|
||||
initArgs = []
|
||||
runArgs = []
|
||||
def __init__(self, *args, **kwargs):
|
||||
self.initArgs.append((args, kwargs))
|
||||
def run(self, test):
|
||||
self.runArgs.append(test)
|
||||
return result
|
||||
|
||||
class Program(unittest.TestProgram):
|
||||
def __init__(self, catchbreak):
|
||||
self.exit = False
|
||||
self.verbosity = verbosity
|
||||
self.failfast = failfast
|
||||
self.catchbreak = catchbreak
|
||||
self.testRunner = FakeRunner
|
||||
self.test = test
|
||||
self.result = None
|
||||
|
||||
p = Program(False)
|
||||
p.runTests()
|
||||
|
||||
self.assertEqual(FakeRunner.initArgs, [((), {'buffer': None,
|
||||
'verbosity': verbosity,
|
||||
'failfast': failfast})])
|
||||
self.assertEqual(FakeRunner.runArgs, [test])
|
||||
self.assertEqual(p.result, result)
|
||||
|
||||
self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
|
||||
|
||||
FakeRunner.initArgs = []
|
||||
FakeRunner.runArgs = []
|
||||
p = Program(True)
|
||||
p.runTests()
|
||||
|
||||
self.assertEqual(FakeRunner.initArgs, [((), {'buffer': None,
|
||||
'verbosity': verbosity,
|
||||
'failfast': failfast})])
|
||||
self.assertEqual(FakeRunner.runArgs, [test])
|
||||
self.assertEqual(p.result, result)
|
||||
|
||||
self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
|
||||
|
||||
def testRemoveHandler(self):
|
||||
default_handler = signal.getsignal(signal.SIGINT)
|
||||
unittest.installHandler()
|
||||
unittest.removeHandler()
|
||||
self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
|
||||
|
||||
# check that calling removeHandler multiple times has no ill-effect
|
||||
unittest.removeHandler()
|
||||
self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
|
||||
|
||||
def testRemoveHandlerAsDecorator(self):
|
||||
default_handler = signal.getsignal(signal.SIGINT)
|
||||
unittest.installHandler()
|
||||
|
||||
@unittest.removeHandler
|
||||
def test():
|
||||
self.assertEqual(signal.getsignal(signal.SIGINT), default_handler)
|
||||
|
||||
test()
|
||||
self.assertNotEqual(signal.getsignal(signal.SIGINT), default_handler)
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,362 @@
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
import unittest
|
||||
|
||||
|
||||
class TestDiscovery(unittest.TestCase):
|
||||
|
||||
# Heavily mocked tests so I can avoid hitting the filesystem
|
||||
def test_get_name_from_path(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
loader._top_level_dir = '/foo'
|
||||
name = loader._get_name_from_path('/foo/bar/baz.py')
|
||||
self.assertEqual(name, 'bar.baz')
|
||||
|
||||
if not __debug__:
|
||||
# asserts are off
|
||||
return
|
||||
|
||||
with self.assertRaises(AssertionError):
|
||||
loader._get_name_from_path('/bar/baz.py')
|
||||
|
||||
def test_find_tests(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
original_listdir = os.listdir
|
||||
def restore_listdir():
|
||||
os.listdir = original_listdir
|
||||
original_isfile = os.path.isfile
|
||||
def restore_isfile():
|
||||
os.path.isfile = original_isfile
|
||||
original_isdir = os.path.isdir
|
||||
def restore_isdir():
|
||||
os.path.isdir = original_isdir
|
||||
|
||||
path_lists = [['test1.py', 'test2.py', 'not_a_test.py', 'test_dir',
|
||||
'test.foo', 'test-not-a-module.py', 'another_dir'],
|
||||
['test3.py', 'test4.py', ]]
|
||||
os.listdir = lambda path: path_lists.pop(0)
|
||||
self.addCleanup(restore_listdir)
|
||||
|
||||
def isdir(path):
|
||||
return path.endswith('dir')
|
||||
os.path.isdir = isdir
|
||||
self.addCleanup(restore_isdir)
|
||||
|
||||
def isfile(path):
|
||||
# another_dir is not a package and so shouldn't be recursed into
|
||||
return not path.endswith('dir') and not 'another_dir' in path
|
||||
os.path.isfile = isfile
|
||||
self.addCleanup(restore_isfile)
|
||||
|
||||
loader._get_module_from_name = lambda path: path + ' module'
|
||||
loader.loadTestsFromModule = lambda module: module + ' tests'
|
||||
|
||||
top_level = os.path.abspath('/foo')
|
||||
loader._top_level_dir = top_level
|
||||
suite = list(loader._find_tests(top_level, 'test*.py'))
|
||||
|
||||
expected = [name + ' module tests' for name in
|
||||
('test1', 'test2')]
|
||||
expected.extend([('test_dir.%s' % name) + ' module tests' for name in
|
||||
('test3', 'test4')])
|
||||
self.assertEqual(suite, expected)
|
||||
|
||||
def test_find_tests_with_package(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
original_listdir = os.listdir
|
||||
def restore_listdir():
|
||||
os.listdir = original_listdir
|
||||
original_isfile = os.path.isfile
|
||||
def restore_isfile():
|
||||
os.path.isfile = original_isfile
|
||||
original_isdir = os.path.isdir
|
||||
def restore_isdir():
|
||||
os.path.isdir = original_isdir
|
||||
|
||||
directories = ['a_directory', 'test_directory', 'test_directory2']
|
||||
path_lists = [directories, [], [], []]
|
||||
os.listdir = lambda path: path_lists.pop(0)
|
||||
self.addCleanup(restore_listdir)
|
||||
|
||||
os.path.isdir = lambda path: True
|
||||
self.addCleanup(restore_isdir)
|
||||
|
||||
os.path.isfile = lambda path: os.path.basename(path) not in directories
|
||||
self.addCleanup(restore_isfile)
|
||||
|
||||
class Module(object):
|
||||
paths = []
|
||||
load_tests_args = []
|
||||
|
||||
def __init__(self, path):
|
||||
self.path = path
|
||||
self.paths.append(path)
|
||||
if os.path.basename(path) == 'test_directory':
|
||||
def load_tests(loader, tests, pattern):
|
||||
self.load_tests_args.append((loader, tests, pattern))
|
||||
return 'load_tests'
|
||||
self.load_tests = load_tests
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.path == other.path
|
||||
|
||||
# Silence py3k warning
|
||||
__hash__ = None
|
||||
|
||||
loader._get_module_from_name = lambda name: Module(name)
|
||||
def loadTestsFromModule(module, use_load_tests):
|
||||
if use_load_tests:
|
||||
raise self.failureException('use_load_tests should be False for packages')
|
||||
return module.path + ' module tests'
|
||||
loader.loadTestsFromModule = loadTestsFromModule
|
||||
|
||||
loader._top_level_dir = '/foo'
|
||||
# this time no '.py' on the pattern so that it can match
|
||||
# a test package
|
||||
suite = list(loader._find_tests('/foo', 'test*'))
|
||||
|
||||
# We should have loaded tests from the test_directory package by calling load_tests
|
||||
# and directly from the test_directory2 package
|
||||
self.assertEqual(suite,
|
||||
['load_tests', 'test_directory2' + ' module tests'])
|
||||
self.assertEqual(Module.paths, ['test_directory', 'test_directory2'])
|
||||
|
||||
# load_tests should have been called once with loader, tests and pattern
|
||||
self.assertEqual(Module.load_tests_args,
|
||||
[(loader, 'test_directory' + ' module tests', 'test*')])
|
||||
|
||||
def test_discover(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
original_isfile = os.path.isfile
|
||||
original_isdir = os.path.isdir
|
||||
def restore_isfile():
|
||||
os.path.isfile = original_isfile
|
||||
|
||||
os.path.isfile = lambda path: False
|
||||
self.addCleanup(restore_isfile)
|
||||
|
||||
orig_sys_path = sys.path[:]
|
||||
def restore_path():
|
||||
sys.path[:] = orig_sys_path
|
||||
self.addCleanup(restore_path)
|
||||
|
||||
full_path = os.path.abspath(os.path.normpath('/foo'))
|
||||
with self.assertRaises(ImportError):
|
||||
loader.discover('/foo/bar', top_level_dir='/foo')
|
||||
|
||||
self.assertEqual(loader._top_level_dir, full_path)
|
||||
self.assertIn(full_path, sys.path)
|
||||
|
||||
os.path.isfile = lambda path: True
|
||||
os.path.isdir = lambda path: True
|
||||
|
||||
def restore_isdir():
|
||||
os.path.isdir = original_isdir
|
||||
self.addCleanup(restore_isdir)
|
||||
|
||||
_find_tests_args = []
|
||||
def _find_tests(start_dir, pattern):
|
||||
_find_tests_args.append((start_dir, pattern))
|
||||
return ['tests']
|
||||
loader._find_tests = _find_tests
|
||||
loader.suiteClass = str
|
||||
|
||||
suite = loader.discover('/foo/bar/baz', 'pattern', '/foo/bar')
|
||||
|
||||
top_level_dir = os.path.abspath('/foo/bar')
|
||||
start_dir = os.path.abspath('/foo/bar/baz')
|
||||
self.assertEqual(suite, "['tests']")
|
||||
self.assertEqual(loader._top_level_dir, top_level_dir)
|
||||
self.assertEqual(_find_tests_args, [(start_dir, 'pattern')])
|
||||
self.assertIn(top_level_dir, sys.path)
|
||||
|
||||
def test_discover_with_modules_that_fail_to_import(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
listdir = os.listdir
|
||||
os.listdir = lambda _: ['test_this_does_not_exist.py']
|
||||
isfile = os.path.isfile
|
||||
os.path.isfile = lambda _: True
|
||||
orig_sys_path = sys.path[:]
|
||||
def restore():
|
||||
os.path.isfile = isfile
|
||||
os.listdir = listdir
|
||||
sys.path[:] = orig_sys_path
|
||||
self.addCleanup(restore)
|
||||
|
||||
suite = loader.discover('.')
|
||||
self.assertIn(os.getcwd(), sys.path)
|
||||
self.assertEqual(suite.countTestCases(), 1)
|
||||
test = list(list(suite)[0])[0] # extract test from suite
|
||||
|
||||
with self.assertRaises(ImportError):
|
||||
test.test_this_does_not_exist()
|
||||
|
||||
def test_command_line_handling_parseArgs(self):
|
||||
# Haha - take that uninstantiable class
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
|
||||
args = []
|
||||
def do_discovery(argv):
|
||||
args.extend(argv)
|
||||
program._do_discovery = do_discovery
|
||||
program.parseArgs(['something', 'discover'])
|
||||
self.assertEqual(args, [])
|
||||
|
||||
program.parseArgs(['something', 'discover', 'foo', 'bar'])
|
||||
self.assertEqual(args, ['foo', 'bar'])
|
||||
|
||||
def test_command_line_handling_do_discovery_too_many_arguments(self):
|
||||
class Stop(Exception):
|
||||
pass
|
||||
def usageExit():
|
||||
raise Stop
|
||||
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program.usageExit = usageExit
|
||||
|
||||
with self.assertRaises(Stop):
|
||||
# too many args
|
||||
program._do_discovery(['one', 'two', 'three', 'four'])
|
||||
|
||||
|
||||
def test_command_line_handling_do_discovery_calls_loader(self):
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
|
||||
class Loader(object):
|
||||
args = []
|
||||
def discover(self, start_dir, pattern, top_level_dir):
|
||||
self.args.append((start_dir, pattern, top_level_dir))
|
||||
return 'tests'
|
||||
|
||||
program._do_discovery(['-v'], Loader=Loader)
|
||||
self.assertEqual(program.verbosity, 2)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['--verbose'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery([], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['fish'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['fish', 'eggs'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'eggs', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['fish', 'eggs', 'ham'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'eggs', 'ham')])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['-s', 'fish'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'test*.py', None)])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['-t', 'fish'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'test*.py', 'fish')])
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['-p', 'fish'], Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('.', 'fish', None)])
|
||||
self.assertFalse(program.failfast)
|
||||
self.assertFalse(program.catchbreak)
|
||||
|
||||
Loader.args = []
|
||||
program = object.__new__(unittest.TestProgram)
|
||||
program._do_discovery(['-p', 'eggs', '-s', 'fish', '-v', '-f', '-c'],
|
||||
Loader=Loader)
|
||||
self.assertEqual(program.test, 'tests')
|
||||
self.assertEqual(Loader.args, [('fish', 'eggs', None)])
|
||||
self.assertEqual(program.verbosity, 2)
|
||||
self.assertTrue(program.failfast)
|
||||
self.assertTrue(program.catchbreak)
|
||||
|
||||
def test_detect_module_clash(self):
|
||||
class Module(object):
|
||||
__file__ = 'bar/foo.py'
|
||||
sys.modules['foo'] = Module
|
||||
full_path = os.path.abspath('foo')
|
||||
original_listdir = os.listdir
|
||||
original_isfile = os.path.isfile
|
||||
original_isdir = os.path.isdir
|
||||
|
||||
def cleanup():
|
||||
os.listdir = original_listdir
|
||||
os.path.isfile = original_isfile
|
||||
os.path.isdir = original_isdir
|
||||
del sys.modules['foo']
|
||||
if full_path in sys.path:
|
||||
sys.path.remove(full_path)
|
||||
self.addCleanup(cleanup)
|
||||
|
||||
def listdir(_):
|
||||
return ['foo.py']
|
||||
def isfile(_):
|
||||
return True
|
||||
def isdir(_):
|
||||
return True
|
||||
os.listdir = listdir
|
||||
os.path.isfile = isfile
|
||||
os.path.isdir = isdir
|
||||
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
mod_dir = os.path.abspath('bar')
|
||||
expected_dir = os.path.abspath('foo')
|
||||
msg = re.escape(r"'foo' module incorrectly imported from %r. Expected %r. "
|
||||
"Is this module globally installed?" % (mod_dir, expected_dir))
|
||||
self.assertRaisesRegexp(
|
||||
ImportError, '^%s$' % msg, loader.discover,
|
||||
start_dir='foo', pattern='foo.py'
|
||||
)
|
||||
self.assertEqual(sys.path[0], full_path)
|
||||
|
||||
|
||||
def test_discovery_from_dotted_path(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
tests = [self]
|
||||
expectedPath = os.path.abspath(os.path.dirname(unittest.test.__file__))
|
||||
|
||||
self.wasRun = False
|
||||
def _find_tests(start_dir, pattern):
|
||||
self.wasRun = True
|
||||
self.assertEqual(start_dir, expectedPath)
|
||||
return tests
|
||||
loader._find_tests = _find_tests
|
||||
suite = loader.discover('unittest.test')
|
||||
self.assertTrue(self.wasRun)
|
||||
self.assertEqual(suite._tests, tests)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,148 @@
|
||||
import unittest
|
||||
|
||||
from .support import LoggingResult
|
||||
|
||||
|
||||
class Test_FunctionTestCase(unittest.TestCase):
|
||||
|
||||
# "Return the number of tests represented by the this test object. For
|
||||
# TestCase instances, this will always be 1"
|
||||
def test_countTestCases(self):
|
||||
test = unittest.FunctionTestCase(lambda: None)
|
||||
|
||||
self.assertEqual(test.countTestCases(), 1)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if setUp() raises
|
||||
# an exception.
|
||||
def test_run_call_order__error_in_setUp(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
def setUp():
|
||||
events.append('setUp')
|
||||
raise RuntimeError('raised by setUp')
|
||||
|
||||
def test():
|
||||
events.append('test')
|
||||
|
||||
def tearDown():
|
||||
events.append('tearDown')
|
||||
|
||||
expected = ['startTest', 'setUp', 'addError', 'stopTest']
|
||||
unittest.FunctionTestCase(test, setUp, tearDown).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if the test raises
|
||||
# an error (as opposed to a failure).
|
||||
def test_run_call_order__error_in_test(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
def setUp():
|
||||
events.append('setUp')
|
||||
|
||||
def test():
|
||||
events.append('test')
|
||||
raise RuntimeError('raised by test')
|
||||
|
||||
def tearDown():
|
||||
events.append('tearDown')
|
||||
|
||||
expected = ['startTest', 'setUp', 'test', 'addError', 'tearDown',
|
||||
'stopTest']
|
||||
unittest.FunctionTestCase(test, setUp, tearDown).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if the test signals
|
||||
# a failure (as opposed to an error).
|
||||
def test_run_call_order__failure_in_test(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
def setUp():
|
||||
events.append('setUp')
|
||||
|
||||
def test():
|
||||
events.append('test')
|
||||
self.fail('raised by test')
|
||||
|
||||
def tearDown():
|
||||
events.append('tearDown')
|
||||
|
||||
expected = ['startTest', 'setUp', 'test', 'addFailure', 'tearDown',
|
||||
'stopTest']
|
||||
unittest.FunctionTestCase(test, setUp, tearDown).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "When a setUp() method is defined, the test runner will run that method
|
||||
# prior to each test. Likewise, if a tearDown() method is defined, the
|
||||
# test runner will invoke that method after each test. In the example,
|
||||
# setUp() was used to create a fresh sequence for each test."
|
||||
#
|
||||
# Make sure the proper call order is maintained, even if tearDown() raises
|
||||
# an exception.
|
||||
def test_run_call_order__error_in_tearDown(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
def setUp():
|
||||
events.append('setUp')
|
||||
|
||||
def test():
|
||||
events.append('test')
|
||||
|
||||
def tearDown():
|
||||
events.append('tearDown')
|
||||
raise RuntimeError('raised by tearDown')
|
||||
|
||||
expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError',
|
||||
'stopTest']
|
||||
unittest.FunctionTestCase(test, setUp, tearDown).run(result)
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
# "Return a string identifying the specific test case."
|
||||
#
|
||||
# Because of the vague nature of the docs, I'm not going to lock this
|
||||
# test down too much. Really all that can be asserted is that the id()
|
||||
# will be a string (either 8-byte or unicode -- again, because the docs
|
||||
# just say "string")
|
||||
def test_id(self):
|
||||
test = unittest.FunctionTestCase(lambda: None)
|
||||
|
||||
self.assertIsInstance(test.id(), basestring)
|
||||
|
||||
# "Returns a one-line description of the test, or None if no description
|
||||
# has been provided. The default implementation of this method returns
|
||||
# the first line of the test method's docstring, if available, or None."
|
||||
def test_shortDescription__no_docstring(self):
|
||||
test = unittest.FunctionTestCase(lambda: None)
|
||||
|
||||
self.assertEqual(test.shortDescription(), None)
|
||||
|
||||
# "Returns a one-line description of the test, or None if no description
|
||||
# has been provided. The default implementation of this method returns
|
||||
# the first line of the test method's docstring, if available, or None."
|
||||
def test_shortDescription__singleline_docstring(self):
|
||||
desc = "this tests foo"
|
||||
test = unittest.FunctionTestCase(lambda: None, description=desc)
|
||||
|
||||
self.assertEqual(test.shortDescription(), "this tests foo")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,255 @@
|
||||
from cStringIO import StringIO
|
||||
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
|
||||
class Test_TestProgram(unittest.TestCase):
|
||||
|
||||
def test_discovery_from_dotted_path(self):
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
tests = [self]
|
||||
expectedPath = os.path.abspath(os.path.dirname(unittest.test.__file__))
|
||||
|
||||
self.wasRun = False
|
||||
def _find_tests(start_dir, pattern):
|
||||
self.wasRun = True
|
||||
self.assertEqual(start_dir, expectedPath)
|
||||
return tests
|
||||
loader._find_tests = _find_tests
|
||||
suite = loader.discover('unittest.test')
|
||||
self.assertTrue(self.wasRun)
|
||||
self.assertEqual(suite._tests, tests)
|
||||
|
||||
# Horrible white box test
|
||||
def testNoExit(self):
|
||||
result = object()
|
||||
test = object()
|
||||
|
||||
class FakeRunner(object):
|
||||
def run(self, test):
|
||||
self.test = test
|
||||
return result
|
||||
|
||||
runner = FakeRunner()
|
||||
|
||||
oldParseArgs = unittest.TestProgram.parseArgs
|
||||
def restoreParseArgs():
|
||||
unittest.TestProgram.parseArgs = oldParseArgs
|
||||
unittest.TestProgram.parseArgs = lambda *args: None
|
||||
self.addCleanup(restoreParseArgs)
|
||||
|
||||
def removeTest():
|
||||
del unittest.TestProgram.test
|
||||
unittest.TestProgram.test = test
|
||||
self.addCleanup(removeTest)
|
||||
|
||||
program = unittest.TestProgram(testRunner=runner, exit=False, verbosity=2)
|
||||
|
||||
self.assertEqual(program.result, result)
|
||||
self.assertEqual(runner.test, test)
|
||||
self.assertEqual(program.verbosity, 2)
|
||||
|
||||
class FooBar(unittest.TestCase):
|
||||
def testPass(self):
|
||||
assert True
|
||||
def testFail(self):
|
||||
assert False
|
||||
|
||||
class FooBarLoader(unittest.TestLoader):
|
||||
"""Test loader that returns a suite containing FooBar."""
|
||||
def loadTestsFromModule(self, module):
|
||||
return self.suiteClass(
|
||||
[self.loadTestsFromTestCase(Test_TestProgram.FooBar)])
|
||||
|
||||
|
||||
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 test_Exit(self):
|
||||
self.assertRaises(
|
||||
SystemExit,
|
||||
unittest.main,
|
||||
argv=["foobar"],
|
||||
testRunner=unittest.TextTestRunner(stream=StringIO()),
|
||||
exit=True,
|
||||
testLoader=self.FooBarLoader())
|
||||
|
||||
|
||||
def test_ExitAsDefault(self):
|
||||
self.assertRaises(
|
||||
SystemExit,
|
||||
unittest.main,
|
||||
argv=["foobar"],
|
||||
testRunner=unittest.TextTestRunner(stream=StringIO()),
|
||||
testLoader=self.FooBarLoader())
|
||||
|
||||
|
||||
class InitialisableProgram(unittest.TestProgram):
|
||||
exit = False
|
||||
result = None
|
||||
verbosity = 1
|
||||
defaultTest = None
|
||||
testRunner = None
|
||||
testLoader = unittest.defaultTestLoader
|
||||
progName = 'test'
|
||||
test = 'test'
|
||||
def __init__(self, *args):
|
||||
pass
|
||||
|
||||
RESULT = object()
|
||||
|
||||
class FakeRunner(object):
|
||||
initArgs = None
|
||||
test = None
|
||||
raiseError = False
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
FakeRunner.initArgs = kwargs
|
||||
if FakeRunner.raiseError:
|
||||
FakeRunner.raiseError = False
|
||||
raise TypeError
|
||||
|
||||
def run(self, test):
|
||||
FakeRunner.test = test
|
||||
return RESULT
|
||||
|
||||
class TestCommandLineArgs(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.program = InitialisableProgram()
|
||||
self.program.createTests = lambda: None
|
||||
FakeRunner.initArgs = None
|
||||
FakeRunner.test = None
|
||||
FakeRunner.raiseError = False
|
||||
|
||||
def testHelpAndUnknown(self):
|
||||
program = self.program
|
||||
def usageExit(msg=None):
|
||||
program.msg = msg
|
||||
program.exit = True
|
||||
program.usageExit = usageExit
|
||||
|
||||
for opt in '-h', '-H', '--help':
|
||||
program.exit = False
|
||||
program.parseArgs([None, opt])
|
||||
self.assertTrue(program.exit)
|
||||
self.assertIsNone(program.msg)
|
||||
|
||||
program.parseArgs([None, '-$'])
|
||||
self.assertTrue(program.exit)
|
||||
self.assertIsNotNone(program.msg)
|
||||
|
||||
def testVerbosity(self):
|
||||
program = self.program
|
||||
|
||||
for opt in '-q', '--quiet':
|
||||
program.verbosity = 1
|
||||
program.parseArgs([None, opt])
|
||||
self.assertEqual(program.verbosity, 0)
|
||||
|
||||
for opt in '-v', '--verbose':
|
||||
program.verbosity = 1
|
||||
program.parseArgs([None, opt])
|
||||
self.assertEqual(program.verbosity, 2)
|
||||
|
||||
def testBufferCatchFailfast(self):
|
||||
program = self.program
|
||||
for arg, attr in (('buffer', 'buffer'), ('failfast', 'failfast'),
|
||||
('catch', 'catchbreak')):
|
||||
if attr == 'catch' and not hasInstallHandler:
|
||||
continue
|
||||
|
||||
short_opt = '-%s' % arg[0]
|
||||
long_opt = '--%s' % arg
|
||||
for opt in short_opt, long_opt:
|
||||
setattr(program, attr, None)
|
||||
|
||||
program.parseArgs([None, opt])
|
||||
self.assertTrue(getattr(program, attr))
|
||||
|
||||
for opt in short_opt, long_opt:
|
||||
not_none = object()
|
||||
setattr(program, attr, not_none)
|
||||
|
||||
program.parseArgs([None, opt])
|
||||
self.assertEqual(getattr(program, attr), not_none)
|
||||
|
||||
def testRunTestsRunnerClass(self):
|
||||
program = self.program
|
||||
|
||||
program.testRunner = FakeRunner
|
||||
program.verbosity = 'verbosity'
|
||||
program.failfast = 'failfast'
|
||||
program.buffer = 'buffer'
|
||||
|
||||
program.runTests()
|
||||
|
||||
self.assertEqual(FakeRunner.initArgs, {'verbosity': 'verbosity',
|
||||
'failfast': 'failfast',
|
||||
'buffer': 'buffer'})
|
||||
self.assertEqual(FakeRunner.test, 'test')
|
||||
self.assertIs(program.result, RESULT)
|
||||
|
||||
def testRunTestsRunnerInstance(self):
|
||||
program = self.program
|
||||
|
||||
program.testRunner = FakeRunner()
|
||||
FakeRunner.initArgs = None
|
||||
|
||||
program.runTests()
|
||||
|
||||
# A new FakeRunner should not have been instantiated
|
||||
self.assertIsNone(FakeRunner.initArgs)
|
||||
|
||||
self.assertEqual(FakeRunner.test, 'test')
|
||||
self.assertIs(program.result, RESULT)
|
||||
|
||||
def testRunTestsOldRunnerClass(self):
|
||||
program = self.program
|
||||
|
||||
FakeRunner.raiseError = True
|
||||
program.testRunner = FakeRunner
|
||||
program.verbosity = 'verbosity'
|
||||
program.failfast = 'failfast'
|
||||
program.buffer = 'buffer'
|
||||
program.test = 'test'
|
||||
|
||||
program.runTests()
|
||||
|
||||
# If initializing raises a type error it should be retried
|
||||
# without the new keyword arguments
|
||||
self.assertEqual(FakeRunner.initArgs, {})
|
||||
self.assertEqual(FakeRunner.test, 'test')
|
||||
self.assertIs(program.result, RESULT)
|
||||
|
||||
def testCatchBreakInstallsHandler(self):
|
||||
module = sys.modules['unittest.main']
|
||||
original = module.installHandler
|
||||
def restore():
|
||||
module.installHandler = original
|
||||
self.addCleanup(restore)
|
||||
|
||||
self.installed = False
|
||||
def fakeInstallHandler():
|
||||
self.installed = True
|
||||
module.installHandler = fakeInstallHandler
|
||||
|
||||
program = self.program
|
||||
program.catchbreak = True
|
||||
|
||||
program.testRunner = FakeRunner
|
||||
|
||||
program.runTests()
|
||||
self.assertTrue(self.installed)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,567 @@
|
||||
import sys
|
||||
import textwrap
|
||||
from StringIO import StringIO
|
||||
from test import test_support
|
||||
|
||||
import traceback
|
||||
import unittest
|
||||
|
||||
|
||||
class Test_TestResult(unittest.TestCase):
|
||||
# Note: there are not separate tests for TestResult.wasSuccessful(),
|
||||
# TestResult.errors, TestResult.failures, TestResult.testsRun or
|
||||
# TestResult.shouldStop because these only have meaning in terms of
|
||||
# other TestResult methods.
|
||||
#
|
||||
# Accordingly, tests for the aforenamed attributes are incorporated
|
||||
# in with the tests for the defining methods.
|
||||
################################################################
|
||||
|
||||
def test_init(self):
|
||||
result = unittest.TestResult()
|
||||
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 0)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
self.assertIsNone(result._stdout_buffer)
|
||||
self.assertIsNone(result._stderr_buffer)
|
||||
|
||||
|
||||
# "This method can be called to signal that the set of tests being
|
||||
# run should be aborted by setting the TestResult's shouldStop
|
||||
# attribute to True."
|
||||
def test_stop(self):
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.stop()
|
||||
|
||||
self.assertEqual(result.shouldStop, True)
|
||||
|
||||
# "Called when the test case test is about to be run. The default
|
||||
# implementation simply increments the instance's testsRun counter."
|
||||
def test_startTest(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
result.stopTest(test)
|
||||
|
||||
# "Called after the test case test has been executed, regardless of
|
||||
# the outcome. The default implementation does nothing."
|
||||
def test_stopTest(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
result.stopTest(test)
|
||||
|
||||
# Same tests as above; make sure nothing has changed
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
# "Called before and after tests are run. The default implementation does nothing."
|
||||
def test_startTestRun_stopTestRun(self):
|
||||
result = unittest.TestResult()
|
||||
result.startTestRun()
|
||||
result.stopTestRun()
|
||||
|
||||
# "addSuccess(test)"
|
||||
# ...
|
||||
# "Called when the test case test succeeds"
|
||||
# ...
|
||||
# "wasSuccessful() - Returns True if all tests run so far have passed,
|
||||
# otherwise returns False"
|
||||
# ...
|
||||
# "testsRun - The total number of tests run so far."
|
||||
# ...
|
||||
# "errors - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test which raised an
|
||||
# unexpected exception. Contains formatted
|
||||
# tracebacks instead of sys.exc_info() results."
|
||||
# ...
|
||||
# "failures - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test where a failure was
|
||||
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
|
||||
# methods. Contains formatted tracebacks instead
|
||||
# of sys.exc_info() results."
|
||||
def test_addSuccess(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
result.addSuccess(test)
|
||||
result.stopTest(test)
|
||||
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
# "addFailure(test, err)"
|
||||
# ...
|
||||
# "Called when the test case test signals a failure. err is a tuple of
|
||||
# the form returned by sys.exc_info(): (type, value, traceback)"
|
||||
# ...
|
||||
# "wasSuccessful() - Returns True if all tests run so far have passed,
|
||||
# otherwise returns False"
|
||||
# ...
|
||||
# "testsRun - The total number of tests run so far."
|
||||
# ...
|
||||
# "errors - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test which raised an
|
||||
# unexpected exception. Contains formatted
|
||||
# tracebacks instead of sys.exc_info() results."
|
||||
# ...
|
||||
# "failures - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test where a failure was
|
||||
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
|
||||
# methods. Contains formatted tracebacks instead
|
||||
# of sys.exc_info() results."
|
||||
def test_addFailure(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
try:
|
||||
test.fail("foo")
|
||||
except:
|
||||
exc_info_tuple = sys.exc_info()
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
result.addFailure(test, exc_info_tuple)
|
||||
result.stopTest(test)
|
||||
|
||||
self.assertFalse(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.failures), 1)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
test_case, formatted_exc = result.failures[0]
|
||||
self.assertTrue(test_case is test)
|
||||
self.assertIsInstance(formatted_exc, str)
|
||||
|
||||
# "addError(test, err)"
|
||||
# ...
|
||||
# "Called when the test case test raises an unexpected exception err
|
||||
# is a tuple of the form returned by sys.exc_info():
|
||||
# (type, value, traceback)"
|
||||
# ...
|
||||
# "wasSuccessful() - Returns True if all tests run so far have passed,
|
||||
# otherwise returns False"
|
||||
# ...
|
||||
# "testsRun - The total number of tests run so far."
|
||||
# ...
|
||||
# "errors - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test which raised an
|
||||
# unexpected exception. Contains formatted
|
||||
# tracebacks instead of sys.exc_info() results."
|
||||
# ...
|
||||
# "failures - A list containing 2-tuples of TestCase instances and
|
||||
# formatted tracebacks. Each tuple represents a test where a failure was
|
||||
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
|
||||
# methods. Contains formatted tracebacks instead
|
||||
# of sys.exc_info() results."
|
||||
def test_addError(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
test = Foo('test_1')
|
||||
try:
|
||||
raise TypeError()
|
||||
except:
|
||||
exc_info_tuple = sys.exc_info()
|
||||
|
||||
result = unittest.TestResult()
|
||||
|
||||
result.startTest(test)
|
||||
result.addError(test, exc_info_tuple)
|
||||
result.stopTest(test)
|
||||
|
||||
self.assertFalse(result.wasSuccessful())
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
self.assertEqual(result.shouldStop, False)
|
||||
|
||||
test_case, formatted_exc = result.errors[0]
|
||||
self.assertTrue(test_case is test)
|
||||
self.assertIsInstance(formatted_exc, str)
|
||||
|
||||
def testGetDescriptionWithoutDocstring(self):
|
||||
result = unittest.TextTestResult(None, True, 1)
|
||||
self.assertEqual(
|
||||
result.getDescription(self),
|
||||
'testGetDescriptionWithoutDocstring (' + __name__ +
|
||||
'.Test_TestResult)')
|
||||
|
||||
@unittest.skipIf(sys.flags.optimize >= 2,
|
||||
"Docstrings are omitted with -O2 and above")
|
||||
def testGetDescriptionWithOneLineDocstring(self):
|
||||
"""Tests getDescription() for a method with a docstring."""
|
||||
result = unittest.TextTestResult(None, True, 1)
|
||||
self.assertEqual(
|
||||
result.getDescription(self),
|
||||
('testGetDescriptionWithOneLineDocstring '
|
||||
'(' + __name__ + '.Test_TestResult)\n'
|
||||
'Tests getDescription() for a method with a docstring.'))
|
||||
|
||||
@unittest.skipIf(sys.flags.optimize >= 2,
|
||||
"Docstrings are omitted with -O2 and above")
|
||||
def testGetDescriptionWithMultiLineDocstring(self):
|
||||
"""Tests getDescription() for a method with a longer docstring.
|
||||
The second line of the docstring.
|
||||
"""
|
||||
result = unittest.TextTestResult(None, True, 1)
|
||||
self.assertEqual(
|
||||
result.getDescription(self),
|
||||
('testGetDescriptionWithMultiLineDocstring '
|
||||
'(' + __name__ + '.Test_TestResult)\n'
|
||||
'Tests getDescription() for a method with a longer '
|
||||
'docstring.'))
|
||||
|
||||
def testStackFrameTrimming(self):
|
||||
class Frame(object):
|
||||
class tb_frame(object):
|
||||
f_globals = {}
|
||||
result = unittest.TestResult()
|
||||
self.assertFalse(result._is_relevant_tb_level(Frame))
|
||||
|
||||
Frame.tb_frame.f_globals['__unittest'] = True
|
||||
self.assertTrue(result._is_relevant_tb_level(Frame))
|
||||
|
||||
def testFailFast(self):
|
||||
result = unittest.TestResult()
|
||||
result._exc_info_to_string = lambda *_: ''
|
||||
result.failfast = True
|
||||
result.addError(None, None)
|
||||
self.assertTrue(result.shouldStop)
|
||||
|
||||
result = unittest.TestResult()
|
||||
result._exc_info_to_string = lambda *_: ''
|
||||
result.failfast = True
|
||||
result.addFailure(None, None)
|
||||
self.assertTrue(result.shouldStop)
|
||||
|
||||
result = unittest.TestResult()
|
||||
result._exc_info_to_string = lambda *_: ''
|
||||
result.failfast = True
|
||||
result.addUnexpectedSuccess(None)
|
||||
self.assertTrue(result.shouldStop)
|
||||
|
||||
def testFailFastSetByRunner(self):
|
||||
runner = unittest.TextTestRunner(stream=StringIO(), failfast=True)
|
||||
def test(result):
|
||||
self.assertTrue(result.failfast)
|
||||
runner.run(test)
|
||||
|
||||
|
||||
classDict = dict(unittest.TestResult.__dict__)
|
||||
for m in ('addSkip', 'addExpectedFailure', 'addUnexpectedSuccess',
|
||||
'__init__'):
|
||||
del classDict[m]
|
||||
|
||||
def __init__(self, stream=None, descriptions=None, verbosity=None):
|
||||
self.failures = []
|
||||
self.errors = []
|
||||
self.testsRun = 0
|
||||
self.shouldStop = False
|
||||
self.buffer = False
|
||||
|
||||
classDict['__init__'] = __init__
|
||||
OldResult = type('OldResult', (object,), classDict)
|
||||
|
||||
class Test_OldTestResult(unittest.TestCase):
|
||||
|
||||
def assertOldResultWarning(self, test, failures):
|
||||
with test_support.check_warnings(("TestResult has no add.+ method,",
|
||||
RuntimeWarning)):
|
||||
result = OldResult()
|
||||
test.run(result)
|
||||
self.assertEqual(len(result.failures), failures)
|
||||
|
||||
def testOldTestResult(self):
|
||||
class Test(unittest.TestCase):
|
||||
def testSkip(self):
|
||||
self.skipTest('foobar')
|
||||
@unittest.expectedFailure
|
||||
def testExpectedFail(self):
|
||||
raise TypeError
|
||||
@unittest.expectedFailure
|
||||
def testUnexpectedSuccess(self):
|
||||
pass
|
||||
|
||||
for test_name, should_pass in (('testSkip', True),
|
||||
('testExpectedFail', True),
|
||||
('testUnexpectedSuccess', False)):
|
||||
test = Test(test_name)
|
||||
self.assertOldResultWarning(test, int(not should_pass))
|
||||
|
||||
def testOldTestTesultSetup(self):
|
||||
class Test(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.skipTest('no reason')
|
||||
def testFoo(self):
|
||||
pass
|
||||
self.assertOldResultWarning(Test('testFoo'), 0)
|
||||
|
||||
def testOldTestResultClass(self):
|
||||
@unittest.skip('no reason')
|
||||
class Test(unittest.TestCase):
|
||||
def testFoo(self):
|
||||
pass
|
||||
self.assertOldResultWarning(Test('testFoo'), 0)
|
||||
|
||||
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'))
|
||||
|
||||
|
||||
class MockTraceback(object):
|
||||
@staticmethod
|
||||
def format_exception(*_):
|
||||
return ['A traceback']
|
||||
|
||||
def restore_traceback():
|
||||
unittest.result.traceback = traceback
|
||||
|
||||
|
||||
class TestOutputBuffering(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self._real_out = sys.stdout
|
||||
self._real_err = sys.stderr
|
||||
|
||||
def tearDown(self):
|
||||
sys.stdout = self._real_out
|
||||
sys.stderr = self._real_err
|
||||
|
||||
def testBufferOutputOff(self):
|
||||
real_out = self._real_out
|
||||
real_err = self._real_err
|
||||
|
||||
result = unittest.TestResult()
|
||||
self.assertFalse(result.buffer)
|
||||
|
||||
self.assertIs(real_out, sys.stdout)
|
||||
self.assertIs(real_err, sys.stderr)
|
||||
|
||||
result.startTest(self)
|
||||
|
||||
self.assertIs(real_out, sys.stdout)
|
||||
self.assertIs(real_err, sys.stderr)
|
||||
|
||||
def testBufferOutputStartTestAddSuccess(self):
|
||||
real_out = self._real_out
|
||||
real_err = self._real_err
|
||||
|
||||
result = unittest.TestResult()
|
||||
self.assertFalse(result.buffer)
|
||||
|
||||
result.buffer = True
|
||||
|
||||
self.assertIs(real_out, sys.stdout)
|
||||
self.assertIs(real_err, sys.stderr)
|
||||
|
||||
result.startTest(self)
|
||||
|
||||
self.assertIsNot(real_out, sys.stdout)
|
||||
self.assertIsNot(real_err, sys.stderr)
|
||||
self.assertIsInstance(sys.stdout, StringIO)
|
||||
self.assertIsInstance(sys.stderr, StringIO)
|
||||
self.assertIsNot(sys.stdout, sys.stderr)
|
||||
|
||||
out_stream = sys.stdout
|
||||
err_stream = sys.stderr
|
||||
|
||||
result._original_stdout = StringIO()
|
||||
result._original_stderr = StringIO()
|
||||
|
||||
print 'foo'
|
||||
print >> sys.stderr, 'bar'
|
||||
|
||||
self.assertEqual(out_stream.getvalue(), 'foo\n')
|
||||
self.assertEqual(err_stream.getvalue(), 'bar\n')
|
||||
|
||||
self.assertEqual(result._original_stdout.getvalue(), '')
|
||||
self.assertEqual(result._original_stderr.getvalue(), '')
|
||||
|
||||
result.addSuccess(self)
|
||||
result.stopTest(self)
|
||||
|
||||
self.assertIs(sys.stdout, result._original_stdout)
|
||||
self.assertIs(sys.stderr, result._original_stderr)
|
||||
|
||||
self.assertEqual(result._original_stdout.getvalue(), '')
|
||||
self.assertEqual(result._original_stderr.getvalue(), '')
|
||||
|
||||
self.assertEqual(out_stream.getvalue(), '')
|
||||
self.assertEqual(err_stream.getvalue(), '')
|
||||
|
||||
|
||||
def getStartedResult(self):
|
||||
result = unittest.TestResult()
|
||||
result.buffer = True
|
||||
result.startTest(self)
|
||||
return result
|
||||
|
||||
def testBufferOutputAddErrorOrFailure(self):
|
||||
unittest.result.traceback = MockTraceback
|
||||
self.addCleanup(restore_traceback)
|
||||
|
||||
for message_attr, add_attr, include_error in [
|
||||
('errors', 'addError', True),
|
||||
('failures', 'addFailure', False),
|
||||
('errors', 'addError', True),
|
||||
('failures', 'addFailure', False)
|
||||
]:
|
||||
result = self.getStartedResult()
|
||||
buffered_out = sys.stdout
|
||||
buffered_err = sys.stderr
|
||||
result._original_stdout = StringIO()
|
||||
result._original_stderr = StringIO()
|
||||
|
||||
print >> sys.stdout, 'foo'
|
||||
if include_error:
|
||||
print >> sys.stderr, 'bar'
|
||||
|
||||
|
||||
addFunction = getattr(result, add_attr)
|
||||
addFunction(self, (None, None, None))
|
||||
result.stopTest(self)
|
||||
|
||||
result_list = getattr(result, message_attr)
|
||||
self.assertEqual(len(result_list), 1)
|
||||
|
||||
test, message = result_list[0]
|
||||
expectedOutMessage = textwrap.dedent("""
|
||||
Stdout:
|
||||
foo
|
||||
""")
|
||||
expectedErrMessage = ''
|
||||
if include_error:
|
||||
expectedErrMessage = textwrap.dedent("""
|
||||
Stderr:
|
||||
bar
|
||||
""")
|
||||
expectedFullMessage = 'A traceback%s%s' % (expectedOutMessage, expectedErrMessage)
|
||||
|
||||
self.assertIs(test, self)
|
||||
self.assertEqual(result._original_stdout.getvalue(), expectedOutMessage)
|
||||
self.assertEqual(result._original_stderr.getvalue(), expectedErrMessage)
|
||||
self.assertMultiLineEqual(message, expectedFullMessage)
|
||||
|
||||
def testBufferSetupClass(self):
|
||||
result = unittest.TestResult()
|
||||
result.buffer = True
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
1//0
|
||||
def test_foo(self):
|
||||
pass
|
||||
suite = unittest.TestSuite([Foo('test_foo')])
|
||||
suite(result)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
|
||||
def testBufferTearDownClass(self):
|
||||
result = unittest.TestResult()
|
||||
result.buffer = True
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
1//0
|
||||
def test_foo(self):
|
||||
pass
|
||||
suite = unittest.TestSuite([Foo('test_foo')])
|
||||
suite(result)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
|
||||
def testBufferSetUpModule(self):
|
||||
result = unittest.TestResult()
|
||||
result.buffer = True
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
def test_foo(self):
|
||||
pass
|
||||
class Module(object):
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
1//0
|
||||
|
||||
Foo.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
self.addCleanup(sys.modules.pop, 'Module')
|
||||
suite = unittest.TestSuite([Foo('test_foo')])
|
||||
suite(result)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
|
||||
def testBufferTearDownModule(self):
|
||||
result = unittest.TestResult()
|
||||
result.buffer = True
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
def test_foo(self):
|
||||
pass
|
||||
class Module(object):
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
1//0
|
||||
|
||||
Foo.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
self.addCleanup(sys.modules.pop, 'Module')
|
||||
suite = unittest.TestSuite([Foo('test_foo')])
|
||||
suite(result)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,253 @@
|
||||
import unittest
|
||||
|
||||
from cStringIO import StringIO
|
||||
import pickle
|
||||
|
||||
from .support import LoggingResult, ResultWithNoStartTestRunStopTestRun
|
||||
|
||||
|
||||
class TestCleanUp(unittest.TestCase):
|
||||
|
||||
def testCleanUp(self):
|
||||
class TestableTest(unittest.TestCase):
|
||||
def testNothing(self):
|
||||
pass
|
||||
|
||||
test = TestableTest('testNothing')
|
||||
self.assertEqual(test._cleanups, [])
|
||||
|
||||
cleanups = []
|
||||
|
||||
def cleanup1(*args, **kwargs):
|
||||
cleanups.append((1, args, kwargs))
|
||||
|
||||
def cleanup2(*args, **kwargs):
|
||||
cleanups.append((2, args, kwargs))
|
||||
|
||||
test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye')
|
||||
test.addCleanup(cleanup2)
|
||||
|
||||
self.assertEqual(test._cleanups,
|
||||
[(cleanup1, (1, 2, 3), dict(four='hello', five='goodbye')),
|
||||
(cleanup2, (), {})])
|
||||
|
||||
result = test.doCleanups()
|
||||
self.assertTrue(result)
|
||||
|
||||
self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3),
|
||||
dict(four='hello', five='goodbye'))])
|
||||
|
||||
def testCleanUpWithErrors(self):
|
||||
class TestableTest(unittest.TestCase):
|
||||
def testNothing(self):
|
||||
pass
|
||||
|
||||
class MockResult(object):
|
||||
errors = []
|
||||
def addError(self, test, exc_info):
|
||||
self.errors.append((test, exc_info))
|
||||
|
||||
result = MockResult()
|
||||
test = TestableTest('testNothing')
|
||||
test._resultForDoCleanups = result
|
||||
|
||||
exc1 = Exception('foo')
|
||||
exc2 = Exception('bar')
|
||||
def cleanup1():
|
||||
raise exc1
|
||||
|
||||
def cleanup2():
|
||||
raise exc2
|
||||
|
||||
test.addCleanup(cleanup1)
|
||||
test.addCleanup(cleanup2)
|
||||
|
||||
self.assertFalse(test.doCleanups())
|
||||
|
||||
(test1, (Type1, instance1, _)), (test2, (Type2, instance2, _)) = reversed(MockResult.errors)
|
||||
self.assertEqual((test1, Type1, instance1), (test, Exception, exc1))
|
||||
self.assertEqual((test2, Type2, instance2), (test, Exception, exc2))
|
||||
|
||||
def testCleanupInRun(self):
|
||||
blowUp = False
|
||||
ordering = []
|
||||
|
||||
class TestableTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
ordering.append('setUp')
|
||||
if blowUp:
|
||||
raise Exception('foo')
|
||||
|
||||
def testNothing(self):
|
||||
ordering.append('test')
|
||||
|
||||
def tearDown(self):
|
||||
ordering.append('tearDown')
|
||||
|
||||
test = TestableTest('testNothing')
|
||||
|
||||
def cleanup1():
|
||||
ordering.append('cleanup1')
|
||||
def cleanup2():
|
||||
ordering.append('cleanup2')
|
||||
test.addCleanup(cleanup1)
|
||||
test.addCleanup(cleanup2)
|
||||
|
||||
def success(some_test):
|
||||
self.assertEqual(some_test, test)
|
||||
ordering.append('success')
|
||||
|
||||
result = unittest.TestResult()
|
||||
result.addSuccess = success
|
||||
|
||||
test.run(result)
|
||||
self.assertEqual(ordering, ['setUp', 'test', 'tearDown',
|
||||
'cleanup2', 'cleanup1', 'success'])
|
||||
|
||||
blowUp = True
|
||||
ordering = []
|
||||
test = TestableTest('testNothing')
|
||||
test.addCleanup(cleanup1)
|
||||
test.run(result)
|
||||
self.assertEqual(ordering, ['setUp', 'cleanup1'])
|
||||
|
||||
def testTestCaseDebugExecutesCleanups(self):
|
||||
ordering = []
|
||||
|
||||
class TestableTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
ordering.append('setUp')
|
||||
self.addCleanup(cleanup1)
|
||||
|
||||
def testNothing(self):
|
||||
ordering.append('test')
|
||||
|
||||
def tearDown(self):
|
||||
ordering.append('tearDown')
|
||||
|
||||
test = TestableTest('testNothing')
|
||||
|
||||
def cleanup1():
|
||||
ordering.append('cleanup1')
|
||||
test.addCleanup(cleanup2)
|
||||
def cleanup2():
|
||||
ordering.append('cleanup2')
|
||||
|
||||
test.debug()
|
||||
self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2'])
|
||||
|
||||
|
||||
class Test_TextTestRunner(unittest.TestCase):
|
||||
"""Tests for TextTestRunner."""
|
||||
|
||||
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 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 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_works_with_result_without_startTestRun_stopTestRun(self):
|
||||
class OldTextResult(ResultWithNoStartTestRunStopTestRun):
|
||||
separator2 = ''
|
||||
def printErrors(self):
|
||||
pass
|
||||
|
||||
class Runner(unittest.TextTestRunner):
|
||||
def __init__(self):
|
||||
super(Runner, self).__init__(StringIO())
|
||||
|
||||
def _makeResult(self):
|
||||
return OldTextResult()
|
||||
|
||||
runner = Runner()
|
||||
runner.run(unittest.TestSuite())
|
||||
|
||||
def test_startTestRun_stopTestRun_called(self):
|
||||
class LoggingTextResult(LoggingResult):
|
||||
separator2 = ''
|
||||
def printErrors(self):
|
||||
pass
|
||||
|
||||
class LoggingRunner(unittest.TextTestRunner):
|
||||
def __init__(self, events):
|
||||
super(LoggingRunner, self).__init__(StringIO())
|
||||
self._events = events
|
||||
|
||||
def _makeResult(self):
|
||||
return LoggingTextResult(self._events)
|
||||
|
||||
events = []
|
||||
runner = LoggingRunner(events)
|
||||
runner.run(unittest.TestSuite())
|
||||
expected = ['startTestRun', 'stopTestRun']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
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)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,508 @@
|
||||
import sys
|
||||
|
||||
from cStringIO import StringIO
|
||||
|
||||
import unittest
|
||||
|
||||
|
||||
def resultFactory(*_):
|
||||
return unittest.TestResult()
|
||||
|
||||
|
||||
class TestSetups(unittest.TestCase):
|
||||
|
||||
def getRunner(self):
|
||||
return unittest.TextTestRunner(resultclass=resultFactory,
|
||||
stream=StringIO())
|
||||
def runTests(self, *cases):
|
||||
suite = unittest.TestSuite()
|
||||
for case in cases:
|
||||
tests = unittest.defaultTestLoader.loadTestsFromTestCase(case)
|
||||
suite.addTests(tests)
|
||||
|
||||
runner = self.getRunner()
|
||||
|
||||
# creating a nested suite exposes some potential bugs
|
||||
realSuite = unittest.TestSuite()
|
||||
realSuite.addTest(suite)
|
||||
# adding empty suites to the end exposes potential bugs
|
||||
suite.addTest(unittest.TestSuite())
|
||||
realSuite.addTest(unittest.TestSuite())
|
||||
return runner.run(realSuite)
|
||||
|
||||
def test_setup_class(self):
|
||||
class Test(unittest.TestCase):
|
||||
setUpCalled = 0
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
Test.setUpCalled += 1
|
||||
unittest.TestCase.setUpClass()
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(Test)
|
||||
|
||||
self.assertEqual(Test.setUpCalled, 1)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_teardown_class(self):
|
||||
class Test(unittest.TestCase):
|
||||
tearDownCalled = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tearDownCalled += 1
|
||||
unittest.TestCase.tearDownClass()
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(Test)
|
||||
|
||||
self.assertEqual(Test.tearDownCalled, 1)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_teardown_class_two_classes(self):
|
||||
class Test(unittest.TestCase):
|
||||
tearDownCalled = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tearDownCalled += 1
|
||||
unittest.TestCase.tearDownClass()
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
tearDownCalled = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test2.tearDownCalled += 1
|
||||
unittest.TestCase.tearDownClass()
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(Test, Test2)
|
||||
|
||||
self.assertEqual(Test.tearDownCalled, 1)
|
||||
self.assertEqual(Test2.tearDownCalled, 1)
|
||||
self.assertEqual(result.testsRun, 4)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_error_in_setupclass(self):
|
||||
class BrokenTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
raise TypeError('foo')
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(BrokenTest)
|
||||
|
||||
self.assertEqual(result.testsRun, 0)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
error, _ = result.errors[0]
|
||||
self.assertEqual(str(error),
|
||||
'setUpClass (%s.BrokenTest)' % __name__)
|
||||
|
||||
def test_error_in_teardown_class(self):
|
||||
class Test(unittest.TestCase):
|
||||
tornDown = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tornDown += 1
|
||||
raise TypeError('foo')
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
tornDown = 0
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test2.tornDown += 1
|
||||
raise TypeError('foo')
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(Test, Test2)
|
||||
self.assertEqual(result.testsRun, 4)
|
||||
self.assertEqual(len(result.errors), 2)
|
||||
self.assertEqual(Test.tornDown, 1)
|
||||
self.assertEqual(Test2.tornDown, 1)
|
||||
|
||||
error, _ = result.errors[0]
|
||||
self.assertEqual(str(error),
|
||||
'tearDownClass (%s.Test)' % __name__)
|
||||
|
||||
def test_class_not_torndown_when_setup_fails(self):
|
||||
class Test(unittest.TestCase):
|
||||
tornDown = False
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
raise TypeError
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tornDown = True
|
||||
raise TypeError('foo')
|
||||
def test_one(self):
|
||||
pass
|
||||
|
||||
self.runTests(Test)
|
||||
self.assertFalse(Test.tornDown)
|
||||
|
||||
def test_class_not_setup_or_torndown_when_skipped(self):
|
||||
class Test(unittest.TestCase):
|
||||
classSetUp = False
|
||||
tornDown = False
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
Test.classSetUp = True
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.tornDown = True
|
||||
def test_one(self):
|
||||
pass
|
||||
|
||||
Test = unittest.skip("hop")(Test)
|
||||
self.runTests(Test)
|
||||
self.assertFalse(Test.classSetUp)
|
||||
self.assertFalse(Test.tornDown)
|
||||
|
||||
def test_setup_teardown_order_with_pathological_suite(self):
|
||||
results = []
|
||||
|
||||
class Module1(object):
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
results.append('Module1.setUpModule')
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
results.append('Module1.tearDownModule')
|
||||
|
||||
class Module2(object):
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
results.append('Module2.setUpModule')
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
results.append('Module2.tearDownModule')
|
||||
|
||||
class Test1(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
results.append('setup 1')
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
results.append('teardown 1')
|
||||
def testOne(self):
|
||||
results.append('Test1.testOne')
|
||||
def testTwo(self):
|
||||
results.append('Test1.testTwo')
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
results.append('setup 2')
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
results.append('teardown 2')
|
||||
def testOne(self):
|
||||
results.append('Test2.testOne')
|
||||
def testTwo(self):
|
||||
results.append('Test2.testTwo')
|
||||
|
||||
class Test3(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
results.append('setup 3')
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
results.append('teardown 3')
|
||||
def testOne(self):
|
||||
results.append('Test3.testOne')
|
||||
def testTwo(self):
|
||||
results.append('Test3.testTwo')
|
||||
|
||||
Test1.__module__ = Test2.__module__ = 'Module'
|
||||
Test3.__module__ = 'Module2'
|
||||
sys.modules['Module'] = Module1
|
||||
sys.modules['Module2'] = Module2
|
||||
|
||||
first = unittest.TestSuite((Test1('testOne'),))
|
||||
second = unittest.TestSuite((Test1('testTwo'),))
|
||||
third = unittest.TestSuite((Test2('testOne'),))
|
||||
fourth = unittest.TestSuite((Test2('testTwo'),))
|
||||
fifth = unittest.TestSuite((Test3('testOne'),))
|
||||
sixth = unittest.TestSuite((Test3('testTwo'),))
|
||||
suite = unittest.TestSuite((first, second, third, fourth, fifth, sixth))
|
||||
|
||||
runner = self.getRunner()
|
||||
result = runner.run(suite)
|
||||
self.assertEqual(result.testsRun, 6)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
self.assertEqual(results,
|
||||
['Module1.setUpModule', 'setup 1',
|
||||
'Test1.testOne', 'Test1.testTwo', 'teardown 1',
|
||||
'setup 2', 'Test2.testOne', 'Test2.testTwo',
|
||||
'teardown 2', 'Module1.tearDownModule',
|
||||
'Module2.setUpModule', 'setup 3',
|
||||
'Test3.testOne', 'Test3.testTwo',
|
||||
'teardown 3', 'Module2.tearDownModule'])
|
||||
|
||||
def test_setup_module(self):
|
||||
class Module(object):
|
||||
moduleSetup = 0
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
Module.moduleSetup += 1
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
result = self.runTests(Test)
|
||||
self.assertEqual(Module.moduleSetup, 1)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_error_in_setup_module(self):
|
||||
class Module(object):
|
||||
moduleSetup = 0
|
||||
moduleTornDown = 0
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
Module.moduleSetup += 1
|
||||
raise TypeError('foo')
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
Module.moduleTornDown += 1
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
classSetUp = False
|
||||
classTornDown = False
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
Test.classSetUp = True
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.classTornDown = True
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
Test2.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
result = self.runTests(Test, Test2)
|
||||
self.assertEqual(Module.moduleSetup, 1)
|
||||
self.assertEqual(Module.moduleTornDown, 0)
|
||||
self.assertEqual(result.testsRun, 0)
|
||||
self.assertFalse(Test.classSetUp)
|
||||
self.assertFalse(Test.classTornDown)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
error, _ = result.errors[0]
|
||||
self.assertEqual(str(error), 'setUpModule (Module)')
|
||||
|
||||
def test_testcase_with_missing_module(self):
|
||||
class Test(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules.pop('Module', None)
|
||||
|
||||
result = self.runTests(Test)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
|
||||
def test_teardown_module(self):
|
||||
class Module(object):
|
||||
moduleTornDown = 0
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
Module.moduleTornDown += 1
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
result = self.runTests(Test)
|
||||
self.assertEqual(Module.moduleTornDown, 1)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
|
||||
def test_error_in_teardown_module(self):
|
||||
class Module(object):
|
||||
moduleTornDown = 0
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
Module.moduleTornDown += 1
|
||||
raise TypeError('foo')
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
classSetUp = False
|
||||
classTornDown = False
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
Test.classSetUp = True
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
Test.classTornDown = True
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
class Test2(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
Test.__module__ = 'Module'
|
||||
Test2.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
result = self.runTests(Test, Test2)
|
||||
self.assertEqual(Module.moduleTornDown, 1)
|
||||
self.assertEqual(result.testsRun, 4)
|
||||
self.assertTrue(Test.classSetUp)
|
||||
self.assertTrue(Test.classTornDown)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
error, _ = result.errors[0]
|
||||
self.assertEqual(str(error), 'tearDownModule (Module)')
|
||||
|
||||
def test_skiptest_in_setupclass(self):
|
||||
class Test(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
raise unittest.SkipTest('foo')
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
result = self.runTests(Test)
|
||||
self.assertEqual(result.testsRun, 0)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.skipped), 1)
|
||||
skipped = result.skipped[0][0]
|
||||
self.assertEqual(str(skipped), 'setUpClass (%s.Test)' % __name__)
|
||||
|
||||
def test_skiptest_in_setupmodule(self):
|
||||
class Test(unittest.TestCase):
|
||||
def test_one(self):
|
||||
pass
|
||||
def test_two(self):
|
||||
pass
|
||||
|
||||
class Module(object):
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
raise unittest.SkipTest('foo')
|
||||
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
result = self.runTests(Test)
|
||||
self.assertEqual(result.testsRun, 0)
|
||||
self.assertEqual(len(result.errors), 0)
|
||||
self.assertEqual(len(result.skipped), 1)
|
||||
skipped = result.skipped[0][0]
|
||||
self.assertEqual(str(skipped), 'setUpModule (Module)')
|
||||
|
||||
def test_suite_debug_executes_setups_and_teardowns(self):
|
||||
ordering = []
|
||||
|
||||
class Module(object):
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
ordering.append('setUpModule')
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
ordering.append('tearDownModule')
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
ordering.append('setUpClass')
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
ordering.append('tearDownClass')
|
||||
def test_something(self):
|
||||
ordering.append('test_something')
|
||||
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
suite = unittest.defaultTestLoader.loadTestsFromTestCase(Test)
|
||||
suite.debug()
|
||||
expectedOrder = ['setUpModule', 'setUpClass', 'test_something', 'tearDownClass', 'tearDownModule']
|
||||
self.assertEqual(ordering, expectedOrder)
|
||||
|
||||
def test_suite_debug_propagates_exceptions(self):
|
||||
class Module(object):
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
if phase == 0:
|
||||
raise Exception('setUpModule')
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
if phase == 1:
|
||||
raise Exception('tearDownModule')
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
if phase == 2:
|
||||
raise Exception('setUpClass')
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
if phase == 3:
|
||||
raise Exception('tearDownClass')
|
||||
def test_something(self):
|
||||
if phase == 4:
|
||||
raise Exception('test_something')
|
||||
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
|
||||
_suite = unittest.defaultTestLoader.loadTestsFromTestCase(Test)
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(_suite)
|
||||
|
||||
messages = ('setUpModule', 'tearDownModule', 'setUpClass', 'tearDownClass', 'test_something')
|
||||
for phase, msg in enumerate(messages):
|
||||
with self.assertRaisesRegexp(Exception, msg):
|
||||
suite.debug()
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,138 @@
|
||||
import unittest
|
||||
|
||||
from .support import LoggingResult
|
||||
|
||||
|
||||
class Test_TestSkipping(unittest.TestCase):
|
||||
|
||||
def test_skipping(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_skip_me(self):
|
||||
self.skipTest("skip")
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
test = Foo("test_skip_me")
|
||||
test.run(result)
|
||||
self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
|
||||
self.assertEqual(result.skipped, [(test, "skip")])
|
||||
|
||||
# Try letting setUp skip the test now.
|
||||
class Foo(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.skipTest("testing")
|
||||
def test_nothing(self): pass
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
test = Foo("test_nothing")
|
||||
test.run(result)
|
||||
self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
|
||||
self.assertEqual(result.skipped, [(test, "testing")])
|
||||
self.assertEqual(result.testsRun, 1)
|
||||
|
||||
def test_skipping_decorators(self):
|
||||
op_table = ((unittest.skipUnless, False, True),
|
||||
(unittest.skipIf, True, False))
|
||||
for deco, do_skip, dont_skip in op_table:
|
||||
class Foo(unittest.TestCase):
|
||||
@deco(do_skip, "testing")
|
||||
def test_skip(self): pass
|
||||
|
||||
@deco(dont_skip, "testing")
|
||||
def test_dont_skip(self): pass
|
||||
test_do_skip = Foo("test_skip")
|
||||
test_dont_skip = Foo("test_dont_skip")
|
||||
suite = unittest.TestSuite([test_do_skip, test_dont_skip])
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
suite.run(result)
|
||||
self.assertEqual(len(result.skipped), 1)
|
||||
expected = ['startTest', 'addSkip', 'stopTest',
|
||||
'startTest', 'addSuccess', 'stopTest']
|
||||
self.assertEqual(events, expected)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
self.assertEqual(result.skipped, [(test_do_skip, "testing")])
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
|
||||
def test_skip_class(self):
|
||||
@unittest.skip("testing")
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self):
|
||||
record.append(1)
|
||||
record = []
|
||||
result = unittest.TestResult()
|
||||
test = Foo("test_1")
|
||||
suite = unittest.TestSuite([test])
|
||||
suite.run(result)
|
||||
self.assertEqual(result.skipped, [(test, "testing")])
|
||||
self.assertEqual(record, [])
|
||||
|
||||
def test_expected_failure(self):
|
||||
class Foo(unittest.TestCase):
|
||||
@unittest.expectedFailure
|
||||
def test_die(self):
|
||||
self.fail("help me!")
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
test = Foo("test_die")
|
||||
test.run(result)
|
||||
self.assertEqual(events,
|
||||
['startTest', 'addExpectedFailure', 'stopTest'])
|
||||
self.assertEqual(result.expectedFailures[0][0], test)
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
|
||||
def test_unexpected_success(self):
|
||||
class Foo(unittest.TestCase):
|
||||
@unittest.expectedFailure
|
||||
def test_die(self):
|
||||
pass
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
test = Foo("test_die")
|
||||
test.run(result)
|
||||
self.assertEqual(events,
|
||||
['startTest', 'addUnexpectedSuccess', 'stopTest'])
|
||||
self.assertFalse(result.failures)
|
||||
self.assertEqual(result.unexpectedSuccesses, [test])
|
||||
self.assertTrue(result.wasSuccessful())
|
||||
|
||||
def test_skip_doesnt_run_setup(self):
|
||||
class Foo(unittest.TestCase):
|
||||
wasSetUp = False
|
||||
wasTornDown = False
|
||||
def setUp(self):
|
||||
Foo.wasSetUp = True
|
||||
def tornDown(self):
|
||||
Foo.wasTornDown = True
|
||||
@unittest.skip('testing')
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
result = unittest.TestResult()
|
||||
test = Foo("test_1")
|
||||
suite = unittest.TestSuite([test])
|
||||
suite.run(result)
|
||||
self.assertEqual(result.skipped, [(test, "testing")])
|
||||
self.assertFalse(Foo.wasSetUp)
|
||||
self.assertFalse(Foo.wasTornDown)
|
||||
|
||||
def test_decorated_skip(self):
|
||||
def decorator(func):
|
||||
def inner(*a):
|
||||
return func(*a)
|
||||
return inner
|
||||
|
||||
class Foo(unittest.TestCase):
|
||||
@decorator
|
||||
@unittest.skip('testing')
|
||||
def test_1(self):
|
||||
pass
|
||||
|
||||
result = unittest.TestResult()
|
||||
test = Foo("test_1")
|
||||
suite = unittest.TestSuite([test])
|
||||
suite.run(result)
|
||||
self.assertEqual(result.skipped, [(test, "testing")])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,367 @@
|
||||
import unittest
|
||||
|
||||
import sys
|
||||
from .support import LoggingResult, TestEquality
|
||||
|
||||
|
||||
### Support code for Test_TestSuite
|
||||
################################################################
|
||||
|
||||
class Test(object):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self): pass
|
||||
def test_2(self): pass
|
||||
def test_3(self): pass
|
||||
def runTest(self): pass
|
||||
|
||||
def _mk_TestSuite(*names):
|
||||
return unittest.TestSuite(Test.Foo(n) for n in names)
|
||||
|
||||
################################################################
|
||||
|
||||
|
||||
class Test_TestSuite(unittest.TestCase, TestEquality):
|
||||
|
||||
### Set up attributes needed by inherited tests
|
||||
################################################################
|
||||
|
||||
# Used by TestEquality.test_eq
|
||||
eq_pairs = [(unittest.TestSuite(), unittest.TestSuite()),
|
||||
(unittest.TestSuite(), unittest.TestSuite([])),
|
||||
(_mk_TestSuite('test_1'), _mk_TestSuite('test_1'))]
|
||||
|
||||
# Used by TestEquality.test_ne
|
||||
ne_pairs = [(unittest.TestSuite(), _mk_TestSuite('test_1')),
|
||||
(unittest.TestSuite([]), _mk_TestSuite('test_1')),
|
||||
(_mk_TestSuite('test_1', 'test_2'), _mk_TestSuite('test_1', 'test_3')),
|
||||
(_mk_TestSuite('test_1'), _mk_TestSuite('test_2'))]
|
||||
|
||||
################################################################
|
||||
### /Set up attributes needed by inherited tests
|
||||
|
||||
### Tests for TestSuite.__init__
|
||||
################################################################
|
||||
|
||||
# "class TestSuite([tests])"
|
||||
#
|
||||
# The tests iterable should be optional
|
||||
def test_init__tests_optional(self):
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
self.assertEqual(suite.countTestCases(), 0)
|
||||
|
||||
# "class TestSuite([tests])"
|
||||
# ...
|
||||
# "If tests is given, it must be an iterable of individual test cases
|
||||
# or other test suites that will be used to build the suite initially"
|
||||
#
|
||||
# TestSuite should deal with empty tests iterables by allowing the
|
||||
# creation of an empty suite
|
||||
def test_init__empty_tests(self):
|
||||
suite = unittest.TestSuite([])
|
||||
|
||||
self.assertEqual(suite.countTestCases(), 0)
|
||||
|
||||
# "class TestSuite([tests])"
|
||||
# ...
|
||||
# "If tests is given, it must be an iterable of individual test cases
|
||||
# or other test suites that will be used to build the suite initially"
|
||||
#
|
||||
# TestSuite should allow any iterable to provide tests
|
||||
def test_init__tests_from_any_iterable(self):
|
||||
def tests():
|
||||
yield unittest.FunctionTestCase(lambda: None)
|
||||
yield unittest.FunctionTestCase(lambda: None)
|
||||
|
||||
suite_1 = unittest.TestSuite(tests())
|
||||
self.assertEqual(suite_1.countTestCases(), 2)
|
||||
|
||||
suite_2 = unittest.TestSuite(suite_1)
|
||||
self.assertEqual(suite_2.countTestCases(), 2)
|
||||
|
||||
suite_3 = unittest.TestSuite(set(suite_1))
|
||||
self.assertEqual(suite_3.countTestCases(), 2)
|
||||
|
||||
# "class TestSuite([tests])"
|
||||
# ...
|
||||
# "If tests is given, it must be an iterable of individual test cases
|
||||
# or other test suites that will be used to build the suite initially"
|
||||
#
|
||||
# Does TestSuite() also allow other TestSuite() instances to be present
|
||||
# in the tests iterable?
|
||||
def test_init__TestSuite_instances_in_tests(self):
|
||||
def tests():
|
||||
ftc = unittest.FunctionTestCase(lambda: None)
|
||||
yield unittest.TestSuite([ftc])
|
||||
yield unittest.FunctionTestCase(lambda: None)
|
||||
|
||||
suite = unittest.TestSuite(tests())
|
||||
self.assertEqual(suite.countTestCases(), 2)
|
||||
|
||||
################################################################
|
||||
### /Tests for TestSuite.__init__
|
||||
|
||||
# Container types should support the iter protocol
|
||||
def test_iter(self):
|
||||
test1 = unittest.FunctionTestCase(lambda: None)
|
||||
test2 = unittest.FunctionTestCase(lambda: None)
|
||||
suite = unittest.TestSuite((test1, test2))
|
||||
|
||||
self.assertEqual(list(suite), [test1, test2])
|
||||
|
||||
# "Return the number of tests represented by the this test object.
|
||||
# ...this method is also implemented by the TestSuite class, which can
|
||||
# return larger [greater than 1] values"
|
||||
#
|
||||
# Presumably an empty TestSuite returns 0?
|
||||
def test_countTestCases_zero_simple(self):
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
self.assertEqual(suite.countTestCases(), 0)
|
||||
|
||||
# "Return the number of tests represented by the this test object.
|
||||
# ...this method is also implemented by the TestSuite class, which can
|
||||
# return larger [greater than 1] values"
|
||||
#
|
||||
# Presumably an empty TestSuite (even if it contains other empty
|
||||
# TestSuite instances) returns 0?
|
||||
def test_countTestCases_zero_nested(self):
|
||||
class Test1(unittest.TestCase):
|
||||
def test(self):
|
||||
pass
|
||||
|
||||
suite = unittest.TestSuite([unittest.TestSuite()])
|
||||
|
||||
self.assertEqual(suite.countTestCases(), 0)
|
||||
|
||||
# "Return the number of tests represented by the this test object.
|
||||
# ...this method is also implemented by the TestSuite class, which can
|
||||
# return larger [greater than 1] values"
|
||||
def test_countTestCases_simple(self):
|
||||
test1 = unittest.FunctionTestCase(lambda: None)
|
||||
test2 = unittest.FunctionTestCase(lambda: None)
|
||||
suite = unittest.TestSuite((test1, test2))
|
||||
|
||||
self.assertEqual(suite.countTestCases(), 2)
|
||||
|
||||
# "Return the number of tests represented by the this test object.
|
||||
# ...this method is also implemented by the TestSuite class, which can
|
||||
# return larger [greater than 1] values"
|
||||
#
|
||||
# Make sure this holds for nested TestSuite instances, too
|
||||
def test_countTestCases_nested(self):
|
||||
class Test1(unittest.TestCase):
|
||||
def test1(self): pass
|
||||
def test2(self): pass
|
||||
|
||||
test2 = unittest.FunctionTestCase(lambda: None)
|
||||
test3 = unittest.FunctionTestCase(lambda: None)
|
||||
child = unittest.TestSuite((Test1('test2'), test2))
|
||||
parent = unittest.TestSuite((test3, child, Test1('test1')))
|
||||
|
||||
self.assertEqual(parent.countTestCases(), 4)
|
||||
|
||||
# "Run the tests associated with this suite, collecting the result into
|
||||
# the test result object passed as result."
|
||||
#
|
||||
# And if there are no tests? What then?
|
||||
def test_run__empty_suite(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
suite.run(result)
|
||||
|
||||
self.assertEqual(events, [])
|
||||
|
||||
# "Note that unlike TestCase.run(), TestSuite.run() requires the
|
||||
# "result object to be passed in."
|
||||
def test_run__requires_result(self):
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
try:
|
||||
suite.run()
|
||||
except TypeError:
|
||||
pass
|
||||
else:
|
||||
self.fail("Failed to raise TypeError")
|
||||
|
||||
# "Run the tests associated with this suite, collecting the result into
|
||||
# the test result object passed as result."
|
||||
def test_run(self):
|
||||
events = []
|
||||
result = LoggingResult(events)
|
||||
|
||||
class LoggingCase(unittest.TestCase):
|
||||
def run(self, result):
|
||||
events.append('run %s' % self._testMethodName)
|
||||
|
||||
def test1(self): pass
|
||||
def test2(self): pass
|
||||
|
||||
tests = [LoggingCase('test1'), LoggingCase('test2')]
|
||||
|
||||
unittest.TestSuite(tests).run(result)
|
||||
|
||||
self.assertEqual(events, ['run test1', 'run test2'])
|
||||
|
||||
# "Add a TestCase ... to the suite"
|
||||
def test_addTest__TestCase(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test(self): pass
|
||||
|
||||
test = Foo('test')
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
suite.addTest(test)
|
||||
|
||||
self.assertEqual(suite.countTestCases(), 1)
|
||||
self.assertEqual(list(suite), [test])
|
||||
|
||||
# "Add a ... TestSuite to the suite"
|
||||
def test_addTest__TestSuite(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test(self): pass
|
||||
|
||||
suite_2 = unittest.TestSuite([Foo('test')])
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(suite_2)
|
||||
|
||||
self.assertEqual(suite.countTestCases(), 1)
|
||||
self.assertEqual(list(suite), [suite_2])
|
||||
|
||||
# "Add all the tests from an iterable of TestCase and TestSuite
|
||||
# instances to this test suite."
|
||||
#
|
||||
# "This is equivalent to iterating over tests, calling addTest() for
|
||||
# each element"
|
||||
def test_addTests(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def test_1(self): pass
|
||||
def test_2(self): pass
|
||||
|
||||
test_1 = Foo('test_1')
|
||||
test_2 = Foo('test_2')
|
||||
inner_suite = unittest.TestSuite([test_2])
|
||||
|
||||
def gen():
|
||||
yield test_1
|
||||
yield test_2
|
||||
yield inner_suite
|
||||
|
||||
suite_1 = unittest.TestSuite()
|
||||
suite_1.addTests(gen())
|
||||
|
||||
self.assertEqual(list(suite_1), list(gen()))
|
||||
|
||||
# "This is equivalent to iterating over tests, calling addTest() for
|
||||
# each element"
|
||||
suite_2 = unittest.TestSuite()
|
||||
for t in gen():
|
||||
suite_2.addTest(t)
|
||||
|
||||
self.assertEqual(suite_1, suite_2)
|
||||
|
||||
# "Add all the tests from an iterable of TestCase and TestSuite
|
||||
# instances to this test suite."
|
||||
#
|
||||
# What happens if it doesn't get an iterable?
|
||||
def test_addTest__noniterable(self):
|
||||
suite = unittest.TestSuite()
|
||||
|
||||
try:
|
||||
suite.addTests(5)
|
||||
except TypeError:
|
||||
pass
|
||||
else:
|
||||
self.fail("Failed to raise TypeError")
|
||||
|
||||
def test_addTest__noncallable(self):
|
||||
suite = unittest.TestSuite()
|
||||
self.assertRaises(TypeError, suite.addTest, 5)
|
||||
|
||||
def test_addTest__casesuiteclass(self):
|
||||
suite = unittest.TestSuite()
|
||||
self.assertRaises(TypeError, suite.addTest, Test_TestSuite)
|
||||
self.assertRaises(TypeError, suite.addTest, unittest.TestSuite)
|
||||
|
||||
def test_addTests__string(self):
|
||||
suite = unittest.TestSuite()
|
||||
self.assertRaises(TypeError, suite.addTests, "foo")
|
||||
|
||||
def test_function_in_suite(self):
|
||||
def f(_):
|
||||
pass
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(f)
|
||||
|
||||
# when the bug is fixed this line will not crash
|
||||
suite.run(unittest.TestResult())
|
||||
|
||||
|
||||
|
||||
def test_basetestsuite(self):
|
||||
class Test(unittest.TestCase):
|
||||
wasSetUp = False
|
||||
wasTornDown = False
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.wasSetUp = True
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.wasTornDown = True
|
||||
def testPass(self):
|
||||
pass
|
||||
def testFail(self):
|
||||
fail
|
||||
class Module(object):
|
||||
wasSetUp = False
|
||||
wasTornDown = False
|
||||
@staticmethod
|
||||
def setUpModule():
|
||||
Module.wasSetUp = True
|
||||
@staticmethod
|
||||
def tearDownModule():
|
||||
Module.wasTornDown = True
|
||||
|
||||
Test.__module__ = 'Module'
|
||||
sys.modules['Module'] = Module
|
||||
self.addCleanup(sys.modules.pop, 'Module')
|
||||
|
||||
suite = unittest.BaseTestSuite()
|
||||
suite.addTests([Test('testPass'), Test('testFail')])
|
||||
self.assertEqual(suite.countTestCases(), 2)
|
||||
|
||||
result = unittest.TestResult()
|
||||
suite.run(result)
|
||||
self.assertFalse(Module.wasSetUp)
|
||||
self.assertFalse(Module.wasTornDown)
|
||||
self.assertFalse(Test.wasSetUp)
|
||||
self.assertFalse(Test.wasTornDown)
|
||||
self.assertEqual(len(result.errors), 1)
|
||||
self.assertEqual(len(result.failures), 0)
|
||||
self.assertEqual(result.testsRun, 2)
|
||||
|
||||
|
||||
def test_overriding_call(self):
|
||||
class MySuite(unittest.TestSuite):
|
||||
called = False
|
||||
def __call__(self, *args, **kw):
|
||||
self.called = True
|
||||
unittest.TestSuite.__call__(self, *args, **kw)
|
||||
|
||||
suite = MySuite()
|
||||
result = unittest.TestResult()
|
||||
wrapper = unittest.TestSuite()
|
||||
wrapper.addTest(suite)
|
||||
wrapper(result)
|
||||
self.assertTrue(suite.called)
|
||||
|
||||
# reusing results should be permitted even if abominable
|
||||
self.assertFalse(result._testRunEntered)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user