# Packages, classes, and methods

By default, `dcover create` automatically runs across the entire project. If required, you can specify what modules, packages, classes, or methods you want to restrict these operations to.

## Module examples

For modules this can be done in two different ways. Diffblue Cover can be run on a single module by invoking `dcover` in the appropriate module directory. If `dcover` is run across an entire multi-module project, you can also fine tune the selection of modules using the `--exclude-modules=<module>,[<module>,...]` option;

**Example:** `dcover create --exclude-modules=scripts`

or alternatively, you can directly specify the modules you want Diffblue Cover to run on by using the `--include-modules=<module>,[<module>,...]` option.

**Example:** `dcover create --include-modules=api`

## Packages, classes, and methods

If required, you can specify what packages, classes, or methods you want to restrict these operations to, by specifying one or more entry points on the command line using `[<entryPoint>...]` .

**Example:** `dcover create io.corebanking.Account`

Also you can use similar specifications for excluding particular packages, classes, and methods from test-writing.

**Example:** `dcover create --exclude=io.corebanking.Account`

***

### Package example

Specify a package entry point on the command line using the standard Java naming convention, plus an optional trailing dot and/or wildcards.

**Syntax:** `dcover create <package>[.][*]`

***

**Trailing dot:** `dcover create <package>.`

**For example:** `dcover create com.a.`

**Description:** Write tests for all accessible methods within package `<package>` (in our example, `com.a`) and any sub-packages. For example, tests could be written for sub-packages `com.a.B` and `com.a.b.C` . Trailing dot prefix doesn't support wildcard `*`.

***

**No trailing dot:** `dcover create <package>`

**For example:** `dcover create com.a`

**Description:** Write tests for all accessible methods within any package that begins with `<package>` (in our example, `com.a`) and any sub-packages. For example, tests could be written for `com.apple`, `com.apricot`, `com.apricot.pip`, etc.

***

**Wildcard:** `dcover create '<package>*'`

**For example:** `dcover create '*.controller.*'`

**Description:** Write tests for all accessible methods within any package that contains `<package>` (in our example, `.controller.`) and any sub-packages plus wildcard matches. For example, tests could be written for `com.controller.apple`, `org.controller`, etc. Note that when using the `*` wildcard character, the entry point must be enclosed in single quotes, as shown.

***

### Class example

Specify a class entry point on the command line using the standard Java naming convention, plus an optional trailing dot and/or wildcards.

**Syntax:** `dcover create <package>[.][*].<className>[.][*][extends][implements[|]]`

***

**Trailing dot:** `dcover create <package>.<className>.`

**For example:** `dcover create io.diffblue.corebanking.account.Account.`

**Description:** Write tests for all accessible methods within class `<package>.<className>.` only - in our example, `io.diffblue.corebanking.account.Account`. Trailing dot prefix doesn't support wildcard `*`.

***

**No trailing dot:** `dcover create <pacakge>.<className>`

**For example:** `dcover create io.diffblue.corebanking.account.Account`

**Description:** Write tests for all accessible methods within any class that begins with `<package>.<className>` - in our example, this could include `...Account` and `...AccountException`.

***

**Wildcard:** `dcover create '<package>*.<className>*'`

**For example:** `dcover create 'io.diffblue.corebanking.account.*Exception'`

**Description:** Write tests for all accessible methods within any class that begins with `<package>` and contains `<className>` plus any wildcard matches. In our example, this could include `...UserException` and `...AccountException`. You can also combine this with `*` in the package name. Note that when using the `*` wildcard character, the entry point must be enclosed in single quotes, as shown.

**For example:** `dcover create '*.User*'` could match `io.diffblue.account.User`, `io.diffblue.account.UserController`, `io.diffblue.order.UserController` and `io.diffblue.order.UserRepository`.

***

**extends:** `dcover create '<package>.<className> extends <package>.<parentClassName>'`

**For example:** `dcover create 'io.diffblue.account.Foo extends io.diffblue.Bar'`

