Java 如何测试if-else语句？_Java_Testing_Junit_Automated Tests_Mockito

Java 如何测试if-else语句？

java testing junit automated-tests

Java 如何测试if-else语句？,java,testing,junit,automated-tests,mockito,Java,Testing,Junit,Automated Tests,Mockito,我一直在努力测试if-else和for循环，这里是一个例子，你能告诉我自动测试是如何为这些循环工作的吗声明 for (int i=1; i<=10; i++){ // for loop from 1 to 10 System.out.println(" guess "+i+ ":"); int guess = scan.nextInt(); //if guess is greater than number entered

我一直在努力测试if-else和for循环，这里是一个例子，你能告诉我自动测试是如何为这些循环工作的吗声明

for (int i=1; i<=10; i++){                     // for loop from 1 to 10
    System.out.println(" guess "+i+ ":");
    int guess = scan.nextInt();
    //if guess is greater than number entered 
    if(guess>number)
        System.out.println("Clue: lower");
    //if guess is less than number entered 
    else if (guess<number )
        System.out.println("Clue: Higher");
    //if guess is equal than number entered 
    else if(guess==number) {
        System.out.println("Correct answer after only "+ i + " guesses – Excellent!");

    }

for（int i=1；inumber）
System.out.println（“线索：下”）；
//如果猜测小于输入的数字
否则，如果（guess提取一个函数guess（）
并传递guess
和number
。使其返回结果字符串或表示它的抽象值
将函数和计数器封装在一个新类中。每次guess（）
，将其递增。当达到10次猜测时，禁用猜测
现在，您可以控制代码的输入和输出，并且可以在不依赖副作用（控制台输入/输出）的情况下对其进行正确测试。
提取函数guess（）
并传递guess
和number
。使其返回结果字符串或表示它的抽象值
将函数和计数器封装在一个新类中。每次guess（）
，将其递增。当达到10次猜测时，禁用猜测
现在，您可以控制代码的输入和输出，并且可以正确地测试代码，而不必依赖于副作用（控制台输入/输出）.
您只需编写满足不同条件的三种不同断言。您还需要将其放入某种函数中。我从未尝试过对主函数进行单元测试，但我想您可以这样做，但通常是在返回某些值的函数中。我不确定如何测试print语句。也许您可以将在一个变量中输入文本，然后打印出来。它看起来像这样
public string gameFunction(int guess){  
String printVariable;
for (int i=1; i<=10; i++){                     // for loop from 1 to 10
    System.out.println(" guess "+i+ ":");
    int guess = scan.nextInt();
    //if guess is greater than number entered 
    if(guess>number)
        printVariable = "Clue: lower";
        System.out.println("Clue: lower");
    //if guess is less than number entered 
    else if (guess<number )
        printVariable = "Clue: Higher";
        System.out.println("Clue: Higher");
    //if guess is equal than number entered 
    else if(guess==number) {
        printVariable = "Correct answer after only "+ i + " guesses – Excellent!";
        System.out.println("Correct answer after only "+ i + " guesses – Excellent!");

return printVariable;
} 
}

@Test
public void testDiscreteize(){
    int guess = 1
    int number = 2
    String testPrint = "Clue: lower";
    String returnValue = game function(guess);
    assertEquals(testPrint, returnValue);
}

publicstringgamefunction（int-guess）{
字符串打印变量；
对于（整数i=1；整数）
printVariable=“线索：较低”；
System.out.println（“线索：下”）；
//如果猜测小于输入的数字
否则如果（猜测您只需编写满足不同条件的三种不同断言。您还需要将其放入某种函数中。我从未尝试过对主函数进行单元测试，但我猜您可以这样做，但通常是在返回某个值的函数中。我不确定如何测试print语句。也许您可以将在一个变量中输入文本，然后打印出来。它看起来像这样
public string gameFunction(int guess){  
String printVariable;
for (int i=1; i<=10; i++){                     // for loop from 1 to 10
    System.out.println(" guess "+i+ ":");
    int guess = scan.nextInt();
    //if guess is greater than number entered 
    if(guess>number)
        printVariable = "Clue: lower";
        System.out.println("Clue: lower");
    //if guess is less than number entered 
    else if (guess<number )
        printVariable = "Clue: Higher";
        System.out.println("Clue: Higher");
    //if guess is equal than number entered 
    else if(guess==number) {
        printVariable = "Correct answer after only "+ i + " guesses – Excellent!";
        System.out.println("Correct answer after only "+ i + " guesses – Excellent!");

return printVariable;
} 
}

@Test
public void testDiscreteize(){
    int guess = 1
    int number = 2
    String testPrint = "Clue: lower";
    String returnValue = game function(guess);
    assertEquals(testPrint, returnValue);
}

publicstringgamefunction（int-guess）{
字符串打印变量；
对于（整数i=1；整数）
printVariable=“线索：较低”；
System.out.println（“线索：下”）；
//如果猜测小于输入的数字
否则，如果（猜测提取一个捕获代码逻辑的“纯函数”，那么测试将是微不足道的
static String reply(int guess, int number, int guessCount) {
    return guess > number ? "Clue: lower"
         : guess < number ? "Clue: Higher"
         : "Correct answer after only " + guessCount + " guesses -- Excellent!";
 }

静态字符串回复（int guess、int number、int guessCount）{
返回猜测>数字？“线索：更低”
：猜测<数字？“线索：更高”
：“仅在“+猜测计数+”猜测之后回答正确--非常好！”；
}
提取一个捕获代码逻辑的“纯函数”，那么测试将变得微不足道
static String reply(int guess, int number, int guessCount) {
    return guess > number ? "Clue: lower"
         : guess < number ? "Clue: Higher"
         : "Correct answer after only " + guessCount + " guesses -- Excellent!";
 }

静态字符串回复（int guess、int number、int guessCount）{
返回猜测>数字？“线索：更低”
：猜测<数字？“线索：更高”
：“仅在“+猜测计数+”猜测之后回答正确--非常好！”；
}
目录

步骤0-将代码重构为可操作、可编译的示例
步骤1-重构以能够进行依赖项注入
步骤2-将java.util.Scanner包装到您自己的委托中
步骤3-创建一个常规测试
步骤4-从循环中提取处理单次尝试
步骤5-为游戏创建单元测试
步骤6-为SingleGuessHandler创建单元测试
最后说明

步骤0-将代码重构为可操作、可编译的示例
步骤3-创建一个常规测试
步骤4-从循环中提取处理单次尝试
在循环中有3个可能的流，我们有10次迭代。这总共提供了3^10~60000个可能的流。我们不想编写60000个测试。因此我们再次重构（仅使用IDE重构选项）以达到以下状态。注意，所有的流都应该编译，测试应该仍然是绿色的
public class Main {

    public static void main(String[] args) {
        Game game = new Game(new SingleGuessHandler(new MyScanner(), System.out), new Random().nextInt(100));

        game.run();
    }

}

public class Game {

    private final SingleGuessHandler singleGuessHandler;
    private final int number;

    public Game(SingleGuessHandler singleGuessHandler, int number) {
        this.singleGuessHandler = singleGuessHandler;
        this.number = number;
    }

    public void run() {
        for (int i = 1; i <= 10; i++) {
            singleGuessHandler.runSingleGuess(i, number);
        }
    }

}

public class SingleGuessHandler {

    private final MyScanner scanner;
    private final PrintStream printStream;

    public SingleGuessHandler(MyScanner scanner, PrintStream printStream) {
        this.scanner = scanner;
        this.printStream = printStream;
    }

    public void runSingleGuess(int attempt, int number) {
        printStream.println(" guess " + attempt + ":");
        int guess = scanner.nextInt();
        if (guess > number) {
            printStream.println("Clue: lower");
        } else if (guess < number) {
            printStream.println("Clue: Higher");
        } else if (guess == number) {
            printStream.println("Correct answer after only " + attempt + " guesses – Excellent!");
        }
    }

}

public class MyScanner {

    private final Scanner scanner = new Scanner(System.in);

    public int nextInt() {
        return scanner.nextInt();
    }

}

public class GameTest {

    private final MyScanner scanner = mock(MyScanner.class);
    private final PrintStream printStream = mock(PrintStream.class);

    private final Game game = new Game(new SingleGuessHandler(scanner, printStream), 15);

    @Test
    public void returnsCorrectOutputWhenNumberGuessedAfterThreeAttempts() {
        when(scanner.nextInt()).thenReturn(10, 20, 15);

        game.run();

        InOrder inOrder = inOrder(scanner, printStream);
        inOrder.verify(printStream).println(" guess 1:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Clue: Higher");
        inOrder.verify(printStream).println(" guess 2:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Clue: lower");
        inOrder.verify(printStream).println(" guess 3:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Correct answer after only 3 guesses – Excellent!");
    }

}

步骤6-为SingleGuessHandler创建单元测试
最后说明
请注意，类MyScanner
和Main
未经测试。测试它们需要使用realjava.util.Scanner
和realSystem.out
打印流。这是一种验收测试（一切都是真实的，没有伪造或模仿）在这种情况下，最好将java应用程序作为单独的进程运行，并为其提供编号并检查其输出
测试被猜测的数字的范围是个好主意。我可以通过将new Random（）.nextInt（100）
提取到一个类中，例如RandomNumberProvider
。然后剩下的就是：

将其作为依赖项添加到游戏
为Game
添加测试，该测试将Game
传递给SingleGuessHandler
提供程序返回的任何内容
为RandomNumberProvider
添加测试-属性测试或通过模拟Random

还请注意，当不同的测试调用同一方法时，会使用不同的值。这样可以防止在实现中意外硬编码这些值。目录

步骤0-将代码重构为可操作、可编译的示例
步骤1-重构以能够进行依赖项注入
步骤2-将java.util.Scanner包装到您自己的委托中
步骤3-创建一个常规测试
步骤4-从循环中提取处理单次尝试
步骤5-为游戏创建单元测试
步骤6-为SingleGuessHandler创建单元测试
最后说明

步骤0-将代码重构为可操作、可编译的示例
步骤3-创建一个常规测试
s
import org.junit.Test;
import org.mockito.InOrder;

import java.io.PrintStream;

import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class GameTest {

    private final MyScanner scanner = mock(MyScanner.class);
    private final PrintStream printStream = mock(PrintStream.class);

    private final Game game = new Game(scanner, printStream, 15);

    @Test
    public void returnsCorrectOutputWhenNumberGuessedAfterThreeAttempts() {
        when(scanner.nextInt()).thenReturn(10, 20, 15);

        game.run();

        InOrder inOrder = inOrder(scanner, printStream);
        inOrder.verify(printStream).println(" guess 1:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Clue: Higher");
        inOrder.verify(printStream).println(" guess 2:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Clue: lower");
        inOrder.verify(printStream).println(" guess 3:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Correct answer after only 3 guesses – Excellent!");
    }

}

public class Main {

    public static void main(String[] args) {
        Game game = new Game(new SingleGuessHandler(new MyScanner(), System.out), new Random().nextInt(100));

        game.run();
    }

}

public class Game {

    private final SingleGuessHandler singleGuessHandler;
    private final int number;

    public Game(SingleGuessHandler singleGuessHandler, int number) {
        this.singleGuessHandler = singleGuessHandler;
        this.number = number;
    }

    public void run() {
        for (int i = 1; i <= 10; i++) {
            singleGuessHandler.runSingleGuess(i, number);
        }
    }

}

public class SingleGuessHandler {

    private final MyScanner scanner;
    private final PrintStream printStream;

    public SingleGuessHandler(MyScanner scanner, PrintStream printStream) {
        this.scanner = scanner;
        this.printStream = printStream;
    }

    public void runSingleGuess(int attempt, int number) {
        printStream.println(" guess " + attempt + ":");
        int guess = scanner.nextInt();
        if (guess > number) {
            printStream.println("Clue: lower");
        } else if (guess < number) {
            printStream.println("Clue: Higher");
        } else if (guess == number) {
            printStream.println("Correct answer after only " + attempt + " guesses – Excellent!");
        }
    }

}

public class MyScanner {

    private final Scanner scanner = new Scanner(System.in);

    public int nextInt() {
        return scanner.nextInt();
    }

}

public class GameTest {

    private final MyScanner scanner = mock(MyScanner.class);
    private final PrintStream printStream = mock(PrintStream.class);

    private final Game game = new Game(new SingleGuessHandler(scanner, printStream), 15);

    @Test
    public void returnsCorrectOutputWhenNumberGuessedAfterThreeAttempts() {
        when(scanner.nextInt()).thenReturn(10, 20, 15);

        game.run();

        InOrder inOrder = inOrder(scanner, printStream);
        inOrder.verify(printStream).println(" guess 1:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Clue: Higher");
        inOrder.verify(printStream).println(" guess 2:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Clue: lower");
        inOrder.verify(printStream).println(" guess 3:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Correct answer after only 3 guesses – Excellent!");
    }

}

@Test
public void callsSingleGuessHandlerTenTimes() {
    SingleGuessHandler singleGuessHandler = mock(SingleGuessHandler.class);
    Game game = new Game(singleGuessHandler, 17);

    game.run();

    InOrder inOrder = inOrder(singleGuessHandler);
    inOrder.verify(singleGuessHandler).runSingleGuess(1, 17);
    inOrder.verify(singleGuessHandler).runSingleGuess(2, 17);
    inOrder.verify(singleGuessHandler).runSingleGuess(3, 17);
    inOrder.verify(singleGuessHandler).runSingleGuess(4, 17);
    inOrder.verify(singleGuessHandler).runSingleGuess(5, 17);
    inOrder.verify(singleGuessHandler).runSingleGuess(6, 17);
    inOrder.verify(singleGuessHandler).runSingleGuess(7, 17);
    inOrder.verify(singleGuessHandler).runSingleGuess(8, 17);
    inOrder.verify(singleGuessHandler).runSingleGuess(9, 17);
    inOrder.verify(singleGuessHandler).runSingleGuess(10, 17);
    inOrder.verifyNoMoreInteractions();
}

public class SingleGuessHandlerTest {

    private final MyScanner scanner = mock(MyScanner.class);
    private final PrintStream printStream = mock(PrintStream.class);

    private final SingleGuessHandler singleGuessHandler = new SingleGuessHandler(scanner, printStream);

    @Test
    public void printsLowerClue() {
        when(scanner.nextInt()).thenReturn(5);

        singleGuessHandler.runSingleGuess(99, 4);

        InOrder inOrder = inOrder(scanner, printStream);
        inOrder.verify(printStream).println(" guess 99:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Clue: lower");
        inOrder.verifyNoMoreInteractions();
    }

    @Test
    public void printsHigherClue() {
        when(scanner.nextInt()).thenReturn(16);

        singleGuessHandler.runSingleGuess(2, 100);

        InOrder inOrder = inOrder(scanner, printStream);
        inOrder.verify(printStream).println(" guess 2:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Clue: Higher");
        inOrder.verifyNoMoreInteractions();
    }

    @Test
    public void printsSuccessfulGuessMessage() {
        when(scanner.nextInt()).thenReturn(65);

        singleGuessHandler.runSingleGuess(8, 65);

        InOrder inOrder = inOrder(scanner, printStream);
        inOrder.verify(printStream).println(" guess 8:");
        inOrder.verify(scanner).nextInt();
        inOrder.verify(printStream).println("Correct answer after only 8 guesses – Excellent!");
        inOrder.verifyNoMoreInteractions();
    }

}