测试函数是用以自动化测试,使用python模块中的unittest中的工具来拓展测试

测试代码

测试代码,

测试代码

  介绍如何利用Python模块unittest 中的工具来测试代码。

 

1.  测试函数

  在Python中,测试函数是用以自动化测试,使用python模块中的unittest中的工具来开始展览测试。

  例如,创立一个函数max_function()接受七个数字,求其最大值,更创造1个函数number_function()提示用户输入七个数

  代码1:

1 def get_max_number(x,y):
2     """求两个数中的最大值"""
3     if x > y :
4         max_number = x
5     else:
6         max_number = y
7     return max_number

 

  代码2:

 1 from max_function import get_max_number
 2 
 3 print("Enter 'q' at any time to quit.")
 4 while True:
 5     x = input("Please enter x:")
 6     if x == 'q':
 7         break
 8     y = input("Please enter y:")
 9     if y == 'q':
10         break
11     max_number = get_max_number(x,y)
12     print("The max is :",max_number,".")

 

  运维结果:

1 Enter 'q' at any time to quit.
2 Please enter x:12
3 Please enter y:23
4 The max is : 23 .
5 Please enter x:66
6 Please enter y:99
7 The max is : 99 .
8 Please enter x:q

 

1.1  单元测试和测试用例

  Python标准库中的模块 unittest
提供了代码测试工具。单元测试用于核实函数的某些方面从未难题;测试用例是一组单元测试,那么些单元测试一起核实函数在各类境况下的行事都符合需求。非凡的测试用例考虑到了函数大概收取的各样输入,包涵针对具有那个情况的测试。全覆盖式测试用例包涵一整套单元测试,涵盖了各个大概的函数使用方法。对于大型项目,要贯彻全覆盖恐怕很难。常常,最初只要针对代码的重点表现编写测试即可,等类型被周边运用时再考虑全覆盖。

 

1.2 可通过的测试

  创造测试用例的语法要求一段时间才能习惯,但测试用例成立后,再添加针对函数的单元测试就很不难了。要为函数编写测试用例,可起始入模块
unittest 以及要测试的函数,再成立一个一而再 unittest.TestCase
的类,并编写制定一文山会海措施对函数行为的例外方面拓展测试。

  例如,创设二个涵盖一个形式的测试用例,它检查函数get_max_number()在给定x、y值时,是不是能科学求出最大值。

  代码:

 1 import  unittest
 2 
 3 from max_function import get_max_number
 4 
 5 class TestMaxCase(unittest.TestCase):
 6     """测试max_function.py"""
 7 
 8     def test_x_y(self):
 9         """能够处理x,y这样的数字"""
10         max_number = get_max_number(20,18)
11         self.assertEqual(max_number,20)
12 
13 unittest.main

  说明:

  第壹行,导入3个模块unittest。

  第2行,从模块max_function中程导弹入函数get_max_number()。

  第6行,创造了四个名为Test马克斯Case的类,用于包涵一星罗棋布针对
get_max_number() 的单元测试。

  第捌行,定义一个艺术test_x_y()。

  第九行,调用函数get_max_number()求出最大值,并赋值给变量max_number

  第三1行,调用 unittest 的方法 assertEqual() ,并向它传递
max_number 和
20代码行self.assertEqual(max_number,20)的趣味是说:“将
max_number的值同字数字20拓展相比较,即便它们相当于,就万事大吉,借使它们不对等,跟小编说一声!”

  第13行,调用unittest的main方法。

 

  运转结果:

1 Ran 1 test in 0.001s
2 
3 OK

   从第3行可见,测试了贰个函数,开支了0.001s;第贰行,表达测试OK,通过测试。

 

1.3 不可能通过的测试

  例如,大家创造的3个求多个数的最大值的函数,可是只给其提供四个值。

  代码1:

 1 def get_max_number(x,y,z):
 2     """求三个数中的最大值"""
 3     if x > y  and  x > z:
 4         max_number = x
 5     elif y > z:
 6         max_number = y
 7     else:
 8         max_number = z
 9 
