JaCoCo

https://www.jacoco.org/jacoco/trunk/doc
Admin
JaCoCo is a free Java code coverage library that uses instrumentation to record execution coverage...
Tokens:132,261
Snippets:1,726
Trust Score:9.6
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### startup(RuntimeData data)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/runtime/ModifiedSystemClassRuntime.html

Starts the runtime with the provided execution data.

```APIDOC
## Method: startup(RuntimeData data)

### Description
Subclasses must call this method when overwriting it. Starts up the runtime with the given execution data.

### Method Signature
`public void startup(RuntimeData data) throws Exception`

### Parameters
- **data** (RuntimeData) - Required - The execution data for this runtime.

### Throws
- **Exception** - Any internal problem during startup.

```

--------------------------------

### Main entry point for CoreTutorial

Source: https://www.jacoco.org/jacoco/trunk/doc/examples/java/CoreTutorial.java

Entry point that runs the CoreTutorial example as a Java application, passing System.out as the output stream.

```java
public static void main(final String[] args) throws Exception {
    new CoreTutorial(System.out).execute();
}
```

--------------------------------

### JaCoCo Core API instrumentation and coverage example

Source: https://www.jacoco.org/jacoco/trunk/doc/examples/java/CoreTutorial.java

Complete JaCoCo core API example that instruments a target class, executes it with a custom class loader, and dumps coverage metrics. Requires the JaCoCo core library and a PrintStream for output. The example uses LoggerRuntime, Instrumenter, RuntimeData, ExecutionDataStore, SessionInfoStore, CoverageBuilder, and Analyzer.

```java
/*******************************************************************************
 * Copyright (c) 2009, 2026 Mountainminds GmbH & Co. KG and Contributors
 * This program and the accompanying materials are made available under
 * the terms of the Eclipse Public License 2.0 which is available at
 * https://www.eclipse.org/legal/epl-2.0
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *    Marc R. Hoffmann - initial API and implementation
 *
 *******************************************************************************/
package org.jacoco.examples;

import java.io.InputStream;
import java.io.PrintStream;
import java.util.HashMap;
import java.util.Map;

import org.jacoco.core.analysis.Analyzer;
import org.jacoco.core.analysis.CoverageBuilder;
import org.jacoco.core.analysis.IClassCoverage;
import org.jacoco.core.analysis.ICounter;
import org.jacoco.core.data.ExecutionDataStore;
import org.jacoco.core.data.SessionInfoStore;
import org.jacoco.core.instr.Instrumenter;
import org.jacoco.core.runtime.IRuntime;
import org.jacoco.core.runtime.LoggerRuntime;
import org.jacoco.core.runtime.RuntimeData;

/**
 * Example usage of the JaCoCo core API. In this tutorial a single target class
 * will be instrumented and executed. Finally the coverage information will be
 * dumped.
 */
public final class CoreTutorial {

	/**
	 * The test target we want to see code coverage for.
	 */
	public static class TestTarget implements Runnable {

		public void run() {
			isPrime(7);
		}

		private boolean isPrime(final int n) {
			for (int i = 2; i * i <= n; i++) {
				if ((n ^ i) == 0) {
					return false;
				}
			}
			return true;
		}

	}

	/**
	 * A class loader that loads classes from in-memory data.
	 */
	public static class MemoryClassLoader extends ClassLoader {

		private final Map<String, byte[]> definitions = new HashMap<String, byte[]>();

		/**
		 * Add an in-memory representation of a class.
		 *
		 * @param name
		 *            name of the class
		 * @param bytes
		 *            class definition
		 */
		public void addDefinition(final String name, final byte[] bytes) {
			definitions.put(name, bytes);
		}

		@Override
		protected Class<?> loadClass(final String name, final boolean resolve)
				throws ClassNotFoundException {
			final byte[] bytes = definitions.get(name);
			if (bytes != null) {
				return defineClass(name, bytes, 0, bytes.length);
			}
			return super.loadClass(name, resolve);
		}

	}

	private final PrintStream out;

	/**
	 * Creates a new example instance printing to the given stream.
	 *
	 * @param out
	 *            stream for outputs
	 */
	public CoreTutorial(final PrintStream out) {
		this.out = out;
	}

	/**
	 * Run this example.
	 *
	 * @throws Exception
	 *             in case of errors
	 */
	public void execute() throws Exception {
		final String targetName = TestTarget.class.getName();

		// For instrumentation and runtime we need a IRuntime instance
		// to collect execution data:
		final IRuntime runtime = new LoggerRuntime();

		// The Instrumenter creates a modified version of our test target class
		// that contains additional probes for execution data recording:
		final Instrumenter instr = new Instrumenter(runtime);
		InputStream original = getTargetClass(targetName);
		final byte[] instrumented = instr.instrument(original, targetName);
		original.close();

		// Now we're ready to run our instrumented class and need to startup the
		// runtime first:
		final RuntimeData data = new RuntimeData();
		runtime.startup(data);

		// In this tutorial we use a special class loader to directly load the
		// instrumented class definition from a byte[] instances.
		final MemoryClassLoader memoryClassLoader = new MemoryClassLoader();
		memoryClassLoader.addDefinition(targetName, instrumented);
		final Class<?> targetClass = memoryClassLoader.loadClass(targetName);

		// Here we execute our test target class through its Runnable interface:
		final Runnable targetInstance = (Runnable) targetClass.newInstance();
		targetInstance.run();

		// At the end of test execution we collect execution data and shutdown
		// the runtime:
		final ExecutionDataStore executionData = new ExecutionDataStore();
		final SessionInfoStore sessionInfos = new SessionInfoStore();
		data.collect(executionData, sessionInfos, false);
		runtime.shutdown();

		// Together with the original class definition we can calculate coverage
		// information:
		final CoverageBuilder coverageBuilder = new CoverageBuilder();
		final Analyzer analyzer = new Analyzer(executionData, coverageBuilder);
		original = getTargetClass(targetName);
		analyzer.analyzeClass(original, targetName);
		original.close();

		// Let's dump some metrics and line coverage information:
		for (final IClassCoverage cc : coverageBuilder.getClasses()) {
			out.printf("Coverage of class %s%n", cc.getName());

```

