Junit4 简单教程(转载)

时间:2023-01-07 05:08:57

一、环境搭建

       对于习惯使用Eclipse开发平台来说,Junit早已是非常通常的插件,在Eclipse开发平台中,可以非常方便地搭建Junit测试环境。

       1、在Eclipse上创建工程,任何Java工程都行。

       2、引入Junit的libraries库,选用Junit4。如下图所示:

Junit4 简单教程(转载)Junit4 简单教程(转载)Junit4 简单教程(转载)

3、新建一个Java类,用于演示Junit4类的自动生成,java代码如下:

[java] view plaincopyJunit4 简单教程(转载)Junit4 简单教程(转载)
  1. package com.hy;  
  2.   
  3. public class Demo {  
  4.   
  5.     public void method1() {  
  6.         System.out.println("method1");  
  7.     }  
  8.   
  9.     public void method2() {  
  10.         System.out.println("method2");  
  11.     }  
  12.   
  13.     public void method3() {  
  14.         System.out.println("method3");  
  15.     }  
  16.   
  17. }  

4、在该类上右键单击新建,选JUnit Test Case,自动生成一个对应的测试类,如下图所示:

Junit4 简单教程(转载)Junit4 简单教程(转载)


4、这样就能自动地生成对应的测试类了,测试类代码发下:

[java] view plaincopyJunit4 简单教程(转载)Junit4 简单教程(转载)
  1. package com.hy;  
  2.   
  3. import static org.junit.Assert.*;  
  4.   
  5. import org.junit.After;  
  6. import org.junit.AfterClass;  
  7. import org.junit.Before;  
  8. import org.junit.BeforeClass;  
  9. import org.junit.Test;  
  10.   
  11. public class DemoTest {  
  12.   
  13.     @BeforeClass  
  14.     public static void setUpBeforeClass() throws Exception {  
  15.     }  
  16.   
  17.     @AfterClass  
  18.     public static void tearDownAfterClass() throws Exception {  
  19.     }  
  20.   
  21.     @Before  
  22.     public void setUp() throws Exception {  
  23.     }  
  24.   
  25.     @After  
  26.     public void tearDown() throws Exception {  
  27.     }  
  28.   
  29.     @Test  
  30.     public void testMethod1() {  
  31.         fail("Not yet implemented");  
  32.     }  
  33.   
  34.     @Test  
  35.     public void testMethod2() {  
  36.         fail("Not yet implemented");  
  37.     }  
  38.   
  39.     @Test  
  40.     public void testMethod3() {  
  41.         fail("Not yet implemented");  
  42.     }  
  43.   
  44. }  


5、如此一来,测试类环境的搭建过程就完成了,最后要做的就是,根据实际的业务需求,对测试类中的测试方法编写单元测试代码,直到运行调通。

 

二、基本规则

       从上面的演示可知,测试类名一般都以Test结尾,测试方法名以test开头。这个也是Junit的基本命名规则。

 

三、Junit注解

      我们此次针对的是Junit4版本,注解也是在Junit4版本才有的,之前的版本并无注解功能。而注解开发基本上被认为是一种优秀的设计,所以我们写单元测试用例时,尽可能地去了解并使用注解。

     @Test:使用该注解的方法为测试方法,自动运行时能够识别并被执行

      包含两个参数:expected=XXXException.class 期望出现的异常

                               timeout=xxx 设定程序运行的超时时间

     @Ignore:被忽略的测试方法

     @Before:在每个测试方法之前运行

     @After: 在每个测试方法之后运行

     @BeforeClass:在所有测试开始之前运行

     @AfterClass:在所有测试开始之后运行
  

      以上几个就是Junit 4的关键注解,熟练使用这几个注解,将来的测试用例编写肯定能事半功倍。

     注意:@Before与@BeforeClass的区别

     @Before会加在每个方法前执行,即有几个@Test就会执行几遍。

     @BeforeClass 只在所有测试之前执行,只会执行一次。并且@BeforeClass修饰的方法必须是公有的静态方法(public static )。

     @After和@AfterClass也类似

     每个测试类中这四个注解不能重复使用,一个方法只能从这四个注解中挑选其中一个。

 

