Python单元测试unittest加载方式之二：加载测试套件

在运用测试套件进行单元测试之前，还是稍微研究一下unittest模块的内容有哪些，其大概的运行方式是什么样的。而后在给出根据各种情况如何制定单元测试套件。

一、查看unittest模块有哪些成员

>>> import unittest
>>> dir(unittest)
['BaseTestSuite', 'FunctionTestCase', 'SkipTest', 'TestCase', 'TestLoader', 'TestProgram', 'TestResult', 'TestSuite', 'TextTestResult', 'TextTestRunner', '_TextTestResult', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__', '__unittest', 'case', 'defaultTestLoader', 'expectedFailure', 'findTestCases', 'getTestCaseNames', 'installHandler', 'loader', 'main', 'makeSuite', 'registerResult', 'removeHandler', 'removeResult', 'result', 'runner', 'signals', 'skip', 'skipIf', 'skipUnless', 'suite', 'util']

在IDLE中查看如下图：

可以看到其自身的成员也不是很多，大概包括有：
['FunctionTestCase', 'TestCase', 'TestLoader', 'TestProgram', 'TestResult',
 'TestSuite','TextTestRunner', '_CmpToKey', '_TextTestResult', '_WritelnDecorator',
 'defaultTestLoader','findTestCases', 'getTestCaseNames', 'main', 'makeSuite']

我们来看看他们到底是干什么的？

>>> import unittest
>>> memblist = ['FunctionTestCase', 'TestCase', 'TestLoader', 'TestProgram', 'TestResult',\
 'TestSuite','TextTestRunner', 'defaultTestLoader','findTestCases', 'getTestCaseNames', \
 'main', 'makeSuite']
>>> for memb in memblist:
	cur = getattr(unittest, memb)
	print help(cur)

IDLE中返回的结果为： 待插入

 'FunctionTestCase':函数测试用例，即给一个函数作为参数，返回一个testcase实例，可选参数有set-up，tear-down方法
 'TestCase'：所有测试用例的基本类，给一个测试方法的名字，返回一个测试用例实例
 'TestLoader'：测试用例加载器，其包括多个加载测试用例的方法。返回一个测试套件
 loadTestsFromModule(self, module)--根据给定的模块实例来获取测试用例套件
 loadTestsFromName(self, name, module=None)
 --根据给定的字符串来获取测试用例套件，字符串可以是模块名，测试类名，测试类中的测试方法名，或者一个可调用的是实例对象
 这个实例对象返回一个测试用例或一个测试套件
 loadTestsFromNames(self, names, module=None) --和上面功能相同，只不过接受的是字符串列表
 loadTestsFromTestCase(self, testCaseClass)--根据给定的测试类，获取其中的所有测试方法，并返回一个测试套件
'TestProgram'：命令行进行单元测试的调用方法，作用是执行一个测试用例。其实unittest.main()方法执行的就是这个命令，
而这个类实例时默认加载当前执行的作为测试对象，
原型为 __init__(self, module='__main__', defaultTest=None, argv=None, testRunner=xx, testLoader=xx)
其中module='__main__'就是默认加载自身
'TestResult'：测试用例的结果保存实例，通常有测试框架调用
 'TestSuite'：组织测试用例的实例，支持测试用例的添加和删除，最终将传递给testRunner进行测试执行
 'TextTestRunner'：进行测试用例执行的实例，其中Text的意思是以文本形式显示测试结果。显示测试名称，即完成的测试结果，其过同执行单元测试脚本时添加-v参数
 'defaultTestLoader':其实就是TestLoader
 'findTestCases', 'getTestCaseNames'：这个2个就不用解释了
 'main': 其实就是TestProgram
 'makeSuite'：通常是由单元测试框架调用的，用于生产testsuite对象的实例

IDLE中返回的结果为：

Help on class FunctionTestCase in module unittest.case:

class FunctionTestCase(TestCase)
 |  A test case that wraps a test function.
 |  
 |  This is useful for slipping pre-existing test functions into the
 |  unittest framework. Optionally, set-up and tidy-up functions can be
 |  supplied. As with TestCase, the tidy-up ('tearDown') function will
 |  always be called if the set-up ('setUp') function ran successfully.
 |  
 |  Method resolution order:
 |      FunctionTestCase
 |      TestCase
 |      __builtin__.object
 |  
 |  Methods defined here:
 |  
 |  __eq__(self, other)
 |  
 |  __hash__(self)
 |  
 |  __init__(self, testFunc, setUp=None, tearDown=None, description=None)
 |  
 |  __ne__(self, other)
 |  
 |  __repr__(self)
 |  
 |  __str__(self)
 |  
 |  id(self)
 |  
 |  runTest(self)
 |  
 |  setUp(self)
 |  
 |  shortDescription(self)
 |  
 |  tearDown(self)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from TestCase:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  addCleanup(self, function, *args, **kwargs)
 |      Add a function, with arguments, to be called when the test is
 |      completed. Functions added are called on a LIFO basis and are
 |      called after tearDown on test failure or success.
 |      
 |      Cleanup items are called even if setUp fails (unlike tearDown).
 |  
 |  addTypeEqualityFunc(self, typeobj, function)
 |      Add a type specific assertEqual style function to compare a type.
 |      
 |      This method is for use by TestCase subclasses that need to register
 |      their own type equality functions to provide nicer error messages.
 |      
 |      Args:
 |          typeobj: The data type to call this function on when both values
 |                  are of the same type in assertEqual().
 |          function: The callable taking two arguments and an optional
 |                  msg= argument that raises self.failureException with a
 |                  useful error message when the two arguments are not equal.
 |  
 |  assertAlmostEqual(self, first, second, places=None, msg=None, delta=None)
 |      Fail if the two objects are unequal as determined by their
 |      difference rounded to the given number of decimal places
 |      (default 7) and comparing to zero, or by comparing that the
 |      between the two objects is more than the given delta.
 |      
 |      Note that decimal places (from zero) are usually not the same
 |      as significant digits (measured from the most signficant digit).
 |      
 |      If the two objects compare equal then they will automatically
 |      compare almost equal.
 |  
 |  assertAlmostEquals = assertAlmostEqual(self, first, second, places=None, msg=None, delta=None)
 |      Fail if the two objects are unequal as determined by their
 |      difference rounded to the given number of decimal places
 |      (default 7) and comparing to zero, or by comparing that the
 |      between the two objects is more than the given delta.
 |      
 |      Note that decimal places (from zero) are usually not the same
 |      as significant digits (measured from the most signficant digit).
 |      
 |      If the two objects compare equal then they will automatically
 |      compare almost equal.
 |  
 |  assertDictContainsSubset(self, expected, actual, msg=None)
 |      Checks whether actual is a superset of expected.
 |  
 |  assertDictEqual(self, d1, d2, msg=None)
 |  
 |  assertEqual(self, first, second, msg=None)
 |      Fail if the two objects are unequal as determined by the '=='
 |      operator.
 |  
 |  assertEquals = assertEqual(self, first, second, msg=None)
 |      Fail if the two objects are unequal as determined by the '=='
 |      operator.
 |  
 |  assertFalse(self, expr, msg=None)
 |      Check that the expression is false.
 |  
 |  assertGreater(self, a, b, msg=None)
 |      Just like self.assertTrue(a > b), but with a nicer default message.
 |  
 |  assertGreaterEqual(self, a, b, msg=None)
 |      Just like self.assertTrue(a >= b), but with a nicer default message.
 |  
 |  assertIn(self, member, container, msg=None)
 |      Just like self.assertTrue(a in b), but with a nicer default message.
 |  
 |  assertIs(self, expr1, expr2, msg=None)
 |      Just like self.assertTrue(a is b), but with a nicer default message.
 |  
 |  assertIsInstance(self, obj, cls, msg=None)
 |      Same as self.assertTrue(isinstance(obj, cls)), with a nicer
 |      default message.
 |  
 |  assertIsNone(self, obj, msg=None)
 |      Same as self.assertTrue(obj is None), with a nicer default message.
 |  
 |  assertIsNot(self, expr1, expr2, msg=None)
 |      Just like self.assertTrue(a is not b), but with a nicer default message.
 |  
 |  assertIsNotNone(self, obj, msg=None)
 |      Included for symmetry with assertIsNone.
 |  
 |  assertItemsEqual(self, expected_seq, actual_seq, msg=None)
 |      An unordered sequence specific comparison. It asserts that
 |      actual_seq and expected_seq have the same element counts.
 |      Equivalent to::
 |      
 |          self.assertEqual(Counter(iter(actual_seq)),
 |                           Counter(iter(expected_seq)))
 |      
 |      Asserts that each element has the same count in both sequences.
 |      Example:
 |          - [0, 1, 1] and [1, 0, 1] compare equal.
 |          - [0, 0, 1] and [0, 1] compare unequal.
 |  
 |  assertLess(self, a, b, msg=None)
 |      Just like self.assertTrue(a < b), but with a nicer default message.
 |  
 |  assertLessEqual(self, a, b, msg=None)
 |      Just like self.assertTrue(a <= b), but with a nicer default message.
 |  
 |  assertListEqual(self, list1, list2, msg=None)
 |      A list-specific equality assertion.
 |      
 |      Args:
 |          list1: The first list to compare.
 |          list2: The second list to compare.
 |          msg: Optional message to use on failure instead of a list of
 |                  differences.
 |  
 |  assertMultiLineEqual(self, first, second, msg=None)
 |      Assert that two multi-line strings are equal.
 |  
 |  assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None)
 |      Fail if the two objects are equal as determined by their
 |      difference rounded to the given number of decimal places
 |      (default 7) and comparing to zero, or by comparing that the
 |      between the two objects is less than the given delta.
 |      
 |      Note that decimal places (from zero) are usually not the same
 |      as significant digits (measured from the most signficant digit).
 |      
 |      Objects that are equal automatically fail.
 |  
 |  assertNotAlmostEquals = assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None)
 |      Fail if the two objects are equal as determined by their
 |      difference rounded to the given number of decimal places
 |      (default 7) and comparing to zero, or by comparing that the
 |      between the two objects is less than the given delta.
 |      
 |      Note that decimal places (from zero) are usually not the same
 |      as significant digits (measured from the most signficant digit).
 |      
 |      Objects that are equal automatically fail.
 |  
 |  assertNotEqual(self, first, second, msg=None)
 |      Fail if the two objects are equal as determined by the '!='
 |      operator.
 |  
 |  assertNotEquals = assertNotEqual(self, first, second, msg=None)
 |      Fail if the two objects are equal as determined by the '!='
 |      operator.
 |  
 |  assertNotIn(self, member, container, msg=None)
 |      Just like self.assertTrue(a not in b), but with a nicer default message.
 |  
 |  assertNotIsInstance(self, obj, cls, msg=None)
 |      Included for symmetry with assertIsInstance.
 |  
 |  assertNotRegexpMatches(self, text, unexpected_regexp, msg=None)
 |      Fail the test if the text matches the regular expression.
 |  
 |  assertRaises(self, excClass, callableObj=None, *args, **kwargs)
 |      Fail unless an exception of class excClass is raised
 |      by callableObj when invoked with arguments args and keyword
 |      arguments kwargs. If a different type of exception is
 |      raised, it will not be caught, and the test case will be
 |      deemed to have suffered an error, exactly as for an
 |      unexpected exception.
 |      
 |      If called with callableObj omitted or None, will return a
 |      context object used like this::
 |      
 |           with self.assertRaises(SomeException):
 |               do_something()
 |      
 |      The context manager keeps a reference to the exception as
 |      the 'exception' attribute. This allows you to inspect the
 |      exception after the assertion::
 |      
 |          with self.assertRaises(SomeException) as cm:
 |              do_something()
 |          the_exception = cm.exception
 |          self.assertEqual(the_exception.error_code, 3)
 |  
 |  assertRaisesRegexp(self, expected_exception, expected_regexp, callable_obj=None, *args, **kwargs)
 |      Asserts that the message in a raised exception matches a regexp.
 |      
 |      Args:
 |          expected_exception: Exception class expected to be raised.
 |          expected_regexp: Regexp (re pattern object or string) expected
 |                  to be found in error message.
 |          callable_obj: Function to be called.
 |          args: Extra args.
 |          kwargs: Extra kwargs.
 |  
 |  assertRegexpMatches(self, text, expected_regexp, msg=None)
 |      Fail the test unless the text matches the regular expression.
 |  
 |  assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None)
 |      An equality assertion for ordered sequences (like lists and tuples).
 |      
 |      For the purposes of this function, a valid ordered sequence type is one
 |      which can be indexed, has a length, and has an equality operator.
 |      
 |      Args:
 |          seq1: The first sequence to compare.
 |          seq2: The second sequence to compare.
 |          seq_type: The expected datatype of the sequences, or None if no
 |                  datatype should be enforced.
 |          msg: Optional message to use on failure instead of a list of
 |                  differences.
 |  
 |  assertSetEqual(self, set1, set2, msg=None)
 |      A set-specific equality assertion.
 |      
 |      Args:
 |          set1: The first set to compare.
 |          set2: The second set to compare.
 |          msg: Optional message to use on failure instead of a list of
 |                  differences.
 |      
 |      assertSetEqual uses ducktyping to support different types of sets, and
 |      is optimized for sets specifically (parameters must support a
 |      difference method).
 |  
 |  assertTrue(self, expr, msg=None)
 |      Check that the expression is true.
 |  
 |  assertTupleEqual(self, tuple1, tuple2, msg=None)
 |      A tuple-specific equality assertion.
 |      
 |      Args:
 |          tuple1: The first tuple to compare.
 |          tuple2: The second tuple to compare.
 |          msg: Optional message to use on failure instead of a list of
 |                  differences.
 |  
 |  assert_ = assertTrue(self, expr, msg=None)
 |      Check that the expression is true.
 |  
 |  countTestCases(self)
 |  
 |  debug(self)
 |      Run the test without collecting errors in a TestResult
 |  
 |  defaultTestResult(self)
 |  
 |  doCleanups(self)
 |      Execute all cleanup functions. Normally called for you after
 |      tearDown.
 |  
 |  fail(self, msg=None)
 |      Fail immediately, with the given message.
 |  
 |  failIf = deprecated_func(*args, **kwargs)
 |  
 |  failIfAlmostEqual = deprecated_func(*args, **kwargs)
 |  
 |  failIfEqual = deprecated_func(*args, **kwargs)
 |  
 |  failUnless = deprecated_func(*args, **kwargs)
 |  
 |  failUnlessAlmostEqual = deprecated_func(*args, **kwargs)
 |  
 |  failUnlessEqual = deprecated_func(*args, **kwargs)
 |  
 |  failUnlessRaises = deprecated_func(*args, **kwargs)
 |  
 |  run(self, result=None)
 |  
 |  skipTest(self, reason)
 |      Skip this test.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods inherited from TestCase:
 |  
 |  setUpClass(cls) from __builtin__.type
 |      Hook method for setting up class fixture before running tests in the class.
 |  
 |  tearDownClass(cls) from __builtin__.type
 |      Hook method for deconstructing the class fixture after running all tests in the class.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from TestCase:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from TestCase:
 |  
 |  failureException = <type 'exceptions.AssertionError'>
 |      Assertion failed.
 |  
 |  longMessage = False
 |  
 |  maxDiff = 640

