The first thing to do when your Java program crashes is run a debugger and find the offending line of code that crashed. You can write an unit test for each class or method you want to verify, but by default JUnit tests are written only once at compile time before testing begins. In this article we’ll see how lifecycle methods allow us to create more effective tests after compilation than what’s possible with just regular unit-tests in advance.
The “junit 5” is a testing framework that has been around for quite some time. It has changed drastically over the years, and it is now known as JUnit5. This guide will help you understand how to use junit 5.
You will learn about JUnit5 Lifecycle methods in this tutorial. Any method that is directly or meta-annotated with @BeforeAll, @AfterAll, @BeforeEach, or @AfterEach is a Lifecycle Method. Let’s take a look at each of these annotations individually.
@BeforeAll
When a method is annotated with @BeforeAll, it indicates that it should be run before any @Test, @RepeatedTest, @ParameterizedTest, or @TestFactory methods in the current class.
@BeforeEach
When a method is annotated with @BeforeEach, it specifies that it should be run before any @Test, @RepeatedTest, @ParameterizedTest, or @TestFactory methods in the current class.
@AfterEach
When a method is annotated with @AfterEach, it indicates that it should be run after each @Test, @RepeatedTest, @ParameterizedTest, or @TestFactory method in the current class.
@AfterAll
When a method is annotated with @AfterAll, it indicates that it should be run after all @Test, @RepeatedTest, @ParameterizedTest, and @TestFactory methods in the current class have been run.
The pom.xml Document
The dependencies you’ll need to add to your project are listed below.
Dependency on junit-jupiter-engine
In JUnit 5, JUnit Jupiter combines the new programming paradigm with the extension concept for developing tests and extensions. To get started with the JUnit Platform, we need to add at least one TestEngine implementation to our project.
If we wish to create tests using Jupiter, we’ll add the junit-jupiter-engine test artifact to the dependencies in pom.xml. Then, in our test source directory, we can write tests.
org.junit.jupiter 5.8.2 junit-jupiter-engine test
maven-surefire-plugin
During the test step of the build lifecycle, we utilize Surefire Plugin to run an application’s unit tests. It creates reports in two distinct file formats: plain text and XML.
org.apache.maven.plugins 3.0.0-M5 maven-surefire-plugin
Examples of JUnit5 Lifecycle Methods
To understand more about JUnit5 Lifecycle Methods, let’s look at how the annotations stated above function. We’ve used @BeforeEach, @AfterEach, @BeforeAll, @AfterAll, and @Test in this example. Simple print statements have been inserted in our sample class to help us understand how lifecycle methods are executed.
DemoTestLifeCycleMethods.java
import org.junit.jupiter.api; package com.junit5.lifecyle After all, org.junit.jupiter.api is imported. Import org.junit.jupiter.api afterEach. Import org.junit.jupiter.api before anything else. Import org.junit.jupiter.api before each. public class; test DemoTestLifeCycleMethods @BeforeAll static void demoBeforeAllTests() System.out.println(“This test will run before all tests”); @BeforeAll static void demoBeforeAllTests() @AfterAll static void demoAfterAllTests() System.out.println(“This test will run after all tests”); @AfterAll static void @AfterAll static void @AfterAll static void @AfterAll static void @AfterAll static void @AfterAll static void @AfterAll static void @AfterAll static @BeforeEach void demoBeforeEachTest() System.out.println(“This test will run before each test”); @BeforeEach void @BeforeEach void @BeforeEach void @BeforeEach void @BeforeEach void @BeforeEach void @Be @AfterEach void demoAfterEachTest() System.out.println(“This test will run after each test”); @AfterEach void @AfterEach void @AfterEach void @AfterEach void @AfterEach void @AfterEach void @AfterEach void @AfterEach @Test void demoTestOne() System.out.println(“Demo Test One”); @Test void demoTestOne() void demoTestOne() void demoTestOne() void demoTestOne() void demoTestOne() void demo @Test void demoTestTwo() System.out.println(“Demo Test Two”); @Test void demoTestTwo() void demoTestTwo() void demoTestTwo() void demoTestTwo() void demoTestTwo
Performing a JUnit test
Let’s try running the class as a JUnit Test now. The method with the @BeforeAll annotation was performed first, followed by the method with the @BeforeEach annotation, which was executed before each test. Similarly, the @AfterEach annotation caused the method to run after each test. Finally, the @AfterAll annotation was applied to the method.
Calculator.java
Let’s look at another case. We have a Calculator class with methods for adding, multiplying, dividing, and subtracting. For our Calculator class, we will now create a test class.
com.junit5.lifecyle; public class Calculator int add(int a, int b) return a+b; int multiply(int a, int b) return a*b; int divide(int a, int b) return a/b; int subtract(int a, int b) return a-b; int add(int a, int b) return a-
CalculatorTest.java
The CalculatorTest class is shown below. Let’s take a look at what’s going on in our test class.
- The term setUp is a method with the @BeforeAll annotation. We’re creating a Calculator object with a print statement in this method. This method will only be called once before the rest of the methods are called.
- Then there’s a function called beforeEach() that has the annotation @BeforeEach. We have a basic print statement in this approach. It is currently doing nothing meaningful. However, if a need exists, we may add code that must be performed before each test function.
- Then there’s testAdd(), testSub(), testMultiply(), and testDivide(), all of which contain @Test annotations (). There is an assertEquals declaration and a print statement in each of these methods. We have the desired result in the first parameter, and then we call the Calculator class’s add, subtract, multiply, and division methods using the reference to the object we constructed in the setUp function, which will yield the actual output. In the event that the test fails, we may additionally provide an error message.
- Then there’s a method with the @AfterEach annotation. It features a simple print statement with a message that will be printed once each test method is executed.
- The method with the annotation @AfterAll will execute at the end. The Calculator object is set to null in this function.
- It’s worth noting that we’ve utilized the @DisplayName annotation here. We define a custom display name for the test class or test method using @DisplayName.
package com.junit5.lifecyle; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.AfterEach; Import org.junit.jupiter.api before anything else. BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; public class org.junit.jupiter.api.Assertions.assertEquals; public class org.junit.jupiter.api.Assertions.asser CalculatorTest @BeforeAll static void setUp; static Calculator calculator () calculator = new Calculator(); System.out.println(“Running before all tests”); @BeforeEach void beforeEach() System.out.println(“Running before each test”); @AfterEach void afterEach() System.out.println(“Running after each test”); @AfterEach void afterEach() System.out.println(“Running after each test”); @Test @DisplayName(“Addition”) void testAdd() System.out.println(“Testing addition”); assertEquals(10, calculator.add(5, 5)); assertEquals(10, calculator.add(5, 5)); assertEquals(10, calculator.add(5, 5)); assertEquals(10, calculator.add(5, 5)); assertEquals(10, calculator.add(5, 5)); assertE @Test @DisplayName(“Subtraction”) void testSubtract() System.out.println(“Testing subtraction”); assertEquals(0, calculator.subtract(5, 5)); @Test @DisplayName(“Multiplication”) void testMultiply() @Test @DisplayName(“Division”) void testDivide() System.out.println(“Testing division”); assertEquals(1, calculator.divide(5, 5)); assertEquals(1, calculator.divide(5, 5)); assertEquals(1, calculator.divide(5, 5)); assertEquals(1, calculator.divide(5, 5)); assertEquals(1, calculator.divide(5, 5)); assertEquals @AfterAll static void tearDown(); calculator = null; System.out.println(“Running after all tests”);
Performing a JUnit test
When we run our test class as a JUnit test, the terminal now displays the following statements.
We can tell that all of our test methods have succeeded since the anticipated and actual outputs are the same. Using the @DisplayName annotation, we can also view the custom display names of test methods we’ve specified.
Conclusion
This brings us to the conclusion of our lesson. We learnt about JUnit5 Lifecycle Methods in this lesson. We examined the annotations that we would later utilize to construct lifecycle methods. Finally, we completed a hands-on exercise in which we utilized the annotations in our sample classes.
Stay tuned for additional educational lessons in the near future. Please feel free to make any remarks in the space below.
Good luck with your studies!
The “junit 5 example” is a guide to the JUnit5 Lifecycle Methods. The methods are how we can use them in our tests and what they do.
Frequently Asked Questions
Which is life cycle annotation in junit5?
A: An annotation is a comment that appears on the code line and notifies you about what it does.
How do I run junit5 test?
A: You can run junit5 test by typing junit5 on the command prompt.
How do I get junit5?
A: You can either download it or you can use Maven Central.
Related Tags
- junit 5 tutorial
- junit 5 maven dependency
- junit 5 before
- junit 5 lifecycle
- junit 5 dependency
