LogoLogo
diffblue.comFree trial
  • Discover Diffblue Cover
  • Get Started
    • What is Diffblue Cover?
    • Get started
      • Free trial
      • Get started - Cover Plugin
      • Get started - Cover CLI
      • Get started - Cover Pipeline
      • Get started - Cover Reports
    • Specs & Reqs
    • Reference Deployments
    • Licensing
      • Online license activation
      • Offline license activation
      • Diffblue License Manager
    • Update Cover
    • FAQs
    • Diffblue Learning
      • Get started
        • Just the basics
        • Free trial
        • Cover Plugin (IDE)
        • Cover CLI (Command Line)
      • Developer
        • Unit tests (IDE)
        • Unit tests (CLI)
        • Test coverage
      • DevOps
        • GitHub
        • GitLab
        • Other CI
      • Administrator
        • Admin - IntelliJ
        • Admin - CLI
        • Admin - Reports
      • Test coverage
        • Developer
        • Senior developer
        • Cover Reports Administrator
  • EVALUATION & ONBOARDING
    • Proof of Value
    • Jumpstart
      • Prerequisites for onboarding
      • Phase 1: Up and running
        • Module 1: Create your Cover unit test baseline
        • Module 2: Cover Pipeline CI integration
      • Phase 2: Developer productivity
        • Module 3: Getting started using Cover
        • Module 4: Introduction to Cover Reports
      • Phase 3: Advanced topics
        • Module 5: Speed up your test execution
        • Module 6: Getting more from Cover
  • Features
    • Cover Plugin
      • Writing tests
        • Gutter icons
        • Menu options
        • Run configurations
        • Cover Plugin tool window
        • Test Review
        • Test examples
        • Creating partial tests
        • Creating skeleton tests
        • Covering all enum values
        • Test insertion order
        • Diffblue Sandbox
        • Environment Check Cache
      • Project configuration
        • General dependencies
        • Test framework dependencies
      • Cover Plugin settings
        • Test Naming
        • Test Formatting
        • Spring configuration options
        • Method Annotations
        • Test Directory
        • Reset Cover Plugin settings
      • Cover Plugin admin
        • Core Maintenance
        • Cover Plugin toolbar menu
        • Cover Plugin status bar widget
        • Telemetry
        • Memory management
        • Using SonarQube with Cover Plugin
        • Log files
        • Troubleshooting
    • Cover CLI
      • Writing tests
        • Command summary
        • Test examples
        • Creating partial tests
        • Customizing test inputs
        • Customizing test setup
        • Test naming
        • Test formatting
        • Test insertion order
        • Patch files
        • Diffblue Sandbox
        • Operational behaviors
        • Test validation
      • Project configuration
        • Preflight checks
        • General dependencies
        • Test framework dependencies
        • Compiling your project successfully
          • Building a Maven project
          • Building a Gradle project
        • Configuring Cover to work with your project's build system
          • Quick guide
          • Configuration file in detail
          • Getting Started with Ant Projects
          • Default configuration
        • Mocking using Mockito
        • Spring profiles
        • Runtime environment
      • Commands & Arguments
        • Environment configuration for CI
        • Packages, classes, and methods
        • Quoting command line arguments
        • Argument files
      • Cover CLI admin
        • Core Maintenance
        • Telemetry
        • Memory management
        • Using Cover CLI in Eclipse
        • Using SonarQube with Cover CLI
        • Log files
        • Troubleshooting
      • Environment Configuration
    • Cover Pipeline
      • Cover Pipeline for CI
        • Quick Start - General
        • Quick Start - Jenkins
        • Quick Start - Azure Pipelines
        • Quick Start - AWS Codebuild
        • Integrating Diffblue Cover into CI on pull requests
        • Installation - VMs or CI run
      • Cover Pipeline for GitLab
        • Introduction
        • Installation and initial setup
        • GitLab workflow
        • Configuration
        • Troubleshooting
        • Related topics
      • Cover Pipeline for GitHub
        • Introduction
        • Installation and initial setup
        • GitHub workflow
        • Configuration
        • Troubleshooting
        • Related topics
    • Cover Reports
      • Cover Reports Contributor
        • Java project config (JaCoCo)
        • Generate and upload reports bundles
        • Authenticated uploads
      • Cover Reports User
        • Navigation
        • Dashboards
        • Telemetry data
        • Export API
        • Considerations
      • Cover Reports Administrator
        • Install and update Cover Reports
        • Configuration options
        • Database backup
        • SSO with Cover Reports
        • Uninstall Cover Reports
    • Cover Optimize
      • Get started - Cover Optimize
      • Cover Optimize & Gradle
      • Cover Optimize & Maven
      • Patch files
    • Cover Refactor
      • Get started - Cover Refactor
    • Cover Annotations
      • Mocking Annotations
      • Custom Input Annotations
      • Interesting Value Annotations
    • Output Codes
      • E - Environment Codes
      • L - License Codes
      • R - Reason Codes
      • T - Testability Codes
      • V - Validation Codes
      • Working with output codes
        • Working with code E020
        • Working with codes E057 to E065
        • Working with code E085
        • Working with code R005
        • Working with code R006
        • Working with code R008
        • Working with code R011
        • Working with code R012
        • Working with code R013
        • Working with code R026
        • Working with code R031
        • Working with code V003
    • Tutorials
      • How to measure test quality
      • How to improve code coverage
      • How to test a new feature
      • How to find regressions
      • How to use Diffblue Cover in test driven development (TDD)
      • How to write tests for Kotlin projects
      • Examples of tests created by Diffblue Cover
      • Best practices for testing private methods
  • Updates & Upgrades
    • Update Cover
    • Cover Editions
    • What's new
    • Release archive
      • 2025-05-01
      • 2025-04-02
      • 2025-04-01
      • 2025-03-02
      • 2025-03-01
      • 2025-02-02
      • 2025-02-01
      • 2025-01-02
      • 2025-01-01
      • 2024-12-02
      • 2024-12-01
      • 2024-11-02
      • 2024-11-01
      • 2024-10-02
      • 2024-10-01
      • 2024-09-02
      • 2024-09-01
      • 2024-08-02
      • 2024-08-01
      • 2024-07-04
      • 2024-07-03
      • 2024-07-01
      • 2024-06-02
      • 2024-06-01
      • 2024-05-02
      • 2024-05-01
      • 2024-04-02
      • 2024-04-01
      • 2024-03-02
      • 2024-03-01
      • 2024-02-02
      • 2024-02-01
      • 2024-01-02
      • 2024-01-01
      • 2023-12-02
      • 2023-12-01
      • 2023-11-03
      • 2023-11-02
      • 2023-11-01
      • 2023-10-02
      • 2023-10-01
      • 2023-09-02
      • 2023-09-01
      • 2023-08-02
      • 2023-08-01
      • 2023-07-03
      • 2023-07-02
      • 2023-07-01
      • 2023-06-02
      • 2023-06-01
      • 2023-05-02
      • 2023-05-01
      • 2023-04-02
      • 2023-04-01
      • 2023-03-02
      • 2023-03-01
      • 2023-02-02
      • 2023-02-01
      • 2023-01-02
      • 2023-01-01
      • 2022-12-02
      • 2022-12-01
      • 2022-11-02
      • 2022-11-01
      • 2022-10-03
      • 2022-10-02
      • 2022-10-01
      • 2022-09-02
      • 2022-09-01
      • 2022-08-05
      • 2022-08-03
      • 2022-08-02
      • 2022-08-01
      • 2022-07-02
      • 2022-07-01
      • 2022-06-02
      • 2022-06-01
      • 2022-05-02
      • 2022-05-01
      • 2022-04-02
      • 2022-04-01
      • 2022-03-02
      • 2022-03-01
      • 2022-02-02
      • 2022-02-01
      • 2022-01-02
      • 2022-01-01
      • 2021-06-02
      • 2021-02-01
  • Legal
    • Diffblue Legal
      • Diffblue End User License Agreement (EULA)
      • Cover Third Party Notices and/or Licenses
      • Privacy Notice