**Description:** Similar to regular Java syntax, the `extends` keyword instructs Cover to write tests for all accessible methods within any class where the name contains `<package>.<className>` and extends/is a direct child to a class where the name contains `<package>.<parentClassName>`. Note that when using the `extends` keyword, the entry point must be enclosed in single quotes, as shown.

**For example:** `dcover create '* extends io.diffblue.Bar'` could match any class in any package that extends `io.diffblue.Bar`.

***

**implements:** `dcover create '<package>.<className> implements <package>.<interfaceName>'`

**For example:** `dcover create 'io.diffblue.account.Foo implements io.diffblue.Bar'`

**Description:** Similar to regular Java syntax, the `implements` keyword instructs Cover to write tests for all accessible methods within any class where the name contains `<package>.<className>` and implements an interface where the name contains `<package>.<interfaceName>`.\
You can specify a list of interfaces using the `|` delimiter - here, a target class has to match at least one of the interfaces. Note that when using the `implements` keyword, the entry point must be enclosed in single quotes, as shown.

**For example:** `dcover create '* implements *.Callable | *.Runnable'` will match all classes that implement either `Callable`, `Runnable`, or both.

***

### Method example

There are two ways of specifying particular methods to be selected for operation - **Prefix** and **Extended**.

***

**Prefix**

Specify a method entry point on the command line using the standard Java naming convention, plus an optional method descriptor. Wildcards, `extends`, and `implements` are not supported for prefixes.

**Syntax:** `dcover create <package>.<className>.<methodName>:[<methodDescriptor>]`

**Example:** `dcover create io.diffblue.corebanking.account.Account.addToBalance:`

**Description:** Write tests for the specified method. If the optional method descriptor is omitted, all parameter and return types will be included.

A method descriptor is a list of type descriptors that describe the parameter types and the return type of a method, in a single string. For more information on method descriptors, see section 2.1.4 of the [ASM 4.0 A Java bytecode engineering library](https://asm.ow2.io/asm4-guide.pdf).

**Example:** Complete prefix of `addToBalance(double[] sum, String account)` with ASM 4.0 signature will look like this '`io.diffblue.corebanking.account.Account.addToBalance:([DLjava/lang/String;)'`.

***

**Extended**

The Extended syntax supports wildcards, `extends`, and `implements`, utilizing "Java-like" syntax.

**Syntax:** `dcover create '<package>[.][*].<className>[.][*][extends][implements[|]]`\
`{<methodName>[*][([<parameterType>,...])];}'`

* `dcover create 'com.example.Foo { bar(int[], double);}'` will match `bar` method in `Foo` class with exactly two parameters in order `int[], double`.
* `dcover create 'com.example.Foo { bar();}'` will match `bar` method in `Foo` class with no parameters only.
* `dcover create 'com.example.Foo { bar;}'` will match `bar` method in `Foo` class with any number and types of parameters.
* `dcover create 'com.example.Foo { *bar;}'` will match any method in `Foo` class which ends with `*bar`. `foobar()` method will match in our example. Wildcard `*` can match any part of a method name but can't be used in parameter type.
* Short qualifiers can be used when parameter is a primitive `byte, char, double, float, long, short, boolean` or an object of type `String, Object, List`. For other object types full qualifier has to be specified.\
  `com.example.Foo { bar(String);}` but `com.example.Foo { bar(com.example.FooBar);}`.
* Constructor method has to be specified as `<init>`.\
  `dcover create 'com.example.Foo { <init>(int);}'` will match `Foo(int)` constructor method of `Foo` class.
* Note that when using the Extended syntax, the entry point must be enclosed in single quotes, as shown.

***

### Multiple specification entries

In order to specify multiple **Extended** syntax entries the whitespace separator should be used for the `create` command.

**Example**: `dcover create 'com.foo.*' 'com.bar.*'`

In case `--exclude` option is used it has to be specified for each entry separately.

**Example**: `dcover create --exclude='com.foo.*' --exclude='com.bar.*'`