10     return max_number

 

  代码2:

 1 import  unittest
 2 
 3 from max_function1 import get_max_number
 4 
 5 class TestMaxCase(unittest.TestCase):
 6     """测试max_function.py"""
 7 
 8     def test_x_y(self):
 9         """能够处理x,y这样的数字"""
10         max_number = get_max_number(20,18)
11         self.assertEqual(max_number,20)
12 
13 unittest.main

 

  代码2的运作结果如下:

 1  Ran 1 test in 0.000s
 2 
 3 FAILED (errors=1)
 4 Launching unittests with arguments python -m unittest test_max_function1.TestMaxCase in F:\PyProject\s14\exercise\chapter_eleven
 5 
 6 Error
7 Traceback (most recent call last):
8   File "D:\Python\Python36\lib\unittest\case.py", line 59, in testPartExecutor
9     yield
10   File "D:\Python\Python36\lib\unittest\case.py", line 601, in run
11     testMethod()
12   File "F:\PyProject\s14\exercise\chapter_eleven\test_max_function1.py", line 12, in test_x_y
13     max_number = get_max_number(20,18)
14 TypeError: get_max_number() missing 1 required positional argument: 'z'

  从以上运行结果能够,由于取最大值的函数必要七个职分实参,不过只给其传了五个,少了贰个,由于报错。

 

1.4 测试未经过时怎么做

  当测试不通过时,大家不要测试区修改用于测试的函数,而应该去修改被测试的函数,使其经过测试。

  例如,对1.3中测试未通过的函数实行周详。

  代码1:

 1 def get_max_number(x=0,y=0,z=0):
 2     """求三个数中的最大值"""
 3     if x > y  and  x > z:
 4         max_number = x
 5     elif y > z:
 6         max_number = y
 7     else:
 8         max_number = z
 9 
10     return max_number

  说明:

  第三行,为了在用户不提供别的参数而调用求最大值的函数时不报错,大家给每种形参都赋予一个暗中同意值0。

  

  代码2:

 1 import  unittest
 2 
 3 from max_function2 import get_max_number
 4 
 5 class TestMaxCase(unittest.TestCase):
 6     """测试max_function.py"""
 7 
 8     def test_x_y(self):
 9         """能够处理x,y这样的数字"""
10         max_number = get_max_number(20,18)
11         self.assertEqual(max_number,20)
12 
13 unittest.main

 

  运转结果:

1 Ran 1 test in 0.000s
2 
3 OK

  从以上运行结果能够,测试已因而。

  

1.5 添加新测试

  例如,大家在上述求最大的模块中,扩展一个求最小值的函数。

  代码1:

 1 def get_max_number(x=0,y=0,z=0):
 2     """求三个数中的最大值"""
 3     if x > y  and  x > z:
 4         max_number = x
 5     elif y > z:
 6         max_number = y
 7     else:
 8         max_number = z
 9 
10     return max_number
11 
12 def get_min_number(x=0,y=0,z=0):
13     """求三个数中的最小值"""
14     if x < y and x < z :
15         min_number = x
16     elif y < z :
17         min_number = y
18     else:
19         min_number = z
20 
21     return min_number

 

  代码2:

 1 import  unittest
 2 
 3 from max_min_function import get_max_number
 4 from max_min_function import get_min_number
 5 
 6 class TestMaxCase(unittest.TestCase):
 7     """测试max_function.py"""
 8 
 9     def test_max_number(self):
10         """能够处理x,y这样的数字"""
11         max_number = get_max_number(20,18)
12         self.assertEqual(max_number,20)
13 
14     def test_min_number(self):
15         """能否处理x、y、z这样的数字"""
16         min_number = get_min_number(1,13,18)
17         self.assertEqual(min_number,1)
18 
19 
20 unittest.main

 

  运维结果:

1 Ran 2 test in 0.001s
2 
3 OK

  从上述结果可见,两测试都已透过,耗费时间0.001s。

 

2. 测试类

  测试类就是针对类来编排测试,验证类是不是能想笔者没指望的那么。假设针对类的测试通过了,小编没就能确信对类所做的革新没有意外省破坏其本来的一言一动。

 

2.1 各类断言方法

  Python在 unittest.TestCase
