@Test
public void isValidEmployee_withNullEmployee() {
    assertEquals(new Double(0.0), employeeService.calculateTax(null));
}

Annotation	Description
@Test	Identifies a method as a test method.
@Before	Executed before each test. It is used to prepare the test environment (e.g., read input data, initialize the class).
@After	Executed after each test. It is used to clean up the test environment (e.g., delete temporary data, restore defaults). It can also save memory by cleaning up expensive memory structures.
@BeforeClass	Executed once, before the start of all tests. It is used to perform time intensive activities, for example, to connect to a database. Methods marked with this annotation need to be defined as static to work with JUnit.
@AfterClass	Executed once, after all tests have been finished. It is used to perform clean-up activities, for example, to disconnect from a database. Methods annotated with this annotation need to be defined as static to work with JUnit.
@Ignore or @Ignore("Why disabled")	Marks that the test should be disabled. This is useful when the underlying code has been changed and the test case has not yet been adapted. Or if the execution time of this test is too long to be included. It is best practice to provide the optional description, why the test is disabled.
@Test (expected = Exception.class)	Fails if the method does not throw the named exception.
@Test(timeout=100)	Fails if the method takes longer than 100 milliseconds.

Let’s write some business logic to add the test cases:
Business Logic Class:

package com.onlyfullstack.unittesting.service;

import java.util.Collections;
import java.util.Map;

import com.onlyfullstack.unittesting.bean.Employee;

public final class EmployeeService {

    private Map<Integer, Employee> employeeMap = Collections.singletonMap(1, new Employee());

    public boolean isValidEmployee(Employee employee) {
        boolean isValid = false;
        if(employee != null) {
            if(employee.getId() != null && employee.getName() !=null) {
                isValid = true;
            }
        }
        return isValid;
    }

    public Double calculateTax(Employee employee) {
        Double tax = 0.0;
        if(employee!=null && employee.getSalary() >0) {
            if(employee.getSalary() < 500000) {
                tax = employee.getSalary() * 0.05;
            } else if(employee.getSalary() > 500000 && employee.getSalary() < 1000000) {
                tax = employee.getSalary() * 0.1;
            } else {
                tax = employee.getSalary() * 0.2;
            }
        }
        return tax;
    }

    public Employee getEmployeeFromId(Integer id) {
        return employeeMap.get(id);
    }
}

package com.onlyfullstack.unittesting.service;

import com.onlyfullstack.unittesting.bean.Employee;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import static org.junit.Assert.*;

/**
 * This class contains Unit Test cases of {@link EmployeeService}
 */
public class EmployeeServiceTest {

    private EmployeeService employeeService = new EmployeeService();

    private Employee employee = null;

    @BeforeClass
    public static void beforeClass() {
        System.out.println("Executing Before Class");
    }

    @Before
    public void before() {
        System.out.println("Executing Before");
        employee = new Employee();
        employee.setSalary(1000000.0);
    }

    @AfterClass
    public static void afterClass() {
        System.out.println("Executing After Class");
    }

    @After
    public void after() {
        System.out.println("Executing After");
    }

    @Test
    public void isValidEmployee_withNullEmployee() {
        System.out.println("Entered in isValidEmployee_withNullEmployee");
        assertEquals(new Double(0.0), employeeService.calculateTax(null));
        System.out.println("Exited from isValidEmployee_withNullEmployee");
    }

    @Test
    public void isValidEmployee_withNegativeSalary() {
        System.out.println("Entered in isValidEmployee_withNegativeSalary");
        employee.setSalary(-2.0);
        assertEquals(new Double(0.0), employeeService.calculateTax(null));
        System.out.println("Exited from isValidEmployee_withNegativeSalary");
    }
}

Let’s run the test cases with Eclipse run with Junit test option.

Output

Executing Before Class

Executing Before

Entered in isValidEmployee_withNegativeSalary

Exited from isValidEmployee_withNegativeSalary

Executing After

Executing Before

Entered in isValidEmployee_withNullEmployee

Exited from isValidEmployee_withNullEmployee

Executing After

Executing After Class

@BeforeClass and @AfterClass are called once

Source Code
Download the source code of JUnit tutorial from below git repository :
unit-testing-and-integration-testing-with-spring-boot

Let’s go to our next tutorial where we will discuss below points :

Part 4 – JUnit Assert Methods

– Assert Methods
1. assertEquals()
2. assertTrue() + assertFalse()
3. assertNull() + assertNotNull()
4. assertSame() and assertNotSame()
5. assertThat()