首页 > 应用开发 > IT综合 > JUnit 注解@RunWith的工作原理

JUnit 注解@RunWith的工作原理

原创 IT综合 作者:i042416 时间:2020-09-21 09:47:47 0 删除 编辑

In order to introduce the usage of this annotation in JUnit, I use an example to demonstrate.

I have a very simple price calculator:

public class PriceCalculator {
    private int quantity;
    private double unitPrice;
    private double discount;
    public PriceCalculator(int quantity, double price, double discount){
        this.quantity = quantity;
        this.unitPrice = price; = discount;
    public double getPrice(){
        return this.quantity * this.unitPrice *  ( / 100 );

Test class for this calculator:

import static org.junit.Assert.assertEquals;import org.junit.Test;public class RunWithOneTestCase {
    private final static int QUANTITY1 = 5;
    private final static double PRICE1 = 10;
    private final static double DISCOUNT1 = 90;
    private final static double EXPECTED1 = QUANTITY1 * PRICE1 * ( DISCOUNT1 / 100 );
    private final static int QUANTITY2 = 4;
    private final static double PRICE2 = 5;
    private final static double DISCOUNT2 = 80;
    private final static double EXPECTED2 = QUANTITY2 * PRICE2 * ( DISCOUNT2 / 100 );
    public void testPriceCalculation(){
        PriceCalculator priceCalculator = new PriceCalculator(QUANTITY1, PRICE1, DISCOUNT1);
        assertEquals("price calculated for test data1", 
                EXPECTED1, priceCalculator.getPrice(), 0);
        PriceCalculator priceCalculator2 = new PriceCalculator(QUANTITY2, PRICE2, DISCOUNT2);
        assertEquals("price calculated for test data2", 
                EXPECTED2, priceCalculator2.getPrice(), 0);

The disadvantage of this solution: here I have two sets of test data, so duplicate static attribute QUANTITY2, PRICE2, DISCOUNT2 and EXPECTED2 are introduced, which is a violation of DRY – Don’t Repeat Yourself.

A better solution

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;import org.junit.runners.Parameterized.Parameters;@RunWith(Parameterized.class)public class RunWithTwoTestCase {
    private int quantity;
    private double price;
    private double discount;
    private double expected; 
    private PriceCalculator priceCalculator;
    public RunWithTwoTestCase(int qty, double price, double discount, double expected){
        this.quantity = qty;
        this.price = price; = discount;
        this.expected = expected;
    @Parameters(name = "{index}: (Quantity {0} * Price {1}) * (Discount{2}/100) = {3}")
    public static Collection<Object[]> generateData()
        return Arrays.asList(new Object[][] {
                              { 5, 10, 90, 45 },
                              { 4, 5, 80, 16 } });
    public void setUp() throws Exception {      
        this.priceCalculator = new PriceCalculator(this.quantity, this.price,;
    public void testPrice(){
        assertEquals("price calculated for test data", this.expected, 
                this.priceCalculator.getPrice(), 0);

Briefly introduction

The advantage of this solution is, the test data is in fact somehow separated from test class itself. In case you need more test data, you can simply append array in method generateData() without any duplicate static attributes.

Another benefit is, the test data injected with @Parameters are also available in JUnit result view, which is easier for tester to analyze result. Just compare the normal test case and the solution where @Parameters is used:

In the runtime, (1) the annotation “@org.junit.runners.Parameterized$Parameters(name={index}: (Quantity {0} * Price {1}) * (Discount{2}/100) = {3})” I write in method generateData is extracted by framework:

After that call allParameters method to retrieve test data written in test code. (2) In allParameters method, my prepared test data is passed to JUnit framework via reflective call:

(3) then my test case class is instantiated by reflection, the first set of test data is passed into constructor. After that the method annotated with @Before and @Test are executed sequentially. And then, @Before and @Test will be executed once again for the second set of test data. This could be observed by id displayed in debugger.


来自 “ ITPUB博客 ” ,链接:,如需转载,请注明出处,否则将追究法律责任。

请登录后发表评论 登录


  • 博文量
  • 访问量