类中提供了广大预知方法。断言方法检查自个儿没以为应该满意的规则是不是真正满意。假诺该条件真正知足,大家对程序行为的如若就收获了认同,大家就足以确信个中没有错误。借使大家以为应当满足的尺码实在并不满意,Python将吸引那1个。

  常用的断言方法有:

  (1)assertEqual(a, b),核实 a == b。

*  (2)*assertNotEqual(a, b),核实 a != b。

  (3)assertTrue(x),核实 x 为 True。

  (4)assertFalse(x),核实 x 为 False。

  (5)assertIn( item , list ),核实 item 在 list 中。

  (6)assertNotIn( item , list ),核实 item 不在 list 中。

 

2.2  测试类

  类的测试与函数的测试相似,只可是类测试所做的超过四分之一做事都以测试类中艺术的表现,但存在部分不相同之处。

  例如,大家制造三个管制匿名调查问卷的类AnonymousSurvey,并将其存于模块survey中,然后测试它。

  (1)创建类AnonymousSurvey

  代码1:

 1 class AnonymousSurvey():
 2     """收集匿名调查问卷的答案"""
 3 
 4     def __init__(self,question):
 5         """存储一个问题,并为存储答案做准备"""
 6         self.question = question
 7         self.responses = []
 8 
 9     def show_question(self):
10         """显示调查问卷"""
11         print(self.question)
12 
13     def store_response(self,new_response):
14         """存储单份调查问卷"""
15         self.responses.append(new_response)
16 
17     def show_results(self):
18         """显示收集到的所有答案"""
19         print("Survey results:")
20         for reponse in  self.responses:
21             print(('-' + reponse))

  说明:

  第4~7行,存款和储蓄了1个内定的考察难点,并创办了二个空列表response,用于存款和储蓄答案。

  第9~11行,创立叁个函数show_question(),用于体现调查问卷。

  第13~15行,创立三个函数store_response(),用于存款和储蓄单份调查问卷,即便用append()方法往答案列表中添加新答案。

  第17~21行,创制二个函数show_response(),用于呈现收集到的兼具答案,个中使用for循环遍历答案列表response。

 

  代码2:

 1 from survey import AnonymousSurvey
 2 
 3 # 定义一个问题,并创建一个表示调查的AnonymousSurvey对象
 4 question = "What language did you first learn to speak?"
 5 my_survey = AnonymousSurvey(question)
 6 
 7 # 显示问题并存储答案
 8 my_survey.show_question()
 9 print("Enter 'q' at time to quit.\n")
10 while True:
11     response = input("language:")
12     if response == 'q':
13         break
14     my_survey.store_response(response)
15 
16 # 显示调查结果
17 print("\nThank you to everyone who participated in the survey!")
18 my_survey.show_results()

  说明:

  第三行,从模块survey中程导弹入三个类AnonymousSurvey。

  第4~5行,定义七个题材,并动用该难点创设叁个意味调查的AnonymousSurvey对象。

  第8~14行,调用 show_question()
来展现难题,并提醒用户输入答案。收到种种答案的同时将其储存起来。用户输入全数答案(输入
q 供给退出)

后。

  第17~18行,呈现调查结果,即调用 show_results() 来打字与印刷调查结果。

 

  运营结果:

 1 What language did you first learn to speak?
 2 Enter 'q' at time to quit.
 3 
 4 language:English
 5 language:Spanish
 6 language:English
 7 language:Chinese
 8 language:Mandarin
 9 language:q
10 
11 Thank you to everyone who participated in the survey!
12 Survey results:
13 -English
14 -Spanish
15 -English
16 -Chinese
17 -Mandarin

 

  (2)测试 AnonymousSurvey 类

  • 测试单个答案

  代码1:

 1 import unittest
 2 from survey import AnonymousSurvey
 3 
 4 class TestAnonmyousSurvey(unittest.TestCase):
 5     """针对AnonymousSurvey类的测试"""
 6 
 7     def test_store_single_response(self):
 8         """测试单个答案会被妥善地存储"""
 9         question = "What language did you first learn to speak?"