None
Help on class TestCase in module unittest.case:

class TestCase(__builtin__.object)
 |  A class whose instances are single test cases.
 |  
 |  By default, the test code itself should be placed in a method named
 |  'runTest'.
 |  
 |  If the fixture may be used for many test cases, create as
 |  many test methods as are needed. When instantiating such a TestCase
 |  subclass, specify in the constructor arguments the name of the test method
 |  that the instance is to execute.
 |  
 |  Test authors should subclass TestCase for their own tests. Construction
 |  and deconstruction of the test's environment ('fixture') can be
 |  implemented by overriding the 'setUp' and 'tearDown' methods respectively.
 |  
 |  If it is necessary to override the __init__ method, the base class
 |  __init__ method must always be called. It is important that subclasses
 |  should not change the signature of their __init__ method, since instances
 |  of the classes are instantiated automatically by parts of the framework
 |  in order to be run.
 |  
 |  When subclassing TestCase, you can set these attributes:
 |  * failureException: determines which exception will be raised when
 |      the instance's assertion methods fail; test methods raising this
 |      exception will be deemed to have 'failed' rather than 'errored'.
 |  * longMessage: determines whether long messages (including repr of
 |      objects used in assert methods) will be printed on failure in *addition*
 |      to any explicit message passed.
 |  * maxDiff: sets the maximum length of a diff in failure messages
 |      by assert methods using difflib. It is looked up as an instance
 |      attribute so can be configured by individual tests if required.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __eq__(self, other)
 |  
 |  __hash__(self)
 |  
 |  __init__(self, methodName='runTest')
 |      Create an instance of the class that will use the named test
 |      method when executed. Raises a ValueError if the instance does
 |      not have a method with the specified name.
 |  
 |  __ne__(self, other)
 |  
 |  __repr__(self)
 |  
 |  __str__(self)
 |  
 |  addCleanup(self, function, *args, **kwargs)
 |      Add a function, with arguments, to be called when the test is
 |      completed. Functions added are called on a LIFO basis and are
 |      called after tearDown on test failure or success.
 |      
 |      Cleanup items are called even if setUp fails (unlike tearDown).
 |  
 |  addTypeEqualityFunc(self, typeobj, function)
 |      Add a type specific assertEqual style function to compare a type.
 |      
 |      This method is for use by TestCase subclasses that need to register
 |      their own type equality functions to provide nicer error messages.
 |      
 |      Args:
 |          typeobj: The data type to call this function on when both values
 |                  are of the same type in assertEqual().
 |          function: The callable taking two arguments and an optional
 |                  msg= argument that raises self.failureException with a
 |                  useful error message when the two arguments are not equal.
 |  
 |  assertAlmostEqual(self, first, second, places=None, msg=None, delta=None)
 |      Fail if the two objects are unequal as determined by their
 |      difference rounded to the given number of decimal places
 |      (default 7) and comparing to zero, or by comparing that the
 |      between the two objects is more than the given delta.
 |      
 |      Note that decimal places (from zero) are usually not the same
 |      as significant digits (measured from the most signficant digit).
 |      
 |      If the two objects compare equal then they will automatically
 |      compare almost equal.
 |  
 |  assertAlmostEquals = assertAlmostEqual(self, first, second, places=None, msg=None, delta=None)
 |  
 |  assertDictContainsSubset(self, expected, actual, msg=None)
 |      Checks whether actual is a superset of expected.
 |  
 |  assertDictEqual(self, d1, d2, msg=None)
 |  
 |  assertEqual(self, first, second, msg=None)
 |      Fail if the two objects are unequal as determined by the '=='
 |      operator.
 |  
 |  assertEquals = assertEqual(self, first, second, msg=None)
 |  
 |  assertFalse(self, expr, msg=None)
 |      Check that the expression is false.
 |  
 |  assertGreater(self, a, b, msg=None)
 |      Just like self.assertTrue(a > b), but with a nicer default message.
 |  
 |  assertGreaterEqual(self, a, b, msg=None)
 |      Just like self.assertTrue(a >= b), but with a nicer default message.
 |  
 |  assertIn(self, member, container, msg=None)
 |      Just like self.assertTrue(a in b), but with a nicer default message.
 |  
 |  assertIs(self, expr1, expr2, msg=None)
 |      Just like self.assertTrue(a is b), but with a nicer default message.
 |  
 |  assertIsInstance(self, obj, cls, msg=None)
 |      Same as self.assertTrue(isinstance(obj, cls)), with a nicer
 |      default message.
 |  
 |  assertIsNone(self, obj, msg=None)
 |      Same as self.assertTrue(obj is None), with a nicer default message.
 |  
 |  assertIsNot(self, expr1, expr2, msg=None)
 |      Just like self.assertTrue(a is not b), but with a nicer default message.
 |  
 |  assertIsNotNone(self, obj, msg=None)
 |      Included for symmetry with assertIsNone.
 |  
 |  assertItemsEqual(self, expected_seq, actual_seq, msg=None)
 |      An unordered sequence specific comparison. It asserts that
 |      actual_seq and expected_seq have the same element counts.
 |      Equivalent to::
 |      
 |          self.assertEqual(Counter(iter(actual_seq)),
 |                           Counter(iter(expected_seq)))
 |      
 |      Asserts that each element has the same count in both sequences.
 |      Example:
 |          - [0, 1, 1] and [1, 0, 1] compare equal.
 |          - [0, 0, 1] and [0, 1] compare unequal.
 |  
 |  assertLess(self, a, b, msg=None)
 |      Just like self.assertTrue(a < b), but with a nicer default message.
 |  
 |  assertLessEqual(self, a, b, msg=None)
 |      Just like self.assertTrue(a <= b), but with a nicer default message.
 |  
 |  assertListEqual(self, list1, list2, msg=None)
 |      A list-specific equality assertion.
 |      
 |      Args:
 |          list1: The first list to compare.
 |          list2: The second list to compare.
 |          msg: Optional message to use on failure instead of a list of
 |                  differences.
 |  
 |  assertMultiLineEqual(self, first, second, msg=None)
 |      Assert that two multi-line strings are equal.
 |  
 |  assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None)
 |      Fail if the two objects are equal as determined by their
 |      difference rounded to the given number of decimal places
 |      (default 7) and comparing to zero, or by comparing that the
 |      between the two objects is less than the given delta.
 |      
 |      Note that decimal places (from zero) are usually not the same
 |      as significant digits (measured from the most signficant digit).
 |      
 |      Objects that are equal automatically fail.
 |  
 |  assertNotAlmostEquals = assertNotAlmostEqual(self, first, second, places=None, msg=None, delta=None)
 |  
 |  assertNotEqual(self, first, second, msg=None)
 |      Fail if the two objects are equal as determined by the '!='
 |      operator.
 |  
 |  assertNotEquals = assertNotEqual(self, first, second, msg=None)
 |  
 |  assertNotIn(self, member, container, msg=None)
 |      Just like self.assertTrue(a not in b), but with a nicer default message.
 |  
 |  assertNotIsInstance(self, obj, cls, msg=None)
 |      Included for symmetry with assertIsInstance.
 |  
 |  assertNotRegexpMatches(self, text, unexpected_regexp, msg=None)
 |      Fail the test if the text matches the regular expression.
 |  
 |  assertRaises(self, excClass, callableObj=None, *args, **kwargs)
 |      Fail unless an exception of class excClass is raised
 |      by callableObj when invoked with arguments args and keyword
 |      arguments kwargs. If a different type of exception is
 |      raised, it will not be caught, and the test case will be
 |      deemed to have suffered an error, exactly as for an
 |      unexpected exception.
 |      
 |      If called with callableObj omitted or None, will return a
 |      context object used like this::
 |      
 |           with self.assertRaises(SomeException):
 |               do_something()
 |      
 |      The context manager keeps a reference to the exception as
 |      the 'exception' attribute. This allows you to inspect the
 |      exception after the assertion::
 |      
 |          with self.assertRaises(SomeException) as cm:
 |              do_something()
 |          the_exception = cm.exception
 |          self.assertEqual(the_exception.error_code, 3)
 |  
 |  assertRaisesRegexp(self, expected_exception, expected_regexp, callable_obj=None, *args, **kwargs)
 |      Asserts that the message in a raised exception matches a regexp.
 |      
 |      Args:
 |          expected_exception: Exception class expected to be raised.
 |          expected_regexp: Regexp (re pattern object or string) expected
 |                  to be found in error message.
 |          callable_obj: Function to be called.
 |          args: Extra args.
 |          kwargs: Extra kwargs.
 |  
 |  assertRegexpMatches(self, text, expected_regexp, msg=None)
 |      Fail the test unless the text matches the regular expression.
 |  
 |  assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None)
 |      An equality assertion for ordered sequences (like lists and tuples).
 |      
 |      For the purposes of this function, a valid ordered sequence type is one
 |      which can be indexed, has a length, and has an equality operator.
 |      
 |      Args:
 |          seq1: The first sequence to compare.
 |          seq2: The second sequence to compare.
 |          seq_type: The expected datatype of the sequences, or None if no
 |                  datatype should be enforced.
 |          msg: Optional message to use on failure instead of a list of
 |                  differences.
 |  
 |  assertSetEqual(self, set1, set2, msg=None)
 |      A set-specific equality assertion.
 |      
 |      Args:
 |          set1: The first set to compare.
 |          set2: The second set to compare.
 |          msg: Optional message to use on failure instead of a list of
 |                  differences.
 |      
 |      assertSetEqual uses ducktyping to support different types of sets, and
 |      is optimized for sets specifically (parameters must support a
 |      difference method).
 |  
 |  assertTrue(self, expr, msg=None)
 |      Check that the expression is true.
 |  
 |  assertTupleEqual(self, tuple1, tuple2, msg=None)
 |      A tuple-specific equality assertion.
 |      
 |      Args:
 |          tuple1: The first tuple to compare.
 |          tuple2: The second tuple to compare.
 |          msg: Optional message to use on failure instead of a list of
 |                  differences.
 |  
 |  assert_ = assertTrue(self, expr, msg=None)
 |  
 |  countTestCases(self)
 |  
 |  debug(self)
 |      Run the test without collecting errors in a TestResult
 |  
 |  defaultTestResult(self)
 |  
 |  doCleanups(self)
 |      Execute all cleanup functions. Normally called for you after
 |      tearDown.
 |  
 |  fail(self, msg=None)
 |      Fail immediately, with the given message.
 |  
 |  failIf = deprecated_func(*args, **kwargs)
 |  
 |  failIfAlmostEqual = deprecated_func(*args, **kwargs)
 |  
 |  failIfEqual = deprecated_func(*args, **kwargs)
 |  
 |  failUnless = deprecated_func(*args, **kwargs)
 |  
 |  failUnlessAlmostEqual = deprecated_func(*args, **kwargs)
 |  
 |  failUnlessEqual = deprecated_func(*args, **kwargs)
 |  
 |  failUnlessRaises = deprecated_func(*args, **kwargs)
 |  
 |  id(self)
 |  
 |  run(self, result=None)
 |  
 |  setUp(self)
 |      Hook method for setting up the test fixture before exercising it.
 |  
 |  shortDescription(self)
 |      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 specified test method's docstring.
 |  
 |  skipTest(self, reason)
 |      Skip this test.
 |  
 |  tearDown(self)
 |      Hook method for deconstructing the test fixture after testing it.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  setUpClass(cls) from __builtin__.type
 |      Hook method for setting up class fixture before running tests in the class.
 |  
 |  tearDownClass(cls) from __builtin__.type
 |      Hook method for deconstructing the class fixture after running all tests in the class.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  failureException = <type 'exceptions.AssertionError'>
 |      Assertion failed.
 |  
 |  longMessage = False
 |  
 |  maxDiff = 640