--------------------------------

### ClassInfo example: dump JaCoCo class coverage metrics

Source: https://www.jacoco.org/jacoco/trunk/doc/examples/java/ClassInfo.java

Complete Java example that reads class files, directories, or JARs from command-line arguments and prints coverage metrics (class name, id, instructions, branches, lines, methods, complexity) using JaCoCo's Analyzer and ICoverageVisitor. Requires JaCoCo core on the classpath; run with class file paths as arguments.

```java
/*******************************************************************************
 * Copyright (c) 2009, 2026 Mountainminds GmbH & Co. KG and Contributors
 * This program and the accompanying materials are made available under
 * the terms of the Eclipse Public License 2.0 which is available at
 * https://www.eclipse.org/legal/epl-2.0
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *    Marc R. Hoffmann - initial API and implementation
 *
 *******************************************************************************/
package org.jacoco.examples;

import java.io.File;
import java.io.IOException;
import java.io.PrintStream;

import org.jacoco.core.analysis.Analyzer;
import org.jacoco.core.analysis.IClassCoverage;
import org.jacoco.core.analysis.ICoverageVisitor;
import org.jacoco.core.data.ExecutionDataStore;

/**
 * This example reads Java class files, directories or JARs given as program
 * arguments and dumps information about the classes.
 */
public final class ClassInfo implements ICoverageVisitor {

	private final PrintStream out;
	private final Analyzer analyzer;

	/**
	 * Creates a new example instance printing to the given stream.
	 *
	 * @param out
	 *            stream for outputs
	 */
	public ClassInfo(final PrintStream out) {
		this.out = out;
		analyzer = new Analyzer(new ExecutionDataStore(), this);
	}

	/**
	 * Run this example with the given parameters.
	 *
	 * @param args
	 *            command line parameters
	 * @throws IOException
	 *             in case of error reading an input file
	 */
	public void execute(final String[] args) throws IOException {
		for (final String file : args) {
			analyzer.analyzeAll(new File(file));
		}
	}

	public void visitCoverage(final IClassCoverage coverage) {
		out.printf("class name:   %s%n", coverage.getName());
		out.printf("class id:     %016x%n", Long.valueOf(coverage.getId()));
		out.printf("instructions: %s%n", Integer
				.valueOf(coverage.getInstructionCounter().getTotalCount()));
		out.printf("branches:     %s%n",
				Integer.valueOf(coverage.getBranchCounter().getTotalCount()));
		out.printf("lines:        %s%n",
				Integer.valueOf(coverage.getLineCounter().getTotalCount()));
		out.printf("methods:      %s%n",
				Integer.valueOf(coverage.getMethodCounter().getTotalCount()));
		out.printf("complexity:   %s%n%n", Integer
				.valueOf(coverage.getComplexityCounter().getTotalCount()));
	}

	/**
	 * Entry point to run this examples as a Java application.
	 *
	 * @param args
	 *            list of program arguments
	 * @throws IOException
	 *             in case of errors executing the example
	 */
	public static void main(final String[] args) throws IOException {
		new ClassInfo(System.out).execute(args);
	}

}

```

