Diffblue Cover is a reinforcement learning AI platform that automatically writes comprehensive, human-like Java unit tests - saving developer time, increasing test coverage, and reducing regression risks. Cover is provided as an IntelliJ IDE plugin, a CLI application, and a CI integration to provide fully autonomous operation. Three additional components, for test management and analytics, complete the Diffblue Cover solution.

Get started

Discover the details

Product specific:

General information:

Diffblue Cover is a reinforcement learning AI platform that automatically writes comprehensive, human-like Java unit tests for Java and Kotlin projects - saving developer time, increasing test coverage, and reducing regression risks. Cover is provided as an IntelliJ IDE plugin (Cover Plugin), a CLI application (Cover CLI), and a CI integration to provide fully autonomous operation (Cover Pipeline). Three additional components (Cover Reports, Cover Optimize, and Cover Refactor), for test management and analytics, complete the Diffblue Cover platform.

But what does that mean in practical terms? As an example, let's take a method for uploading a file to an Amazon S3 bucket. The method is relatively simple, just a few lines of code, but the required test is more complex and would take a developer approximately 30 minutes to write if they've never done it before. Diffblue Cover did this in 1.6 seconds - that's not a typo - 1.6 seconds, computationally perfect, human readable, every pathway tested.

    public PutObjectResult uploadFileToBucket(String bucketName, String key, File file) {
        try {
            return s3client.putObject(bucketName, key, file);
        } catch (AmazonS3Exception e) {
            throw new IllegalStateException("Totally handled this exception", e);
        }
    }

@ContextConfiguration(classes = {AmazonService.class})
@ExtendWith(SpringExtension.class)
class AmazonServiceDiffblueTest {
    @MockBean
    private AmazonS3 amazonS3;

    @Autowired
    private AmazonService amazonService;

    /**
     * Method under test: {@link AmazonService#uploadFileToBucket(String, String, File)}
     */
    @Test
    void diffbluetestUploadFileToBucket() throws SdkClientException {
        // Arrange
        PutObjectResult putObjectResult = new PutObjectResult();
        putObjectResult.setContentMd5("MjdjN2NmNDAwMjI5MTAzZTAwYzZkODgzMDAyOWUyOWI=");
        when(amazonS3.putObject(Mockito.<String>any(), Mockito.<String>any(), Mockito.<File>any()))
                .thenReturn(putObjectResult);

        // Act and Assert
        assertSame(putObjectResult, amazonService.uploadFileToBucket("bucket-name", "object-key",
                Paths.get(System.getProperty("java.io.tmpdir"), "test.txt").toFile()));
        verify(amazonS3).putObject(Mockito.<String>any(), Mockito.<String>any(), Mockito.<File>any());
    }
}

Taking another real-world example from an existing customer we can illustrate how this is scaled up for an organization. Diffblue Cover was able to write 3,000 unit tests across an expansive code base for a single mission-critical application, right out of the box. A conservative estimate is that this would have taken a senior developer an estimated 268 developer days to write. Diffblue Cover achieved this in 8 hours, doubling test coverage, even before any refactoring.

Some basics

If you missed our short intro video on the website, take a look here - this captures the essentials of Diffblue Cover:

Key features

Diffblue Cover is the generative AI engine at the center of our platform. Cover automatically writes human-like Java unit tests that are easy for a developer to read and understand. AI-written unit tests are ready to use - they compile, run, and accurately validate the current behavior of your code.

Cover is fully autonomous. It can create an entire unit test suite for your whole application in a single execution, run locally within your environment, no cloud service required, no developer overhead. Cover also maintains this unit test suite as your software evolves, even on applications with millions of lines of code. Thanks to a deep understanding of how your code works, Diffblue Cover knows what tests need to be added and updated for every code change. It implements the necessary updates automatically, ensuring coverage doesn’t dip while your teams move faster.

IDE, CLI, CI Pipeline

Diffblue Cover is one AI, provided in three interaction models - an IDE plugin (Cover Plugin) and a CLI tool (Cover CLI) for developer use, and a CI Pipeline integration (Cover Pipeline) for DevOps teams. Use Cover Plugin, CLI, and Pipeline in isolation or in partnership as needed, depending on your preferred workflow.

Report, Optimize, Refactor

Three additional features are provided to allow you to monitor your test coverage (Cover Reports), optimize test runs (Cover Optimize), and automatically refactor your code to improve testability (Cover Refactor).

Key benefits - in summary

It's difficult to summarize all the benefits of Diffblue Cover, but here's our top ten:

• Automated Java unit tests. This one's a given. Automatic, unbiased unit tests that exercise the actual behavior of your code, including obscure corner cases and scenarios developers may not know how to test.

• Eliminate developer overhead. Avoid researching tests, writing tests, maintaining tests, learning unfamiliar code source, context switching, waiting time, and more. Target your developer skills at improving your applications instead.

• Catch regressions early and at the most granular level. Avoid rework time, optimize workflows, and avoid outages in the field.

• Increase coverage. Get to 80% coverage in half the time! Diffblue Cover creates unit tests in bulk to help your team quickly assess the quality of your test suite.

• Untangle legacy code. Our tests document your code, making scary code changes easy. This helps you to quickly write tests for large legacy codebases, and identifies untestable code that should be refactored.

• Reduce development costs and increase productivity. With reduced or eliminated developer time, optimized test runs, CI/CD integration, and more, Diffblue Cover works 24/7.

• Document your code. Diffblue Cover unit tests describe every behavior of every method - effectively documenting your code to make future code changes quicker and reduce regressions.

• Monitor coverage and understand risk. Cover shows you exactly what code isn’t tested, how important it is, and why tests might not have been written. Target developer expertise more efficiently, either at areas of most risk or those where additional coverage can most easily be delivered.

• Accelerate modernization and cloud migration. Diffblue Cover can support the migration from applications to microservices by providing a documented code base and improved test coverage.

• Keep code private. Diffblue Cover’s generative AI operates entirely within your environment. No data ever leaves your organization.

How it works

• Diffblue Cover first ensures that your code is compiled and examines each method that Cover will create tests for, and any related methods.

• Cover then creates initial test candidates for each method, which are then evaluated and adjusted to maximize test coverage. This process is repeated until the set of tests that optimize coverage are selected and committed to your code base. The tests are computationally correct and human readable, every time.

• Diffblue Cover is intended to be used for unit regression testing. That means it creates tests that reflect the current behavior of your code. Later, when you make changes to the code, these tests may fail and therefore highlight regressions. Since tests are written for your entire application at the most granular level, this means the smallest of regressions are caught which can avoid the dangers of incubated regressions that can manifest and build over time.

Trying out Diffblue Cover for the first time? Get up and running with the trial version of Cover Plugin for IntelliJ and Cover CLI – download, install, license, and play.

eLearning

Short on time? If you'd like a fast-track experience check out our free trial experience video. [7 min]

A few points first...

Cover components

Cover is provided as an IDE plugin tool so you can write tests with one click in the IntelliJ IDE (Cover Plugin), a CLI application to write tests for your entire project (Cover CLI), and a CI integration to automatically write tests within your CI workflow (Cover Pipeline).

Perfect partners

