看了几天unittest，看的头晕，却感觉没啥心得

发现了1点，继承自unittest.TestCase 的subclass 不能重写__init__()方法。
setUp()和tearDown()：会被每个test函数调用。每个test函数是按照字母排序，所以我在test_run_process后用了test_s2.
被测试的函数定义在此：

点击(此处)折叠或打开

1. 
   
2. 
   
3. class Calculate:
   
4.     def add(self,x,y):
   
5.         if type(x)==int and type(y)==int:
   
6.             return x+y
   
7.         else:
   
8.             raise TypeError("Invalid type: {} and {}".format(type(x),type(y)))

test文件在这里：

点击(此处)折叠或打开

1. import numbers
   
2. import unittest
   
3. from calculate import Calculate
   
4. import sys
   
5. import subprocess
   
6. import shutil
   
7. import os
   
8. import os.path
   
9. import time
   
10. import filecmp
    
11. 
    
12. class TestCalculate(unittest.TestCase):
    
13.     def setUp(self):
    
14.         self.calc=Calculate()
    
15. 
    
16.     @unittest.skip("demonstrating skipping")
    
17.     def test_nothing(self):
    
18.         self.fail("should not happen")
    
19. 
    
20.     @unittest.skipIf(sys.version_info<(3,6),"not supported in this library version")
    
21.     def test_format(self):
    
22.         # Tests that work for only a certain version of the library
    
23.         pass
    
24.     
    
25.     @unittest.skipUnless(sys.platform.startswith('win'),"requires windows")
    
26.     def test_windows_support(self):
    
27.         #windows specific testing code
    
28.         pass
    
29. 
    
30. 
    
31.     def test_add_method_returns_correct_result(self):
    
32.         self.assertEqual(4,self.calc.add(2,2))
    
33.     
    
34.     def test_add_method_raises_typerror_if_not_int(self):
    
35.         self.assertRaises(TypeError,self.calc.add,"Hello","world")
    
36.     
    
37.     def test_assert_raises(self):
    
38.         with self.assertRaises(AttributeError):
    
39.             [].get
    
40.     
    
41.     #assertEqaul(x,y,msg=None)
    
42.     def test_assert_equal(self):
    
43.         self.assertEqual(1,2,msg="we not are equal")
    
44.     
    
45.     #assertAlsmotEqual(x,y,places=None,msg=None,delta=None)
    
46.     def test_assert_almost_equal_delta_0_5(self):
    
47.         self.assertAlmostEqual(1,1.2,delta=0.5,msg="we are not almost equal")
    
48. 
    
49.     def test_assert_almost_equal_places(self):
    
50.         self.assertAlmostEqual(1,1.00001, places=4)
    
51.     
    
52.     #assertRaises(exception,method,arguments,msg=None)
    
53.     def test_assert_raises_2(self):
    
54.         self.assertRaises(ValueError,int, 'a')
    
55.     
    
56.     #assertDictContainsSubset is deprecated in python 3.2
    
57.     #assertDictContainsSubset(expected, actual, msg=None)
    
58.     @unittest.skipIf(sys.version_info>(3,2),"not supported in this library version")
    
59.     def test_assert_dict_contains_subset(self):
    
60.         expected={'a':'b',"k":"g"}
    
61.         actual={'a':'b','c':'d','e':'f'}
    
62.         self.assertDictContainsSubset(expected,actual,msg="not contain")
    
63.     
    
64.     #assertDictEqual(d1,d2,msg=None)
    
65.     def test_assert_dict_equal(self):
    
66.         expected={'a':'b',"k":"g"}
    
67.         actual={'a':'b',"k":'g'}
    
68.         self.assertDictEqual(expected,actual)
    
69.     
    
70.     #assertTrue(exper,msg=None)
    
71.     def test_assert_true(self):
    
72.         self.assertTrue(1)
    
73.         self.assertTrue("hello world")
    
74.     
    
75.     def test_assert_true_2(self):
    
76.         d1=dict(a=1,b=2,c=3,d=4)
    
77.         d2=dict(a=1,b=2)
    
78.         self.assertTrue(set(d2.items()).issubset(set(d1.items())))
    
79. 
    
80.     #assertGreater(a,b,msg=None):
    
81.     def test_assert_greater(self):
    
82.         self.assertGreater(2,1,msg="smaller")
    
83. 
    
84.     
    
85.     #assertGreaterEqual(a,b,msg=None)
    
86.     def test_assert_greater_equal(self):
    
87.         self.assertGreaterEqual(2,2)
    
88. 
    
89.     
    
90.     #assertIn(member,container,msg=None)
    
91.     def test_assert_in(self):
    
92.         self.assertIn(1,[1,2,3,4,5])
    
93.     
    
94.     #assertIs(expr1,expr2)
    
95.     def test_assert_is(self):
    
96.         self.assertIs("a","a")
    
97. 
    
98.     #assertIsInstance(obj, class, msg=None):
    
99.     def test_assert_is_instance(self):
    
100.         self.assertIsInstance(1,numbers.Integral)
     
101. 
     
102.     #assertNotIsInstance(obj,class, msg=None)
     
103.     def test_assert_is_not_instance(self):
     
104.         self.assertNotIsInstance(1,str)
     
105. 
     
106.     #assertIsNone(obj, msg=None)
     