--------------------------------

### Bytecode for example method

Source: https://www.jacoco.org/jacoco/trunk/doc/flow.html

Bytecode generated from the example Java method. Uses symbolic labels (L1, L2) instead of relative offsets for readability, as the ASM API does.

```bytecode
  1. public static example()V
  2.       INVOKESTATIC a()V
  3.       INVOKESTATIC cond()Z
  4.       IFEQ L1
  5.       INVOKESTATIC b()V
  6.       GOTO L2
  7.   L1: INVOKESTATIC c()V
  8.   L2: INVOKESTATIC d()V
  9.       RETURN

```

--------------------------------

### SessionInfo(String id, long start, long dump)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/data/SessionInfo.html

Creates an immutable session info with the given data. The id must not be null, start is the epoch-based timestamp when recording started, and dump is the epoch-based timestamp when data was collected.

```APIDOC
## SessionInfo(String id, long start, long dump)

### Description
Creates an immutable session info with the given data.

### Constructor
`public SessionInfo(String id, long start, long dump)`

### Parameters
- **id** (String) - Required - Arbitrary session identifier, must not be `null`.
- **start** (long) - Required - The epoch-based time stamp when execution data recording has been started.
- **dump** (long) - Required - The epoch-based time stamp when execution data was collected.

```

--------------------------------

### getStartTimeStamp()

Source: https://www.jacoco.org/jacoco/trunk/doc/api/index-all.html

Returns the start timestamp of the session.

```APIDOC
## getStartTimeStamp()

### Description
Returns the start timestamp of the session.

### Method
getStartTimeStamp()

### Return Type
long

```

--------------------------------

### getStartTimeStamp()

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/data/SessionInfo.html

Returns the epoch-based time stamp when execution data recording has been started.

```APIDOC
## getStartTimeStamp()

### Description
Returns the epoch-based time stamp when execution data recording has been started.

### Method
`public long getStartTimeStamp()`

### Returns
- **long** - The epoch-based start time stamp.

```

--------------------------------

### values() method declaration and iteration example

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/analysis/ICounter.CounterValue.html

Shows the values() method declaration and a usage example that iterates over all enum constants using an enhanced for loop.

```java
public static final ICounter.CounterValue[] **values**()
```

```java
for(ICounter.CounterValue c : ICounter.CounterValue.values())
        System.out.println(c);
```

--------------------------------

### Iterate over AgentOptions.OutputMode constants

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/runtime/AgentOptions.OutputMode.html

Example iteration over the enum constants using the values() method, printing each constant to standard output.

```java
for(AgentOptions.OutputMode c : AgentOptions.OutputMode.values())
        System.out.println(c);

```

--------------------------------

### Configure jacoco:report task

Source: https://www.jacoco.org/jacoco/trunk/doc/ant.html

A basic example of the jacoco:report task declaration, specifying execution data, class files, source files, and an HTML output format.

