如何测试其他语句？

Question

i have been struggling with testing the if else and for loops here is the example can you pleas guide me how does the automated testing actually work for these statements?

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!");

    } 

Answer 1

Table of Contents

• Step 0 - refactor the code to workable, compilable example
• Step 1 - refactor to be able to do dependency injection
• Step 2 - wrap java.util.Scanner into your own delegate
• Step 3 - create one general test
• Step 4 - extract handling single attempt from the loop
• Step 5 - create unit test for Game
• Step 6 - create unit test for SingleGuessHandler
• Final notes

Step 0 - refactor the code to workable, compilable example

public class Main {

    public static void main(String[] args) {
        new Game().run();
    }

}

public class Game {

    public void run() {
        Scanner scan = new Scanner(System.in);
        int number = new Random().nextInt(100);

        for (int i = 1; i <= 10; i++) {
            System.out.println(" guess " + i + ":");
            int guess = scan.nextInt();
            if (guess > number) {
                System.out.println("Clue: lower");
            } else if (guess < number) {
                System.out.println("Clue: Higher");
            } else if (guess == number) {
                System.out.println("Correct answer after only " + i + " guesses – Excellent!");
            }
        }
    }

}

Step 1 - refactor to be able to do dependency injection

All of these operations should be done with IDE refactoring - move method, extract to field, create constructor, move initializer to constructor, extract to parameter etc.

public class Main {

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

        game.run();
    }

}

public class Game {

    private final Scanner scanner;
    private final PrintStream printStream;
    private final int number;

    public Game(Scanner scanner, PrintStream out, int number) {
        this.scanner = scanner;
        this.printStream = out;
        this.number = number;
    }

    public void run() {
        for (int i = 1; i <= 10; i++) {
            printStream.println(" guess " + i + ":");
            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 " + i + " guesses – Excellent!");
            }
        }
    }

}

Step 2 - wrap java.util.Scanner into your own delegate

Trying to mock java.util.Scanner you will quickly find out that class is final, so we create a simple wrapper and replace java.util.Scanner with our one in Main and Game classes.

public class MyScanner {

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

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

}

Step 3 - create one general test

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!");
    }

}

Step 4 - extract handling single attempt from the loop

In the loop there are 3 possible flows and we have 10 iterations. This gives in total 3^10 ~ 60.000 possible flows. And we don't want to write 60 thousand tests. So we refactor again (using only IDE refactoring options) to get to the following state. Note, all should compile and the test should be still green.

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!");
    }

}

Step 5 - create unit test for Game

Our existing GameTest tests together a couple of classes but now we want to test only the interaction of Game and SingleGuessHandler . At this point, I have realised that your original code didn't contain any logic to handle breaking the loop in case of correct guess. This makes below unit test much simpler, otherwise runSingleGuess would have to return true/false value (indicating whether to call it again) and we would have to write 1 more test to check that if it returns false , then it is not called again. So in short:

• 1 test for failure - loop iterated 10 times
• 1 test for success - early termination of the loop (I will not do this since it was not in your original code)

@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();
}

Step 6 - create unit test for SingleGuessHandler

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();
    }

}

Final notes

Please note that classes MyScanner and Main are untested. Testing them would require to use real java.util.Scanner and real System.out print stream. This is a type of acceptance test (everything is real, no fakes or mocks) and in this case would be probably best achievable by running the java application as separate process and feeding it numbers and checking what it outputs.

It would be good idea to test the range of the number that is being guessed. I would do it by extracting new Random().nextInt(100) into a class eg RandomNumberProvider . Then all that's left is:

• adding it as dependency to Game
• adding a test for Game that Game passes to SingleGuessHandler whatever provider returned
• adding a test for RandomNumberProvider - either property test or by mocking Random

Also note that when different tests are calling the same method, different values are used. It prevents accidental hardcoding of these values in the implementation.

Answer 2

Extract a "pure function" that captures the logic of your code, then testing will be trivial.

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!";
 }

Answer 3

Extract a function guess() and pass guess and number . Make it return your result string or an abstract value representing it.

Encapsulate the function and the counter in a new class. Each time you guess() , increment it. Disable guessing when you've reached 10 guesses.

Now you control the inputs and outputs of your code and can test it properly without having to rely on side effects (console in/out).

Answer 4

You just write three different asserts that satisfy the different conditions.You also need to put it in some sort of function. I've never tried to unit test a main function but I guess you could do it that way, but usually it is in a function that returns some value. I'm not sure how you would test the print statement. Perhaps you can put the text in a variable and then print that. It would look something like this.

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);
}

Be aware that I haven't tested any of this code, this is just the general idea as to how you would set things up.