import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Assertions;

public class TicTacToe_Test 
{
} 

Note: This activity (example) use JUnit 5. For JUnit 4 developers/testers, be sure to import appropriate classes instead of the above

import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test; 

public class TicTacToe_Test 
{
   private TicTacToe ttt;

   @BeforeEach
   public void setUp() throws Exception 
   {
      ttt = new TicTacToe();    		
   } 
} 

Notice: the test file does not compile. This is because a TicTacToe class does not exist.

Note: For JUnit 4 developers/testers, use @Before annotation instead of @BeforeEach

public class TicTacToe 
{
} 

@Test
public void whenXOutsideBoardException()
{
   Assertions.assertThrows(RuntimeException.class, () -> {
      ttt.play(4, 2);
   });	   	   
} 

Notice: the test file does not compile since a play() method does not exist.

Note: For JUnit 4 developers/testers, exception handling may be

@Test (expected=RuntimeException.class)
public void whenXOutsideBoardException()
{
   ttt.play(4, 2);
}

public void play(int x, int y)
{
}   

[Key idea: make the test pass as quickly as possible and with minimal effort]

Note: As part of the TDD process, it is normal to start with a hard-coded throw (or return) statement to pass the test as quickly as possible and with minimal effort. Since the test expects a RunTimeException to be thrown, to make the test pass, the play() method can simply throw the exception.

public void play(int x, int y)
{   
   throw new java.lang.RuntimeException("X is outside board"); 
}

Run the test method.
The test passes since the play() method throws the expected exception (i.e., result of running the test matches the expectation)

However, since this example is relatively small and straightforward, we can simply write code to check X and throw an exception.

public void play(int x, int y)
{   
   if (x < 1 || x > 3)
      throw new java.lang.RuntimeException("X is outside board");
}

@Test
public void whenYOutsideBoardException()
{
   Assertions.assertThrows(RuntimeException.class, () -> {
      ttt.play(2, 4);
   });	   	   
}   

[Reminder -- key idea: make the test pass as quickly as possible and with minimal effort]

public void play(int x, int y)
{
   if (x < 1 || x > 3)
      throw new java.lang.RuntimeException("X is outside board");
   if (y < 1 || y > 3)
      throw new java.lang.RuntimeException("Y is outside board");
}  

@Test
public void whenOccupiedException()
{
   ttt.play(1, 3);       // imitate player X places a piece in (1,3)
      
   // imitate player O tries to place a piece in an occupied space (1,3)
   Assertions.assertThrows(RuntimeException.class, () -> {
      ttt.play(1, 3);
   });
}   

[Reminder -- key idea: make the test pass as quickly as possible and with minimal effort]

To be able to identify if the space is occupied, the location of the placed pieces needs to be maintained. In this example, we will store the location of the placed pieces in an array. Every time a new piece is placed, we will verify that the place is not occupied. Otherwise, an exception will be thrown.

public class TicTacToe 
{
   private String[][] board = { {"", "", ""}, 
                                {"", "", ""},
                                {"", "", ""} };    

   public void play(int x, int y)
   {
      if (x < 1 || x > 3)
         throw new java.lang.RuntimeException("X is outside board");
      if (y < 1 || y > 3)
         throw new java.lang.RuntimeException("Y is outside board");
      
      if (board[x-1][y-1] != "")
         throw new java.lang.RuntimeException("Place is occupied");
      else
         board[x-1][y-1] = "occupied";
   }
}  

[Key ideas: identify any potential refactoring and then decide which of them we will carry out]

public void play(int x, int y)
{
   checkAxis(x);
   checkAxis(y);
   setOccupied(x, y);
}
   
private void checkAxis(int axis)
{
   if (axis < 1 || axis > 3)
      throw new java.lang.RuntimeException("outside board");
}   
   
private void setOccupied(int x, int y)
{	      
   if (board[x-1][y-1] != "")
      throw new java.lang.RuntimeException("Place is occupied");
   else
      board[x-1][y-1] = "occupied";      
}