Question

How can I make a test case with Junit?

import java.util.ArrayList;

import board.Board;

public class Pawn extends Piece{

   public Pawn(int positionX, int positionY, boolean isWhite) {
       super("P", positionX, positionY, isWhite);
   }

   @Override
   public String getPossibleMoves() {
       ArrayList<String> possibleMoves = new ArrayList<>();
      
       //check side, different color pawns go on different ways
       if(isWhite) {
           if(positionX != 7 && positionY != 0) {
               if(Board.board[positionX + 1][positionY - 1] != null && !Board.board[positionX + 1][positionY - 1].isWhite()) {
                   possibleMoves.add(Board.positionToChessPosition(positionX + 1, positionY - 1));
               }
           }

           if(positionX != 7 && positionY != 7) {
               if(Board.board[positionX + 1][positionY + 1] != null && !Board.board[positionX + 1][positionY + 1].isWhite()) {
                   possibleMoves.add(Board.positionToChessPosition(positionX + 1, positionY + 1));
               }
           }
           if(positionX != 7) {
               if(Board.board[positionX + 1][positionY] == null) {
                   possibleMoves.add(Board.positionToChessPosition(positionX + 1, positionY));
               }
           }
          
           if(positionX == 1 && Board.board[3][positionY] == null) {
               possibleMoves.add(Board.positionToChessPosition(3, positionY));
           }
       }else {
           if(positionX != 0 && positionY != 0) {
               if(Board.board[positionX - 1][positionY - 1] != null && Board.board[positionX - 1][positionY - 1].isWhite()) {
                   possibleMoves.add(Board.positionToChessPosition(positionX - 1, positionY - 1));
               }
           }
           if(positionX != 0 && positionY != 7) {
               if(Board.board[positionX - 1][positionY + 1] != null && Board.board[positionX - 1][positionY + 1].isWhite()) {
                   possibleMoves.add(Board.positionToChessPosition(positionX - 1, positionY + 1));
               }
           }
           if(positionX != 0) {
               if(Board.board[positionX - 1][positionY] == null) {
                   possibleMoves.add(Board.positionToChessPosition(positionX - 1, positionY));
               }
           }
          
           if(positionX == 6 && Board.board[4][positionY] == null) {
               possibleMoves.add(Board.positionToChessPosition(4, positionY));
           }
       }
      
       String result = "";
      
       if(!possibleMoves.isEmpty()) {
           result += possibleMoves.get(0);
          
           for(int i = 1; i < possibleMoves.size(); i++) {
               result += ", " + possibleMoves.get(i);
           }
       }
      
       return result;
   }

   @Override
   public String toString() {
       return "P" + Board.positionToChessPosition(positionX, positionY);
   }
}

public abstract class Piece {
   protected String name;
   protected int positionX, positionY;
   public boolean isWhite;
  
  
   public Piece(String name, int positionX, int positionY, boolean isWhite) {
       this.name = name;
       this.positionX = positionX;
       this.positionY = positionY;
       this.isWhite = isWhite;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getPositionX() {
       return positionX;
   }

   public void setPositionX(int positionX) {
       this.positionX = positionX;
   }

   public int getPositionY() {
       return positionY;
   }

   public void setPositionY(int positionY) {
       this.positionY = positionY;
   }

   public boolean isWhite() {
       return isWhite;
   }

   public void setWhite(boolean isWhite) {
       this.isWhite = isWhite;
   }
  
   public abstract String getPossibleMoves();
  
}

Answer 1

Hi,

Please find the answer below:

-------------------------------------------------

There are main 3 versions in Junit that are widely used.

• JUnit 3
• JUnit 4 -> Vintage
• Junit 5 -> Jupiter

Junit3 doesn't have any annotations and is old now.
JUnit 4 introduced annotations i.e @Test, @Before, @After etc.
JUnit 5 the current version introduced more annotations and basically divided the monolithic junit jar into three APIs.

We need to annotate a method as @Test to mark it as a test method.

Things we do in JUnit testing ina high-level

Perform Setup.-> instantiate a class like chessboard, pawn etc.
Perform Action. In a test method you basically perform some action and validate using assertions.( Assert class)
Perform CleanUp.-> nullify objects to make tests independent to each other.

Create JUnit Test case:

Right click the class >> New >> JUnit Test Case.

Choose all method stubs.

Class Under Test choose Pawn class.

In the next screen choose which methods to test.

Hit Finish.

---------------------------------

Implement the test methods , setup and tear down stubs.

Run and check the junit test results.

--------------------------------

Sample Junit test case :

Note that: You need to perform test actions and assertions as per the board class.

Positive testcase:

Basically create a Pawn at some point x,y and color balck and white and test the legal moves.

Negative testcase:

Basically create a Pawn at some INVALID point x,y say 10 , 10 and color brown and test how the method reponds.

---------------------------------------------

package test;
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 chess.Pawn;

/**
*
*/

/**
* @author
*
*/
class PawnTest {
   Pawn _pawn;
   Board _board;

   /**
   * @throws java.lang.Exception
   */
   @BeforeAll
   static void setUpBeforeClass() throws Exception {
       //Setup a chess board here.
   }

   /**
   * @throws java.lang.Exception
   */
   @AfterAll
   static void tearDownAfterClass() throws Exception {
   }

   /**
   * @throws java.lang.Exception
   */
   @BeforeEach
   void setUp() throws Exception {
       //Creating a white Pawn @ 2,2
       // This runs before the test method
       _pawn = new Pawn(2, 2,true);
   }

   /**
   * @throws java.lang.Exception
   */
   @AfterEach
   void tearDown() throws Exception {
       // making the pawn null
       // This runs after the test method
       _pawn = null;
   }

   /**
   * Test method for {@link chess.Pawn#getPossibleMoves()}.
   */
   @Test
   void testGetPossibleMoves() {
       System.out.println(_pawn.getPossibleMoves());
       // Check the valid moves here using asertions.
       // look at the org.junit.Assert.
       // Junit 5 : org.junit.jupiter.api.Assertions
   }

   /**
   * Test method for {@link chess.Pawn#Pawn(int, int, boolean)}.
   */
   @Test
   void testPawn() {
       fail("Not yet implemented");
   }

}

----------------------------------------------------

Hope this helps.