Cover Plugin, Cover CLI, and Cover Pipeline are not mutually exclusive, in fact they make perfect partners. Use Cover Plugin within the IntelliJ IDE to write and check unit tests for your application during development, and also use Cover CLI directly from the IntelliJ Terminal/Console or your OS command line to access the wider and deeper functionality provided by Cover CLI - finally, use Cover Pipeline within your CI tool to automate the whole process and provide consistency across your organisation.

The free trial

This topic focuses on Cover Plugin and Cover CLI, and will take you through the key steps to download, install, and license both tools, as well as covering a few basics and getting some tests written using each tool. Cover Pipeline for GitLab is also available as a free trial version, see Cover Pipeline for GitLab for details - for all other CI integrations please contact Diffblue.

1. Sign up

If you haven't already done so, sign up for the free trial - see https://www.diffblue.com/try-cover.

After successful sign-up, you'll receive a welcome email with general information and a license key for Cover Plugin and Cover CLI.

2. Install Cover Plugin for IntelliJ

You can install the Cover Plugin either from a downloaded ZIP archive or from the IntelliJ marketplace.

3. Install Cover CLI

4. Apply licenses

5. Try it out

Four steps to automatically write tests - clone an example project, compile the project and check your environment, learn a few basics, and then one click or one command to write tests.

Step 1 - Clone the example project Spring PetClinic

We're going to make use of an example project (Spring PetClinic) to show the Diffblue Cover Plugin for IntelliJ at work. First, we'll clone the project from the Git repo:

git clone https://github.com/diffblue/demo-spring-petclinic

Step 2 - Compile the project and check your environment

Before we write any tests, we need to compile the PetClinic project. Diffblue Cover works by analyzing the bytecode of any project used with Cover. You can do this from the Maven plugin in IntelliJ (click the Maven tab, open petclinic > Lifecycle, and double-click package) or open a command line, navigate to the directory containing the PetClinic project, and run the Maven package command:

cd demo-spring-petclinic
./mvnw package

Basic prerequisites:

• Java 8, 11, 17, or 21 compatible source code, or Kotlin source code.

• Maven 3.2.5+ or Gradle 4.9+ build tools.

• Any project (for use with Diffblue Cover) must compile and run with no failing unit tests. JUnit and TestNG testing frameworks are supported.

More details:

Diffblue Cover requires that the system environment (hardware, operating system, network connectivity, Java installation) as well as the project environment (build tooling, dependencies, presence of artifacts, existing unit tests) meet the minimum requirements as detailed in Specs & Reqs. Cover will perform an environment check before analysis begins to ensure that the requirements are met - if there are any issues, these will be reported via the Diffblue Cover panel in IntelliJ using E(Environment) Output Codes.

Check your environment:

Cover CLI also provides a command line option to run these checks, without writing any tests, useful when you just want to check-out your environment without doing anything else. To run a preflight environment check, open a command line, navigate to the directory containing the PetClinic project, and run the preflight checks:

cd demo-spring-petclinic
dcover create --preflight

Step 3 - A few basics

Before we start using Diffblue Cover to write tests, it's worth covering a few basics first.

Step 4 - Automatically write tests for the example project

In this step we're going to use Diffblue Cover to automatically write tests for two classes and then for the entire PetClinic project. We'll make use of Cover Plugin for IntelliJ and run Cover CLI commands from a command line. You can also use Cover CLI straight from the IntelliJ terminal - handy when you’re using both tools in partnership

Note that the examples here use DiffblueTest as the default class name suffix and diffbluetest as the default method name prefix, just to highlight the tests created by Diffblue Cover.

• To change your suffix and prefix in IntelliJ, go to Diffblue > Change Settings > Test Naming > Class Template/Method Template.

• To change your suffix and prefix in Cover CLI, use the --class-name-template and --method-name-template command arguments - see Cover CLI Commands & Arguments for details.

First we'll use Cover Plugin for IntelliJ:

1. In IntelliJ, open the PetClinic project and navigate to a class - for example, OwnerController.

3. Click the links in the Diffblue Cover panel to see the tests produced. And that's it, simple - 1 click, 9 methods analyzed, 7 tests written, around 340 lines of code, and all in around 65 seconds - computationally perfect, human readable. You'll find these tests in the test folder for the project.

package org.springframework.samples.petclinic.owner;

import ...

@ContextConfiguration(classes = {OwnerController.class})
@ExtendWith(SpringExtension.class)
class OwnerControllerDiffblueTest {
	@Autowired
	private OwnerController ownerController;

	@MockBean
	private OwnerRepository ownerRepository;

	/**
	 * Method under test: {@link OwnerController#initCreationForm(Map)}
	 */
	@Test
	void diffbluetestInitCreationForm() throws Exception {
		MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.get("/owners/new");
		MockMvcBuilders.standaloneSetup(ownerController)
			.build()
			.perform(requestBuilder)
			.andExpect(MockMvcResultMatchers.status().isOk())
			.andExpect(MockMvcResultMatchers.model().size(1))
			.andExpect(MockMvcResultMatchers.model().attributeExists("owner"))
			.andExpect(MockMvcResultMatchers.view().name("owners/createOrUpdateOwnerForm"))
			.andExpect(MockMvcResultMatchers.forwardedUrl("owners/createOrUpdateOwnerForm"));
	}

....

Now we'll move on to using Cover CLI.

1. Open a command line or open the IntelliJ terminal, and navigate to the demo-spring-petclinic folder.

2. Enter the following command to write tests for the PetController class:

dcover create org.springframework.samples.petclinic.owner.PetController

1. Cover CLI will now write the tests for the class - 1 command line, 10 methods analyzed, 9 tests written, around 214 lines of code created, and again, all in around 65 seconds - computationally perfect, human readable. You'll find these tests in the test folder for the project.

package org.springframework.samples.petclinic.owner;

import ...

@ContextConfiguration(classes = {PetController.class})
@ExtendWith(SpringExtension.class)
class PetControllerDiffblueTest {
	@MockBean
	private OwnerRepository ownerRepository;

	@Autowired
	private PetController petController;