None
Help on class TestLoader in module unittest.loader:

class TestLoader(__builtin__.object)
 |  This class is responsible for loading tests according to various criteria
 |  and returning them wrapped in a TestSuite
 |  
 |  Methods defined here:
 |  
 |  discover(self, start_dir, pattern='test*.py', top_level_dir=None)
 |      Find and return all test modules from the specified start
 |      directory, recursing into subdirectories to find them. Only test files
 |      that match the pattern will be loaded. (Using shell style pattern
 |      matching.)
 |      
 |      All test modules must be importable from the top level of the project.
 |      If the start directory is not the top level directory then the top
 |      level directory must be specified separately.
 |      
 |      If a test package name (directory with '__init__.py') matches the
 |      pattern then the package will be checked for a 'load_tests' function. If
 |      this exists then it will be called with loader, tests, pattern.
 |      
 |      If load_tests exists then discovery does  *not* recurse into the package,
 |      load_tests is responsible for loading all tests in the package.
 |      
 |      The pattern is deliberately not stored as a loader attribute so that
 |      packages can continue discovery themselves. top_level_dir is stored so
 |      load_tests does not need to pass this argument in to loader.discover().
 |  
 |  getTestCaseNames(self, testCaseClass)
 |      Return a sorted sequence of method names found within testCaseClass
 |  
 |  loadTestsFromModule(self, module, use_load_tests=True)
 |      Return a suite of all tests cases contained in the given module
 |  
 |  loadTestsFromName(self, name, module=None)
 |      Return a suite of all tests cases given a string specifier.
 |      
 |      The name may resolve either to a module, a test case class, a
 |      test method within a test case class, or a callable object which
 |      returns a TestCase or TestSuite instance.
 |      
 |      The method optionally resolves the names relative to a given module.
 |  
 |  loadTestsFromNames(self, names, module=None)
 |      Return a suite of all tests cases found using the given sequence
 |      of string specifiers. See 'loadTestsFromName()'.
 |  
 |  loadTestsFromTestCase(self, testCaseClass)
 |      Return a suite of all tests cases contained in testCaseClass
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  sortTestMethodsUsing = <built-in function cmp>
 |      cmp(x, y) -> integer
 |      
 |      Return negative if x<y, zero if x==y, positive if x>y.
 |  
 |  suiteClass = <class 'unittest.suite.TestSuite'>
 |      A test suite is a composite test consisting of a number of TestCases.
 |      
 |      For use, create an instance of TestSuite, then add test case instances.
 |      When all tests have been added, the suite can be passed to a test
 |      runner, such as TextTestRunner. It will run the individual test cases
 |      in the order in which they were added, aggregating the results. When
 |      subclassing, do not forget to call the base class constructor.
 |  
 |  testMethodPrefix = 'test'