```xml
  1. <jacoco:report>  

  2.   

  3.     <executiondata>  

  4.         <file file="jacoco.exec"/>  

  5.     </executiondata>  

  6.   

  7.     <structure name="Example Project">  

  8.         <classfiles>  

  9.             <fileset dir="classes"/>  

  10.         </classfiles>  

  11.         <sourcefiles encoding="UTF-8">  

  12.             <fileset dir="src"/>  

  13.         </sourcefiles>  

  14.     </structure>  

  15.   

  16.     <html destdir="report"/>  

  17.   

  18. </jacoco:report>
```

--------------------------------

### SystemPropertiesRuntime()

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/runtime/SystemPropertiesRuntime.html

Creates a new runtime instance.

```APIDOC
## Constructor: SystemPropertiesRuntime()

### Description
Creates a new runtime.

### Signature
```java
public SystemPropertiesRuntime()
```
```

--------------------------------

### accept(IExecutionDataVisitor)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/index-all.html

Writes the content of the store to the given visitor interface.

```APIDOC
## [METHOD] accept(IExecutionDataVisitor)

### Description
Writes the content of the store to the given visitor interface.

### Method
accept

### Parameters
#### Parameters
- **visitor** (IExecutionDataVisitor) - Required - The visitor to write the execution data to.

### Response
#### Success Response
No explicit response documented.
```

--------------------------------

### accept(IExecutionDataVisitor)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/data/ExecutionDataStore.html

Writes the store contents to a visitor.

```APIDOC
## accept(IExecutionDataVisitor visitor)

### Description
Writes the content of the store to the given visitor interface.

### Method Signature
`public void accept(IExecutionDataVisitor visitor)`

### Parameters
- **visitor** (IExecutionDataVisitor) - Required - Visitor to receive the execution data.

```

--------------------------------

### get(long)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/data/ExecutionDataStore.html

Retrieves execution data by class id.

```APIDOC
## get(long id)

### Description
Returns the ExecutionData entry with the given id if it exists in this store.

### Method Signature
`public ExecutionData get(long id)`

### Parameters
- **id** (long) - Required - Class id.

### Returns
- **ExecutionData** - The execution data entry, or `null` if not found.

```

--------------------------------

### startup(RuntimeData) - IRuntime

Source: https://www.jacoco.org/jacoco/trunk/doc/api/index-all.html

Method in interface org.jacoco.core.runtime.IRuntime

```APIDOC
## startup(RuntimeData)

### Description
Starts the coverage runtime.

### Method
startup

### Parameters
- **data** (RuntimeData) - Required - The runtime data.

### Returns
void
```

--------------------------------

### Run the JaCoCo build with Maven Wrapper

Source: https://www.jacoco.org/jacoco/trunk/doc/build.html

Executes the full Maven build (clean and verify) from the `./org.jacoco.build/` directory. Requires JDK 21. The build typically takes around 3 minutes, but the first run may take longer as Maven downloads plugins and dependencies. The resulting download ZIP is created at `../jacoco/target/jacoco-_x.y.z.qualifier_.zip`.

```bash
  ../mvnw clean verify

```

--------------------------------

### ExecDumpClient()

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/tools/ExecDumpClient.html

Constructor that creates a new instance with default settings: dump=true, reset=false, retryCount=0, and retryDelay=1000 milliseconds.

```APIDOC
## ExecDumpClient()

### Description
Creates a new ExecDumpClient instance with default settings: dump=true, reset=false, retryCount=0, and retryDelay=1000 milliseconds.

### Method
Constructor

### Signature
`public ExecDumpClient()`

### Parameters
None

### Returns
A new ExecDumpClient instance.

### Example
```java
ExecDumpClient client = new ExecDumpClient();
```
```

--------------------------------

### get(Long, String, int)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/data/ExecutionDataStore.html

Returns or creates coverage data for a class.

```APIDOC
## get(Long id, String name, int probecount)

### Description
Returns the coverage data for the class with the given identifier. If the entry does not exist, it is created with the given name and probe count.

### Method Signature
`public ExecutionData get(Long id, String name, int probecount)`

### Parameters
- **id** (Long) - Required - Class identifier.
- **name** (String) - Required - VM name of the class.
- **probecount** (int) - Required - Number of probes.

### Returns
- **ExecutionData** - The coverage data for the class.

```