Powered by GitBook
On this page
  • eLearning
  • A few points first...
  • 1. Sign up
  • 2. Install Cover Plugin for IntelliJ
  • 3. Install Cover CLI
  • 4. Apply licenses
  • 5. Try it out
  • Step 1 - Clone the example project Spring PetClinic
  • Step 2 - Compile the project and check your environment
  • Step 3 - A few basics
  • Step 4 - Automatically write tests for the example project
  • More...
  • What does Diffblue Cover do?
  • Next steps
  • Notes

Was this helpful?

Export as PDF
  1. Get Started
  2. Get started

Free trial

PreviousGet startedNextGet started - Cover Plugin

Last updated 1 month ago

Was this helpful?

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

1. Sign up

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.

  1. In the IntelliJ IDE, open the Plugins menu - either File > Settings > Plugins (Windows/Linux) or IntelliJ IDEA > Preferences > Plugins (macOS).

  2. Click on the cog icon next to the Installed tab and select Install Plugin from Disk.... Navigate to the location of the plugin, select the zip file, and click OK.

  3. When prompted, click Restart IDE to complete the install.

  1. In the IntelliJ IDE, open the Plugins menu - either File > Settings > Plugins (Windows/Linux) or IntelliJ IDEA > Preferences > Plugins (macOS).

  2. Select the Marketplace tab, search for Diffblue, and click Install. Your plugin will now be downloaded and installed.

  3. When prompted, click Restart IDE to complete the install.

