This guide explains how to integrate JaCoCo into SpringBoot projects using Maven or Gradle, generate detailed HTML and XML coverage reports, interpret line, branch, and method metrics, exclude irrelevant code, set coverage thresholds, and address common pitfalls to ensure thorough testing of critical business logic.
This article walks through adjusting Java unit tests with ChatGPT, measuring coverage using JaCoCo, rewriting test code for User and PasswordRecovery classes, adding Mockito and PowerMock mocks, and showing how the changes raise coverage from 73.7% to over 80% across the project.
This article explains how a long‑standing Java backend service was instrumented with JVM agents and JaCoCo to collect execution coverage, visualize results in an IntelliJ IDEA plugin, and systematically remove dead code, improving maintainability while minimizing impact on production performance.
The article explains how integrating JaCoCo introduced a synthetic boolean array field ($jacocoData) that caused a ClassCastException during object encryption, analyzes the root cause by inspecting bytecode and reflection, and provides a fix by filtering synthetic fields using isSynthetic().
After integrating JaCoCo, a Java service threw a ClassCastException during order processing due to the synthetic $jacocoData boolean array, and the article details the root cause, code analysis, synthetic fields, JaCoCo probe insertion, and a robust fix using field.isSynthetic() filtering.
This article details a Java ClassCastException caused by JaCoCo’s injected $jacocoData boolean array, explains how synthetic fields arise during bytecode instrumentation, analyzes the failing encryptObject method, and presents a fix by filtering synthetic fields using isSynthetic() to restore normal order processing.
This article presents a design and implementation of both static AST‑based scanning and runtime JaCoCo coverage analysis to automatically detect unused (zombie) Java methods, describing the workflow, required dependencies, code snippets, and how to visualize active versus dead code in the IDE.
This article describes how Agoda engineers tackled slow CI pipelines caused by exhaustive UI testing by implementing selective testing using code‑coverage data, JaCoCo, and a device farm, resulting in faster feedback, reduced flakiness, and more efficient integration for Android applications.
Facing rapid business expansion, Huolala’s quality assurance team tackled redundant code, high regression costs, and lack of coverage metrics by designing an intelligent automated testing framework that analyzes effective code, provides smart test case recommendations, visualizes progress, and integrates monitoring, resulting in significant coverage improvements and efficiency gains across services.
This article explains how to use static analysis tools like IDEA and PMD together with dynamic coverage tools such as JaCoCo to identify, clean up, and refactor unused, duplicated, or dead Java code in large backend projects, improving maintainability and stability.
By instrumenting Java services with JaCoCo’s agent and analyzing runtime coverage data, teams can identify unused (“zombie”) code, safely remove or deactivate it, and consequently reduce maintenance costs, shorten delivery cycles, and improve overall system performance and developer productivity.
This article explains what unit testing is, why it is essential for software quality, outlines its benefits such as early bug detection and design improvement, and provides practical guidance on writing effective Java unit tests using JUnit5, Mockito, and JaCoCo, along with CI integration and best‑practice principles.
This article explains how to use JaCoCo probes to analyze online Java code execution, identify and remove zombie code, and improve development efficiency through detailed steps including Maven dependencies, a REST dump endpoint, javaagent configuration, script automation, and coverage analysis results.
This article explains what unit testing is, why it’s essential, and provides a step‑by‑step guide for writing Java unit tests with JUnit, integrating them into Maven projects, and generating detailed coverage reports using IDE features and JaCoCo.
This article explores Test‑Driven Development (TDD), explaining its core concepts, common misconceptions, tool choices such as JUnit, Mockito and JaCoCo, and provides practical case studies including a simple calculator and layered architecture examples in both anemic and DDD models.
The Vivo Internet Server Team describes how they integrated JaCoCo into their internal CI/CD platform to measure Java test coverage, explaining JaCoCo’s probe‑based instrumentation, the need for consistent compilation, handling incremental code and class‑ID changes, and showing that the resulting coverage data improves testing quality despite added effort.
This article presents the design, implementation details, and workflow of a Java code coverage platform built on JaCoCo, covering full and incremental coverage collection, configuration, analysis of diff code, reporting, and future integration plans to improve testing quality and code reliability.
This guide explains how to separate unit and integration tests in a Maven project, configure the Build Helper and Failsafe plugins, set up JaCoCo to generate combined coverage reports, and visualize them in SonarQube, including a complete example pom.xml.
This article details the design, deployment steps, technical architecture, and operational workflow of the Jingwei system—a Java code‑coverage solution built on JaCoCo that automates coverage collection, merges execution data, and visualizes results to improve testing quality and efficiency.
iQIYI integrated JaCoCo with its DevOps pipeline, using Git diff and Jira‑linked branch naming to automatically generate fine‑grained coverage reports at incremental, branch, and requirement levels, enforcing 90 % thresholds that lifted backend service coverage from under 70 % to over 90 % and markedly improved reliability.
This article details the motivation, design, key features, implementation techniques, and evaluation standards of a real‑time Java code‑coverage platform built on Jacoco, covering background industry trends, platform architecture, incremental reporting, visualization, Maven integration, and practical lessons for developers and QA teams.
This article describes the design and implementation of a Gradle plugin that extends JaCoCo to collect incremental code‑coverage data for Android applications, covering project background, significance, JaCoCo injection mechanisms, compile‑time instrumentation, runtime data handling, report generation, and practical results.
This article explains what code coverage is, why it matters, the different coverage metrics, how coverage measurement works, and reviews several mainstream tools across various programming languages.
This article describes a solution that merges incremental unit test coverage into overall test environment coverage by leveraging Maven Surefire Report Plugin and JaCoCo, detailing steps from CI platform integration, plugin configuration, report generation, to coverage platform processing, enabling comprehensive coverage analysis for release admission.
This article explains how Zhongtong implemented a Java‑based code‑coverage service using Jacoco, integrated it into their CI pipeline, generated multi‑dimensional coverage reports, and refined testing workflows to improve software quality and reduce untested code.
Super‑Jacoco is a one‑stop Java code‑coverage platform built on JaCoCo and Git that non‑intrusively gathers both full‑stack and incremental (diff) coverage for unit and manual tests, visualizes results, scales across distributed nodes, and provides REST APIs for triggering and retrieving coverage data.
Super‑Jacoco is an open‑source, one‑stop Java coverage platform that extends JaCoCo with Git diff analysis to provide low‑overhead, non‑intrusive full‑run and incremental (diff) coverage for unit, functional, and environment tests, offering distributed scalability and HTML visual reports for easy insight.
This article describes how Dada built a JaCoCo-powered code coverage platform for Java services deployed on Kubernetes, covering tool selection, on‑the‑fly instrumentation, data collection, incremental coverage analysis, CI gate enforcement, encountered pitfalls, and future enhancements.
This guide explains how to restructure a Maven project to isolate unit and integration tests, configure Maven Surefire, Failsafe, Build‑Helper, and JaCoCo plugins for separate execution and combined coverage reports, and finally display the results in SonarQube.
The article explains how to use JaCoCo to instrument Android SDK classes—detailing probe insertion strategies for methods, branches, and code blocks, offline and Ant/Gradle integration, building instrumented packages, collecting execution data, and generating HTML coverage reports without modifying source code.
This guide explains how to structure a Maven project to run unit tests and integration tests separately, configure the Build Helper, Surefire, Failsafe, and JaCoCo plugins, and generate combined test reports that can be visualized in SonarQube.
This article explains why JaCoCo coverage reports become noisy due to config, bean, and adapter classes, compares two filtering approaches, and provides a step‑by‑step Ant build configuration with XML examples to exclude irrelevant classes for more accurate coverage metrics.
This article explains JaCoCo's mission to provide a lightweight, flexible, and well-documented Java code‑coverage library, outlines its core features, integration options with build tools and IDEs, and details the various coverage counters such as instructions, branches, lines, methods, classes, and cyclomatic complexity.
This guide walks you through configuring JaCoCo agent parameters, running Ant tasks to produce a jacoco.exec file, and generating detailed HTML coverage reports, including class and line‑level insights, with practical command examples and visual explanations.
This article compiles a comprehensive list of Java and Python development tools, including JaCoCo code coverage solutions, Moco API mock server tips, various Java utility libraries, Gradle build guides, and multiple Plotly visualization tutorials, providing direct links for each resource.
This tutorial explains how to install and configure Java 8, Ant, JUnit 4, JaCoCo, Jenkins, and SonarQube on Windows or Linux to create a fully functional CI server with code‑coverage and quality analysis for a modular Java project.
This article explains how to configure the JaCoCo Maven plugin to generate separate code coverage reports for unit and integration tests, including plugin setup in the POM, execution configurations, and integration with Maven Surefire and Failsafe plugins, plus Maven commands to produce the reports.
This guide explains how to embed JaCoCo into Tomcat startup, use Ant build scripts to collect and merge execution data across three servers, generate HTML coverage reports, and centralize them for easy viewing in a Jenkins‑driven API testing pipeline.
The author explains why JaCoCo coverage failed after changing file paths, reveals that class file paths are flexible but source paths must point to the package root (usually src/main/java), and provides a complete, working Ant build.xml example to generate accurate coverage reports.
This guide explains how to add JaCoCo to a Tomcat service, use Ant build.xml to collect and merge execution data from remote JVMs, generate HTML coverage reports, and centralize the results for API testing in a multi‑server Jenkins environment.
This article explains how to configure JaCoCo in Java service startup parameters, use Ant build.xml to collect execution data, generate HTML coverage reports, and centralize the results on a dedicated server within a multi‑machine Jenkins CI environment.
The article presents a comprehensive approach to improve backend service testing by building a mapping between automated test cases and code coverage, enabling selective test execution, objective impact assessment, and incremental coverage analysis to enhance test efficiency, reliability, and CI stability.
The article discusses challenges of regression testing and proposes an incremental code‑coverage solution using a diff engine, AST analysis, and JaCoCo integration within a Jenkins CI pipeline, enabling precise test scope identification, visual coverage feedback, and improved collaboration between manual and automated testing.
This article explains the concept and advantages of continuous integration, outlines a typical CI workflow including submission, testing, building, deployment and rollback, discusses challenges in test case management, reviews popular CI tools such as Jenkins and Qone, and details code‑coverage measurement using Jacoco with Maven configuration.
This article explains the design and implementation of an incremental code‑coverage tool built on JaCoCo, detailing how it collects exec files, extracts changed Java methods via JGit, modifies JaCoCo to report only those methods, generates coverage reports, and integrates the whole process into a DevOps platform for automated feedback.
This article explains the concept, measurement dimensions, and practical issues of code coverage, compares full and differential coverage, describes JaCoCo's on‑the‑fly and offline instrumentation techniques, and outlines how to resolve instrumentation conflicts in a Java service environment.