10         my_survey = AnonymousSurvey(question)
11         my_survey.store_response('English')
12         self.assertIn('English', my_survey.responses)
13 
14     unittest.main

  说明:

  第③行,导入测试模块unittest。

  第②行,从模块survey中程导弹入类AnonymousSurvey。

  第肆行,继承模块unittest中的类TestCase成立二个测试类TestAnonmyousSurvey。

  第7~12行,成立叁个方法test_store_single_response来测试单个答案会被安妥地囤积。

  第壹4行,调用模块unittest中的main方法来施行测试。

 

  运转结果:

1 Ran 1 test in 0.000s
2 
3 OK

 

  

  • 测试八个答案

  代码2:

 1 import unittest
 2 from survey import AnonymousSurvey
 3 
 4 class TestAnonmyousSurvey(unittest.TestCase):
 5     """针对AnonymousSurvey类的测试"""
 6 
 7     def test_store_single_response(self):
 8         """测试单个答案会被妥善地存储"""
 9         question = "What language did you first learn to speak?"
10         my_survey = AnonymousSurvey(question)
11         my_survey.store_response('English')
12         self.assertIn('English', my_survey.responses)
13 
14     def test_store_three_responses(self):
15         """测试三个答案会被妥善地存储"""
16         question = "What language did you first learn to speak?"
17         my_survey = AnonymousSurvey(question)
18         responses = ['English', 'Spanish', 'Mandarin']
19         for response in responses:
20             my_survey.store_response(response)
21 
22         for response in responses:
23             self.assertIn(response, my_survey.responses)
24 
25     unittest.main

 

  运营结果:

1 Ran 2 tests in 0.000s2 
3 OK

 

2.3 方法 setUp()的使用

  在前边的test_survey.py中,大家在每种测试方法中都创制了四个AnonymousSurvey 实例,并在各种方法中都创设了答案。 unittest.TestCase
类包括方法 setUp()
,让我们只需创造这几个指标二次,并在种种测试方法中选择它们。倘使您在
TestCase 类中涵盖了章程 setUp()
,Python将先运维它,再运维各类以test_超过的主意。那样,在大家编辑的各种测试方法中都可应用在措施
setUp()中创设的靶子了。

   例如,使用 setUp() 来创建2个调查商量对象和一组答案,供方法
test_store_single_response() 和test_store_three_responses() 使用。

  代码:

 1 import unittest
 2 from survey import AnonymousSurvey
 3 
 4 class TestAnonymousSurvey(unittest.TestCase):
 5     """针对AnonymousSurvey类的测试"""
 6     def setUp(self):
 7         """
 8         创建一个调查对象和一组答案,供使用的测试方法使用
 9         """
10         question = "What language did you first learn to speak?"
11         self.my_survey = AnonymousSurvey(question)
12         self.responses = ['English', 'Spanish', 'Mandarin']
13 
14     def test_store_single_response(self):
15         """测试单个答案会被妥善地存储"""
16         self.my_survey.store_response(self.responses[0])
17         self.assertIn(self.responses[0], self.my_survey.responses)
18 
19     def test_store_three_responses(self):
20         """测试三个答案会被妥善地存储"""
21         for response in self.responses:
22             self.my_survey.store_response(response)
23         for response in self.responses:
24             self.assertIn(response, self.my_survey.responses)
25 
26     unittest.main

  说明:

  第贰1行,创造七个调查斟酌对象。

  第32行,创制多少个答案列表。

 

  运行结果:

1 Ran 1 test in 0.000s
2 
3 OK

  

  测试本人编写的类时,方法 setUp() 让测试方法编写起来更便于:可在
setUp()
方法中开创一多级实例并安装它们的本性,再在测试方法中平素利用这么些实例。比较于在种种测试方法中都创设实例并安装其天性,那要便于得多。  

  运维测试用例时,每成功多个单元测试,Python都打字与印刷三个字符:测试通过时打印二个句点;测试引发错误时打字与印刷二个E ;测试导致断言战败时打字与印刷二个 F
。那便是你运维测试用例时,在出口的首先行中看出的句点和字符数量各分化的由来。假设测试用例包罗众多单元测试,必要周转十分长日子,就可通过观望这么些结果来获知有稍许个测试通过了。

 