--------------------------------

### accept

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/data/ExecutionDataStore.html

Writes the content of the store to the given visitor interface.

```APIDOC
## accept

### Description
Writes the content of the store to the given visitor interface.

### Parameters
- `visitor` (IExecutionDataVisitor) - interface to write content to
```

--------------------------------

### getAddress

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/runtime/AgentOptions.html

Gets the hostname or IP address to listen to when output is `tcpserver` or connect to when output is `tcpclient`.

```APIDOC
## getAddress()

### Description
Gets the hostname or IP address to listen to when output is `tcpserver` or connect to when output is `tcpclient`.

### Method
getAddress

### Returns
- Hostname or IP address

```

--------------------------------

### IRuntime Interface

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/runtime/IRuntime.html

Documentation for the IRuntime interface, including its startup and shutdown methods.

```APIDOC
## Interface IRuntime

### Description
This interface represents a particular mechanism to collect execution information in the target VM at runtime. It extends IExecutionDataAccessorGenerator.

### Methods

#### startup

```java
void startup(RuntimeData data) throws Exception
```

Starts the coverage runtime. This method MUST be called before any class instrumented for this runtime is loaded.

**Parameters:**
- `data` (RuntimeData) - Required - The execution data for this runtime.

**Throws:**
- `Exception` - Any internal problem during startup.

#### shutdown

```java
void shutdown()
```

Allows the coverage runtime to cleanup internals. This method should be called when classes instrumented for this runtime are not used any more.
```

--------------------------------

### Iterating over enum constants with values()

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/analysis/ICoverageNode.CounterEntity.html

Example from the documentation showing how to iterate over the enum constants using the values() method.

```java
for(ICoverageNode.CounterEntity c : ICoverageNode.CounterEntity.values())
        System.out.println(c);
```

--------------------------------

### IReportVisitor.visitInfo(List<SessionInfo> sessionInfos, Collection<ExecutionData> executionData)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/data/class-use/ExecutionData.html

Initializes a report with global session and execution data.

```APIDOC
## IReportVisitor.visitInfo(List<SessionInfo> sessionInfos, Collection<ExecutionData> executionData)

### Description
Initializes the report with global information.

### Method
POST

### Endpoint
IReportVisitor.visitInfo(List<SessionInfo> sessionInfos, Collection<ExecutionData> executionData)

### Parameters
#### Request Body
- **sessionInfos** (List<SessionInfo>) - Required - The session information.
- **executionData** (Collection<ExecutionData>) - Required - The execution data.

### Response
#### Success Response (200)
- **void** - No return value.

```

--------------------------------

### onConnecting(InetAddress address, int port)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/tools/ExecDumpClient.html

Protected callback method that can be overridden to get an event just before a connection is made.

```APIDOC
## onConnecting(InetAddress address, int port)

### Description
This method can be overwritten to get an event just before a connection is made.

### Method
Callback

### Signature
`protected void onConnecting(InetAddress address, int port)`

### Parameters
- **address** (InetAddress) - Required - Target address.
- **port** (int) - Required - Target port.

### Returns
void

### Example
```java
@Override
protected void onConnecting(InetAddress address, int port) {
    System.out.println("Connecting to " + address + ":" + port);
}
```
```

--------------------------------

### Describe jacoco-maven-plugin goals with maven-help-plugin

Source: https://www.jacoco.org/jacoco/trunk/doc/maven.html

Lists all goals and available parameters of the JaCoCo Maven plug-in using the maven-help-plugin.

```bash
mvn help:describe -Dplugin=org.jacoco:jacoco-maven-plugin -Ddetail
```

--------------------------------

### MultiReportVisitor.visitInfo(List<SessionInfo> sessionInfos, Collection<ExecutionData> executionData)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/data/class-use/ExecutionData.html

Initializes a multi-report with global session and execution data.

```APIDOC
## MultiReportVisitor.visitInfo(List<SessionInfo> sessionInfos, Collection<ExecutionData> executionData)

### Description
Initializes the report with global information.

### Method
POST

### Endpoint
MultiReportVisitor.visitInfo(List<SessionInfo> sessionInfos, Collection<ExecutionData> executionData)

### Parameters
#### Request Body
- **sessionInfos** (List<SessionInfo>) - Required - The session information.
- **executionData** (Collection<ExecutionData>) - Required - The execution data.

### Response
#### Success Response (200)
- **void** - No return value.

```

