码迷,mamicode.com
首页 > 编程语言 > 详细

Python断言方法:assert

时间:2019-06-23 11:39:43      阅读:214      评论:0      收藏:0      [点我收藏+]

标签:first   mat   nice   fun   different   tis   method   cas   diff   

在测试用例中,执行完测试用例后,最后一步是判断测试结果是pass还是fail,自动化测试脚本里面一般把这种生成测试结果的方法称为断言(assert)。

用unittest组件测试用例的时候,断言的方法还是很多的,下面介绍几种常用的断言方法:assertEqual、assertIn、assertTrue

基本断言方法
基本的断言方法提供了测试结果是True还是False。所有的断言方法都有一个msg参数,如果指定msg参数的值,则将该信息作为失败的错误信息返回。

 技术图片

 

unittest常用的断言方法

1.assertEqual(self, first, second, msg=None)

--判断两个参数相等:first == second

2.assertNotEqual(self, first, second, msg=None)

--判断两个参数不相等:first != second

3.assertIn(self, member, container, msg=None)

--判断是字符串是否包含:member in container

4.assertNotIn(self, member, container, msg=None)

--判断是字符串是否不包含:member not in container

5.assertTrue(self, expr, msg=None)

--判断是否为真:expr is True

6.assertFalse(self, expr, msg=None)

--判断是否为假:expr is False

7.assertIsNone(self, obj, msg=None)

--判断是否为None:obj is None

8.assertIsNotNone(self, obj, msg=None)
--判断是否不为None:obj is not None

 

unittest所有断言方法

1.下面是unittest框架支持的所有断言方法,有兴趣的同学可以慢慢看。

|  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.

 

Python断言方法:assert

标签:first   mat   nice   fun   different   tis   method   cas   diff   

原文地址:https://www.cnblogs.com/yyht-xgy/p/11072107.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!