http://www.bkjia.com/Pythonjc/1292788.htmlwww.bkjia.comtruehttp://www.bkjia.com/Pythonjc/1292788.htmlTechArticle测试代码, 测试代码
介绍怎么样使用Python模块unittest 中的工具来测试代码。 1. 测试函数
在Python中,测试函数是用来自动化测试,使用pytho…

  介绍怎样使用Python模块unittest 中的工具来测试代码。

 

1.  测试函数

  在Python中,测试函数是用来自动化测试,使用python模块中的unittest中的工具来进展测试。

  例如,创建2个函数max_function()接受七个数字,求其最大值,再次创下立三个函数number_function()提示用户输入八个数

  代码1:

1 def get_max_number(x,y):
2     """求两个数中的最大值"""
3     if x > y :
4         max_number = x
5     else:
6         max_number = y
7     return max_number

 

  代码2:

 1 from max_function import get_max_number
 2 
 3 print("Enter 'q' at any time to quit.")
 4 while True:
 5     x = input("Please enter x:")
 6     if x == 'q':
 7         break
 8     y = input("Please enter y:")
 9     if y == 'q':
10         break
11     max_number = get_max_number(x,y)
12     print("The max is :",max_number,".")

 

  运转结果:

1 Enter 'q' at any time to quit.
2 Please enter x:12
3 Please enter y:23
4 The max is : 23 .
5 Please enter x:66
6 Please enter y:99
7 The max is : 99 .
8 Please enter x:q

 

1.1  单元测试和测试用例

  Python标准库中的模块 unittest
提供了代码测试工具。单元测试用于核实函数的某部地点从未难题;测试用例是一组单元测试,那一个单元测试一起核实函数在各样处境下的表现都符合须求。优秀的测试用例考虑到了函数恐怕接收的种种输入,包蕴针对富有那几个情况的测试。全覆盖式测试用例包蕴一整套单元测试,涵盖了种种只怕的函数使用办法。对于大型项目,要贯彻全覆盖大概很难。常常,最初只要针对代码的重中之重表现编写测试即可,等体系被大规模运用时再考虑全覆盖。

 

1.2 可由此的测试

  创造测试用例的语法须要一段时间才能习惯,但测试用例成立后,再添加针对函数的单元测试就很容易了。要为函数编写测试用例,可起始入模块
unittest 以及要测试的函数,再创造多少个后续 unittest.TestCase
的类,并编辑一文山会海措施对函数行为的分裂地点开展测试。

  例如,创设七个包蕴四个方法的测试用例,它检查函数get_max_number()在给定x、y值时,是或不是能正确求出最大值。

  代码:

 1 import  unittest
 2 
 3 from max_function import get_max_number
 4 
 5 class TestMaxCase(unittest.TestCase):
 6     """测试max_function.py"""
 7 
 8     def test_x_y(self):
 9         """能够处理x,y这样的数字"""
10         max_number = get_max_number(20,18)
11         self.assertEqual(max_number,20)
12 
13 unittest.main

  说明:

  第壹行,导入二个模块unittest。

  第2行,从模块max_function中程导弹入函数get_max_number()。

  第陆行,创制了三个名为Test马克斯Case的类,用于包罗一雨后春笋针对
get_max_number() 的单元测试。

  第十行,定义1个艺术test_x_y()。

  第八行,调用函数get_max_number()求出最大值,并赋值给变量max_number

  第贰1行,调用 unittest 的方法 assertEqual() ,并向它传递
max_number 和
20代码行self.assertEqual(max_number,20)的趣味是说:“将
max_number的值同字数字20拓展比较,如果它们也就是,就顺遂,假如它们不对等,跟自家说一声!”

  第13行,调用unittest的main方法。

 

  运营结果:

1 Ran 1 test in 0.001s
2 
3 OK

   从第2行可见,测试了叁个函数,开支了0.001s;第③行,表明测试OK,通过测试。

 

1.3 无法透过的测试

  例如,大家成立的2个求四个数的最大值的函数,可是只给其提供五个值。

  代码1:

 1 def get_max_number(x,y,z):
 2     """求三个数中的最大值"""
 3     if x > y  and  x > z:
 4         max_number = x
 5     elif y > z:
 6         max_number = y
 7     else:
 8         max_number = z
 9 
