Jump to: navigation, search

Difference between revisions of "JaCoCo/Proposal"

Line 16: Line 16:
== Architecture and Extensibility ==
== Architecture and Extensibility ==
TODO Add image explaining dependencies
The following image shows the dependencies for JaCoCo
=== Java Agent Jar ===
=== Java Agent Jar ===

Revision as of 20:53, 3 April 2011

Draft proposal

This is a draft proposal, feel free to contribute to it!


JaCoCo is a free code coverage library for Java, which is currently developed by the EclEmma team based on the lessons learned from using and integration existing libraries over the last three years.

JaCoCo is proposed as an open source project under the Eclipse Technology Project (http://www.eclipse.org/technology/). This proposal is still in the Project Proposal Phase, and is being made in order to call for more community participation. You are invited to comment on and/or join the project. Please send all feedback to the http://www.eclipse.org/newsportal/thread.php?group=eclipse.technology.jacoco newsgroup.

Background and Goal

There are several open source coverage technologies for Java available. While implementing the Eclipse plug-in EclEmma (http://www.eclemma.org/) the observation was that none of them are really designed for integration. Most of them are specifically fit to a particular tool (Ant tasks, command line, IDE plug-in) and do not offer a documented API that allows embedding in different contexts. One of the best and widely used available open source tools is EMMA (http://emma.sourceforge.net/). While EclEmma is based on it the EMMA library is not actively maintained any more by the original author. Due to the lack of regression tests maintenance and feature additions will become very difficult.

JaCoCo should become the standard backend technology for code coverage analysis in Java VM based environments. The focus is providing a lightweight, flexible and well documented library for integration with various build and development tools. Ant tasks are provided as reference usage scenarios. Other tools like a ready to use Eclipse plug-in (future version of EclEmma) or a Maven plug-in might follow.

Architecture and Extensibility

The following image shows the dependencies for JaCoCo

Jacoco proposal dependencies.png

Java Agent Jar

The Agent jar is the entrypoint into the Java instrumnetation agent. Its sole purpose is to implement the interface as specified by the Java Instrumentation package and pass off all requests to the Agent runtime.

Agent Runtime

The agent runtime jar provides the 'public face' of the Java instrumentation agent. It is responsible for seting up an agent controller (either local or remote) and determining which classes should be instrumented. Classes that are to be instrumented will be passed to the core library for instrumentation.

The Agent Runtime also contains the code that is reposonsible for inserting the coverage runtime into the current Java execution environment. Several strategies are available to work around restrictions in some constrained environments, such as J2EE containers. These runtimes are supplies by the core library, but created/installed by the agent

Current strategies include:

  • (default) Modified System Class - Instruments a standard java class (UUID)
  • Java Util Logging - Adds a special 'logger'
  • URL Stream handler - Registers a custom URL handler
  • System properties - Inserts an object into the sysem properties


The core jar is reposible for performing the actual bytecode manipution required to add the coverage recording ability to classes.


The reporting bundle is not externally extensible but does provide an internal API for writing new report types. Currently the following report types are supported:

  • HTML - Designed for end users
  • XML - designed for further processing by external tools such as Sonar or Hudson
  • CSV - Basic report type suitable for creating simple graphs

Ant Tasks

The Ant tasks bundle is an all in one jar that contains all dependencies required to launch an application with the coverage agent and produce a report from the execution data.

Project Scope

The primary scope of the JaCoCo project is to build a code coverage library that can be used by other tools to provide coverage reports. To ensure that the library is usable we also maintain a small number of exemplary tools that use the library. Currently this includes standalone example programs and Ant tasks.

Providing integration with other tools such as Hundson/Jenkins, Sonar and Maven are currently out of scope

Future Roadmap

  • API cleanup
  • Eclipse Plugin (EclEmma 2.0)
  • Support filtering of untestable/synthetic code



Packaging and Deployment

JaCoCo currently ships in the form of a .zip download that contains the following:

  • JaCoCo Java agent jar continaing all dependencies
  • Ant jar containing all dependencies
  • runtime agent, ant task, core and reporting bundles (not required if using the all in one jars)
  • Documentation including usage examples

We will continue to use this archive for distributing the framework portion of JaCoCo but will provide a P2 repository containing the agent, core and report bundles to support the EclEmma 2.0 plugin.

All bundles will also be uploaded to a Maven2 repository to make the creation of a Maven2 plugin easier



  • Chris Aniszczyk
  • TODO

Initial committers

  • Marc R. Hoffmann
  • Brock Janiczak, Individual
  • Evgeny Mandrikov, SonarSource

Interested parties

  • Chris Aniszczyk
  • Dave Carver