单元测试

╰半橙微兮° 2022-02-22 08:53 542阅读 0赞

**1、测试类型有哪些？**  
各种常用的测试类型有：  
![测试类型][20190409080208505.png]  
**单元测试（unit test）：**

可测试代码的最小的一部分。通常是一个单一的方法，不会使用其它方法或者类。非常快！上千个单元测试能够在10秒以内跑完！单元测试永远不会使用：

*  数据库
 *  一个app服务器（或者任何类型的服务器）
 *  文件/网络 I/O或者文件系统
 *  另外的应用
 *  控制台（System.out,system.err等等）
 *  日志
 *  大多数其他类（但不包括DTO‘s，String,Integer,mock和一些其他的类）

单元测试几乎总是回归测试套件（regression suite）的一部分。

**回归测试套件（Regression Suite）:**

能够立刻被运行的测试用例的集合。一个例子就是放在一个特定文件夹中的能够被Junit运行的所有测试用例。一个开发人员能够在一天中把一个单元测试回归套件运行20次或者他们可能一个月跑两次功能测试回归套件。

**功能测试（Functional Test）:**

比一个单元要大，比一个完整的组件测试要小。通常为工作在一起的的几个方法/函数/类。上百的测试用例允许运行几个小时。大部分功能测试是功能测试回归套件的一部分。通常由Junit来运行。

**组件测试（Component Test）:**

运行一个组件。经常由QA，经理，XP客户等等来执行。这种类别的测试不是回归套件的一部分，它不由Junit来执行。

**组件验收测试（Component Acceptance Test C.A.T.）:**

作为正常流程的一部分，它是在众多人面前运行的一个组件测试。由大家共同决定这个组件是不是满足需求标准。

**集成测试（Integration Test）:**

测试两个或者更多的组件一起工作的情况。有时候是回归套件的一部分。

**系统测试（system Test）：**

所有的组件在一起运行。

**系统验收测试（System Acceptance Test S.A.T.）:**

作为正常流程的一部分，它是在众多人面前运行的一个系统测试，由大家来共同决定这个系统是不是满足需求标准。

**压力测试（Stress Tests）:**

另外一个程序加载一个组件，一些组件或者整个系统。我曾经看到过把一些小的压力测试放到回归功能测试中来进行——这是测试并发代码的一个很聪明的做法。

**2、单元测试介绍**

**2.1 单元测试简介**

单元测试用于测试各个代码组件，并确保代码按照预期的方式工作。单元测试由开发人员编写和执行。大多数情况下，使用JUnit或TestNG之类的测试框架。测试用例通常是在方法级别写入并通过自动化执行。

单元测试不仅仅用来保证当前代码的正确性，更重要的是用来保证代码修复、改进或重构之后的正确性。

**2.2 单元测试相关概念**

**2.2.1 正面测试（Positive Testing）**

测试被测对象的正确功能实现无误，即正常流程功能。往往需要根据设计说明进行用例导出，严格按照设计说明编写即可，用例划分注意等价类区分等方法。

**2.2.2 负面测试（Negative Testing）**

测试被测对象的异常功能实现无误，多在异常流程，异常数据中体现。该部分测试需要对被测对象进行错误发散，常依赖于边界值区分等方法。

**2.2.3 分支测试**

使用流程图，明确可能出现的每条分支，制造响应的数据进行覆盖，实现对被测对象的测试。这个过程对于分支可以进行响应的简化，可以穿插等价类等方法去除同类分支。

**2.2.3 边界值分析法**

这种方法更偏向于黑盒测试用例设计中使用，对被测输入进行边界分析，从各个角度都会有边界值，例如程序内部依赖之间，已经有一些边界存在，在程序集成展示后，也会有新的边界出现，在设计的时候，需要注意这些细节。例如我们可输入范围是3-6，和输入类型为浮点数。那么边界值为7-8之间

**3、单元测试的特性**

**3.1、单元测试的原则**

为了提高开发人员的代码质量，编写高质量的单元测试，要遵守3R（Responsible, Reliable, Repeative）原则，具体含义如下：

Responsible: 谁开发谁负责测试，在哪里开发就在哪里测试。

Reliable: 测试case要可靠，并且是值得信赖的，对于底层的任何改动都要能够及时感知。

Repeative: 所有单元测试用例都要能够重复运行。能够重复运行就能够进行回归测试、覆盖率统计等等。

**3.2、单元测试的好处**

1.  单元测试不但会使你的工作完成得更轻松。而且会令你的设计会变得更好，甚至大大减少你花在调试上面的时间
2.  提高代码质量
3.  减少bug，快速定位bug
4.  放心地修改、重构

**3.3、断言**

**断言** 是一种放在程序中的一阶逻辑（如一个结果为真或是假的逻辑判断式），目的是为了标示与验证程序开发者预期的结果－当程序运行到断言的位置时，对应的断言应该为真。若断言不为真时，程序会中止运行，并给出错误消息