--------------------------------

### visitInfo

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/report/IReportVisitor.html

Method to initialize the report with global information. Must be called before any other method.

```APIDOC
## visitInfo

### Description
Initializes the report with global information. This method has to be called before any other method can be called.

### Method
visitInfo

### Signature
`void visitInfo(List<SessionInfo> sessionInfos, Collection<ExecutionData> executionData) throws IOException`

### Parameters
- `sessionInfos` (List<SessionInfo>) - Required - list of chronological ordered `SessionInfo` objects where execution data has been collected for this report.
- `executionData` (Collection<ExecutionData>) - Required - collection of all `ExecutionData` objects that are considered for this report.

### Throws
- `IOException` - in case of IO problems with the report writer.
```

--------------------------------

### onConnectionFailure(IOException exception)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/tools/ExecDumpClient.html

Protected callback method that can be overridden to get an event for connection failures when another retry will be attempted.

```APIDOC
## onConnectionFailure(IOException exception)

### Description
This method can be overwritten to get an event for connection failures when another retry will be attempted.

### Method
Callback

### Signature
`protected void onConnectionFailure(IOException exception)`

### Parameters
- **exception** (IOException) - Required - Connection error.

### Returns
void

### Example
```java
@Override
protected void onConnectionFailure(IOException exception) {
    System.err.println("Connection failed: " + exception.getMessage());
}
```
```

--------------------------------

### get

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/data/ExecutionDataStore.html

Returns the coverage data for the class with the given identifier. If there is no data available under the given id a new entry is created.

```APIDOC
## get

### Description
Returns the coverage data for the class with the given identifier. If there is no data available under the given id a new entry is created.

### Method
`public ExecutionData get(Long id, String name, int probecount)`

### Parameters
- `id` (Long) - class identifier
- `name` (String) - VM name of the class
- `probecount` (int) - probe data length

### Returns
Execution data
```

--------------------------------

### ExecFileLoader()

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/tools/ExecFileLoader.html

Creates a new instance to combine session infos and execution data from multiple files.

```APIDOC
## Constructor: ExecFileLoader()

### Description
Creates a new instance to combine session infos and execution data from multiple files.

### Signature
`public ExecFileLoader()`

```

--------------------------------

### DirectorySourceFileLocator(File, String, int)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/report/DirectorySourceFileLocator.html

Constructor for DirectorySourceFileLocator that initializes the locator with a directory, encoding, and tab width.

```APIDOC
## Constructor: DirectorySourceFileLocator(File, String, int)

### Description
Creates a new locator that searches for source files in the given directory.

### Signature
`public DirectorySourceFileLocator(File directory, String encoding, int tabWidth)`

### Parameters
- **directory** (File) - Required - Directory to search for source files.
- **encoding** (String) - Required - Encoding of the source files, `null` for platform default encoding.
- **tabWidth** (int) - Required - Tab width in source files as number of blanks.

```

--------------------------------

### Retrieve Probe Array Instance

Source: https://www.jacoco.org/jacoco/trunk/doc/implementation.html

Example of how an instrumented class retrieves its probe array instance using JRE APIs and the Object.equals method.

```java
  1. Object access = ...                      // Retrieve instance  

  2.   

  3. Object[] args = new Object[3];  

  4. args[0] = Long.valueOf(8060044182221863588); // class id  

  5. args[1] = "com/example/MyClass";           // class name  

  6. args[2] = Integer.valueOf(24);             // probe count  

  7.   

  8. access.equals(args);  

  9.   

  10. boolean[] probes = (boolean[]) args[0];
```

--------------------------------

### SystemPropertiesRuntime() - Constructor

Source: https://www.jacoco.org/jacoco/trunk/doc/api/index-all.html

Constructor for class org.jacoco.core.runtime.SystemPropertiesRuntime

