JUnit4参数化测试两数交换报参数数量错误的修复方案

报错信息 #

编写两数交换功能的JUnit4参数化测试用例时，抛出如下异常：

java.lang.IllegalArgumentException: wrong number of arguments: 4 expected: 2.

分场景修复方案 #

场景1：被测方法入参为int数组 #

被测方法为Swap_Array.swap，入参为长度2的int数组，返回值同为长度2的int数组。
报错原因：@Parameters标注的测试数据集构造逻辑错误，将输入数组元素、预期结果数组元素平铺为4个独立int值，和测试类构造函数定义的2个数组类型入参不匹配，触发参数数量校验异常。

原有业务代码（Swap_Array.java）

package BasicTesting;

import java.io.*;
import java.lang.reflect.Array;
import java.util.Scanner;
public class Swap_Array
{
  public static void main(String args[])throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      int i;
    
      int [] array=new int[2];
      Scanner sc=new Scanner(System.in);
      System.out.println("Enter the two numbers");
      for(i=0;i<2;i++) {
          array[i] =sc.nextInt();
      }
      int [] p = swap(array);
      System.out.println("after swapping first number"+" "+p[0]+" "+" and second number are"+" " +p[1]);
    }

    public static int[] swap(int array[]) {
     int[] c=new int[2];
     int i = array[0];
     int j = array[1];
      
    i=i+j;
    j=i-j;
    i=i-j;
    c[0]=i;
    c[1]=j;
    return c;
  }
}

原有错误测试代码

package BasicTesting;

import static org.junit.Assert.*;

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

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 Swap_Parameterized_testcase {
    public Swap_Parameterized_testcase(int[] input,  int[] expected) {
        super();
        this.input= input;
        this.expected = expected;
    }

    Swap_Array ob=new Swap_Array();
    private int input[];
    private int [] expected;

    @Parameters
    public static Collection<Object[]> testPrime() {
        // 错误写法：将数组元素平铺为4个独立参数，和构造函数的2个入参不匹配
        return Arrays.asList(new Object[][]{{1,2,2,1},{23,44,44,23}});
    }
    
    @Test
    public void Swap_test() {
        assertArrayEquals(expected,ob.swap(input));
    }
}

修正后测试代码

package BasicTesting;

import static org.junit.Assert.*;

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)
public class Swap_Parameterized_testcase {
    private int[] input;
    private int[] expected;
    private Swap_Array ob = new Swap_Array();

    public Swap_Parameterized_testcase(int[] input, int[] expected) {
        this.input = input;
        this.expected = expected;
    }

    @Parameters
    public static Collection<Object[]> testData() {
        return Arrays.asList(new Object[][]{
                // 每组数据2个参数，和构造函数入参顺序、类型对应：输入数组、预期返回数组
                {new int[]{1,2}, new int[]{2,1}},
                {new int[]{23,44}, new int[]{44,23}}
        });
    }

    @Test
    public void Swap_test() {
        assertArrayEquals(expected, ob.swap(input));
    }
}

场景2：被测方法入参为两个独立int值 #

被测方法为Swap_Numbers.swap1，入参为两个独立int类型值，返回值为长度2的int数组。

原有业务代码（Swap_Numbers.java）

package BasicTesting;

import java.io.*;
import java.lang.reflect.Array;
import java.util.Scanner;
public class Swap_Numbers
{
  public static void main(String args[])throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      int i,j;
    System.out.println("enter first number..");
    i=Integer.parseInt(br.readLine());
    System.out.println("enter second number..");
    j=Integer.parseInt(br.readLine());
    int[] p=swap1(i,j);
    
      System.out.println("after swapping first number"+" "+p[0]+" "+" and second number are"+" " +p[1]);
    }

    public static int[] swap1(int i,int j) {
     int[] c=new int[2];
      
    i=i+j;
    j=i-j;
    i=i-j;
    c[0]=i;
    c[1]=j;
    return c;
  }
}

正确参数化测试代码

package BasicTesting;

import static org.junit.Assert.*;

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)
public class Swap_Numbers_Parameterized_Test {
    private int inputA;
    private int inputB;
    private int[] expected;
    private Swap_Numbers ob = new Swap_Numbers();

    // 构造函数入参和测试数据集的每组元素一一对应
    public Swap_Numbers_Parameterized_Test(int inputA, int inputB, int[] expected) {
        this.inputA = inputA;
        this.inputB = inputB;
        this.expected = expected;
    }

    @Parameters
    public static Collection<Object[]> testData() {
        return Arrays.asList(new Object[][]{
                // 每组3个参数：第一个输入值、第二个输入值、预期交换后的返回数组
                {1, 2, new int[]{2,1}},
                {23, 44, new int[]{44,23}}
        });
    }

    @Test
    public void swap1Test() {
        assertArrayEquals(expected, ob.swap1(inputA, inputB));
    }
}

编写注意点 #

• JUnit4参数化测试要求@Parameters返回的集合中，每个Object[]子数组的元素数量、顺序、类型必须和测试类构造函数的入参完全一致
• 数组类型的参数不要将内部元素平铺，要直接传入完整数组对象

内容的提问来源于stack exchange，提问作者Julie