3. Install Cover CLI

  1. If you use the installer, run the .exe installer and follow the on-screen prompts - during installation you can select where to install Diffblue Cover.

  2. If you use the archive file, extract the .zip file to an appropriate installation folder. Add the install folder path to your the PATH environment variable or create a new %DCOVER% environment variable and add that to PATH.

  3. When your done, restart your PC. Once complete, open Windows PowerShell and enter dcover version to check the install and PATH configuration - if all is OK, Cover will display the current version.

  1. Unzip the Cover CLI zip file to an appropriate installation location (for example, ~/bin) and add this location in the PATH environment variable using the following example commands:\

    mkdir ~/bin
    cd ~/bin
    unzip ~/diffblue-cover*.zip
    export PATH=$PATH:~/bin

    Reminder: Make sure that the PATH environment variable is set permanently according to your operating system instructions.

  2. Once complete, run dcover version to check the install and PATH configuration - if all is OK, Cover will display the current version.

4. Apply licenses

Once IntelliJ has restarted (after install), you'll be prompted for your license key (provided in your welcome email or by your organization) to activate the plugin. 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.

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

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:

  1. Open a command line and navigate to where you want to clone this project.

  2. Run the following command:

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

From IntelliJ select File > New... > Project from version control.

  • Ensure Git is selected in Version control.

  • Enter https://github.com/diffblue/demo-spring-petclinic as the URL.

  • Select the directory/folder to clone the project to.

  • When you're ready, click Clone.

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.

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

Icon
Description

Write tests - click this icon to write tests for this method or class.

Not testable - this method or class can't be tested. Click the icon to find out why.

Private method - this method can't be tested as it's private, although it may be tested indirectly via a public method. If you'd like Cover to write unit tests for this method, you can either make the method public or package protected.

Test maintenance - displayed next to test classes and methods in project test files. Click the icon to update or delete tests for the method or class.

Delete test - displayed next to your test methods in project test files. Click the icon to delete a test method.

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

Command
Description

dcover help

Help - get, err, help. Use this with the other commands as well to get some details of what options are available (like dcover create help to get details of the available optional arguments).

dcover activate

<license-key>

Activate License - apply/activate a license. Replace <license-key> with the license key provided in your welcome email or provided by your organization.

dcover license

Check License - display your current license status.

dcover version

Check Version - display the version of Diffblue Cover CLI.

dcover create

Create Tests - write tests for the project (run from the root directory of the project). You can restrict this further by simply specifying the method or class path - this is detailed a little further in the example in Step 4 below.

dcover create --<arguments>

Optional Arguments - there's a few, OK quite a lot. The optional arguments provide access to deeper functionality within Cover CLI such as creating coverage reports, specifying a build configuration file, and running preflight checks (this one is used in Step 3 below).

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.

  2. 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.

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

If you're only planning to use Cover Plugin Community Edition (free), you may just want to jump straight to the topic.

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.

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 Diffblue.

If you haven't already done so, sign up for the free trial - see .

Download the Diffblue Cover Plugin for IntelliJ as a .zip bundle from: - The Diffblue website - or versions. - The (IntelliJ Plugin Marketplace). - The link sent to you via your Diffblue Cover welcome email. - Your organization's internal file/app store.\

Download the Diffblue Cover CLI .exe installer or .zip file from: - The Diffblue website - version. - The link sent to you via your Diffblue Cover welcome email. - Your organization's internal file/app store.\

Download the Diffblue Cover CLI .zip file from: - The Diffblue website - version. - The link sent to you via your Diffblue Cover welcome email. - Your organization's internal file/app store.\

To create tests for this class, click on the Write Tests gutter icon next to the line class OwnerController.

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

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 Diffblue.

contact
https://www.diffblue.com/try-cover
Free Community Edition
Free Trial
JetBrains Marketplace
Free Trial
Free Trial
prerequisites
contact