10     return max_number

 

  代码2:

 1 import  unittest
 2 
 3 from max_function1 import get_max_number
 4 
 5 class TestMaxCase(unittest.TestCase):
 6     """测试max_function.py"""
 7 
 8     def test_x_y(self):
 9         """能够处理x,y这样的数字"""
10         max_number = get_max_number(20,18)
11         self.assertEqual(max_number,20)
12 
13 unittest.main

 

  代码2的运维结果如下:

 1  Ran 1 test in 0.000s
 2 
 3 FAILED (errors=1)
 4 Launching unittests with arguments python -m unittest test_max_function1.TestMaxCase in F:\PyProject\s14\exercise\chapter_eleven
 5 
 6 Error
7 Traceback (most recent call last):
8   File "D:\Python\Python36\lib\unittest\case.py", line 59, in testPartExecutor
9     yield
10   File "D:\Python\Python36\lib\unittest\case.py", line 601, in run
11     testMethod()
12   File "F:\PyProject\s14\exercise\chapter_eleven\test_max_function1.py", line 12, in test_x_y
13     max_number = get_max_number(20,18)
14 TypeError: get_max_number() missing 1 required positional argument: 'z'

  从上述运维结果可见,由于取最大值的函数须求多少个地点实参,不过只给其传了多少个,少了三个,由于报错。

 

1.4 测试未通过时如何是好

  当测试不通过时,大家不用测试区修改用于测试的函数,而应该去修改被测试的函数,使其通过测试。

  例如,对1.3中测试未通过的函数进行全面。

  代码1:

 1 def get_max_number(x=0,y=0,z=0):
 2     """求三个数中的最大值"""
 3     if x > y  and  x > z:
 4         max_number = x
 5     elif y > z:
 6         max_number = y
 7     else:
 8         max_number = z
 9 
10     return max_number

  说明:

  第三行,为了在用户不提供其余参数而调用求最大值的函数时不报错,大家给种种形参都赋予三个私下认可值0。

  

  代码2:

 1 import  unittest
 2 
 3 from max_function2 import get_max_number
 4 
 5 class TestMaxCase(unittest.TestCase):
 6     """测试max_function.py"""
 7 
 8     def test_x_y(self):
 9         """能够处理x,y这样的数字"""
10         max_number = get_max_number(20,18)
11         self.assertEqual(max_number,20)
12 
13 unittest.main

 

  运营结果:

1 Ran 1 test in 0.000s
2 
3 OK

  从上述运转结果能够,测试已通过。

  

1.5 添加新测试

  例如,我们在上述求最大的模块中,增加2个求最小值的函数。

  代码1:

 1 def get_max_number(x=0,y=0,z=0):
 2     """求三个数中的最大值"""
 3     if x > y  and  x > z:
 4         max_number = x
 5     elif y > z:
 6         max_number = y
 7     else:
 8         max_number = z
 9 
10     return max_number
11 
12 def get_min_number(x=0,y=0,z=0):
13     """求三个数中的最小值"""
14     if x < y and x < z :
15         min_number = x
16     elif y < z :
17         min_number = y
18     else:
19         min_number = z
20 
21     return min_number

 

  代码2:

 1 import  unittest
 2 
 3 from max_min_function import get_max_number
 4 from max_min_function import get_min_number
 5 
 6 class TestMaxCase(unittest.TestCase):
 7     """测试max_function.py"""
 8 
 9     def test_max_number(self):
10         """能够处理x,y这样的数字"""
11         max_number = get_max_number(20,18)
12         self.assertEqual(max_number,20)
13 
14     def test_min_number(self):
15         """能否处理x、y、z这样的数字"""
16         min_number = get_min_number(1,13,18)
17         self.assertEqual(min_number,1)
18 
19 
20 unittest.main

 

  运维结果:

1 Ran 2 test in 0.001s
2 
3 OK

  从以上结果能够,两测试都已由此,耗费时间0.001s。

 

2. 测试类

  测试类正是针对性类来编排测试,验证类是或不是能想本身没希望的那样。如若针对类的测试通过了,小编没就能确信对类所做的考订没有意外省破坏其原本的表现。

 

2.1 各个断言方法

  Python在 unittest.TestCase