	/**
	 * Method under test: {@link PetController#populatePetTypes()}
	 */
	@Test
	void diffbluetestPopulatePetTypes() {
		ArrayList<PetType> petTypeList = new ArrayList<>();
		when(ownerRepository.findPetTypes()).thenReturn(petTypeList);
		Collection<PetType> actualPopulatePetTypesResult = petController.populatePetTypes();
		assertSame(petTypeList, actualPopulatePetTypesResult);
		assertTrue(actualPopulatePetTypesResult.isEmpty());
		verify(ownerRepository).findPetTypes();
	}
....

1. Once you're happy with this first set of tests, create the full test suite for the entire PetClinic project - enter dcover create. That's it, two "words" and you're done. Of course this one takes a little longer to complete (around five minutes) as it creates tests across the entire PetClinic project, analyzing 97 methods and creating 77 tests (exact count may vary slightly).

More...

What does Diffblue Cover do?

• Diffblue Cover first ensures that your code is compiled and examines each method that Cover will create tests for, including any dependent methods.

• Cover then creates initial test candidates and uses reinforcement learning to evaluate and adjust the test candidate for each method. This process is repeated until the set of tests that optimize coverage are selected and committed to your code base.

Next steps

Now you're up and running with Diffblue Cover:

• Have a scan through the Test examples topic which provides some additional source code examples along with an explanation of the tests created by Diffblue Cover.

• Create some tests for your own project - as long as you have a project that compiles and your environment meets the Cover prerequisites, you're literally a click away from AI written tests, created in seconds instead of hours.

• See Cover Plugin and Cover CLI to familiarize yourself with the full set of features and functions.

• Cover Pipeline for GitLab is also available as a free trial version, see Cover Pipeline for GitLab for details - for all other CI integrations please contact Diffblue.

Notes

Demo code, statistics, and timings used throughout Diffblue docs and eLearning videos are based on in-house demonstrations. These may differ slightly from those experienced within a live production environment.

Get started with Diffblue Cover Plugin for IntelliJ - in short, install the plugin, apply your license, and you're ready to go. This topic also provides an example and some next steps.

If you've already done this as part of your free trial, you may want to skip this and jump straight to the Cover Plugin details, or perhaps you want to update to the latest version - see Update Cover.

eLearning

Short on time? If you'd like a fast-track experience check out our getting started video. [5 min]

1. Install Diffblue Cover Plugin for IntelliJ

2. Apply a license

Once IntelliJ has restarted, you'll be prompted for your license key (provided in your welcome email or by your organization) to activate the plugin. Alternatively, the license can be activated at any time from the IntelliJ toolbar Diffblue > Activate License. Diffblue Cover requires a remote license check with the Diffblue licensing server each time it's used. For help troubleshooting license keys, network connections, and proxy server settings, see Licensing. Note that:

• Applying a license provides access to the Teams and Enterprise Editions of Diffblue Cover.

• Cover Plugin Community Edition is free to use but does require product verification to activate your perpetual license.

• Offline license activation is available with the Diffblue Cover Enterprise Edition only. This can only be done through the CLI.

• See Cover Editions and Licensing for more details.

3. Try it out

Four steps to automatically write tests - clone an example project, compile the project and check your environment, learn a few basics, and then one click or one command to write tests.

Step 1 - Clone the example project Spring PetClinic

We're going to make use of an example project (Spring PetClinic) to show the Diffblue Cover Plugin for IntelliJ at work. First, we'll clone the project from the Git repo:

git clone https://github.com/diffblue/demo-spring-petclinic

Step 2 - Compile the project and check your environment

Before we write any tests, we need to compile the PetClinic project. Diffblue Cover works by analyzing the bytecode of any project used with Cover. You can do this from the Maven plugin in IntelliJ - click the Maven tab, open petclinic > Lifecycle, and double-click package.

Basic prerequisites:

• Java 8, 11, 17, or 21 compatible source code, or Kotlin source code.

• Maven 3.2.5+ or Gradle 4.9+ build tools.

• The project (for use with Diffblue Cover) must compile and run with no failing unit tests.

  JUnit and TestNG testing frameworks are supported.

More details:

Diffblue Cover requires that the system environment (hardware, operating system, network connectivity, Java installation) as well as the project environment (build tooling, dependencies, presence of artifacts, existing unit tests) meet the minimum requirements as detailed in Specs & Reqs. Cover Plugin will perform an environment check before analysis begins to ensure that the requirements are met - if there are any issues, these will be reported via the Diffblue Cover panel in IntelliJ using E (Environment) Output Codes.

Step 3 - A couple of basics

We won't cover the whole UI here, but here are a few useful gutter icons to get you started:

Step 4 - Automatically write tests for the example project

1. Navigate to a class - for example, OwnerController.

3. Click the links in the Diffblue Cover panel to see the tests produced - example below.

And that's it, simple - 1 click, 9 methods analyzed, 7 tests written, around 340 lines of code, and all in around 65 seconds - computationally perfect, human readable.

package org.springframework.samples.petclinic.owner;

import ...

@ContextConfiguration(classes = {OwnerController.class})
@ExtendWith(SpringExtension.class)
class OwnerControllerDiffblueTest {
	@Autowired
	private OwnerController ownerController;

	@MockBean
	private OwnerRepository ownerRepository;

