2024年3月31日发(作者：)

|

| 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 True(a > b), but with a nicer default message.

|

| assertGreaterEqual(self, a, b, msg=None)

| Just like True(a >= b), but with a nicer default message.

|

| assertIn(self, member, container, msg=None)

| Just like True(a in b), but with a nicer default message.

|

| assertIs(self, expr1, expr2, msg=None)

| Just like True(a is b), but with a nicer default message.

|

| assertIsInstance(self, obj, cls, msg=None)

| Same as True(isinstance(obj, cls)), with a nicer

| default message.

|

| assertIsNone(self, obj, msg=None)

| Same as True(obj is None), with a nicer default message.

|

| assertIsNot(self, expr1, expr2, msg=None)

| Just like True(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::

|

| Equal(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 True(a < b), but with a nicer default message.

|

| assertLessEqual(self, a, b, msg=None)

| Just like True(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 True(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 Raises(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 Raises(SomeException) as cm:

| do_something()

| the_exception = ion

| Equal(the__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.