0
# JUnit Jupiter
1
2
JUnit Jupiter is the new programming and extension model for JUnit 5, providing a comprehensive testing framework for Java applications. As an aggregator module, it combines the core JUnit Jupiter API, parameterized test support, and the Jupiter test engine to deliver a unified, modern testing experience with advanced features like nested tests, dynamic tests, custom extensions, and parallel execution.
3
4
## Package Information
5
6
- **Package Name**: org.junit.jupiter:junit-jupiter
7
- **Package Type**: Maven
8
- **Language**: Java
9
- **Installation**: Add to Maven `pom.xml`:
10
11
```xml
12
<dependency>
13
<groupId>org.junit.jupiter</groupId>
14
<artifactId>junit-jupiter</artifactId>
15
<version>5.12.2</version>
16
<scope>test</scope>
17
</dependency>
18
```
19
20
Or Gradle `build.gradle`:
21
22
```groovy
23
testImplementation 'org.junit.jupiter:junit-jupiter:5.12.2'
24
```
25
26
## Core Imports
27
28
```java
29
import org.junit.jupiter.api.*;
30
import org.junit.jupiter.params.ParameterizedTest;
31
import org.junit.jupiter.params.provider.*;
32
```
33
34
Common static imports for assertions:
35
36
```java
37
import static org.junit.jupiter.api.Assertions.*;
38
import static org.junit.jupiter.api.Assumptions.*;
39
```
40
41
## Basic Usage
42
43
```java
44
import org.junit.jupiter.api.*;
45
import static org.junit.jupiter.api.Assertions.*;
46
47
class CalculatorTest {
48
49
@Test
50
@DisplayName("Addition should work correctly")
51
void testAddition() {
52
Calculator calc = new Calculator();
53
assertEquals(5, calc.add(2, 3));
54
assertNotNull(calc);
55
}
56
57
@BeforeEach
58
void setUp() {
59
// Setup before each test
60
System.out.println("Setting up test");
61
}
62
63
@AfterEach
64
void tearDown() {
65
// Cleanup after each test
66
System.out.println("Cleaning up test");
67
}
68
69
@ParameterizedTest
70
@ValueSource(ints = {1, 2, 3, 4, 5})
71
void testMultipleValues(int value) {
72
assertTrue(value > 0);
73
}
74
}
75
```
76
77
## Architecture
78
79
JUnit Jupiter is built around several key components:
80
81
- **Test API**: Core annotations and interfaces for writing tests (`@Test`, `@BeforeEach`, etc.)
82
- **Assertion Engine**: Comprehensive assertion methods with descriptive failure messages
83
- **Extension Model**: Powerful extension system for custom behavior and integrations
84
- **Test Engine**: Runtime execution engine that discovers and runs tests
85
- **Parameter Resolution**: Dependency injection system for test methods and constructors
86
- **Conditional Execution**: Rich set of conditions for enabling/disabling tests based on environment
87
88
## Capabilities
89
90
### Core Testing API
91
92
Essential testing annotations, lifecycle methods, and basic test structure. Provides the foundation for writing JUnit 5 tests with modern Java features.
93
94
```java { .api }
95
@Test
96
@BeforeAll
97
@BeforeEach
98
@AfterEach
99
@AfterAll
100
@DisplayName(String value)
101
@Nested
102
@Disabled(String reason)
103
@Timeout(long value, TimeUnit unit)
104
```
105
106
[Core Testing](./core-testing.md)
107
108
### Assertions and Assumptions
109
110
Comprehensive assertion methods for verifying test conditions and conditional test execution based on assumptions.
111
112
```java { .api }
113
// Core assertions
114
static void assertEquals(Object expected, Object actual);
115
static void assertTrue(boolean condition);
116
static void assertThrows(Class<T> expectedType, Executable executable);
117
static void assertAll(Executable... executables);
118
119
// Assumptions
120
static void assumeTrue(boolean assumption);
121
static void assumingThat(boolean assumption, Executable executable);
122
```
123
124
[Assertions and Assumptions](./assertions.md)
125
126
### Parameterized Tests
127
128
Advanced parameterized testing with multiple data sources, argument conversion, and aggregation for data-driven test scenarios.
129
130
```java { .api }
131
@ParameterizedTest
132
@ValueSource(ints = {1, 2, 3})
133
@CsvSource({"1,John", "2,Jane"})
134
@MethodSource("argumentProvider")
135
void parameterizedTest(int value, String name);
136
```
137
138
[Parameterized Tests](./parameterized-tests.md)
139
140
### Extensions and Lifecycle
141
142
Powerful extension model for customizing test behavior, dependency injection, and integrating with external frameworks.
143
144
```java { .api }
145
@ExtendWith(MyExtension.class)
146
@RegisterExtension
147
static MyExtension extension = new MyExtension();
148
149
interface Extension { }
150
interface BeforeAllCallback extends Extension;
151
interface ParameterResolver extends Extension;
152
```
153
154
[Extensions](./extensions.md)
155
156
### Conditional Execution
157
158
Rich set of conditions for controlling test execution based on operating system, JRE version, system properties, and custom conditions.
159
160
```java { .api }
161
@EnabledOnOs(OS.LINUX)
162
@DisabledOnJre(JRE.JAVA_8)
163
@EnabledIfSystemProperty(named = "env", matches = "prod")
164
@EnabledIf("customCondition")
165
```
166
167
[Conditional Execution](./conditional-execution.md)
168
169
### Dynamic Tests
170
171
Runtime test generation and nested test organization for complex test scenarios and hierarchical test structure.
172
173
```java { .api }
174
@TestFactory
175
Stream<DynamicTest> dynamicTests();
176
177
static DynamicTest dynamicTest(String displayName, Executable executable);
178
static DynamicContainer dynamicContainer(String displayName, Stream<DynamicNode> children);
179
```
180
181
[Dynamic Tests](./dynamic-tests.md)
182
183
### Parallel Execution and Resource Management
184
185
Configuration for parallel test execution, resource locking, and temporary file management for performance optimization.
186
187
```java { .api }
188
@Execution(ExecutionMode.CONCURRENT)
189
@ResourceLock("database")
190
@TempDir
191
Path tempDirectory;
192
```
193
194
[Parallel Execution](./parallel-execution.md)
195
196
## Types
197
198
### Core Test Interfaces
199
200
```java { .api }
201
interface TestInfo {
202
String getDisplayName();
203
Set<String> getTags();
204
Optional<Class<?>> getTestClass();
205
Optional<Method> getTestMethod();
206
}
207
208
interface TestReporter {
209
void publishEntry(Map<String, String> map);
210
void publishEntry(String key, String value);
211
}
212
213
interface RepetitionInfo {
214
int getCurrentRepetition();
215
int getTotalRepetitions();
216
}
217
```
218
219
### Assertion Utilities
220
221
```java { .api }
222
class AssertionFailureBuilder {
223
static AssertionFailureBuilder assertionFailure();
224
AssertionFailureBuilder message(String message);
225
AssertionFailureBuilder expected(Object expected);
226
AssertionFailureBuilder actual(Object actual);
227
AssertionFailedError build();
228
}
229
```
230
231
### Functional Interfaces
232
233
```java { .api }
234
@FunctionalInterface
235
interface Executable {
236
void execute() throws Throwable;
237
}
238
239
@FunctionalInterface
240
interface ThrowingSupplier<T> {
241
T get() throws Throwable;
242
}
243
244
@FunctionalInterface
245
interface ThrowingConsumer<T> {
246
void accept(T t) throws Throwable;
247
}
248
```