	/**
	 * Method under test: {@link OwnerController#initCreationForm(Map)}
	 */
	@Test
	void diffbluetestInitCreationForm() throws Exception {
		MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.get("/owners/new");
		MockMvcBuilders.standaloneSetup(ownerController)
			.build()
			.perform(requestBuilder)
			.andExpect(MockMvcResultMatchers.status().isOk())
			.andExpect(MockMvcResultMatchers.model().size(1))
			.andExpect(MockMvcResultMatchers.model().attributeExists("owner"))
			.andExpect(MockMvcResultMatchers.view().name("owners/createOrUpdateOwnerForm"))
			.andExpect(MockMvcResultMatchers.forwardedUrl("owners/createOrUpdateOwnerForm"));
	}

....

Note that the examples here use DiffblueTest as the default class name suffix and diffbluetest as the default method name prefix, just to highlight the tests created by Diffblue Cover. To change your suffix and prefix in IntelliJ, go to Diffblue > Change Settings > Test Naming > Class Template/Method Template.

More...

What does the plugin do?

• Diffblue Cover first ensures that your code is compiled and examines each method that Cover will create tests for, including any dependent methods.

• Cover then creates initial test candidates and uses reinforcement learning to evaluate and adjust the test candidate for each method. This process is repeated until the set of tests that optimize coverage are selected and committed to your code base.

More tests

This simple "getting started" example illustrates creating tests for a class using the gutter icons (you can do the same for individual methods too). You can scale this up even further - right-click a Java source file or folder in your project structure and select Write Tests to create tests for all classes/methods contained within the file/folder. Of course that may not always be desirable:

• A large project with potentially a large number of tests can take some time to complete.

• License limits may apply.

Next steps

Now you're up and running with Cover Plugin:

• Have a scan through the Test examples topic which provides some additional source code examples along with an explanation of the tests created by Diffblue Cover.

• Create some tests for your own project - as long as you have a project that compiles and your environment meets the Cover prerequisites, you're literally a click away from AI written tests, created in seconds instead of hours.

• Select your own preferences/settings for Cover Plugin - go to Diffblue > Change Settings.

• See Cover Plugin to familiarize yourself with the full set of plugin features and functions.

Diffblue Cover - one AI

Diffblue Cover is also provided as a CLI tool to write tests for your entire project, all in one hit (see Get started - Cover CLI), and can also be integrated into your CI pipeline to automatically write tests within your CI workflow (see Get started - Cover Pipeline).

But Cover CLI, Cover Plugin, and Cover Pipeline are not mutually exclusive, in fact they make perfect partners. Use Cover Plugin within the IntelliJ IDE to write and check unit tests for your application during development, and also use Cover CLI directly from the IntelliJ Console or your OS command line to access the wider and deeper functionality provided by Cover CLI - finally, use Cover Pipeline within your CI tool to automate the whole process and provide consistency across your organization.

Get started with Diffblue Cover - Plugin, CLI, Pipeline, Reports.

Demo code, statistics, and timings used throughout Diffblue docs and eLearning videos are based on in-house demonstrations. These may differ slightly from those experienced within a live production environment.

A Cover deployment consists of multiple components (Plugin, CLI, Pipeline, Reports), which need to be installed and configured to interact with your CI/CD infrastructure and among each other correctly.

Depending on the properties of your CI/CD system, Cover can integrate in a few different ways so that you get most from your Cover deployment:

1. No CI/CD System Available: This is the most basic deployment which does not make use of a CI/CD system and thus entails most manual effort.

2. Minimal CI/CD System: This deployment is suitable if you are not ready for creating tests in your CI/CD system, but still want to benefit from automated reporting.

3. Slow CI/CD System: This deployment is suitable if your CI/CD system tends to be slow on pull requests.

4. Fast CI/CD System: If your CI/CD system tends to be fast on pull requests then you can take advantage of writing and updating new tests on each pull request.

Reference Deployment 1: No CI/CD System Available

This is the most basic deployment which does not make use of a CI/CD system and thus entails most manual effort. You have to trigger all actions manually from developer workstations. See diagram below.

You need to install Cover Reports on a central server and Cover CLI and Cover Plugin on developer workstations. Telemetry is configured on developer workstations so that you can track Diffblue usage.

The developer onboarding a new project creates the initial test baseline using Cover CLI and uploads coverage data to Cover Reports. On each Cover release, a developer refreshes the baseline using Cover CLI and uploads coverage data to Cover Reports in order to track test coverage across your projects. Developers use Cover Plugin day-to-day to write and update tests.

Reference Deployment 2: Minimal CI/CD System

This deployment is suitable if you are not ready for creating tests in your CI/CD system, but still want to benefit from automated reporting. See diagram below. The difference to Reference Deployment 1 is that it automates uploading coverage data to Cover Reports, enabling more frequent tracking of test coverage across your projects.

You need to install Cover Reports on a central server and Cover CLI and Cover Plugin on developer workstations. Telemetry is configured on developer workstations so that you can track Diffblue usage.

The developer onboarding a new project creates the initial test baseline using Cover CLI and uploads coverage data to Cover Reports. Developers use Cover Plugin day-to-day to write and update tests. CI is configured to run periodically, e.g. nightly, on the stable branch, e.g. main, of the project to create and upload coverage reports to Cover Reports in order to track test coverage across your projects. On each Cover release, the baseline is refreshed using Cover CLI and coverage data uploaded to Cover Reports.

Reference Deployment 3: Slow CI/CD System

This deployment is suitable if your CI/CD system tends to be slow on pull requests. See diagram below. The difference to Reference Deployment 2 is that

• test baselines are triggered automatically and refreshed more frequently, and

• coverage data is automatically uploaded to Cover Reports on merging pull requests.

You need to install Cover Reports on a central server, Cover Pipeline in your CI/CD system and Cover CLI and Cover Plugin on developer workstations. Telemetry is configured on developer workstations and in your CI/CD system so that you can track Diffblue usage.

The developer onboarding a new project creates the initial test baseline using Cover CLI and uploads coverage data to Cover Reports. Developers use Cover Plugin day-to-day to write and update tests. Coverage data is uploaded to Cover Reports whenever a pull request is merged in order to track test coverage across your projects. CI is configured to run periodically (e.g. weekly) to refresh the baseline and to upload coverage data to Cover Reports.

Reference Deployment 4: Fast CI/CD System

If your CI/CD system tends to be fast on pull requests then you can take advantage of writing and updating new tests on each pull request. The difference to Reference Deployment 3 is that tests are added incrementally in the pull request workflow.

You need to install Cover Reports on a central server, Cover Pipeline in your CI/CD system and Cover CLI and Cover Plugin on developer workstations. Telemetry is configured on developer workstations and in your CI/CD system so that you can track Diffblue usage.

The developer onboarding a new project creates the initial test baseline using Cover CLI and uploads coverage data to Cover Reports. Developers use Cover Plugin day-to-day to write and update tests locally. When developers push their code then Cover writes new tests that developers haven't written locally, updates existing ones and commits the changes to their pull request branch. Coverage data is uploaded to Cover Reports whenever a pull request is merged in order to track test coverage across your projects. CI is configured to run periodically (e.g. weekly) to refresh the baseline and to upload coverage data to Cover Reports.

Activate a license

Follow these steps to activate a license. Note that:

• Cover Plugin Community Edition is free to use but does require product verification to activate your perpetual license.

• These steps cover online license activation only.

• Offline licensing for Cover CLI is available for Diffblue Cover Enterprise Edition only - see Editions and Offline license activation.

Online & Offline

Online license activation

Diffblue Cover requires a remote license check with the Diffblue licensing server each time it's used. To perform the license check Diffblue Cover needs an active internet connection to the following servers:

• https://licensing.diffblue.com/

• https://api.licensespring.com/

The license check uses this connection to identify individual devices. Further details regarding the exact data exchanged are available in the Privacy Notice.

For more details, including troubleshooting, see the main Online license activation topic.

Offline license activation

Diffblue Cover Enterprise Edition users with the offline option can activate 100% offline. This means Diffblue Cover can be used in secure and air-gapped environments with no external network connection required.

For more details, including troubleshooting, see the main Offline license activation topic.

Editions

Diffblue Cover is licensed according to the four pricing plans which determine what features and limits apply to your use of Diffblue Cover. Please see Cover Editions for more details.

Diffblue license manager

According to the terms of your subscription, you may be given access to the Diffblue License Management Portal allowing you to see license use, manage license keys, and license users. License manager access is granted according to the exact license type purchased - it may not be applicable to your license type.

This topic details how to use Diffblue Cover to write tests for your project as part of a CI pipeline. It outlines the basic commands that you will need to add to your CI scripts, and provides general information to understand the key steps - for specific CI tools, refer to the following:

• Cover Pipeline for GitLab

• Cover Pipeline for GitHub

• Quick Start - Jenkins

• Quick Start - Azure Pipelines

• Quick Start - AWS Codebuild

Assumptions

This topic assumes that you have:

• A basic understanding of Cover CLI - see Get started - Cover CLI.

• A Maven or Gradle project that:

  • Compiles.

  • Does not have non-compiling or failing tests.

  • Is stored in a Git repository with a CI tool enabled.

• A basic understanding of your chosen CI tool.

• The ability to store secrets variables for your CI tool.

• Diffblue Cover CLI release zip stored in the cloud, along with an appropriate license key.

Summary

To integrate Diffblue Cover into your CI pipeline, we will guide you through creating a CI script that:

1. Builds your project.

2. Downloads and activates Diffblue Cover CLI.

3. Runs Diffblue Cover to create tests.

4. Commits the created tests to a branch.

1. Building the project

To run Diffblue Cover CLI your project must be built. Running the project’s tests is not required, and you will save time by skipping them, but they do need to compile and pass. For example, you can use the following command to build a Maven project while skipping the tests:

mvn --batch-mode --no-transfer-progress clean install -DskipTests

2. Downloading and activating Diffblue Cover CLI

You need to give the CI run access to the Diffblue Cover files and activate the dcover license in order to write tests.

This step assumes that you have a URL with the Diffblue Cover CLI release zip and the license key for online activation during the CI run. If your license allows it you may wish to install Diffblue Cover with offline activation. See Licensing.

You will need to add two secret variables which, here, will be represented as environment variables:

• The first secret variable with the name DIFFBLUE_COVER_URL and the value set to the URL of the Diffblue Cover CLI release zip file.

• The second with the name DIFFBLUE_COVER_LICENSE_KEY and the value set to your Diffblue Cover license key.

Append the code for getting, unzipping, and activating dcover, to your script.