None
Help on class TestProgram in module unittest.main:

class TestProgram(__builtin__.object)
 |  A command-line program that runs a set of tests; this is primarily
 |  for making test modules conveniently executable.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, module='__main__', defaultTest=None, argv=None, testRunner=None, testLoader=<unittest.loader.TestLoader object>, exit=True, verbosity=1, failfast=None, catchbreak=None, buffer=None)
 |  
 |  createTests(self)
 |  
 |  parseArgs(self, argv)
 |  
 |  runTests(self)
 |  
 |  usageExit(self, msg=None)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  USAGE = 'Usage: %(progName)s [options] [test] [...]\n\nOpti...        ...
 |  
 |  buffer = None
 |  
 |  catchbreak = None
 |  
 |  failfast = None
 |  
 |  progName = None

None
Help on class TestResult in module unittest.result:

class TestResult(__builtin__.object)
 |  Holder for test result information.
 |  
 |  Test results are automatically managed by the TestCase and TestSuite
 |  classes, and do not need to be explicitly manipulated by writers of tests.
 |  
 |  Each instance holds the total number of tests run, and collections of
 |  failures and errors that occurred among those test runs. The collections
 |  contain tuples of (testcase, exceptioninfo), where exceptioninfo is the
 |  formatted traceback of the error that occurred.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, stream=None, descriptions=None, verbosity=None)
 |  
 |  __repr__(self)
 |  
 |  addError(self, *args, **kw)
 |      Called when an error has occurred. 'err' is a tuple of values as
 |      returned by sys.exc_info().
 |  
 |  addExpectedFailure(self, test, err)
 |      Called when an expected failure/error occured.
 |  
 |  addFailure(self, *args, **kw)
 |      Called when an error has occurred. 'err' is a tuple of values as
 |      returned by sys.exc_info().
 |  
 |  addSkip(self, test, reason)
 |      Called when a test is skipped.
 |  
 |  addSuccess(self, test)
 |      Called when a test has completed successfully
 |  
 |  addUnexpectedSuccess(self, *args, **kw)
 |      Called when a test was expected to fail, but succeed.
 |  
 |  printErrors(self)
 |      Called by TestRunner after test run
 |  
 |  startTest(self, test)
 |      Called when the given test is about to be run
 |  
 |  startTestRun(self)
 |      Called once before any tests are executed.
 |      
 |      See startTest for a method called before each test.
 |  
 |  stop(self)
 |      Indicates that the tests should be aborted
 |  
 |  stopTest(self, test)
 |      Called when the given test has been run
 |  
 |  stopTestRun(self)
 |      Called once after all tests are executed.
 |      
 |      See stopTest for a method called after each test.
 |  
 |  wasSuccessful(self)
 |      Tells whether or not this result was a success
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

