java JUnit_java junit

JUnit是什么？

• JUnit是一个Java语言的单元测试框架。它由Kent Beck和Erich Gamma建立，逐渐成为源于Kent Beck的sUnit的xUnit家族中最为成功的一个。
  JUnit有它自己的JUnit扩展生态圈。多数Java的开发环境都已经集成了JUnit作为单元测试的工具。
• JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing framework）。Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。Junit是一套框架，继承TestCase类，就可以用Junit进行自动测试了。

JUnit的作用是什么？

通俗来讲，JUnit就是用来帮我们进行代码测试的。大家都知道，平时我们要测试一段代码是否正确，就必须创建main（）方法对其进行测试。JUnit大大简化了这个操作，可以使我们在不创建main（）方法的情况下，对所要进行测试的方法进行测试，真正简单的做到“写一点，测一点”，方便我们发现错误，减少回归错误的纠错程度。

JUnit怎么使用呢？

• 方法一：先下载JUnit的jar包：JUnit4的官网下载地址，下载 junit.jar 和 hamcrest-core.jar 并导入eclipse工程（读者也可自行下载JUnit5），Build—>Add Build Path即可。

• 方法二：或者可以使用eclipse内部集成的JUnit，我们进行引入即可：右击我们创建的项目→ Build Path → Add Libraries… → 选择JUnit → 选择版本（JUnit5或JUnit4等，一般我们都使用JUnit4.0版本以上）。
  

先看下面给出的例子，感受一下JUnit的作用：

①、创建Calculator类，该类为将要进行测试的类：

/**
 * 需要进行单元测试的类
 * @author leidada
 *
 */
public class Calculator {
    /**
     * 计算a和b的和
     * @param a
     * @param b
     * @return
     */
    public int add(int a,int b){
        return a+b;
    }
    
    /**
     * 计算a和b的差
     * @param a
     * @param b
     * @return
     */
    public int sub(int a,int b){   
        return a-b;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

②、首先，让我们不使用JUnit，通过创建类Calculator的mian（）方法对其进行测试：

/**
 * 使用普通方法对Calculator类进行测试
 * @author leidada
 *
 */
public class CalculatorTest {
	public static void main(String[] args) {
		Calculator c = new Calculator();
		/**
		 * 测试add方法
		 */
		int result1 = c.add(2, 3);
		if(result1 == 5) {
			System.out.println("sum方法正确");
		}
		
		/**
		 * 测试sub方法
		 */
		int result2 = c.sub(3, 2);
		if(result2 == 1) {
			System.out.println("sub方法正确");
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

通过上述代码可以看出，我们的测试代码只能写在main方法中，通过输出结果才可以判断代码是否正确。而且我们所进行测试的方法只有两个，但当测试方法数量变多时，试想一下，我们是不是要创建很多个这样的方法并输出才可以判断出代码的正确性呢？对我们程序员来说就非常的不友好了。JUnit就很好的解决了这个问题。

③、使用JUnit进行测试，创建类CalculatorTestJUnit:

import org.junit.Assert;
import org.junit.Test;

public class CalculatorTestJUnit {
	@Test
	public void testAdd() {
		Calculator c = new Calculator();
		int result = c.add(3, 2);
		Assert.assertEquals(5, result);
	}
	
	@Test
	public void testSub() {
		Calculator c = new Calculator();
		int result = c.sub(3, 2);
		Assert.assertEquals(1, result);
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

上述代码中的@Test是JUnit的一种注解，用来告诉JUnit这个方法需要进行测试，而且，JUnit还支持单一方法的测试，需要对那个方法进行测试，则双击该方法名选择该方法，右击 --> Run As -->JUnit Test。若左边出现绿色横条说明测试通过，红色横条则测试失败。

和通过mian（）方法进行测试相比，使用JUnit方法不仅减少了我们的编码量，而且还可以很方便的测试其中的任意一个方法，方法和测试结果一一对应，逻辑清晰。是不是很方便呢？

关于JUnit常用注解的解释

• @Test: 测试方法：告诉JUnit哪个方法需要被测试。
  　　　①、(expected=XXException.class)如果程序的异常和XXException.class一样，则测试通过
  　　　②、(timeout=100)如果程序的执行能在100毫秒之内完成，则测试通过

• @Ignore: 被忽略的测试方法：加上之后，暂时不运行此段代码。

• @Before: 在每一 @Test测试方法运行之前 运行的方法，通常用来创建测试类的实例等。

• @After: 在每一 @Test测试方法运行之后 运行的方法。

• @BeforeClass: 方法必须要是静态方法（static 声明），所有测试开始之前运行，注意区分before，是所有测试方法。

• @AfterClass : 方法必须要是静态方法（static 声明），所有测试结束之后运行，注意区分 @After

• 注意事项： 每一个测试方法必须使用@Test标注，且@Test标注的方法不能带有返回值，必须是void类型； 测试类使用Test作为类名的后缀（不是必须）； 测试方法使用test作为方法名的前缀（不是必须）；

• 接下来我们用@Before对上面的JUnit测试方法进行改进：

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class CalculatorTestJUnit {

	Calculator c = null;
	
	@Before
	public void testBefore() {
		c = new Calculator();
	}
	
	@Test
	public void testAdd() {
		int result = c.add(3, 2);
		Assert.assertEquals(5, result);
	}
	
	@Test
	public void testSub() {
		Calculator c = new Calculator();
		int result = c.sub(3, 2);
		Assert.assertEquals(1, result);
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

这里将Calculator的实例化放到了@Before标注的方法中；

@BeforeClass、@AfterClass等的方法执行顺序

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;

public class Test {
	/**
	 *  对注解进行区别：
	 *  将常用的注解放在这一个类中，用来观察方法的运行顺序。
	 */
	public Test() {
        System.out.println("构造函数");
    }
 
    @BeforeClass
    public static void beforeClass(){
        System.out.println("@BeforeClass");
    }
     
    @Before
    public void before(){
        System.out.println("@Before");
    }
     
    @org.junit.Test
    public void test(){
        System.out.println("@Test");
    }
     
    @Ignore
    public void ignore(){
        System.out.println("@Ignore");
    }
     
    @After
    public void after(){
        System.out.println("@After");
    }
     
    @AfterClass
    public static void afterClass(){
        System.out.println("@AfterClass");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

结果为：

@BeforeClass
构造函数
@Before
@Test
@After
@AfterClass
1
2
3
4
5
6

以上就是JUnit的简单使用方法，希望对大家有所帮助。