**常用断言**

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>void assertEquals(boolean expected, boolean actual)</td> 
   <td>检查两个变量或者等式是否平衡</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>void assertTrue(boolean expected, boolean actual)</td> 
   <td>检查条件为真</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>void assertFalse(boolean condition)</td> 
   <td>检查条件为假</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>void assertNotNull(Object object)</td> 
   <td>检查对象不为空</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>void assertNull(Object object)</td> 
   <td>检查对象为空</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>void assertSame(boolean condition)</td> 
   <td>检查两个相关对象是否指向同一个对象</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>void assertNotSame(boolean condition)</td> 
   <td>检查两个相关对象是否不指向同一个对象</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>void assertArrayEquals(expectedArray, resultArray)</td> 
   <td>检查两个数组是否相等</td> 
  </tr> 
 </tbody> 
</table>

上表列举了常用的八种断言，事实上我们在实际使用中并不需要自己编写这些基础的断言，java的编程框架JUnit已经集成了这些断言和一系列单元测试相关的函数。

JUnit 是一个 Java 编程语言的单元测试框架（回归测试框架）。JUnit 在测试驱动的开发方面有很重要的发展，是起源于 JUnit 的一个统称为 xUnit 的单元测试框架之一。JUnit 促进了“先测试后编码”的理念，强调建立测试数据的一段代码，可以先测试，然后再应用。

**3.4、测试组件与注解**

**test suite：** 测试套件，又称验证套件（validation suite），是测试用例的集合。

**suite()：**

任何测试类都可以包含suite()静态方法，我们可以通过suite()返回任意的测试用例集合。无suite()，默认执行当前类所有的测试用例

举例：  
TestCaseOne执行所有用例；  
TestCaseTwo执行部分用例；  
代码如下：

// TestClassOne.java
    import junit.framework.*;
    public class TestClassOne extends TestCase { 
        public TestClassOne(String method) { 
            super(method);
        }
        public void testadd() { 
            assertEquals(4,2+2);
        }
        public void testsub() { 
            assertEquals(0,2-2);
        }
    }
    
    // TestClassTwo
    import junit.framework.*;
    public class TestClassTwo extends TestCase { 
        public TestClassTwo(String method) { 
            super(method);
        }
        public void testmul() { 
            assertEquals(4,2*2);
        }
        public void testdiv() { 
            assertEquals(0.667,2/3);
        }
        public static Test suite() { 
            TestSuite suite = new TestSuite();
            //此时我们可以看到给构造函数的String参数让TestCase返回了一个对命名测试方法的引用
            suite.addTest(new TestClassTwo("testmul"));
            return suite;
        }
    }
    
    // TestClassComposite
    import junit.framework.*;
    //TestClassComposite来组合两个类的测试方法
    public class TestClassComposite extends TestCase { 
        public TestClassComposite(String method) { 
            super(method);
        }
        static public Test suite() { 
            TestSuite suite = new TestSuite();
            //include everything in TestClassOne
            suite.addTestSuite(TestClassOne.class);
            //use the suite method in TestClassTwo
            suite.addTest(TestClassTwo.suite());
            return suite;
        }
    }

**Setup和Tear-down用于环境/资源的建立和清理**

每个测试的运行都应该是相互独立的，在每个测试开始之前，会需要重新设置某些测试环境，在测试完成后释放这些资源。JUnit的TestCase提供了两个方法以供改写，分别用于环境/资源的建立和清理

protected void setUp();
    protected void tearDown();

比如：我们的每个测试都需要进行数据库连接的话，借助于Setup和Tear-down就不用再每个测试方法中重复写数据库连接的语句，而只需在Setup和Tear-down中分别建立和释放连接

// Per-method的Setup和Tear-down用于环境/资源的建立和清理
    public class TestDB extends TestCase { 
        private Connection dbConnection;
        public TestDB(String method) { 
            super(method);
        }
        protected void setUp() { 
            dbConnection = new Connection("oracle",123456,"wtli");
            dbConnection.connect();
        }
        protected void tearDown() { 
            dbConnection.disconnect();
            dbConnection = null;
        }
        public void testAdminAccess() { 
            ...
        }
        public void testGuestAccess() { 
            ...
        }
    }

**注解：**

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>注解</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>@Test</td> 
   <td>注解描述的方法，可以作为一个测试案例</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>@Before</td> 
   <td>表达执行顺序，@Before修饰的方法在@Test修饰的方法<strong>之前</strong>执行</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>@After</td> 
   <td>表达执行顺序，@Before修饰的方法在@Test修饰的方法<strong>之后</strong>执行</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>@BeforeClass</td> 
   <td>注解描述的方法，将在类的所有方法执行<strong>之前</strong>执行</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>@AfterClass</td> 
   <td>注解描述的方法，将在类的所有方法执行<strong>之后</strong>执行</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>@Ignore</td> 
   <td>注解描述的方法，会被忽略，不会执行</td> 
  </tr> 
 </tbody> 
