Junit的基本使用

Junit 使用详解

1.Junit是什么？

JUnit是一个java语言的开源单元测试框架。用于编写和运行可重复的测试。
Junit测试是一种白盒测试。它能知道被测试软件如何完成功能能和完成什么样的功能。

1. 提供的功能：
   
   • 断言测试预期结果。
   • 测试功能共享通用的测试数据。
   • 测试套件轻松地组织和运行测试。
   • 图形和文本测试运行。
2. 作用范围：
   
   • 整个对象
   • 对象的一部分，如方法
   • 对象间的交互

那么如何通过Junit来进行测试的呢？因为他其实本身就是一个框架，所以得将它导入。不过现在的常用IDE本身都自带了Junit。通过断言和注解的方式实现测试的。

如何建立测试类？
在eclipse中File -> new -> Junit Test Case ，就可以为某一个类建立测试类了

2.Junit注解

在Junit4的基本注释中，基本的注释就有六种

注释	描述
@Test	注解的方法为测试用例，可以使用两个参数“expected”以及“timeout
@Before	注解的public void方法在测试方法前执行，用来执行某些先决条件
@BeforeClass	用来注解public static void方法，并且不带参数，会在测试方法前执行，并且只执行一次
@After	注解的public void方法在测试方法结束后执行
@AfterClass	注解的public static void方法在测试类中所有测试方法执行完后执行
@Ignore	被注解狗的方法不被执行

我们通过一个例子了解下。

import static org.junit.Assert.*;
import java.util.*;
import org.junit.*;


public class AnnotationTest {
    @BeforeClass
    public static void executedBeforeClass() {
        System.out.println("@BeforeClass");
    }

    @Before
    public void executedBefore() {
        System.out.println("@Before");
    }

    @AfterClass
    public static void executedAfterClass() {
        System.out.println("@AfterClass");
    }

    @After
    public void executedAfter() {
        System.out.println("@After");
    }

    //测试是否超时，这里表示不超过100ms则通过测试
    @Test(timeout = 100)
    public void executedTestOne() {
        System.out.println("@Test1");
    }

    //测试是否抛出异常，抛出该指定异常则通过测试
    @Test(expected = ArithmeticException.class)
    public void executedTestTwo() {
        System.out.println("@Test2");
        int i = 1/0;
        System.out.println("@Test3");
    }

    @Ignore
    public void executionIgnored() {
        System.out.println("@Ignore");
    }
}

最后面的输出结果为

@BeforeClass
@Before
@Test1
@After
@Before
@Test2
@After
@AfterClass    

通过上面的测试用例，我们可以得出以下结论
1. BeforeClass和AfterClass注解的方法必须为静态方法。而且这两个静态方法只执行一次
2. 注解方法执行的顺寻为BeforeClass>Before>Test>After>AfterClass。
3. 在每次执行Test之前都会执行Before，之后都会执行After。
4. 至于多个Test的执行顺寻是不固定，目前Test的执行是根据反射API的返回的顺寻执行，若要指定。需要使用@FixMethodOrder的方法。这里不在介绍，有兴趣的小伙伴可以自己找找。
5. Test1设置了一个参数timeout = 100，代表这运行时间不超过100ms，则通过测试
6. Test2设置了一个参数expected = ArithmeticException.class，代表着如果出现该异常，则通过测试。显然1/0会出现该运算异常，所以会通过测试。如果不发生该异常，则表明不通过测试，如改为1/1,是无法通过测试的。
7. 如果发生捕抓到了目标异常，则直接跳出方法，就像test3不输出一样

2.Junit断言

我想断言很多人都听说过。下面是一些Junit常用的断言方法

断言	描述
void assertEquals([String message], expected value, actual value)	断言两个值相等。值可能是类型有 int, short, long, byte, char or java.lang.Object. 第一个参数是一个可选的字符串消息
void assertTrue([String message], boolean condition)	断言一个条件为真
void assertFalse([String message],boolean condition)	断言一个条件为假
void assertNotNull([String message], java.lang.Object object)	断言一个对象不为空(null)
void assertNull([String message], java.lang.Object object)	断言一个对象为空(null)
void assertSame([String message], java.lang.Object expected, java.lang.Object actual)	断言，两个对象引用相同的对象
void assertNotSame([String message], java.lang.Object unexpected, java.lang.Object actual)	断言，两个对象不是引用同一个对象
void assertArrayEquals([String message], expectedArray, resultArray)	断言预期数组和结果数组相等。数组的类型可能是 int, long, short, char, byte or java.lang.Object.

