Unit testing is crucial in Java projects, and mastering the key steps of the JUnit framework can help you get started quickly. 1. Introduce JUnit dependencies and use Maven or Gradle to add JUnit Jupiter's API and Engine dependencies; 2. Write test classes, use @Test annotation to mark the test methods, and simplify assertion calls through static import; 3. Use @BeforeEach, @AfterEach, @BeforeAll and @AfterAll to manage the test life cycle; 4. Use assertEquals, assertTrue, assertNull and assertThrows to verify normal and exception logic to ensure the accuracy and completeness of the test.

Unit testing is a very important part of software development, especially in Java projects, JUnit is one of the most commonly used testing frameworks. If you are just starting to get involved in unit testing, you may feel a bit abstract, but in fact, you can get started quickly by just mastering a few key points.

1. Introducing JUnit dependencies

To use JUnit in a Java project, you must first make sure that your project introduces the correct dependencies. Most modern Java projects use Maven or Gradle to manage dependencies.

• Maven : Add the following content in pom.xml :

   <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>5.10.0</version>
      <scope>test</scope>
  </dependency>
  <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-engine</artifactId>
      <version>5.10.0</version>
      <scope>test</scope>
  </dependency>

• Gradle : Add in the build.gradle file:

  

   testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
  testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'

Note that the version number can be adjusted as needed. Currently, it is recommended to use JUnit Jupiter (that is, JUnit 5) instead of the old version of JUnit 4.

2. Write the first test class

Usually we will create a corresponding test class for each business class. For example, if you have a Calculator class, you can create a CalculatorTest class.

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

class CalculatorTest {

    @Test
    void add_shouldReturnCorrectResult() {
        Calculator calculator = new Calculator();
        int result = calculate(2, 3);
        assertEquals(5, result);
    }
}

A few explanations:

• Use the @Test annotation to mark this is a test method.
• It is recommended to use static import org.junit.jupiter.api.Assertions.* , so you can directly use assertEquals and other assertion methods.
• The test method naming should clearly express the test intention, such as the above add_shouldReturnCorrectResult .

3. Use common annotations and lifecycle methods

JUnit provides some lifecycle-related annotations to help you do some initialization or cleaning before and after testing.

• @BeforeEach : Run before each test method is executed.
• @AfterEach : Run after each test method is executed.
• @BeforeAll : Run once before the entire test class starts (usually a static method).
• @AfterAll : Run once after the entire test class is finished (also often a static method).

For example:

 @BeforeEach
void setUp() {
    // Initialize resources, such as creating objects, connecting to databases, etc.}

@AfterEach
void tearDown() {
    // Clean up resources}

These methods are suitable for handling some shared resources or state, avoiding duplicate code.

4. Assertions and Exception Testing

In addition to basic assertEquals , JUnit also supports many assertion methods, such as:

• assertTrue(boolean condition)
• assertNull(Object object)
• assertThrows(Class<T> expectedType, Executable executable) : used to test whether a specified exception is thrown

For example:

 @Test
void divide_shouldThrowExceptionWhenDivideByZero() {
    Calculator calculator = new Calculator();
    assertThrows(ArithmeticException.class, () -> calculate.divide(10, 0));
}

This test verifies whether an exception is thrown correctly when the divisor is 0.

Basically that's it. There are many functions of JUnit, such as parameterized testing, test grouping, etc., but for daily development, mastering the basic usage is enough to deal with most scenarios first. What is not complicated but is easy to ignore is the accuracy of test naming and assertions, which directly affect the maintainability and effectiveness of the test.

The above is the detailed content of How to perform Unit Testing in Java with JUnit?. For more information, please follow other related articles on the PHP Chinese website!