None
Help on class TestSuite in module unittest.suite:

class TestSuite(BaseTestSuite)
 |  A test suite is a composite test consisting of a number of TestCases.
 |  
 |  For use, create an instance of TestSuite, then add test case instances.
 |  When all tests have been added, the suite can be passed to a test
 |  runner, such as TextTestRunner. It will run the individual test cases
 |  in the order in which they were added, aggregating the results. When
 |  subclassing, do not forget to call the base class constructor.
 |  
 |  Method resolution order:
 |      TestSuite
 |      BaseTestSuite
 |      __builtin__.object
 |  
 |  Methods defined here:
 |  
 |  debug(self)
 |      Run the tests without collecting errors in a TestResult
 |  
 |  run(self, result, debug=False)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from BaseTestSuite:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __eq__(self, other)
 |  
 |  __init__(self, tests=())
 |  
 |  __iter__(self)
 |  
 |  __ne__(self, other)
 |  
 |  __repr__(self)
 |  
 |  addTest(self, test)
 |  
 |  addTests(self, tests)
 |  
 |  countTestCases(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from BaseTestSuite:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from BaseTestSuite:
 |  
 |  __hash__ = None

None
Help on class TextTestRunner in module unittest.runner:

class TextTestRunner(__builtin__.object)
 |  A test runner class that displays results in textual form.
 |  
 |  It prints out the names of tests as they are run, errors as they
 |  occur, and a summary of the results at the end of the test run.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, stream=<idlelib.PyShell.PseudoOutputFile object>, descriptions=True, verbosity=1, failfast=False, buffer=False, resultclass=None)
 |  
 |  run(self, test)
 |      Run the given test case or test suite.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  resultclass = <class 'unittest.runner.TextTestResult'>
 |      A test result class that can print formatted text results to a stream.
 |      
 |      Used by TextTestRunner.

