Java 如何处理空队列参数并在JUnit5中进行测试

我目前正在开发这个程序，该方法将队列作为参数。然后，它将队列按升序排序并返回。工作正常，但我不知道如何处理空队列。我试图打印“无效输入”，但测试类显示错误。即使未传递空队列，“Invalid Input”代码块也会继续执行。因此，没有一项测试通过。我真的需要你的帮助

分类代码：

import java.util.Queue;

public class Sort {

    public static Queue<Integer> queueSort(Queue<Integer> queue) { 
                                                            
        int n = queue.size(); 

        if (queue.isEmpty()) {      
            System.out.println("Invalid Input");

        } else {

            for (int i = 0; i < n; i++) {  

                int minimumIndex = -1;
                int minimumValue = Integer.MAX_VALUE; 
                                                      

                for (int j = 0; j < n; j++) {        
                    int currentValue = queue.poll();

                    if (currentValue < minimumValue && j < (n - i)) {  
                        minimumValue = currentValue;                  
                        minimumIndex = j;            
                    }                                
                    queue.add(currentValue);        
                }

                for (int j = 0; j < n; j++) {     
                    int currentValue = queue.poll();

                    if (j != minimumIndex) {
                        queue.add(currentValue);
                    }
                }

                queue.add(minimumValue);      
            }

        }
        return queue;
    }
}

import java.util.Queue；
公共类排序{
公共静态队列排序（队列队列）{
int n=queue.size（）；
如果（queue.isEmpty（））{
System.out.println（“无效输入”）；
}否则{
对于（int i=0；i

测试等级：

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.util.LinkedList;
import java.util.Queue;

class SortTest {

    Queue<Integer> Q1 = new LinkedList<>();
    Queue<Integer> expectedQ1 = new LinkedList<>();

    Queue<Integer> Q2 = new LinkedList<>();
    Queue<Integer> expectedQ2 = new LinkedList<>();

    Queue<Integer> Q3 = new LinkedList<>();

    void testInputs() {
        Q1.add(10); Q1.add(-1); Q1.add(8); Q1.add(7); Q1.add(2);
        expectedQ1.add(-1); expectedQ1.add(2); expectedQ1.add(7); expectedQ1.add(8); expectedQ1.add(10);

        Q2.add(6000); Q2.add(5999);
        expectedQ2.add(5999); expectedQ2.add(6000);

    }


    @Test
    void queueSortTest1() {
        Assertions.assertEquals(expectedQ1, Sort.queueSort(Q1));
    }

    @Test
    void queueSortTest2() {
        Assertions.assertEquals(expectedQ2, Sort.queueSort(Q2));
    }

    @Test
    void queueSortTest3() {
        Assertions.assertEquals("Invalid Input", Sort.queueSort(Q3));
    }
}

import org.junit.jupiter.api.Assertions；
导入org.junit.jupiter.api.Test；
导入java.util.LinkedList；
导入java.util.Queue；
类别分类测试{
队列Q1=新的LinkedList（）；
队列expectedQ1=新的LinkedList（）；
队列Q2=新的LinkedList（）；
队列expectedQ2=新建LinkedList（）；
队列Q3=新建LinkedList（）；
无效测试输入（）{
Q1.添加（10）；Q1.添加（-1）；Q1.添加（8）；Q1.添加（7）；Q1.添加（2）；
expectedQ1.add（-1）；expectedQ1.add（2）；expectedQ1.add（7）；expectedQ1.add（8）；expectedQ1.add（10）；
Q2.增加（6000）；Q2.增加（5999）；
expectedQ2.add（5999）；expectedQ2.add（6000）；
}
@试验
void queueSortTest1（）{
assertEquals（expectedQ1，Sort.queueSort（Q1））；
}
@试验
void queueSortTest2（）{
assertEquals（expectedQ2，Sort.queueSort（Q2））；
}
@试验
void queueSortTest3（）{
Assertions.assertEquals（“无效输入”，Sort.queueSort（Q3））；
}
}

断言正在检查返回的值。如果队列为空，则您正在打印“无效输入”

，而不返回此消息

if (queue.isEmpty()) {      
    System.out.println("Invalid Input");
}

在这种情况下，返回的值是空队列，它不等于字符串
“无效输入”

因此，如果有这样的需求，您需要更改您的业务逻辑（例如抛出异常）-当然，不要更改您的逻辑以满足测试要求！：）

另一种方法是测试输出，例如
如果要断言System.out，则应该拦截它

这是一个例子：

@Test
void queueSort() {
    final PrintStream standardOut = System.out;
    final ByteArrayOutputStream outputStreamCaptor = new ByteArrayOutputStream();
    System.setOut(new PrintStream(outputStreamCaptor));
    Sort.queueSort(Q3)
    Assertions.assertEquals("Invalid Input", outputStreamCaptor.toString().trim());
}

这件事对贝尔东有好处