类中提供了众多预见方法。断言方法检查本人没觉着应当满意的原则是或不是确实满意。即使该规范确实满意,大家对先后行为的比方就取得了肯定,大家就足以确信在那之中并未不当。若是大家以为应该满意的规格实在并不知足,Python将抓住那些。

  常用的预知方法有:

  (1)assertEqual(a, b),核实 a == b。

*  (2)*assertNotEqual(a, b),核实 a != b。

  (3)assertTrue(x),核实 x 为 True。

  (4)assertFalse(x),核实 x 为 False。

  (5)assertIn( item , list ),核实 item 在 list 中。

  (6)assertNotIn( item , list ),核实 item 不在 list 中。

 

2.2  测试类

  类的测试与函数的测试相似,只可是类测试所做的大部干活都以测试类中方法的行事,但存在部分分化之处。

  例如,大家成立3个管理匿名调查问卷的类AnonymousSurvey,并将其存于模块survey中,然后测试它。

  (1)创建类AnonymousSurvey

  代码1:

 1 class AnonymousSurvey():
 2     """收集匿名调查问卷的答案"""
 3 
 4     def __init__(self,question):
 5         """存储一个问题,并为存储答案做准备"""
 6         self.question = question
 7         self.responses = []
 8 
 9     def show_question(self):
10         """显示调查问卷"""
11         print(self.question)
12 
13     def store_response(self,new_response):
14         """存储单份调查问卷"""
15         self.responses.append(new_response)
16 
17     def show_results(self):
18         """显示收集到的所有答案"""
19         print("Survey results:")
20         for reponse in  self.responses:
21             print(('-' + reponse))

  说明:

  第4~7行,存款和储蓄了贰个钦点的调查研究难点,并创造了一个空驶列车表response,用于存款和储蓄答案。

  第9~11行,创造贰个函数show_question(),用于突显调查问卷。

  第13~15行,创设二个函数store_response(),用于存款和储蓄单份调查问卷,即使用append()方法往答案列表中添加新答案。

  第17~21行,创造3个函数show_response(),用于显示收集到的富有答案,在那之中使用for循环遍历答案列表response。

 

  代码2:

 1 from survey import AnonymousSurvey
 2 
 3 # 定义一个问题,并创建一个表示调查的AnonymousSurvey对象
 4 question = "What language did you first learn to speak?"
 5 my_survey = AnonymousSurvey(question)
 6 
 7 # 显示问题并存储答案
 8 my_survey.show_question()
 9 print("Enter 'q' at time to quit.\n")
10 while True:
11     response = input("language:")
12     if response == 'q':
13         break
14     my_survey.store_response(response)
15 
16 # 显示调查结果
17 print("\nThank you to everyone who participated in the survey!")
18 my_survey.show_results()

  说明:

  第二行,从模块survey中程导弹入3个类AnonymousSurvey。

  第4~5行,定义三个题材,并使用该难题成立三个意味调查的AnonymousSurvey对象。

  第8~14行,调用 show_question()
来展现难题,并提醒用户输入答案。收到每种答案的同时将其储存起来。用户输入全数答案(输入
q 供给退出)

后。

  第17~18行,呈现调查结果,即调用 show_results() 来打字与印刷调查结果。

 

  运维结果:

 1 What language did you first learn to speak?
 2 Enter 'q' at time to quit.
 3 
 4 language:English
 5 language:Spanish
 6 language:English
 7 language:Chinese
 8 language:Mandarin
 9 language:q
10 
11 Thank you to everyone who participated in the survey!
12 Survey results:
13 -English
14 -Spanish
15 -English
16 -Chinese
17 -Mandarin

 

  (2)测试 AnonymousSurvey 类

  • 测试单个答案

  代码1:

 1 import unittest
 2 from survey import AnonymousSurvey
 3 
 4 class TestAnonmyousSurvey(unittest.TestCase):
 5     """针对AnonymousSurvey类的测试"""
 6 
 7     def test_store_single_response(self):
 8         """测试单个答案会被妥善地存储"""
 9         question = "What language did you first learn to speak?"
