摘要：步驟三為測(cè)試類聲明一個(gè)帶有參數(shù)的公共構(gòu)造函數(shù)，并在其中為第二個(gè)環(huán)節(jié)中聲明的幾個(gè)變量賦值。步驟五編寫測(cè)試方法，使用定義的變量作為參數(shù)進(jìn)行測(cè)試。

JUnit is a Regression Testing Framework used by developers to implement unit testing in Java and accelerate programming speed and increase the quality of code

is a fixed state of a set of objects used as a baseline for running tests. The purpose of a test fixture is to ensure that there is a well known and fixed environment in which tests are run so that results are repeatable.

Test suite means bundle a few unit test cases and run it together. In JUnit, both @RunWith and @Suite annotation are used to run the suite test.

Test runner is used for executing the test cases. Here is an example which assumes TestJunit test class already exists

JUnit classes are important classes which is used in writing and testing JUnits. Some of the important classes are：

Assert which contain a set of assert methods.

TestCase which contain a test case defines the fixture to run
multiple tests.

TestResult which contain methods to collect the results of executing
a test case.

// 測(cè)試case寫法1：
// 繼承TestCase ,測(cè)試方法 public void testXXX(){} 形式
import org.junit.Assert;
import junit.framework.TestCase;
public class TestJunit1 extends TestCase{

    public void testAdd(){
        String str = "JUnit is working fine";
        Assert.assertEquals("JUnit is working fine", str);
    }
}

// 測(cè)試case寫法2
// 使用@Test 注解
import org.junit.Assert;
import org.junit.Test;
public class TestJunit1{
    @Test
    public void testAdd(){
        String str = "JUnit is working fine";
        Assert.assertEquals("JUnit is working fine", str);
    }
}

// JUnitCore 這里作為門面類用來執(zhí)行測(cè)試用例
// JUnitCore is a facade for running tests. It supports running JUnit 4 tests, 
// JUnit 3.8.x tests, and mixtures. To run tests from the command line, run java 
// org.junit.runner.JUnitCore TestClass1 TestClass2 .... For one-shot test runs, use the // static method runClasses(Class []). If you want to add special listeners, create an 
// instance of org.junit.runner.JUnitCore first and use it to run the tests.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
} 

// 測(cè)試類
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 JunitAnnotation {
    //Annotating a public static void method with @BeforeClass causes it to be run once before any of the test methods in the class.
    @BeforeClass
    public static void beforeClass(){
        System.out.println("in before class");
    }
    //This will perform the method after all tests have finished. This can be used to perform clean-up activities.
    @AfterClass
    public static void afterClass(){
        System.out.println("in after class");
    }
    //Several tests need similar objects created before they can run. Annotating a public void method with @Before causes that method to be run before each Test method.
    @Before
    public void before(){
        System.out.println("in before");
    }
    //If you allocate external resources in a Before method you need to release them after the test runs. 
    //Annotating a public void method with @After causes that method to be run after the Test method.
    @After
    public void after(){
        System.out.println("in after");
    }
    //The Test annotation tells JUnit that the public void method to which it is attached can be run as a test case.
    @Test
    public void test(){
        System.out.println("in test");
    }
    //The Ignore annotation is used to ignore the test and that test will not be executed.
    @Ignore
    public void ignoreTest(){
        System.out.println("in ignore test");
    }
}

我們還是用JUnitCore來運(yùn)行這個(gè)測(cè)試：
控制臺(tái)輸出：
in before class
in before
in test
in after
in after class

先上來兩個(gè)測(cè)試用例
測(cè)試用例1
import org.junit.Assert;
import junit.framework.TestCase;
public class TestJunit1 extends TestCase{

    public void testAdd(){
        String str = "JUnit is working fine";
        Assert.assertEquals("JUnit is working fine", str);
    }
}

測(cè)試用例2
import org.junit.Test;
import static org.junit.Assert.*;
public class TestJunit2 {
   @Test
   public void testAdd() {
      //test data
      int num= 5;
      String temp= null;
      String str= "Junit is working fine";

      //check for equality
      assertEquals("Junit is working fine2", str);
      
      //check for false condition
      assertFalse(num > 6);

      //check for not null value
      assertNotNull(str);
   }
}

關(guān)鍵在于TestSuite的寫法

方式一：
import junit.framework.*;

public class JunitTestSuite {
    public static void main(String[] a) {
        // add the test"s in the suite
        TestSuite suite = new TestSuite(TestJunit1.class, TestJunit2.class, TestJunit3.class);
        TestResult result = new TestResult();
        suite.run(result);
        System.out.println("Number of test cases = " + result.runCount());
    }
}

直接就可以跑來了

方式二（注解形式）：
import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)
@Suite.SuiteClasses({ TestJunit1.class, TestJunit2.class })

// JUnit suite test
public class JunitTestSuite {

}

然后用JunitCore就可以跑起來了

Junit 4 has introduced a new feature Parameterized tests.Parameterized
tests allow developer to run the same test over and over again using 
different values. There are five steps, that you need to follow to 
create  Parameterized tests.

// 工具類
public class PrimeNumberChecker {
    public boolean validate(final Integer primeNumber){
        for(int i = 2; i<(primeNumber / 2); i++){
            if(primeNumber % i == 0){
                return false;
            }
        }
        return true;
    }
}

import static org.junit.Assert.assertEquals;

import java.util.Arrays;
import java.util.Collection;

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

//步驟一：為準(zhǔn)備使用參數(shù)化測(cè)試的測(cè)試類指定特殊的運(yùn)行器
@RunWith(Parameterized.class)
public class PrimeNumberCheckTest {

    //步驟二：為測(cè)試類聲明幾個(gè)變量，分別用于存放期望值和測(cè)試所用數(shù)據(jù)。
    private Integer inputNumber;
    private Boolean expectedResult;
    private PrimeNumberChecker primeNumberChecker;

    @Before
    public void initialize() {
        primeNumberChecker = new PrimeNumberChecker();
    }

    //步驟三：為測(cè)試類聲明一個(gè)帶有參數(shù)的公共構(gòu)造函數(shù)，并在其中為第二個(gè)環(huán)節(jié)中聲明的幾個(gè)變量賦值。  
    public PrimeNumberCheckTest(Integer inputNumber, Boolean expectedResult){
        this.inputNumber = inputNumber;
        this.expectedResult = expectedResult;
    }
    
    //步驟四：為測(cè)試類聲明一個(gè)使用注解 org.junit.runners.Parameterized.Parameters 修飾的，返回值為  
    //java.util.Collection 的公共靜態(tài)方法，并在此方法中初始化所有需要測(cè)試的參數(shù)對(duì)。
    @Parameterized.Parameters
    public static Collection primberNumbers(){
        return Arrays.asList(new Object[][]{
            {2,true},
            {6,false},
            {19,true},
            {22,false},
            {23,true}
        });
    }
    
    //步驟五：編寫測(cè)試方法，使用定義的變量作為參數(shù)進(jìn)行測(cè)試。
    @Test
    public void testPrimeNumberChecker(){
        System.out.println("Paramerized Number is : " + inputNumber);
        assertEquals(expectedResult, primeNumberChecker.validate(inputNumber));
    }
}