  mkdir -p "~/dcover"
  cd "~/dcover"
  curl --silent --show-error --location --output "diffblue-cover-cli.zip" "$DIFFBLUE_COVER_URL"
  unzip -q "diffblue-cover-cli.zip"
  rm -f "diffblue-cover-cli.zip"
  PATH=$PATH:~/dcover/
  dcover activate "$DIFFBLUE_COVER_LICENSE_KEY"

This will put the Diffblue Cover files into the dcover directory in the root of the workspace. The files contain a script called dcover which has the relative path dcover/dcover (or dcover\dcover.bat in Windows environments). The script is added to your PATH variable so that you can invoke Diffblue Cover CLI as dcover (or dcover.bat).

Push the changes so that your CI is triggered - ensure that you can see the successful activation of dcover in your CI output before moving on. You will see a line starting with "Successfully activated key" if this was successful. If Diffblue Cover did not successfully activate, please see Licensing or contact Diffblue Support.

3. Running Diffblue Cover CLI to create tests

Now that Diffblue Cover is running in CI, you can use it to write tests. The next two items show how to write tests for a single module, and then how to extend this to all modules.

Creating tests for a single module:

Choose a module to test in your project. Append the following to your workflow file, changing moduleToTest to a module in your project or, if your project does not have modules, --working-directory moduleToTest can be removed or changed to --working-directory. Note that the --batch option makes the output more suitable for CI, as it ensures the CI logs are not cluttered with progress bar output.

  dcover create --working-directory="moduleToTest" --batch

Push the changes so that dcover runs in the CI. Once successfully complete, you should expect to see output that looks like this:

INFO  Found 7 callable methods in 2 classes
INFO
INFO  Creating tests:
INFO  ---------------
...
INFO  All 5 created tests were successfully validated.

If you don't see this output, the dcover command may need a small modification for your project, or dependencies adding, until it works. The output gives you warnings along the way to guide you. See Commands & Arguments for more information.

Depending on the size of your module/project, creating tests could take a while. You may wish to restrict test creation to a single class by specifying its fully qualified name:

  dcover create com.somepackage.SomeClass --working-directory="moduleToTest" --batch

Creating tests for all modules:

To write tests for all the modules, you can use a loop as follows:

  for MODULE in module_name_1 module_name_2 module_name_3
  do
    dcover create --batch --working-directory="$MODULE"
  done

4. Committing the created tests to a branch

To see the new tests created in the previous step in your project, you need to commit them and push back to the repository. Depending on your CI tool you may also need to configure a Git user to create the commit. We recommend creating a service account for this.

  git config user.name db-ci-bot
  git config user.email db-ci-bot@yourorg.com

To commit the tests, append the following to your script. This will check for any changes to Diffblue tests, add them to a commit and push to your branch.