10         my_survey = AnonymousSurvey(question)
11         my_survey.store_response('English')
12         self.assertIn('English', my_survey.responses)
13 
14     unittest.main

  说明:

  第①行,导入测试模块unittest。

  第二行,从模块survey中程导弹入类AnonymousSurvey。

  第6行,继承模块unittest中的类TestCase创设贰个测试类TestAnonmyousSurvey。

  第7~12行,创立三个办法test_store_single_response来测试单个答案会被稳当地囤积。

  第①4行,调用模块unittest中的main方法来实行测试。

 

  运营结果:

1 Ran 1 test in 0.000s
2 
3 OK

 

  

  • 测试七个答案

  代码2:

 1 import unittest
 2 from survey import AnonymousSurvey
 3 
 4 class TestAnonmyousSurvey(unittest.TestCase):
 5     """针对AnonymousSurvey类的测试"""
 6 
 7     def test_store_single_response(self):
 8         """测试单个答案会被妥善地存储"""
 9         question = "What language did you first learn to speak?"
10         my_survey = AnonymousSurvey(question)
11         my_survey.store_response('English')
12         self.assertIn('English', my_survey.responses)
13 
14     def test_store_three_responses(self):
15         """测试三个答案会被妥善地存储"""
16         question = "What language did you first learn to speak?"
17         my_survey = AnonymousSurvey(question)
18         responses = ['English', 'Spanish', 'Mandarin']
19         for response in responses:
20             my_survey.store_response(response)
21 
22         for response in responses:
23             self.assertIn(response, my_survey.responses)
24 
25     unittest.main

 

  运行结果:

1 Ran 2 tests in 0.000s2 
3 OK

 

2.3 方法 setUp()的使用

  在前边的test_survey.py中,咱们在各类测试方法中都创立了三个AnonymousSurvey 实例,并在每一种方法中都创立了答案。 unittest.TestCase
类包涵方法 setUp()
,让大家只需成立那一个指标三遍,并在各样测试方法中动用它们。如若您在
TestCase 类中涵盖了点子 setUp()
,Python将先运维它,再运营种种以test_超过的法门。那样,在我们编辑的各类测试方法中都可选择在艺术
setUp()中创设的目的了。

   例如,使用 setUp() 来创建1个调查切磋对象和一组答案,供方法
test_store_single_response() 和test_store_three_responses() 使用。

  代码:

 1 import unittest
 2 from survey import AnonymousSurvey
 3 
 4 class TestAnonymousSurvey(unittest.TestCase):
 5     """针对AnonymousSurvey类的测试"""
 6     def setUp(self):
 7         """
 8         创建一个调查对象和一组答案,供使用的测试方法使用
 9         """
10         question = "What language did you first learn to speak?"
11         self.my_survey = AnonymousSurvey(question)
12         self.responses = ['English', 'Spanish', 'Mandarin']
13 
14     def test_store_single_response(self):
15         """测试单个答案会被妥善地存储"""
16         self.my_survey.store_response(self.responses[0])
17         self.assertIn(self.responses[0], self.my_survey.responses)
18 
19     def test_store_three_responses(self):
20         """测试三个答案会被妥善地存储"""
21         for response in self.responses:
22             self.my_survey.store_response(response)
23         for response in self.responses:
24             self.assertIn(response, self.my_survey.responses)
25 
26     unittest.main

  说明:

  第①1行,创制三个检察对象。

  第32行,创立二个答案列表。

 

  运转结果:

1 Ran 1 test in 0.000s
2 
3 OK

  

  测试本身编排的类时,方法 setUp() 让测试方法编写起来更易于:可在
setUp()
方法中成立一层层实例并安装它们的属性,再在测试方法中平素运用这一个实例。相比较于在每一种测试方法中都创办实例并安装其性质,那要便于得多。  

  运转测试用例时,每达成贰个单元测试,Python都打字与印刷多个字符:测试通过时打字与印刷一个句点;测试引发错误时打印3个E ;测试导致断言战败时打字与印刷三个 F
。这就是您运维测试用例时,在输出的率先行中看看的句点和字符数量各差异的由来。如若测试用例包罗众多单元测试,须求周转相当短日子,就可通过观望那个结果来获知有稍许个测试通过了。

 

相关文章