Java 将数组传递给参数化JUnit

我不熟悉JUnit4.x的参数化特性，但遇到了一个问题。我的参数化测试由3个整数数组组成，我很难声明它们。我下面的内容会生成运行时错误：

testGeneral[0] caused an ERROR: argument type mismatch
    argument type mismatch
    java.lang.IllegalArgumentException
    at java.lang.reflect.Constructor.newInstance(Constructor.java:526)
testGeneral[1] caused an ERROR: argument type mismatch
    argument type mismatch
    java.lang.IllegalArgumentException
    at java.lang.reflect.Constructor.newInstance(Constructor.java:526)

这是我的密码：

@RunWith(Parameterized.class)
public class MyArrayTest {
    private Integer[] inputList1;
    private Integer[] inputList2;
    private Integer[] expectedList;

    public MyArrayTest(Integer[] li1, Integer[] li2, Integer[] expected) {
        // ========> Runtime error happens here. <=========
        this.inputList1 = li1;
        this.inputList2 = li2;
        this.expectedList = expected;
    }

    @Parameterized.Parameters
    public static Collection testCases() {
        return Arrays.asList(new Object[][][] {
            {{1,1,1}, {2,2,2}, {3,3,3}},
            {{2,2,2}, {3,3,3}, {4,4,4}}
        });
    }

    @Test
    public void testGeneral() {
        // Do some test with this.inputList1, this.inputList2,
        // and verify with this.expectedList
        // I am not even getting here yet.
    }
}

@RunWith（参数化的.class）
公共类MyArrayTest{
私有整数[]输入列表1；
私有整数[]输入列表2；
私有整数[]expectedList；
公共MyArrayTest（需要整数[]li1、整数[]li2、整数[]）{
//=======>此处发生运行时错误。失败的原因是测试需要整数数组，而您正在传递对象类型。因此您正在扩展类型。请尝试以下操作：

@Parameterized.Parameters
    public static Collection testCases() {
        return Arrays.asList(new Integer[][][] {
            {{1,1,1}, {2,2,2}, {3,3,3}},
            {{2,2,2}, {3,3,3}, {4,4,4}}
        });
    }

此解决方案使用、实现junitparams.converters.Converter，并将长值列表解析为参数

package example;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.Arrays;
import java.util.stream.Collectors;

import org.junit.Test;
import org.junit.runner.RunWith;

import junitparams.JUnitParamsRunner;
import junitparams.Parameters;
import junitparams.converters.ConversionFailedException;
import junitparams.converters.Converter;
import junitparams.converters.Param;

@RunWith(JUnitParamsRunner.class)
public class LongArrayParameterTest {

    @Parameters({ "0|10", "1|10;20;30" })
    @Test
    public void test(final long otherParameter, @LongArrayParam final long[] expected) {
        System.out.println(Arrays.stream(expected).boxed().map(l -> Long.toString(l)).collect(Collectors.toList()));
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.PARAMETER)
    @Param(converter = LongArrayConverter.class)
    public @interface LongArrayParam {

    }

    public static class LongArrayConverter implements Converter<LongArrayParam, long[]> {

        @Override
        public void initialize(final LongArrayParam annotation) {
        }

        @Override
        public long[] convert(final Object param) throws ConversionFailedException {
            final String str = (String) param;
            final String[] longStrings = str.split(";");
            return Arrays.stream(longStrings).mapToLong(s -> Long.parseLong(s)).toArray();
        }

    }
}

包示例；
导入java.lang.annotation.ElementType；
导入java.lang.annotation.Retention；
导入java.lang.annotation.RetentionPolicy；
导入java.lang.annotation.Target；
导入java.util.array；
导入java.util.stream.collector；
导入org.junit.Test；
导入org.junit.runner.RunWith；
导入junitparams.JUnitParamsRunner；
导入junitparams.Parameters；
导入junitparams.converters.ConversionFailedException；
导入junitparams.converters.Converter；
导入junitparams.converters.Param；
@RunWith（JUnitParamsRunner.class）
公共类LongArrayParameterTest{
@参数（{“0 | 10”、“1 | 10；20；30”}）
@试验
公共空隙测试（最终长度其他参数，@LongArrayParam最终长度[]预期）{
System.out.println（Arrays.stream（预期）.boxed（）.map（l->Long.toString（l））.collect（Collectors.toList（））；
}
@保留（RetentionPolicy.RUNTIME）
@目标（ElementType.PARAMETER）
@参数（converter=longarayconverter.class）
public@interface longarayparam{
}
公共静态类LongArrayConverter实现转换器{
@凌驾
公共void初始化（最终LongArrayParam注释）{
}
@凌驾
公共长[]转换（最终对象参数）抛出ConversionFailedException{
最终字符串str=（字符串）参数；
最终字符串[]longStrings=str.split（“；”）；
返回Arrays.stream（longtrings）.mapToLong（s->Long.parseLong（s））.toArray（）；
}
}
}

此解析器不支持空列表。
我觉得自己太笨了。谢谢。如何使用kotlin实现此目的？