Java 使用@MethodSource处理异常

我刚开始在LeetCode上做一个名为“两个和”的练习，我在测试方面遇到了问题

现在，该练习的代码如下所示：

public class TwoSumCalculator {
public int[] twoSum(int[] numbers, int target) {

    for (int i = 0; i < numbers.length; i++) {

        for (int j = i + 1; j < numbers.length; j++) {

            if (numbers[j] == target - numbers[i]) {
                return new int[]{i, j};
            }
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}

公共类计算器{
公共int[]twoSum（int[]数字，int目标）{
for（int i=0；i

}

这就是我的测试结果：

class TwoSumCalculatorTest {
TwoSumCalculator twoSumCalculator = new TwoSumCalculator();

@ParameterizedTest
@MethodSource("parameters")
void findIndices(int[] expectedNumbers, int[] inputNumbers, int target) {
    int[] resultedNumbers = twoSumCalculator.twoSum(inputNumbers, target);

    assertArrayEquals(expectedNumbers, resultedNumbers);
}

private static Stream<Arguments> parameters() {
    return Stream.of(
            Arguments.of(new int[]{1, 2}, new int[]{3, 2, 4}, 6),
            Arguments.of(new int[]{0, 1}, new int[]{2, 7, 11, 15}, 9),
            Arguments.of(new int[]{0, 1}, new int[]{3, 3}, 6),
            Arguments.of(new IllegalArgumentException("No two sum solution"), new int[]{3, 1, 2}, 6));
}

class TwoSumCalculatorTest{
TwoSumCalculator TwoSumCalculator=新TwoSumCalculator（）；
@参数化测试
@MethodSource（“参数”）
void findIndices（int[]预期数字，int[]输入数字，int目标）{
int[]resultedNumbers=twoSumCalculator.twoSum（输入数字，目标）；
AssertArrayQuals（预期数字、结果数字）；
}
私有静态流参数（）{
回流(
（新的int[]{1,2}，新的int[]{3,2,4}，6），
（新的int[]{0,1}，新的int[]{2,7,11,15}，9），
参数.of（新int[]{0,1}，新int[]{3,3}，6），
（新的IllegalArgumentException（“无二和解”），新的int[]{3，1，2}，6））；
}

}

当前3个测试通过时，我得到以下带有第4个参数的错误消息：

org.junit.jupiter.api.extension.ParameterResolutionException:在索引0处转换参数时出错：没有隐式转换将java.lang.IllegalArgumentException类型的对象转换为[I]类型

---

什么是更好的测试方法？

您可以这样做，或者对抛出异常的情况单独进行测试

    @ParameterizedTest
    @MethodSource("parameters")
    void findIndices(int[] expectedNumbers, int[] inputNumbers, int target, Class expectedException) {
        if (expectedException != null) {
            assertThrows(expectedException, () -> twoSumCalculator.twoSum(inputNumbers, target));
        } else {
            int[] resultedNumbers = twoSumCalculator.twoSum(inputNumbers, target);
            assertArrayEquals(expectedNumbers, resultedNumbers);
        }
    }

    private static Stream<Arguments> parameters() {
        return Stream.of(
                Arguments.of(new int[]{1, 2}, new int[]{3, 2, 4}, 6, null),
                Arguments.of(new int[]{0, 1}, new int[]{2, 7, 11, 15}, 9, null),
                Arguments.of(new int[]{0, 1}, new int[]{3, 3}, 6, null),
                Arguments.of(null, new int[]{3, 1, 2}, 6, IllegalArgumentException.class));
    }

@ParameterizedTest
@MethodSource（“参数”）
void findIndices（int[]expectedNumbers，int[]inputNumbers，int target，类expectedException）{
if（expectedException！=null）{
assertThrows（expectedException，（）->twoSumCalculator.twoSum（InputNumber，target））；
}否则{
int[]resultedNumbers=twoSumCalculator.twoSum（输入数字，目标）；
AssertArrayQuals（预期数字、结果数字）；
}
}
私有静态流参数（）{
回流(
参数.of（新int[]{1,2}，新int[]{3,2,4}，6,null），
参数.of（新int[]{0,1}，新int[]{2,7,11,15}，9,null），
参数.of（新int[]{0,1}，新int[]{3,3}，6,null），
of（null，newint[]{3,1,2}，6，IllegalArgumentException.class））；
}

我建议您单独测试成功和失败案例，而不是尝试在同一测试中参数化成功和失败案例。这允许您使用

assertThrows

方法断言抛出的异常，并避免在测试代码中引入逻辑

比如：

class TwoSumCalculatorTest{
TwoSumCalculator TwoSumCalculator=新TwoSumCalculator（）；
@参数化测试
@MethodSource（“twoSumParameters”）
void twoSumSolutions（int[]expectedNumbers，int[]inputNumbers，int target）{
int[]resultedNumbers=twoSumCalculator.twoSum（输入数字，目标）；
AssertArrayQuals（预期数字、结果数字）；
}
@参数化测试
@MethodSource（“noTwoSumParameters”）
void noTwoSumSolutions（int[]输入编号，int目标）{
assertThrows（IllegalArgumentException.class，（）->{
twoSumCalculator.twoSum（输入数字、目标）；
})
}
私有静态流参数（）{
回流(
（新的int[]{1,2}，新的int[]{3,2,4}，6），
（新的int[]{0,1}，新的int[]{2,7,11,15}，9），
of（新int[]{0,1}，新int[]{3,3}，6）
);
私有静态流noTwoSumParameters（）{
回流(
of（新的int[]{3,1,2}，6）
//可以在这里添加更多例外情况
);
}