```APIDOC
## SystemPropertiesRuntime()

### Description
Creates a new runtime.

### Method
Constructor

### Parameters
None

### Returns
A new instance of SystemPropertiesRuntime.
```

--------------------------------

### Iterate over ICoverageNode.ElementType values()

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/analysis/ICoverageNode.ElementType.html

Iterates over all enum constants of ICoverageNode.ElementType using the values() method and prints each constant. This is the example provided in the Javadoc for the values() method.

```java
for(ICoverageNode.ElementType c : ICoverageNode.ElementType.values())
        System.out.println(c);
```

--------------------------------

### MultiSourceFileLocator(int tabWidth)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/report/MultiSourceFileLocator.html

Constructor for creating a new empty MultiSourceFileLocator instance.

```APIDOC
## MultiSourceFileLocator

### Description
Creates a new empty locator that searches source files in multiple `ISourceFileLocator` instances. For each lookup request the first locator that returns a `Reader` for source content is selected.

### Constructor
`public MultiSourceFileLocator(int tabWidth)`

### Parameters
- **tabWidth** (int) - Required - Tab width in source files as number of blanks used for all source files.

### Usage
```java
MultiSourceFileLocator locator = new MultiSourceFileLocator(4);
```
```

--------------------------------

### Get target class InputStream

Source: https://www.jacoco.org/jacoco/trunk/doc/examples/java/CoreTutorial.java

Resolves a class name to its .class resource path and returns an InputStream for it. Uses the class loader to load the resource.

```java
private InputStream getTargetClass(final String name) {
    final String resource = '/' + name.replace('.', '/') + ".class";
    return getClass().getResourceAsStream(resource);
}
```

--------------------------------

### getBundle(String name)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/core/analysis/CoverageBuilder.html

Creates a bundle coverage node from all classes and source files currently in the builder.

```APIDOC
## getBundle(String name)

### Description
Creates a bundle from all nodes currently contained in this builder.

### Method
`public IBundleCoverage getBundle(String name)`

### Parameters
- **name** (String) - Required - Name of the bundle

### Returns
- **IBundleCoverage** - bundle containing all classes and source files
```

--------------------------------

### Java method with branching point

Source: https://www.jacoco.org/jacoco/trunk/doc/flow.html

Java method with a single branching point used as the starting point for control flow analysis. It calls a(), then conditionally calls b() or c(), and finally calls d().

```java
  1. public static void example() {  
  2.     a();  
  3.     if (cond()) {  
  4.         b();  
  5.     } else {  
  6.         c();  
  7.     }  
  8.     d();  
  9. }

```

--------------------------------

### createVisitor(IViolationsOutput output)

Source: https://www.jacoco.org/jacoco/trunk/doc/api/org/jacoco/report/check/RulesChecker.html

Creates a visitor that processes the configured checks and reports violations to the provided output.

```APIDOC
## createVisitor(IViolationsOutput output)

### Description
Creates a new visitor to process the configured checks.

### Method Signature
`public IReportVisitor createVisitor(IViolationsOutput output)`

### Parameters
- **output** (IViolationsOutput) - Required - Call-back to report violations to.

### Returns
- **IReportVisitor** - Visitor to emit the report data to.

```

--------------------------------

### ExecutionDataServer.java - JaCoCo TCP server for collecting coverage

Source: https://www.jacoco.org/jacoco/trunk/doc/examples/java/ExecutionDataServer.java

Starts a socket server on localhost:6300 to receive coverage data from JaCoCo agents in tcpclient mode. The collected data is written to jacoco-server.exec. Each connection is handled in a separate thread, and the server runs indefinitely.