None
Help on TestLoader in module unittest.loader object:

class TestLoader(__builtin__.object)
 |  This class is responsible for loading tests according to various criteria
 |  and returning them wrapped in a TestSuite
 |  
 |  Methods defined here:
 |  
 |  discover(self, start_dir, pattern='test*.py', top_level_dir=None)
 |      Find and return all test modules from the specified start
 |      directory, recursing into subdirectories to find them. Only test files
 |      that match the pattern will be loaded. (Using shell style pattern
 |      matching.)
 |      
 |      All test modules must be importable from the top level of the project.
 |      If the start directory is not the top level directory then the top
 |      level directory must be specified separately.
 |      
 |      If a test package name (directory with '__init__.py') matches the
 |      pattern then the package will be checked for a 'load_tests' function. If
 |      this exists then it will be called with loader, tests, pattern.
 |      
 |      If load_tests exists then discovery does  *not* recurse into the package,
 |      load_tests is responsible for loading all tests in the package.
 |      
 |      The pattern is deliberately not stored as a loader attribute so that
 |      packages can continue discovery themselves. top_level_dir is stored so
 |      load_tests does not need to pass this argument in to loader.discover().
 |  
 |  getTestCaseNames(self, testCaseClass)
 |      Return a sorted sequence of method names found within testCaseClass
 |  
 |  loadTestsFromModule(self, module, use_load_tests=True)
 |      Return a suite of all tests cases contained in the given module
 |  
 |  loadTestsFromName(self, name, module=None)
 |      Return a suite of all tests cases given a string specifier.
 |      
 |      The name may resolve either to a module, a test case class, a
 |      test method within a test case class, or a callable object which
 |      returns a TestCase or TestSuite instance.
 |      
 |      The method optionally resolves the names relative to a given module.
 |  
 |  loadTestsFromNames(self, names, module=None)
 |      Return a suite of all tests cases found using the given sequence
 |      of string specifiers. See 'loadTestsFromName()'.
 |  
 |  loadTestsFromTestCase(self, testCaseClass)
 |      Return a suite of all tests cases contained in testCaseClass
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  sortTestMethodsUsing = <built-in function cmp>
 |      cmp(x, y) -> integer
 |      
 |      Return negative if x<y, zero if x==y, positive if x>y.
 |  
 |  suiteClass = <class 'unittest.suite.TestSuite'>
 |      A test suite is a composite test consisting of a number of TestCases.
 |      
 |      For use, create an instance of TestSuite, then add test case instances.
 |      When all tests have been added, the suite can be passed to a test
 |      runner, such as TextTestRunner. It will run the individual test cases
 |      in the order in which they were added, aggregating the results. When
 |      subclassing, do not forget to call the base class constructor.
 |  
 |  testMethodPrefix = 'test'

