第三次作业

标签：

一、单元测试的流程

1、判断组件的功能：通过定义应用的整体需求，然后将系统划分成几个对象，我们需要对组件的基本功能十分清楚。因此，J2EE单元测试实际上也属于设计过程的一部分。 
2、设计组件行为：依据所处理的过程，可以通过一个正规或者非正规的过程实现组件行为的设计，我们可以使用UML或者其他文档视图来设计组件行为，从而为组件的测试打下基础。 
3、编写单元测试程序（或测试用例）确认组件行为：这个阶段，应该假定组件的编码已经结束而组件工作正常，我们需要编写单元测试程序来确定其功能是否和预定义的功能相同，测试程序需要考虑所有正常和意外的输入，以及特定的方法能产生的溢出。 
4、编写组件并执行测试：首先，创建类及其所对应的方法标识，然后遍历每个测试实例，为其编写相应代码使其顺利通过，然后返回测试。继续这个过程直至所有实例通过。此时，停止编码。 
5、测试替代品：对组件行为的其他方式进行考虑，设计更周全的输入或者其他错误条件，编写测试用例来捕获这些条件，然后修改代码使得测试通过。 
6、重整代码：如果有必要，在编码结束时，对代码进行重整和优化，改动后，返回单元测试并确认测试通过。 
7、当组件有新的行为时，编写新的测试用例：每次在组件中发现故障。编写一个测试实例重复这个故障，然后修改组件以保证测试实例通过。同样，当发现新的需求或已有的需求改变时，编写或修改测试实例以响应此改变，然后修改代码。 
8、代码修改,返回所有的测试：每次代码修改时，返回所有的测试以确保没有打乱代码。  

java代码：

1. public class Calculator {  
2.   
3.     public int add(int a, int b) {  
4.         return a + b;  
5.     }  
6.   
7.     public int minus(int a, int b) {  
8.         return a - b;  
9.     }  
10.   
11.     public int square(int n) {  
12.         return n * n;  
13.     }  
14.       
15.     //Bug : 死循环  
16.     public void squareRoot(int n) {  
17.         for(; ;)  
18.             ;  
19.     }  
20.       
21.     public int multiply(int a, int b) {  
22.         return a * b;  
23.     }  
24.   
25.     public int divide(int a, int b) throws Exception {  
26.         if (0 == b) {  
27.             throw new Exception("除数不能为零");  
28.         }  
29.         return a / b;  
30.     }  
31. }  

单元测试类

1. import org.junit.After;  
2. import org.junit.AfterClass;  
3. import org.junit.Assert;  
4. import org.junit.Before;  
5. import org.junit.BeforeClass;  
6. import org.junit.Ignore;  
7. import org.junit.Test;  
8.   
9. public class CalculatorTest {  
10.   
11.     private Calculator cal = new Calculator();  
12.   
13.     @BeforeClass // 注意,这里必须是static...因为方法将在类被装载的时候就被调用(那时候还没创建实例)  
14.     public static void before()  
15.     {  
16.         System.out.println("global");  
17.     }  
18.   
19.     @AfterClass  
20.     public static void after() {  
21.         System.out.println("global destroy");  
22.     }  
23.   
24.     @Before  
25.     public void setUp() throws Exception {  
26.         System.out.println("一个测试开始。。");  
27.     }  
28.   
29.     @After  
30.     public void tearDown() throws Exception {  
31.         System.out.println("一个测试结束");  
32.     }  
33.   
34.     @Test  
35.     @Ignore  
36.     public void testAdd() {  
37.         int result = cal.add(1, 2);  
38.         Assert.assertEquals(3, result);  
39.     }  
40.   
41.     @Test  
42.     public void testMinus() {  
43.         int result = cal.minus(5, 2);  
44.         Assert.assertEquals(3, result);  
45.     }  
46.   
47.     @Test  
48.     public void testMultiply() {  
49.         int result = cal.multiply(4, 2);  
50.         Assert.assertEquals(8, result);  
51.     }  
52.   
53.     @Test(timeout = 1000) // 单位为毫秒  
54.     public void testSquareRoot() {  
55.         cal.squareRoot(4);  
56.     }  
57.   
58.     @Test(expected = Exception.class)  
59.     public void testDivide() throws Exception {  
60.         System.out.println("teddd");  
61.         cal.divide(4, 0);// 很简单的办法.......  
62.     }  
63.   
64. //  @Test  
65. //  public void testDivide() {  
66. //      int result = 0;  
67. //      try {  
68. //          result = cal.divide(10, 5);  
69. //      } catch (Exception e) {  
70. //          e.printStackTrace();  
71. //          Assert.fail();// 如果这行没有执行。说明这部分正确。  
72. //      }  
73. //      Assert.assertEquals(2, result);  
74. //  }  
75. }  

运行测试类截图：

 可以看到，CalculatorTest类中总共有5个测试用例，ignore了一个，3个测试用例通过，testSquareRoot测试不通过（因为超时），所以整个的测试结果飘红了。同时，控制台的输出结果为：

1. global  
2. 一个测试开始。。  
3. 一个测试结束  
4. 一个测试开始。。  
5. 一个测试结束  
6. 一个测试开始。。  
7. 一个测试结束  
8. 一个测试开始。。  
9. teddd  
10. 一个测试结束  
11. global destroy  

第三次作业

标签：

原文地址：http://www.cnblogs.com/liucong2dy/p/5860242.html