Java数组升序排序程序JUnit @Test测试失败正确实现求助

基础测试类SortingTest正确实现 #

五个测试场景的预期逻辑如下：

• 空指针场景：入参为null时，sort方法必须抛出UnsupportedOperationException
• 空数组场景：入参为长度0的数组时，无异常抛出，排序后数组仍为空
• 单元素数组场景：入参仅含1个元素时，无异常抛出，排序后元素值不变
• 已排序数组场景：入参本身为升序数组时，无异常抛出，排序后内容与原数组一致
• 普通乱序数组场景：入参为乱序/降序数组时，无异常抛出，排序后为预期升序结果

正确的测试代码如下（基于JUnit 4编写，依赖JUnit 4.13+版本）：

import org.junit.Test;
import static org.junit.Assert.*;
import java.util.Arrays;

public class SortingTest {
    Sorting sorting = new Sorting();

    @Test(expected = UnsupportedOperationException.class)
    public void testNullCase() {
        // 传入null调用sort，预期抛出指定异常
        sorting.sort(null);
    }

    @Test
    public void testEmptyCase() {
        int[] array = new int[0];
        sorting.sort(array);
        assertArrayEquals(new int[0], array);
    }

    @Test
    public void testSingleElementArrayCase() {
        int[] array = new int[]{5};
        sorting.sort(array);
        assertArrayEquals(new int[]{5}, array);
    }

    @Test
    public void testSortedArraysCase() {
        int[] array = new int[]{1,2,3,4,5};
        int[] expected = Arrays.copyOf(array, array.length);
        sorting.sort(array);
        assertArrayEquals(expected, array);
    }

    @Test
    public void testOtherCases() {
        int[] array = new int[]{3,1,4,2,5};
        int[] expected = new int[]{1,2,3,4,5};
        sorting.sort(array);
        assertArrayEquals(expected, array);
    }
}

三个扩展测试方法的正确实现 #

你现有扩展测试失败的核心原因有两个：

1. 基础测试用例逻辑错误，导致运行XXXTestExtension时失败数与预期不符
2. 仅声明了Failure变量，没有从运行结果中匹配对应失败的测试用例做校验

正确的实现代码如下：

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
import static org.junit.Assert.*;

public class SortingExtensionTest {
    @Test
    public void testNullCarelessSorting() {
        JUnitCore junit = new JUnitCore();
        Result result = junit.run(NullCarelessSortingTestExtension.class);

        assertEquals(5, result.getRunCount());
        assertEquals(1, result.getFailureCount());

        // 匹配失败的空指针测试用例
        Failure nullCaseFailure = result.getFailures().stream()
                .filter(f -> f.getDescription().getMethodName().equals("testNullCase"))
                .findFirst()
                .orElse(null);
        // 校验空指针场景确实失败
        assertNotNull("空指针场景未按预期失败", nullCaseFailure);
    }

    @Test
    public void testLazySorting() {
        JUnitCore junit = new JUnitCore();
        Result result = junit.run(LazySortingTestExtension.class);

        assertEquals(5, result.getRunCount());
        assertEquals(2, result.getFailureCount());

        Failure nullCaseFailure = result.getFailures().stream()
                .filter(f -> f.getDescription().getMethodName().equals("testNullCase"))
                .findFirst()
                .orElse(null);
        Failure otherCasesFailure = result.getFailures().stream()
                .filter(f -> f.getDescription().getMethodName().equals("testOtherCases"))
                .findFirst()
                .orElse(null);

        assertNotNull("空指针场景未按预期失败", nullCaseFailure);
        assertNotNull("乱序数组场景未按预期失败", otherCasesFailure);
    }

    @Test
    public void testTrickySorting() {
        JUnitCore junit = new JUnitCore();
        Result result = junit.run(TrickySortingTestExtension.class);

        assertEquals(5, result.getRunCount());
        assertEquals(4, result.getFailureCount());

        Failure emptyCaseFailure = result.getFailures().stream()
                .filter(f -> f.getDescription().getMethodName().equals("testEmptyCase"))
                .findFirst()
                .orElse(null);
        Failure singleCaseFailure = result.getFailures().stream()
                .filter(f -> f.getDescription().getMethodName().equals("testSingleElementArrayCase"))
                .findFirst()
                .orElse(null);
        Failure sortedCaseFailure = result.getFailures().stream()
                .filter(f -> f.getDescription().getMethodName().equals("testSortedArraysCase"))
                .findFirst()
                .orElse(null);
        Failure otherCasesFailure = result.getFailures().stream()
                .filter(f -> f.getDescription().getMethodName().equals("testOtherCases"))
                .findFirst()
                .orElse(null);

        assertNotNull("空数组场景未按预期失败", emptyCaseFailure);
        assertNotNull("单元素数组场景未按预期失败", singleCaseFailure);
        assertNotNull("已排序数组场景未按预期失败", sortedCaseFailure);
        assertNotNull("乱序数组场景未按预期失败", otherCasesFailure);
    }
}

修改完成后先确保基础SortingTest的五个用例全部执行通过，再运行扩展测试即可符合预期。

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