</table>

执行顺序：

beforeClass() 方法首先执行，并且只执行一次。  
afterClass() 方法最后执行，并且只执行一次。  
before() 方法针对每一个测试用例执行，但是是在执行测试用例之前。  
after() 方法针对每一个测试用例执行，但是是在执行测试用例之后。  
在 before() 方法和 after() 方法之间，执行每一个测试用例。

**3.5、Mock**

在单元测试中，实际上经常遇到这种情况：某个方法依赖于其他一些难以掌握的东西，诸如网络、数据库、甚至是servlet引擎，那么该如何进行单元测试。实际上解决这些问题，我们需要的就是找一个“替身”来模拟这些情况。幸运的是，有一种测试模式可以帮助我们：mock对象。

Mock对象  
Mock对象就是真实对象在调试器的替代品。之所以使用mock对象来模拟条件而不是使用真实对象有以下原因：

1.  真实对象具有不可确定的行为，产生不可预测的结果
2.  真实对象很难被创建
3.  真实对象的某些行为很难被触发（如上一章提到的网络错误）
4.  真实对象令程序的运行速度很慢
5.  真实对象有用户界面
6.  测试需要询问真实对象它是如何被调用的（如：测试可能需要验证某个回调函数是否被调用）
7.  真实对象实际上并不存在（当需要和其他的开发小组打交道，这是个不可避免的问题）
8.  被测试代码只会通过接口来引用对象，所以它完全可以不知道它引用的究竟是真实对象还是mock对象

在使用mock对象进行测试的时候，有三个关键的步骤：

1.  使用接口描述此对象
2.  为产品代码实现这个接口
3.  以测试为目的，在mock对象中实现这个接口

**举例：测试Servlet**

/** * 待测试类 *执行：华氏温度转化为设置温度 */
    public class TemperatureServlet { 
        /* public void init() throws ServletException{ String str_f = " "; }*/
        public void doGet(HttpServletRequest req,HttpServletResponse res)
        throws ServletException, IOException{ 
            String str_f = req.getParameter("Fahrenheit");
            res.setContentType("text/html");
            PrintWriter out = res.getWriter();
            try { 
                int temp_f = Integer.parseInt(str_f);
                double temp_c = (temp_f - 32)*5.0/9.0;
                out.println( "Fahrenheit: " + temp_f + ", centigrade: " + temp_c);
            }catch(NumberFormatException e) { 
                out.println( "Invalid temperature: "+str_f);
            }
        }
    }

相应的测试代码其实就是要构建出request和response对象。其中，相应的HttpServletRequest和HttpServletResponse都是接口，所以我们要做的就是写出两个类来实现这个接口，并且使用它们。不要担心，真正使用是时候我们并不用自己来实现这些类，有现成的mock对象框架可供我们选用。代码如下：

// TemperatureServletTest.java
    import junit.framework.*;
    import com.mockobjects.servlet.*;
    import com.mockobjects.*;
    import com.mockobjects.Verifiable;
    public class TemperatureServletTest extends TestCase { 
        public void testTrue() throws Exception { 
            TemperatureServlet s = new TemperatureServlet();
            MockHttpServletRequest request = new MockHttpServletRequest();
            MockHttpServletResponse response = new MockHttpServletResponse();
            request.setupAddParameter("Fahrenheit", "212");
            response.setExpectedContentType("text/html");
            s.doGet(request, response);
            response.verify();
            assertEquals("Fahrenheit: 212, centigrade: 100.0\n" , response.getOutputStreamContents());
        }
        public void testError() throws Exception { 
            TemperatureServlet s = new TemperatureServlet();
            MockHttpServletRequest request = new MockHttpServletRequest();
            MockHttpServletResponse response = new MockHttpServletResponse();
            request.setupAddParameter("Fahrenheit", "wrong");
            response.setExpectedContentType("text/html");       
            s.doGet(request, response);
            response.verify();
            assertEquals("Invalid temperature: wrong\n",response.getOutputStreamContents());
        }
    }

参考：  
[https://www.cnblogs.com/harlanc/p/6838155.html][https_www.cnblogs.com_harlanc_p_6838155.html]  
[https://blog.csdn.net/potatostyles/article/details/79152107][https_blog.csdn.net_potatostyles_article_details_79152107]

[20190409080208505.png]: /images/20220222/0e4eb9b95c7947749119609335749f2d.png
[https_www.cnblogs.com_harlanc_p_6838155.html]: https://www.cnblogs.com/harlanc/p/6838155.html
[https_blog.csdn.net_potatostyles_article_details_79152107]: https://blog.csdn.net/potatostyles/article/details/79152107