Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
1. Introduction
Gradle has become a very popular dependency management tool in recent years, especially among Java developers. It’s easy to learn, and because it’s written in Groovy, it is also very extensible.
In this quick tutorial, we’ll look at the difference between the Gradle test and check tasks. We’ll identify exactly what each one does and when it makes sense to use them.
2. Overview of Gradle
Gradle is a dependency management tool. It provides robust features for defining dependencies in a software project, along with a variety of functions to manage the entire build lifecycle, from testing to deployment.
To accomplish its work, Gradle uses tasks. A task is essentially a set of discrete steps to accomplish a goal. Some examples are:
- Compile source code
- Package source code into a module
- Deploy modules to a remote system
While Gradle is extensible and allows us to define any task we want, the most common tasks a Java developer would want are available by default. Two of those tasks are named test and check.
While they are similar in nature, they each have slightly different roles when it comes to managing a software project. In the following sections, we’ll look at each one a little closer.
3. When to Use Gradle Test
To run the test task, we would simply run:
gradle testThe test task executes all of the unit tests in the project. The test task has quite a few properties that control its behavior, and we won’t cover them all here.
By default, the test task will auto-detect all unit tests in the project, compile them, and then execute them. In the end, it generates a report of which tests have passed and failed.
The test task is a great general-purpose task that all developers should be familiar with when working with Gradle. Typically, it should be executed by each developer before committing any new code to the main branch.
But as an extra layer of protection, it’s also common to automatically execute it as part of any formal software build process. For example, it’s common to utilize the test task as part of any automated software build after compiling the source code but prior to assembling the final artifacts.
4. When to Use Gradle Check
To run the check task, we would simply run:
gradle checkUnlike test, the check task is referred to as a “lifecycle” task. This means that, on its own, it does not do anything. Instead, it executes one or more other tasks.
By default, the check task only executes the test task. This means that, in the absence of any other plugins, the two tasks behave exactly the same way and generate the same output.
The reason check is important is because it can aggregate one or more verification tasks together. This allows us to incorporate multiple tasks into a single step rather than having to execute them one by one.
The Gradle ecosystem contains a number of plugins, such as the checkstyle plugin, that provide additional functionality to the check task.
In general, any task that does source code verification work should be attached to the check task. Things like source code style enforcement, library vulnerability scans, and integration tests are all good candidates to include with the check task.
5. Conclusion
In this article, we’ve taken a closer look at the Gradle test and check tasks. While they’re similar and can sometimes be used interchangeably, they do serve different purposes.
The test task is one most developers should be familiar with, as it executes all of our unit tests and provides a report on which ones are passing and failing.
In contrast, the check task combines the test task with other tasks. There are a number of plugins that add their own steps to the check task, but we can always create our own to meet the specific needs of our software project.