107.     def test_assert_is_none(self):
     
108.         self.assertIsNone(None)
     
109. 
     
110.     #assertIsNot(expr1,expr2,msg=None)
     
111.     def test_assert_is_not(self):
     
112.         self.assertIsNot([],[])
     
113. 
     
114.     #assertIsNotNone(obj,msg=None)
     
115.     def test_assert_is_not_none(self):
     
116.         self.assertIsNotNone(1)
     
117. 
     
118.     #assertLess(a,b,msg=None)
     
119.     def test_assert_less(self):
     
120.         self.assertLess(1,2)
     
121. 
     
122.     #assertLessEqual(a,b,msg=None)
     
123.     def test_assert_less_equal(self):
     
124.         self.assertLessEqual(1,2)
     
125.     
     
126.     #This function not exits in python3
     
127.     #assertItemsEqual(a,b,msg=None):
     
128.     @unittest.skipIf(sys.version_info>(3,0),"not supported in this library version")
     
129.     def test_assert_items_equal(self):
     
130.         try:
     
131.             self.assertItemsEqual([1,2,3],[3,2,1])
     
132.         except AttributeError as e:
     
133.             print(e)
     
134. 
     
135.     #assertRaises(exeClass,callableObj, *args, **kwargs, msg=None)
     
136.     def test_assert_raises(self):
     
137.         self.assertRaises(IndexError,[].pop,0)
     
138.     
     
139. 
     
140. @unittest.skip("showing class skipping")
     
141. class MySkippingTestCase(unittest.TestCase):
     
142.     """
     
143.     def __init__(self):
     
144.         unittest.TestCase.__init__(*args,**kwargs)
     
145.     """
     
146.     
     
147.     def setUp(self):
     
148.         self.a="5 is a good number"
     
149.         self.b=self.test_run_3_post_condition()
     
150.         #self.c=self.test_run_process_file()
     
151.         #self.d=self.test_run_process2()
     
152.         pass
     
153. 
     
154. 
     
155.     def test_not_run(self):
     
156.         pass
     
157.     """
     
158.     def skipUnlessHasattr(obj,attr):
     
159.         if hasattr(obj,attr):
     
160.             return labda func: func
     
161.         return unittest.skip("{!r} does not have {!r}".format(obj, attr))
     
162.     """
     
163. 
     
164.     def test_run_3_post_condition(self):
     
165.         for i in range(1,100):
     
166.             if i==5:
     
167.                 return "{} is a good number".format(i)
     
168.         return "{} is a good number".format(5)
     
169.     
     
170.     def test_run_1(self):
     
171.         self.assertEqual(self.a,self.b)
     
172. 
     
173.     def test_run_2(self):
     
174.         self.assertTrue(self.a!=self.b,"thould be equal")
     
175. 
     
176.     
     
177.     def test_rename_file(self):
     
178.         #ret=os.rename("echo.sh","echo")
     
179.         self.assertTrue(os.path.exists("echo.sh"))
     
180. 
     
181.     def test_final(self):
     
182.         self.assertEqual(self.test_run_process_1(),self.test_run_process_2())
     
183.     
     
184. import difflib
     
185. class MyTest(unittest.TestCase):
     
186.     """
     
187.     def __init__(self):
     
188.         super().__init__()
     
189.     """
     
190. 
     
191.     def setUp(self):
     
192.         pass
     
193. 
     
194.     def test_run_process_1(self):
     
195.         proc=subprocess.Popen("./echo.sh",stdout=subprocess.PIPE,stderr=subprocess.PIPE)
     
196.         sout,serr=proc.communicate()
     
197.         stdout=sout.decode().strip()
     
198.         with open("time_begin.txt","wt") as tb:
     
199.             tb.write(stdout)
     
200.         return True
     
201.     
     
202.     def test_run_process_2(self):
     
203.         time.sleep(5)
     
204.         proc=subprocess.Popen("./echo.sh",stdout=subprocess.PIPE,stderr=subprocess.PIPE)
     
205.         sout,serr=proc.communicate()
     
206.         stdout=sout.decode().strip()
     
207.         with open("time_finish.txt","wt") as tb:
     
208.             tb.write(stdout)
     
209.         return True
     
210.     
     
211.     #def test_s1(self):
     
212.     # self.assertEqual(self.test_run_process_1(),self.test_run_process_2())
     
213.     
     
214.     def test_s2(self):
     
215.         with open("time_begin.txt") as f1:
     
216.             fromlines=f1.readlines()
     
217.         with open("time_finish.txt") as f2:
     
218.             tolines=f2.readlines()
     
219.         diff=difflib.unified_diff(fromlines,tolines)
     
220.         sys.stdout.writelines(diff)
     
221. 
     
222.     def test_s3(self):
     
223.         self.assertFalse(filecmp.cmp("time_begin.txt","time_finish.txt"))
     
224. 
     
225. if __name__=="__main__":
     
226.     #unittest.main() -verbosity 2
     
227.     suite=unittest.TestLoader().loadTestsFromTestCase(MyTest)
     
228.     unittest.TextTestRunner(verbosity=2).run(suite)

以前C语言还要先test 传进去的参数呢，python 这些测试框架整的够复杂的，方法真多。真的是有用还是语法糖太多啊，哎。搞不清楚。