下面我就举一个简单的测试例子

    @Test
    public void test() {
        String obj1 = "junit";
        String obj2 = "junit";
        String obj3 = "test";
        String obj4 = "test";
        String obj5 = null;
        assertEquals(obj1, obj2);

        assertSame(obj3, obj4);

        assertNotSame(obj2, obj4);

        assertNotNull(obj1);

        assertNull(obj5);
    }

可以发现上面的断言方法是可以工作的。
(在eclipse中Junit窗口中表示为绿色，表明可以进行工作，而红色则表示有问题)

3.套件测试

在讲述如何进行套件测试之前，我们必须先明白几个概念

• 测试方法：用@Test注解的方法
• 测试类：XXTest.java。这个类包含着这@Test注解的方法
• 测试集：简单理解为测试类的集合。默认测试集为Suite.class
• 测试运行器：决定使用哪一种测试方法/类/集。一般默认的测试运行器为Junit4.class

从上面概念可以知道从上往下，范围越来越大。

这里新增加了两个注释，@RunWith以及@SuiteClasses

使用方法如下

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)
@Suite.SuiteClasses({ TestOne.class, TestTwo.class })
public class SuitTest {

}

上面代码中，TestOne和TestTwo为两个测试类，里面都包含了自己的测试方法。
我们可以发现，SuiteClasses方法是将两个测试类加入测试集。
而RunWith是以Suite.class这个测试集为运行器来运行。

这样子感觉套件测试好像没有什么用的样子，它其实就是将一系列的测试用例结合在一起，然后按照测试计划所定义的阶段来进行测试。

5.参数测试

我们需要测试的方法当然不可能都是无参数的。更多的时候是带参数的。那我们还是自己手动输入参数，显然不可能，这样效率低而且容易出错。同样的，Junit也给我们带来了带参数的测试方法。

不过要对一个测试类进行参数化测试。那么该测试类需要满足下面几个条件
1. 该类被注解为@RunWith(Parameterized.class)
（Parameterized 是一个进行参数化测试的测试类指定的特殊运行器）
2. 该类有一个带参数构造函数，用来存储数据
3. 需要用@Parameters注解的一个静态方法生成并返回测试数据
4. 有测试方法

下面我们通过一个例子来说明如何进行参数测试

import static org.junit.Assert.assertEquals;
import java.util.Arrays;
import java.util.Collection;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

//RunWith(Parameterized.class)注解

@RunWith(Parameterized.class)
public class CalculateTest {

    private int expected;
    private int first;
    private int second;

    //构造方法
    public CalculateTest(int expectedResult, int firstNumber, int secondNumber) {
        this.expected = expectedResult;
        this.first = firstNumber;
        this.second = secondNumber;
    }

    //生成数据的方法
    @Parameters
    public static Collection addedNumbers() {
        return Arrays.asList(new Integer[][] { { 3, 1, 2 }, { 5, 2, 3 },
                { 7, 3, 4 }, { 9, 4, 5 }, });
    }

    //测试方法
    @Test
    public void sum() {
        //Calculate里面有一个相加的方法
        Calculate add = new Calculate();
        System.out.println("Addition with parameters : " + first + " and "
                + second);
        assertEquals(expected, add.sum(first, second));
    }
}

这里定义了一个Calculate对象，里面有一个相加的方法。改测试类就是用来测试Calculate类的
从上面代码可以看出，他满足进行参数化的所有条件。下面我们看看控制台的输出结果、

Addition with parameters : 1 and 2
Adding values: 1 + 2
Addition with parameters : 2 and 3
Adding values: 2 + 3
Addition with parameters : 3 and 4
Adding values: 3 + 4
Addition with parameters : 4 and 5
Adding values: 4 + 5

其中addNumbers方法提供了测试所用的数据。然后送到测试方法里面。这样子我们就在测试的时候，不用，每次都手动输入参数。如果要修改输入的参数，只需要在这个方法里面修改就好了。

以上就是Junit的一些基本使用~当然Junit还有很多东西，有兴趣的小伙伴可以进一步了解