None
Help on function findTestCases in module unittest.loader:

findTestCases(module, prefix='test', sortUsing=<built-in function cmp>, suiteClass=<class 'unittest.suite.TestSuite'>)

None
Help on function getTestCaseNames in module unittest.loader:

getTestCaseNames(testCaseClass, prefix, sortUsing=<built-in function cmp>)

None
Help on class TestProgram in module unittest.main:

class TestProgram(__builtin__.object)
 |  A command-line program that runs a set of tests; this is primarily
 |  for making test modules conveniently executable.
 |  
 |  Methods defined here:
 |  
 |  __init__(self, module='__main__', defaultTest=None, argv=None, testRunner=None, testLoader=<unittest.loader.TestLoader object>, exit=True, verbosity=1, failfast=None, catchbreak=None, buffer=None)
 |  
 |  createTests(self)
 |  
 |  parseArgs(self, argv)
 |  
 |  runTests(self)
 |  
 |  usageExit(self, msg=None)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  USAGE = 'Usage: %(progName)s [options] [test] [...]\n\nOpti...        ...
 |  
 |  buffer = None
 |  
 |  catchbreak = None
 |  
 |  failfast = None
 |  
 |  progName = None

None
Help on function makeSuite in module unittest.loader:

makeSuite(testCaseClass, prefix='test', sortUsing=<built-in function cmp>, suiteClass=<class 'unittest.suite.TestSuite'>)

None

三、总结

至此，我们知道了。其实整个单元测试框架的逻辑出来了。分三步走：第一步testloader根据传入的参数获得相应的测试用例，即对应具体的测试方法， 然后makesuite在把所有的测试用例组装成testsuite，最后把testsiute传给testrunner进行执行。 而我们通常执行的unittest.main()，其实就是unittest.testprom方法，其执行的功能就是上面分析的三步，在第一步中其传入的参数是自身的模块__main__； 在第二步中把自身模块中的所有测试类中中的测试方法提取出来，并生成测试套件；最后再把测试套件传递给testrunner进行具体的测试。 最后给出一个完整的单元测试组织代码，把该代码放到单元测试用例文件的同一个目录后执行该脚本，即可执行所有的测试用例文件。

参考文章：http://blog.csdn.net/five3/article/details/7104466