四、基本写法

       1、setUp(),tearDown(),setUpBeforeClass(),tearDownAfterClass()这四个方法其实就是对应的@Before、@BeforeClass、@After、@AfterClass这四个注解,在Junit4开始使用注解时,其实可以替代这四个方法的功能,只是这四个方法是历史遗留方法,可以考虑使用,也可以直接使用注解替代。

       2、Assert是单元测试用例的核心,建议使用静态导入。

       3、待测试对象,一般建议设计成静态的。

       4、测试方法的要求:带@Test注解,方法名随意,返回值必须为void,不能带有参数,可以声明异常(可以参考演示代码)。

       5、Fixture方法的作用

            前面介绍的@Before、@BeforeClass、@After、@AfterClass注解修饰的方法,即为Fixture方法,它是在某些阶段必然被调用的方法,如注解功能所示。

            @Before、@After修饰方法的一个用处是对待测试对象的“复原”操作,如成员变量回归,数据库回滚等,目的是消除@Test方法之间的耦合。也可以用来打印日志。

            @BeforeClass修饰方法可以设计成用来加载一些耗时耗力的操作,如文件流的读取,数据库连接等,然后在@AfterClass中释放对应的资源即可。

      6、限时测试

           @Test(timeout=1000)超时时间单位为毫秒

           用于测试是否有死循环工是实时性要求比较高的用例,这个非常方便而且非常有用。

      7、测试异常

            @Test(expected=XXXException.class) XXXException为声明式异常

            用来验证声明式异常,注意此测试的含义:出现了期望的异常,叫做正常,若没出现异常,Junit会报错,认为不正常。这段描述有些拗口,请各位多琢磨琢磨。

      8、运行器Runner

            类注解@RunWith,指定不同的类可以改变测试类的行为

      9、参数化测试

            主要是针对一些相同功能却要进行多组参数测试的情况,开发步骤如下:

            1)参数化测试的类和普通测试类不同,要用特殊的Runner,类注解需要改为@RunWith(Parameterized.class)

            2)定义该测试类的成员变量,一个放测试参数,另一个放该参数产生的预期结果

            3)定义测试数据集合方法 public static Collection data() {...},注意该方法要用@Parameters修饰(数据格式为二维数组)

            4)定义带参数的构造函数,注意定义数据集合时,要和构造函数参数次序一致

            其他的与普通测试类似

            注意:若测试数据有两条,则该类下的所有@Test的方法都会执行两次,所以参数化测试的类不要和别的@Test放在一起。参数化测试方法一般建议单独建立类。

            演示代码如下:

[java] view plaincopyJunit4 简单教程(转载)Junit4 简单教程(转载)
  1. //指定@RunWith  
  2. @RunWith(Parameterized.class)  
  3. public class ParamTest {  
  4.   
  5.     //定义成员变量,i为测试参数,j为测试结果  
  6.     private int i;  
  7.     private int j;  
  8.   
  9.     //构造函数  
  10.     public ParamTest(int i, int j) {  
  11.         super();  
  12.         this.i = i;  
  13.         this.j = j;  
  14.     }  
  15.   
  16.     //测试数据集合,注意使用的注解,数据结构及次序  
  17.     @Parameters  
  18.     public static Collection data() {  
  19.         return Arrays.asList(new Object[][]{{1,2},{3,4},{4,6}});  
  20.     }  
  21.     @Test  
  22.     public void testMethod1() {  
  23.         System.out.println(i);  
  24.         System.out.println(j);  
  25.         //简单测试,只测试参数加1会不会等于预期结果  
  26.         Assert.assertEquals(i+1, j);  
  27.     }  
  28. }  

       预期的执行结果是前两组参数测试正确,最后一组测试错误,运行后的结果为:Junit4 简单教程(转载)

执行结果与预期结果相符合,OK

 

      10、打包测试

            将测试类集中起来运行,提高测试效率,代码如下:

[java] view plaincopyJunit4 简单教程(转载)Junit4 简单教程(转载)
  1. @RunWith(Suite.class)  
  2. @Suite.SuiteClasses({  
  3.     DemoTest.class  
  4. })  
  5. public class ModuleTest {  
  6.   
  7.     public ModuleTest() {  
  8.         // TODO Auto-generated constructor stub  
  9.     }  
  10.   
  11. }  

           1)@Suite.SuiteClasses里面的是需要打包测试的类

           2)该类中可以为空,类名建议为模块名+Test结尾,如ModuleTest.java

      以上是Junit4的最基本的使用,相信掌握了这些,对于编写常规的测试用例已经不是难事,同样,Junit还有更多更有意思的功能等待我们去挖掘……