  if [ -n "$(git status --short **/*DiffblueTest.java)" ]; then 
    git add **/*DiffblueTest.java
    git commit --message "Update Unit Tests for $(git rev-parse --short HEAD)"
    git push --set-upstream origin
  else
    echo "Nothing to commit"
  fi

Note: Be careful not to create an infinite CI loop here. We recommend checking the author of each commit to ensure you're not creating tests for a commit authored by your Diffblue service account.

LAST_NON_BOT_COMMIT="$(git rev-list -1 --author='^(?!db-ci-bot).*$' --perl-regexp HEAD --no-merges)"
LAST_COMMIT="$(git rev-list HEAD -1 --no-merges)"
if [[ "$LAST_NON_BOT_COMMIT" == "$LAST_COMMIT" ]]
then
  ...
fi

Next steps

In this topic we've outlined the basic commands that you will need to add to your CI scripts, but we've only provided general information to understand the key steps - for specific CI tools, refer to the following:

• Cover Pipeline for GitLab

• Cover Pipeline for GitHub

• Quick Start - Jenkins

• Quick Start - Azure Pipelines

• Quick Start - AWS Codebuild

Diffblue Cover - one AI

Diffblue Cover is also provided as an IDE plugin tool so you can write tests with one click in the IntelliJ IDE (see Get started - Cover Plugin) and as a developer CLI tool to write tests for your entire project, all in one hit (see Get started - Cover CLI).

But Cover CLI, Cover Plugin, and Cover Pipeline are not mutually exclusive, in fact they make perfect partners. Use Cover Plugin within the IntelliJ IDE to write and check unit tests for your application during development, and also use Cover CLI directly from the IntelliJ Console or your OS command line to access the wider and deeper functionality provided by Cover CLI - finally, use Cover Pipeline within your CI tool to automate the whole process and provide consistency across your organization.

Requirements

To perform the license check Diffblue Cover needs an active internet connection to the following servers:

• https://licensing.diffblue.com/

• https://api.licensespring.com/

Activate a license

Follow these steps to activate a license. Note that:

• Cover Plugin Community Edition is free to use but does require product verification to activate your perpetual license.

• These steps cover online license activation only.

Configuring a proxy server

Troubleshooting license server connections

1. Check you have an active internet connection at all times when using Diffblue Cover.

2. Ensure you can access https://licensing.diffblue.com/ via a web browser; you will automatically receive a confirmation message when this is successful.

3. Ensure you can access https://api.licensespring.com/ via a web browser, you should see the message "Welcome to the LicenseSpring API".

4. Ensure that any Proxy Server settings are correctly set up (see the bottom of this page).

5. Please speak to your network manager about allowing access to the URLs above, and checking that port 443 is open.

6. For Cover Plugin, restart IntelliJ.

7. Try temporarily disabling anti-virus, malware detector or any firewall software.

Get started with Diffblue Cover Reports - in short, check the prerequisites, download and install Cover Reports, create and upload a reports bundle, and finally, visualize your coverage data.

eLearning

Prefer video? No problem. Check out our overview video.

1. Check the prerequisites

Client workstation - Cover Reports Contributor:

• Diffblue Cover CLI

• JaCoCo 0.8.3+

• Network connectivity between the user's workstation and the Cover Reports server.

Client workstation - Cover Reports User:

• The latest version of Chrome, Edge, Safari, or Firefox with a screen resolution of 1920 x 1080 or higher.

• Network connectivity between the user's workstation and the Cover Reports server.

Server hosting Cover Reports - Cover Reports Administrator::

• Docker Engine 20.10.17

• 4GB RAM (8GB recommended), 2GB* minimum available disk space, 4 CPU cores.

• 2GB Java heap allocation, 4GB recommended.

• Docker Compose v2.10.2

• Network connectivity between the server and client workstations.

• Internet connection if using Docker Hub for install.

2. Install Diffblue Cover Reports

3. Create and upload a reports bundle

Note that, to save you a little time, there's a demo project provided as part of Cover Reports so you can click Open Demo Project from the Reports splash screen and skip this Cover CLI step. If you or your organization have already used Cover Reports, this option won't be available.

The optional arguments used with dcover create perform the following:

• --coverage-reports is used create the coverage data files using Cover and JaCoCo.

• --upload is used to define the URL to upload the reports bundle to - i.e. the URL for your Cover Reports server install. Note that HTTPS direct is currently not supported.

4. Visualize your data

Next steps

Get started with Diffblue Cover - download, install, license, and play:

Achievements:

• Learn what Diffblue Cover is and how it works.

• Know how to download, install, and license Diffblue Cover.

• Know how to use Diffblue Cover to write tests (basic concepts) and how to start applying this to your own code.

Diffblue releases product updates about every two weeks to continuously provide you with product enhancements and new features. Note that:

• When you update, you'll always be updated to the latest version.

• If you're using Cover Plugin and Cover CLI, we recommend that you update both products to the latest version.

The things we get asked the most. Always worth a look.

Licensing Diffblue Cover in the offline mode detailed here is available only when purchased with the Enterprise Edition offline option. To use Diffblue Cover in an offline environment, such as a high-security or air-gapped network, requires this Enterprise Edition offline option.

Otherwise Diffblue Cover requires a remote license check with the Diffblue licensing server each time it is used.

Activating an offline license

This section describes how to activate a Diffblue Cover offline license.

➜  dcover license

12:55:23.365 INFO  Diffblue Cover 2022.02.02
12:55:23.368 INFO  There is no license linked to your product

<USER_HOME>/.diffblue/offline/

➜  dcover activate --offline XXXX-XXXX-XXXX-XXXX

15:48:35.064 INFO  Found an offline license file at '<USER_HOME>/.diffblue/offline/ls_activation.lic'
15:48:35.494 INFO  Successfully activated offline license

dcover activate --offline

Distributing an offline license

This section describes how to make an offline Enterprise license for Diffblue Cover available to users without them requiring their own activation or access to the license key. This is typically useful when users have managed environments where new software can be rolled out to their environment, or as an alternative to environment variables in a CI environment.

1. First, the license will need to be activated as above using the Diffblue Cover CLI and provided ls_activation.lic and license key, e.g.: dcover activate --offline <DIFFBLUE LICENSE KEY> this will put a license.key file into <USER_HOME>/.diffblue/.

2. The license.key file above can now be placed into the <USER_HOME>/.diffblue directory of any user and this will be recognized by Diffblue Cover (Plugin and CLI).

Get the most out of Diffblue Cover - Read, Watch, Learn - select the guided learning path to get what you need.

Get started

Get started with Diffblue Cover - download, install, license, and play:

Achievements:

• Learn what Diffblue Cover is and how it works.

• Know how to download, install, and license Diffblue Cover.

• Know how to use Diffblue Cover to write tests (basic concepts) and how to start applying this to your own code.

Developer

Detailed learning paths targeted at developers:

Achievements:

• Understand Diffblue Cover specifications and requirements and how to configure your projects for automated test writing.

• Know how to use Diffblue Cover to write tests for your projects - basic and advanced concepts.

• Understand output codes and how to resolve them.

• Know how to improve test coverage for your code base, including automated refactoring.

DevOps

Detailed learning paths targeted at DevOps:

Achievements:

• Understand the use of Diffblue Cover within a CI/CD environment.

• Know how to activate and configure Cover Pipeline within your chosen CI/CD tool - initial setup and additional config options.

• Know how to use Cover Pipeline to write tests for your projects - basic and advanced concepts.

Administrator

Detailed learning paths targeted at "administrators" - manage and maintain Diffblue Cover for you, or your organization:

Achievements:

• Understand how to install, update, manage, and maintain Diffblue Cover, including config options and license management.

Test coverage

Improve, monitor, and manage your test coverage:

Achievements:

• Know how to improve, monitor, and manage your test coverage.

• Know how to improve test coverage for your code base, including automated refactoring.

• Understand output codes and how to resolve them.

• Understand how to use Cover Reports to monitor and manage test coverage.

• Know how to manage your Cover Reports instance including installation, database backups, and software updates.

Logging in

The Diffblue license manager is for managing your organization's licenses. A license manager is assigned to each organization.

Log in to https://licenses.diffblue.com using the username and password provided in your Diffblue welcome email.

Dashboard

Once logged in you will be presented with a dashboard which currently lists how many licenses you are managing.

Orders

Click on the Order button on the left hand menu bar to get a list of the orders you are managing. Each order can have 1 or more licenses associated with it. Click on an order to see the licenses it contains.

Order details

After clicking on an order you will see this Order details page. There are several tabs you can click on.

If you click on License managers you can see a list of the license managers assigned to this order. You can also use the Add license manager button to add a new license manager.

After clicking on the Add license manager button you will be given a short form to fill out. Input the email address, first name and last name. Take note of the automatically generated password or supply your own. These details are not automatically sent to the new license manager so you will have to email them yourself or provide them via some other channel.

If you click on Licenses you will get a list of the license keys associated with the order. If there are many keys you will have multiple pages of licenses. The list includes the expiration date of the licenses and 'Status' indicates whether or not they have been activated.

Licenses

If you click on one of the licenses in the license list you will be taken to a page with more information about that license. This page also has a button where you can reset the activations for that license.

Devices

Clicking on the Devices tab on the License details screen will give you a list of all the devices that the license has been activated on. This includes information such as hostname and internal/external IP addresses.

My profile

You can edit your license manager profile by clicking on the My profile button in the left hand menu. From here you can change your first name, last name and also change your password.

Detailed learning paths targeted at developers:

Achievements:

• Understand Diffblue Cover specifications and requirements and how to configure your projects for automated test writing.

• Know how to use Diffblue Cover to write tests for your projects - basic and advanced concepts.

• Understand output codes and how to resolve them.

• Know how to improve test coverage for your code base, including automated refactoring.

Get started with Diffblue Cover CLI - in short, install the CLI tool, apply your license, and you're ready to go. This topic also provides an example and some next steps.

If you've already done this as part of your free trial, you may want to skip this and jump straight to the Cover CLI details, or perhaps you want to update to the latest version - see Update Cover.

eLearning

Short on time? If you'd like a fast-track experience check out our getting started video. [6 min]

1. Install Diffblue Cover CLI

2. Apply a license

Diffblue Cover requires a remote license check with the Diffblue licensing server each time it's used. For help troubleshooting license keys, network connections, and proxy server settings, as well as details of offline licensing (Enterprise Edition only), see Licensing.

• To activate your license, open Windows PowerShell (Windows) or Terminal (macOS/Linux) and enter the command dcover activate <license-key> - replace <license-key> with the license key provided in your welcome email or provided by your organization.

• Entering multiple different license keys will overwrite the existing key.

• You can check your license status by running the command dcover license

3. Try it out

Four steps to automatically write tests - check out a few basics, clone an example project, compile the project and check your environment, and finally, one command to write tests - done.

Step 1 - A few basics

We won't cover every CLI command option, but here are a few details to get you started:

Step 2 - Clone the example project Spring PetClinic

We're going to make use of an example project (Spring PetClinic) to show Diffblue Cover CLI at work. First, we'll clone the project from the Git repo:

git clone https://github.com/diffblue/demo-spring-petclinic

Step 3 - Compile the project and check your environment

Before we write any tests, we need to compile the PetClinic project. Diffblue Cover works by analyzing the bytecode of any project used with Cover. Open a command line, navigate to the directory containing the PetClinic project, and run the Maven package command:

cd demo-spring-petclinic
./mvnw package

Basic prerequisites:

• Java 8, 11, 17, or 21 compatible source code, or Kotlin source code.

• Maven 3.2.5+ or Gradle 4.9+ build tools.

• The project (for use with Diffblue Cover) must compile and run with no failing unit tests.

  JUnit and TestNG testing frameworks are supported.

More details:

Diffblue Cover requires that the system environment (hardware, operating system, network connectivity, Java installation) as well as the project environment (build tooling, dependencies, presence of artifacts, existing unit tests) meet the minimum requirements as detailed in Specs & Reqs. Cover CLI will perform an environment check before analysis begins to ensure that the requirements are met - if there are any issues, these will be reported via the Diffblue Cover panel in IntelliJ using E(Environment) Output Codes.

Check your environment:

Cover CLI also provides a command line option to run these checks, without writing any tests, useful when you just want to check-out your environment without doing anything else. To run a preflight environment check, open a command line, navigate to the directory containing the PetClinic project, and run the preflight checks:

cd demo-spring-petclinic
dcover create --preflight

Step 4 - Automatically write tests for the example project

Initially, we'll create tests for the OwnerController class:

dcover create org.springframework.samples.petclinic.owner.OwnerController

And that's it, simple - 1 command line, 9 methods analyzed, 14 tests written, around 340 lines of code created, and all in around 65 seconds - computationally perfect, human readable. You'll find these tests in:

demo-spring-petclinic/src/test/java/org/springframework/ samples/petclinic/owner/OwnerControllerDiffblueTest.java

package org.springframework.samples.petclinic.owner;

import ...

@ContextConfiguration(classes = {OwnerController.class})
@ExtendWith(SpringExtension.class)
class OwnerControllerDiffblueTest {
	@Autowired
	private OwnerController ownerController;

	@MockBean
	private OwnerRepository ownerRepository;

	/**
	 * Method under test: {@link OwnerController#initCreationForm(Map)}
	 */
	@Test
	void diffbluetestInitCreationForm() throws Exception {
		MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.get("/owners/new");
		MockMvcBuilders.standaloneSetup(ownerController)
			.build()
			.perform(requestBuilder)
			.andExpect(MockMvcResultMatchers.status().isOk())
			.andExpect(MockMvcResultMatchers.model().size(1))
			.andExpect(MockMvcResultMatchers.model().attributeExists("owner"))
			.andExpect(MockMvcResultMatchers.view().name("owners/createOrUpdateOwnerForm"))
			.andExpect(MockMvcResultMatchers.forwardedUrl("owners/createOrUpdateOwnerForm"));
	}

....

Once you're happy with this first set of tests, create the full test suite for the entire PetClinic project:

dcover create

That's it, two "words" and you're done. Of course this one takes a little longer to complete (approx. 5 minutes) as it creates tests across the entire PetClinic project, analyzing 97 methods and creating 77 tests (exact count may vary slightly). To take a look at the tests, open a xxxDiffblueTest.java file in your IDE of choice (these files are saved to the /src/test/java directory structure by default).

Note that the examples here use DiffblueTest as the default class name suffix and diffbluetest as the default method name prefix, just to highlight the tests created by Diffblue Cover. To change your suffix and prefix, use the --class-name-template and --method-name-template command arguments - see Cover CLI Commands & Arguments for details.

More...

What does Cover CLI do?

• Diffblue Cover first ensures that your code is compiled and examines each method that Cover will create tests for, including any dependent methods.

• Cover then creates initial test candidates and uses reinforcement learning to evaluate and adjust the test candidate for each method. This process is repeated until the set of tests that optimize coverage are selected and committed to your code base.

Next steps

Now you're up and running with Cover CLI:

• Have a scan through the Test examples topic which provides some additional source code examples along with an explanation of the tests created by Diffblue Cover.

• Create some tests for your own project - as long as you have a project that compiles and your environment meets the Cover prerequisites, you're literally a single command line away from AI written tests, created in seconds instead of hours.

• See Cover CLI to familiarize yourself with the full set of CLI features and functions.

Diffblue Cover - one AI

Diffblue Cover is also provided as an IDE plugin tool so you can write tests with one click in the IntelliJ IDE (see Get started - Cover Plugin), and can also be integrated into your CI pipeline to automatically write tests within your CI workflow (see Get started - Cover Pipeline).

But Cover CLI, Cover Plugin, and Cover Pipeline are not mutually exclusive, in fact they make perfect partners. Use Cover Plugin within the IntelliJ IDE to write and check unit tests for your application during development, and also use Cover CLI directly from the IntelliJ Console or your OS command line to access the wider and deeper functionality provided by Cover CLI - finally, use Cover Pipeline within your CI tool to automate the whole process and provide consistency across your organization.

Prerequisites

Diffblue Cover requires that the system environment (hardware, operating system, network connectivity, Java installation) as well as the project environment (build tooling, dependencies, presence of artifacts, existing unit tests) meet the minimum requirements as outlined below. Diffblue Cover will perform an environment check before analysis begins to ensure that the requirements are met.

Cover Plugin & Cover CLI

• 32 GB RAM, 5 GB minimum available disk space, 4 CPU cores

• 8GB Java heap allocated

• TCP connection *

• Windows 11 Pro, Windows 10 Enterprise, Ubuntu 18.04, RHEL 7.7, macOS 10.15

• The latest or n-1 64-bit sub-version of Java 8 (8u391 & 8u381), Java 11 (11.0.21 & 11.0.20), Java 17 (17.0.9 & 17.0.8), Java 21 (21.0.1)

• For Maven projects: Maven version 3.2.5+

• For Gradle projects: Gradle version 4.9+ (must be compatible with your version of Java).

• For Ant projects: Ant version 1.10.4+

• JUnit 4.11 - 4.13, JUnit 5.0 - 5.11.4, or TestNG 6.0.1 - 7.10.2.

• For Java 8 projects: Mockito 1.9.5 - 4.11.0

• For Java 11 projects: Mockito 2.22.0 - 5.14.2

• For Java 17 projects: Mockito 4.1.0 - 5.14.2

• For Java 21 projects: Mockito 4.1.0 - 5.14.2

• For Kotlin projects: one of the above versions of Java and associated Mockito

• All necessary tooling to build the project

• The project must compile and run with no failing unit tests

• Access to a dependency repository to download transient dependencies

• Access to the Diffblue licensing server for remote license check

* Cover requires the use of an analysis service that communicates with Cover Plugin and Cover CLI via TCP connections on localhost. In particular, Cover must be able to start up the analysis service and open a bi-directional TCP connection between the frontend and the service.

Cover Plugin

• IntelliJ Community or Ultimate version 2024.3 and 2024.2

• One instance of the Diffblue Cover Plugin for IntelliJ, per project

• A minimum of 4GB memory allocated to IntelliJ

Cover Pipeline for GitLab

• GitLab subscription - Free, Premium, or Ultimate Edition.

Cover Reports

Server hosting Cover Reports - Cover Reports Administrator:

• 4GB RAM (8GB recommended), 2GB* minimum available disk space, 4 CPU cores.

• 2GB Java heap allocation, 4GB recommended.

• Docker Install - Docker Engine 20.10.17, Docker Compose v2.10.2, and if you're using Docker Hub you'll also need an internet connection.

• Zip Install & Windows Installer - Java JDK 17+ (and available in your PATH system environment variable). For production use, you'll also need to provide a vanilla PostgreSQL 14 database (see Cover Reports > Configuration options).

• Windows Install - Windows Server 2019 and above, Windows 10 and above.

• All - Network connectivity between the server(s) and client workstations. Note that if the Cover Reports server and database server are on different hosts, good network connectivity between them will ensure good performance.

* Note that the database server will store the data uploaded to Cover Reports. Sufficient storage should be ensured for projected usage.

Client workstation - Cover Reports Contributor:

• Diffblue Cover CLI

• Java 8 and 11 Projects: JaCoCo 0.8.3+

• Java 17 Projects: JaCoCo 0.8.7+

• Java 21 Projects: JaCoCo 0.8.11+

• Network connectivity between the user's workstation and the Cover Reports server.

Client workstation - Cover Reports User:

• The latest version of Chrome, Edge, Safari, or Firefox with a screen resolution of 1920 x 1080 or higher.

• Network connectivity between the user's workstation and the Cover Reports server.

Cover Refactor

OpenRewrite Maven or Gradle plugin (and its transitive dependencies) must be available in your local Maven or Gradle mirror.

• OpenRewrite Gradle plugin: 6.12.0

• OpenRewrite Maven plugin: 5.28.0

Spring

Spring and Spring Boot versions are required to be compatible with your version of Java, as well as each other. Diffblue Cover supports the following:

• Java 8 Projects: Spring Boot 1.3.3 to 2.7.x, Spring Core 4.1.1 to 5.3.x

• Java 11 Projects: Spring Boot 2.1.0 to 2.7.x, Spring Core 5.1.0 to 5.3.x

• Java 17 Projects: Spring Boot 2.4.0 to 3.1.x, Spring Core 5.3.1 to 6.0.x

• Java 21 Projects: Spring Boot 2.4.0 to 3.1.x, Spring Core 5.3.1 to 6.0.x

• Kotlin Projects: any of the above combinations to support the Java tests

Dependencies

Dependencies required for running tests should be in the project configuration. Additional libraries may also be necessary depending on the project under test.

Other dependencies listed below may be needed, if they are transitive dependencies of your project. If one of these dependencies is required but missing, tests will be generated for some classes but not others. A message will appear in the console output indicating a missing dependency.

Spring projects and Hamcrest

Either:

• Use the spring-boot-starter-test dependency to add Hamcrest.

• Add org.hamcrest:hamcrest. The version of Hamcrest needs to match the relevant version of spring-boot-test. For example, if the user has spring-boot-test:2.4.6, they should look at the dependency list: Maven Repository: org.springframework.boot spring-boot-starter-test 2.4.6. This shows that the matching version is Hamcrest 2.2 (you may have to scroll).

Spring WebFlux projects and Spring Security

When Spring Security is configured for a project in order to unlock full test generation capabilities for Spring WebFlux controllers write a custom configuration to deactivate CSRF(Cross-Site Request Forgery) security for unit tests, which can later be imported in the base class for your test:

@Configuration
@EnableWebFluxSecurity
public class WebFluxTestConfig {
@Bean
public SecurityWebFilterChain filterChain(ServerHttpSecurity http) {
    return http.csrf().disable().build();
  }
}

System Specifications & Requirements

Supported Operating Systems

Supported IntelliJ Versions

Cover Plugin for IntelliJ supports the latest and the previous versions of IntelliJ.

Supported Java Versions

Note that only 64 bit versions of Java are supported.

Supported Jakarta EE Versions

* Note that Diffblue Cover does not use Jakarta EE application context for tests, all injected dependencies will be mocked.

Supported Spring Versions

Spring, Spring Boot and Spring WebFlux versions are required to be compatible with your version of Java, as well as each other.

Supported Kotlin Versions

Currently all 64 bit versions of Kotlin are supported.

Note that Cover writes Java tests for Kotlin code, so you will also need a suitable Java installation with appropriate Java dependencies.

Supported Build Tools

Supported Test Frameworks

JUnit 4

Diffblue Cover supports JUnit 4, from JUnit 4.11 to JUnit 4.13. In the CLI, you can force the usage of JUnit 4 by passing the --testing-framework=junit-4 option. In the plugin, you can select JUnit 4 as a testing framework in the settings dialog.

JUnit Jupiter 5

Diffblue Cover supports JUnit Jupiter, from JUnit Jupiter 5.0 to JUnit Jupiter 5.11.4 In the CLI, you can force the usage of JUnit 5 by passing the --testing-framework=junit-5 option. In the plugin, you can select JUnit 5 as a testing framework in the settings dialog.

You may need some specific set-up for your build system to work properly with JUnit 5, in particular if you wish to use Diffblue Cover's built-in test validation. See Building a Gradle project or Building a Maven project for details.

TestNG 6 and 7

Diffblue Cover supports TestNG versions 6 and 7. In the CLI, you can force the usage of TestNG by passing the --testing-framework=testng option. In the plugin, you can select TestNG as a testing framework in the settings dialog.

Supported Mock Frameworks

Supported JaCoCo Versions

Coverage Measurement

Creating Tests - Scope

* For Cover Plugin, this feature is not available in the Community Edition.

** For Cover Plugin, this feature is only available in the Enterprise Edition.

Cover Reports

* For Cover Reports, when using our Docker distribution Postgres 14 is included. When using Zip distribution, H2 is included. However you can provide a self hosted Postgres 14 database for production purposes. We support vanilla Postgres 14. Postgres 15+ versions and alternative distributions can be used at your own risk.

Trying out Diffblue Cover for the first time? Get up and running with the trial version of Cover Plugin for IntelliJ and start writing unit tests for your methods and classes directly in your IDE.

Start here...

Alternatives...

Next steps...

Now you've got the basics, move on to the core learning paths for Cover Plugin:

Trying out Diffblue Cover for the first time? Get up and running with the trial version of Cover CLI and start writing unit tests for your projects from the command line.

Start here...

Alternatives...

Next steps...

Now you've got the basics, move on to the core learning paths for Cover CLI:

Use Diffblue Cover within the IntelliJ IDE to create tests for your methods and classes.

Start here...

Know more...

Next steps...

Just need to know the basics? You've come to the right place.

Start here...

Next steps...

Trying out Diffblue Cover for the first time? Get up and running with the trial version of our two core developer tools - Cover Plugin for IntelliJ and Cover CLI.

Start here...

Alternatives...

When you want to use the free trial, but you're only interested in using Diffblue Cover within an IDE, or via a command line:

Next steps...

Now you've got the basics, move on to the core learning paths for Cover Plugin and Cover CLI - these provide detailed guided learning paths for each product:

Use Diffblue Cover from a command line to create tests for your projects.

Start here...

Know more...

Next steps...

Detailed learning paths targeted at "administrators" - manage and maintain Diffblue Cover for you, or your organization:

Achievements:

• Understand how to install, update, manage, and maintain Diffblue Cover, including config options and license management.

Detailed learning paths targeted at DevOps:

Achievements:

• Understand the use of Diffblue Cover within a CI/CD environment.

• Know how to activate and configure Cover Pipeline within your chosen CI/CD tool - initial setup and additional config options.

• Know how to use Cover Pipeline to write tests for your projects - basic and advanced concepts.

Integrate Diffblue Cover into your GitLab pipeline - Cover Pipeline for GitLab.

Start here...

Alternatives...

Diffblue Cover CI/CD integrations using alternative CI tools:

Next steps...

Learn about Diffblue's developer tools: