Junit

Jnit

1. org.junit.Assert 类：这个类提供了一系列的编写测试的有用的声明方法。只有失败的声明方法才会被记录。
2. org.junit.TestCaset 类：测试样例定义了运行多重测试的固定格式。
3. TestResult 类: TestResult 类收集所有执行测试案例的结果。它是收集参数层面的一个实例。这个实验框架区分失败和错误。失败是可以预料的并且可以通过假设来检查。错误是不可预料的问题就像 ArrayIndexOutOfBoundsException。
4. org.junit.TestSuite 类(可以同时测试多个class)public class TestSuite extends Object implements Test：TestSuite 类是测试的组成部分。它运行了很多的测试案例。

JUnit - 使用断言

import org.junit.Test;
import static org.junit.Assert.*;
public class TestAssertions {
   @Test
   public void testAssertions() {
      //test data
      String str1 = new String ("abc");
      String str2 = new String ("abc");
      String str3 = null;
      String str4 = "abc";
      String str5 = "abc";
      int val1 = 5;
      int val2 = 6;
      String[] expectedArray = {"one", "two", "three"};
      String[] resultArray =  {"one", "two", "three"};

      //Check that two objects are equal
      //比较两个变量值是否相等
      assertEquals(str1, str2);

      //Check that a condition is true
      //比较是否满足val1 < val2
      assertTrue (val1 < val2);

      //Check that a condition is false
      assertFalse(val1 > val2);

      //Check that an object isn't null
      //检查str1是否不为空
      assertNotNull(str1);

      //Check that an object is null
      assertNull(str3);

      //Check if two object references point to the same object
      //比较str4,str5是否为同一个对象（地址是否相同）
      assertSame(str4,str5);

      //Check if two object references not point to the same object
      assertNotSame(str1,str3);

      //Check whether two arrays are equal to each other.
      //比较两个数组内容是否相等
      assertArrayEquals(expectedArray, resultArray);
   }
}

JUNIT注释及执行过程

序号 注释和描述
1 @Test
这个注释说明依附在 JUnit 的 public void 方法可以作为一个测试案例。
2 @Before
有些测试在运行前需要创造几个相似的对象。在 public void 方法加该注释是因为该方法需要在 test 方法前运行。
3 @After
如果你将外部资源在 Before 方法中分配，那么你需要在测试运行后释放他们。在 public void 方法加该注释是因为该方法需要在 test 方法后运行。
4 @BeforeClass
在 public void 方法加该注释是因为该方法需要在类中所有方法前运行。
5 @AfterClass
它将会使方法在所有测试结束后执行。这个可以用来进行清理活动。
6 @Ignore
这个注释是用来忽略有关不需要执行的测试的。

示例：

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

public class ExecutionProcedureJunit {

   //execute only once, in the starting 
   @BeforeClass
   public static void beforeClass() {
      System.out.println("in before class");
   }

   //execute only once, in the end
   @AfterClass
   public static void  afterClass() {
      System.out.println("in after class");
   }

   //execute for each test, before executing test
   @Before
   public void before() {
      System.out.println("in before");
   }

   //execute for each test, after executing test
   @After
   public void after() {
      System.out.println("in after");
   }

   //test case 1
   @Test
   public void testCase1() {
      System.out.println("in test case 1");
   }

   //test case 2
   @Test
   public void testCase2() {
      System.out.println("in test case 2");
   }
}

结果：

in before class
in before
in test case 1
in after
in before
in test case 2
in after
in after class

观察以上的输出，这是 JUnite 执行过程：

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

JUnit - 测试套件

在实际项目中，随着项目进度的开展，单元测试类会越来越多，可是直到现在我们还只会一个一个的单独运行测试类，这在实际项目实践中肯定是不可行的。为了解决这个问题，JUnit 提供了一种批量运行测试类的方法，叫做测试套件。(理解为可以同时测试多个类)

JUnit - 忽略测试

有时可能会发生我们的代码还没有准备好的情况，这时测试用例去测试这个方法或代码的时候会造成失败。@Ignore 注释会在这种情况时帮助我们。

一个含有 @Ignore 注释的测试方法将不会被执行。
如果一个测试类有 @Ignore 注释，则它的测试方法将不会执行。

JUnit - 时间测试

Junit 提供了一个暂停的方便选项。如果一个测试用例比起指定的毫秒数花费了更多的时间，那么 Junit 将自动将它标记为失败。timeout 参数和 @Test 注释一起使用。现在让我们看看活动中的 @test(timeout)。

@Test(timeout=1000) //执行时间超过一秒，异常提示test timed out after 1000 milliseconds
	   public void testPrintMessage() { 
	      System.out.println("Inside testPrintMessage()");     
	      messageUtil.printMessage();     
	   }

JUnit - 异常测试

Junit 用代码处理提供了一个追踪异常的选项。你可以测试代码是否它抛出了想要得到的异常。expected 参数和 @Test 注释一起使用。现在让我们看看活动中的 @Test(expected)。

@Test(expected = ArithmeticException.class) //当产生的异常是expected使，不会报错
   public void testPrintMessage() { 
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

JUnit - 参数化测试

Junit 4 引入了一个新的功能参数化测试。参数化测试允许开发人员使用不同的值反复运行同一个测试。你将遵循 5 个步骤来创建参数化测试。

1. 用 @RunWith(Parameterized.class) 来注释 test 类。
2. 创建一个由 @Parameters 注释的公共的静态方法，它返回一个对象的集合(数组)来作为测试数据集合。
3. 创建一个公共的构造函数，它接受和一行测试数据相等同的东西。
4. 为每一列测试数据创建一个实例变量。
5. 用实例变量作为测试数据的来源来创建你的测试用例。

一旦每一行数据出现测试用例将被调用。让我们看看活动中的参数化测试。