```java
/*******************************************************************************
 * Copyright (c) 2009, 2026 Mountainminds GmbH & Co. KG and Contributors
 * This program and the accompanying materials are made available under
 * the terms of the Eclipse Public License 2.0 which is available at
 * https://www.eclipse.org/legal/epl-2.0
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *    Marc R. Hoffmann - initial API and implementation
 *
 *******************************************************************************/
package org.jacoco.examples;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

import org.jacoco.core.data.ExecutionData;
import org.jacoco.core.data.ExecutionDataWriter;
import org.jacoco.core.data.IExecutionDataVisitor;
import org.jacoco.core.data.ISessionInfoVisitor;
import org.jacoco.core.data.SessionInfo;
import org.jacoco.core.runtime.RemoteControlReader;
import org.jacoco.core.runtime.RemoteControlWriter;

/**
 * This example starts a socket server to collect coverage from agents that run
 * in output mode <code>tcpclient</code>. The collected data is dumped to a
 * local file.
 */
public final class ExecutionDataServer {

	private static final String DESTFILE = "jacoco-server.exec";

	private static final String ADDRESS = "localhost";

	private static final int PORT = 6300;

	/**
	 * Start the server as a standalone program.
	 *
	 * @param args
	 * @throws IOException
	 */
	public static void main(final String[] args) throws IOException {
		final ExecutionDataWriter fileWriter = new ExecutionDataWriter(
				new BufferedOutputStream(new FileOutputStream(DESTFILE)));
		final ServerSocket server = new ServerSocket(PORT, 0,
				InetAddress.getByName(ADDRESS));
		while (true) {
			final Handler handler = new Handler(server.accept(), fileWriter);
			new Thread(handler).start();
		}
	}

	private static class Handler
			implements Runnable, ISessionInfoVisitor, IExecutionDataVisitor {

		private final Socket socket;

		private final RemoteControlReader reader;

		private final ExecutionDataWriter fileWriter;

		Handler(final Socket socket, final ExecutionDataWriter fileWriter)
				throws IOException {
			this.socket = socket;
			this.fileWriter = fileWriter;

			// Just send a valid header:
			new RemoteControlWriter(
					// BufferedOutputStream will not improve performance here
					// while will add memory overhead because header is short
					socket.getOutputStream());

			reader = new RemoteControlReader(
					new BufferedInputStream(socket.getInputStream()));
			reader.setSessionInfoVisitor(this);
			reader.setExecutionDataVisitor(this);
		}

		public void run() {
			try {
				while (reader.read()) {
				}
				socket.close();
				synchronized (fileWriter) {
					fileWriter.flush();
				}
			} catch (final IOException e) {
				e.printStackTrace();
			}
		}

		public void visitSessionInfo(final SessionInfo info) {
			System.out.printf("Retrieving execution Data for session: %s%n",
					info.getId());
			synchronized (fileWriter) {
				fileWriter.visitSessionInfo(info);
			}
		}

		public void visitClassExecution(final ExecutionData data) {
			synchronized (fileWriter) {
				fileWriter.visitClassExecution(data);
			}
		}
	}

	private ExecutionDataServer() {
	}
}

```

--------------------------------

### SessionInfo.SessionInfo

Source: https://www.jacoco.org/jacoco/trunk/doc/api/index-all.html

Constructor for SessionInfo.

```APIDOC
## SessionInfo(String, long, long)

### Description
Create an immutable session info with the given data.

### Method
Constructor

### Parameters
- **String** - The session identifier.
- **long** - The start timestamp.
- **long** - The dump timestamp.

```

--------------------------------

### Wrap junit task with jacoco:coverage

Source: https://www.jacoco.org/jacoco/trunk/doc/ant.html

Wraps a `junit` task to record coverage. The `junit` task must set `fork="true"` and should use `forkmode="once"` to avoid starting a new JVM per test.

```xml
<jacoco:coverage>
    <junit fork="true" forkmode="once">
        <test name="org.jacoco.examples.HelloJaCoCoTest"/>
        <classpath>
            <pathelement location="./bin"/>
        </classpath>
    </junit>
</jacoco:coverage>
```

--------------------------------

### JaCoCo Ant check element with coverage limits

Source: https://www.jacoco.org/jacoco/trunk/doc/ant.html

Configures the JaCoCo Ant task's check element to enforce coverage rules. The example requires every package to have at least 80% line coverage and no missed classes. Use the failonviolation attribute to control whether the build fails on violations.

```xml
<check>
    <rule element="PACKAGE">
        <limit counter="LINE" value="COVEREDRATIO" minimum="80%"/>
        <limit counter="CLASS" value="MISSEDCOUNT" maximum="0"/>
    </rule>
</check>
```
Tokens:
Raw