This article details an AI‑driven end‑to‑end testing solution that automatically generates test cases from real operation logs, compares traditional DOM‑based testing with AI‑enhanced approaches, selects Midscene + Qwen2.5‑VL‑72B as the execution engine, and builds a four‑stage pipeline that delivers code‑coverage metrics, platform dashboards, and a quality‑feedback loop for rapid product iteration.
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.
This article details the redesign of a code coverage platform, introducing a Kafka‑centric real‑time data stream, language‑agnostic contracts, non‑intrusive agents for Java and PHP, fine‑grained multi‑dimensional analysis, and interactive visualizations that dramatically improve testing efficiency and coverage accuracy.
This article details ZhiZhuan Group's end‑to‑end code‑coverage system for Android and iOS apps, covering its background, design, incremental instrumentation, CI/CD integration, optimization steps, visual reporting, and real‑world impact, offering practical insights for mobile development teams seeking reliable test coverage.
This article examines the current low self‑testing rates in the frontend team, explains why automated quality‑assurance techniques like code coverage and E2E testing are essential, outlines a comprehensive technical and operational plan—including tooling, rollout, metrics, and future road‑maps—to boost R&D self‑testing ratios and overall delivery quality.
This article analyzes the shortcomings of a custom Istanbul-based code coverage pipeline for a Vue frontend, explains why instrumented line numbers were inaccurate, and presents a revised solution using NYC to generate reliable incremental coverage reports with detailed implementation steps and configuration examples.
This article explains how to use php-code-coverage and the pcov extension to collect line, branch, and path coverage for PHP projects, introduces incremental coverage based on diff files, discusses configuration methods, performance optimizations, and practical lessons learned from real‑world deployment.
This article presents a detailed, step‑by‑step guide on improving unit test coverage in large Java codebases, covering strategies such as mocking, divide‑and‑conquer, tool‑assisted test generation, reflection‑based coverage, Maven configuration, and practical tips for handling static methods, final classes, and test data replay.
The article presents a comprehensive overview of Google’s code‑coverage system, describing its metrics, integration into the daily development workflow, underlying infrastructure, visualization tools, data‑driven analysis of five years of coverage data, and developer survey results that reveal adoption patterns and perceived usefulness.
The article describes a reflection‑based workflow that lets an AI iteratively generate, validate, and refine Go unit tests until 70 %+ code coverage is reached, using coverage‑out parsing, role‑based prompts, and automatic error correction, enabling fully autonomous test creation that can be integrated into CI pipelines to dramatically improve developer productivity.
Discover how Kahlan, a full‑featured BDD testing framework for PHP, enhances unit and integration testing with RSpec‑style syntax, built‑in code coverage, powerful stubbing, monkey‑patching, and flexible reporting, all without requiring PECL extensions.
The article reviews typical code‑coverage goals such as 70‑80% for system testing, explains how factors like failure cost, resource constraints, testability, and development stage influence target selection, discusses why full coverage is often impractical, and summarizes major industry standards and coverage metrics used in safety‑critical domains.
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.
This article describes how the ZhaiZhai team designed and built an incremental code‑coverage solution for frontend projects, covering tool selection, instrumentation, data collection, reporting, handling challenges, and future improvements to improve test efficiency and software quality.
The article details a high‑performance, high‑stability Android code‑coverage technique that creates a surrogate ClassLoader, copies the target PathClassLoader’s private classTable pointer, and invokes findLoadedClass on this loader to query a class’s load state without triggering Android’s native optimization that would otherwise automatically load the class.
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 details Shentong's systematic approach to improving test completeness, covering test case design, a custom Quality Keeper workflow, code‑coverage measurement, precise regression strategies, automation effectiveness, issue‑driven optimization, and future plans such as front‑end coverage and AI‑assisted testing.
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 tutorial explains how to set up PHPUnit and Xdebug in a PHP project, write and run unit tests, configure a phpunit.xml file, and generate detailed code‑coverage reports to improve code quality and reliability.
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.
The article examines common functional testing pain points—such as vague impact assessment, high regression cost, and poor test‑dev collaboration—and proposes a data‑driven solution that builds a code‑to‑test‑case mapping using dynamic call chains, static analysis, and coverage snapshots to enable precise test case recommendation and incremental coverage reporting.
This article introduces code‑level quality technologies, covering their background, architectural layers, code understanding methods, probe techniques, coverage metrics, smart unit testing, static analysis, and isolated‑function detection, and explains how these practices improve software robustness and defect‑recall efficiency.
This article introduces code‑level quality technology, outlining its background, a two‑layer architecture for code comprehension and instrumentation, key techniques such as static and dynamic analysis, coverage metrics, intelligent unit testing, rule‑based scanning, and orphan function detection, while previewing deeper future explorations.
This article explains why unit testing is essential for Go development, compares the legacy 2.0 approach with the new 3.0 plugin, details the plugin architecture, execution flow, code snippets, and shows real-world adoption results with clear HTML reports.
This article explores how to effectively use unit testing in daily development, defining its purpose, debunking common misconceptions, presenting the AIR principles, offering coverage level guidelines, and sharing practical tips, code examples, and solutions for handling mocks, static classes, and integration challenges.
This article explains the distinction between code coverage and test coverage, outlines testing strategies across functional, code, and architectural layers, offers practical steps and visualisation techniques, and highlights how AI can enhance both kinds of coverage in modern software testing.
Selecting an appropriate code coverage tool is crucial for ensuring software safety and reliability, and this article outlines ten key criteria—including compiler independence, ease of use, report clarity, support for safety-critical standards, integration flexibility, low overhead, language support, creative coding handling, security suitability, and licensing and support evaluation.
This article introduces Go's native testing ecosystem—including unit testing, benchmark performance measurement, code‑coverage analysis, fuzz testing, and race‑condition detection—through a practical bookkeeping‑app example, demonstrating how each tool can uncover bugs, improve performance, and raise overall code quality.
This article explains why unit tests should focus on verifying behavior rather than merely increasing coverage, outlines essential testing principles such as AIR, FIRST, and ASCII, provides concrete Java examples for writing, validating, and asserting tests, and offers detailed guidance on handling exceptions and method‑call verification to avoid ineffective testing.
This article describes a four‑step approach to precise frontend testing that uses static analysis of routing and import dependencies to identify impacted pages and functions, automatically selects corresponding test cases, runs them, and compares incremental coverage to ensure code changes are fully verified.
Precise testing technology uses static code scanning and dynamic tracing to build a Neo4j call‑graph, automatically recommends test scopes and cases via diff analysis and weighted relationships—including call‑count, module, text similarity, and GCN—thereby improving test adequacy, cutting regression cycles, and dramatically reducing test execution time.
The article details a large‑scale C++ team's unit‑testing workflow, explaining why tests matter, how they set up cross‑platform macOS/Linux environments, adopt Google gtest/gmock with a custom Frida‑based mock, enforce coverage via gcov/lcov, compute incremental coverage, integrate Valgrind, follow deterministic test design principles, avoid common pitfalls, and embed the stable pipeline into CI gates and notifications.
The article explains the purpose of software metrics, warns against measuring individual performance and isolated indicators, and outlines key agile testing metrics such as code coverage, acceptance test pass rate, defect density per story point, and automation rate to help teams track progress toward quality goals.
After a year of cross‑BU experimentation, the Tianji precision testing platform was built to centralize coverage data, automate incremental analysis, and provide actionable insights, resulting in higher test coverage, faster release gating, and measurable productivity gains for both developers and QA teams.
By using Chrome DevTools and Istanbul/NYC to measure JavaScript coverage, developers can detect dead and low‑usage code, then convert such modules into dynamic imports via build plugins, enabling tree‑shaking and code‑splitting that reduces bundle size and speeds up first‑screen rendering.
Unit testing in Java projects, essential for catching over 90% of bugs early, follows the AIR (Automatic, Independent, Repeatable) and BCDE (Boundary, Correct, Design, Error) principles, uses Mockito’s Mock‑Do‑Verify pattern, automated IDE generation, JaCoCo coverage metrics, CI pipelines, achieving 85‑+% coverage, zero production incidents, and guides future TDD adoption.
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 article describes how to set up a low‑maintenance, automated unit‑test and integration‑test environment for Go applications using a Java service in a pre‑integration platform, covering Docker packaging, Go tool installation, coverage plugins, diff‑cover for incremental coverage, and REST APIs for task management.
DeWu’s international e‑commerce team adopts shift‑left, business‑driven testing and a Java‑SpringBoot‑JUnit5 automation framework with continuous coverage analysis, moving tests earlier in the lifecycle to deliver rapid feedback, cut manual effort, and ensure high‑quality, efficient releases aligned with business value.
This article explains how the Finder system combines multi‑language code‑coverage collection, differential analysis, and call‑graph tracing to provide fine‑grained testing metrics, automate test‑case identification, and support continuous quality assurance across complex backend and frontend projects.
The article explains why unit tests are essential for software quality, identifies five typical pitfalls—testing per function instead of per feature, chasing code‑coverage metrics, over‑reliance on mocks, writing tests that never fail, and handling nondeterministic behavior—and provides practical recommendations to overcome each issue.
The article introduces a real-time code coloring system for Lua-based game development, explaining its purpose, usage scenarios, core functionalities, data collection methods, architectural design, technical challenges, performance optimizations, and network communication using Django Channels.
The Marko integrated code‑coverage platform, presented by vivo’s front‑end team, offers a zero‑intrusion, one‑click solution that collects and merges multi‑language coverage data during integration testing, visualizes incremental reports and diffs through a three‑layer architecture, supports Git and OAuth, provides real‑time dashboards and alerts, and is slated for broader language support and open‑source release.
This article explains why and how to use code diff and code‑coverage metrics, provides concrete examples of debugging and test‑case design, and shares step‑by‑step instructions for using IDEA and remote debugging to ensure business quality throughout the development lifecycle.
The 2021 Vivo Developer Conference showcased how the company’s engineering teams built high‑performance push services, a self‑developed storage platform, a full‑link 3D display system, a front‑end code‑coverage tool, a traffic replay solution, and a customizable live‑streaming SDK to support hundreds of millions of users.
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.
This article explains the distinct concepts of code coverage and test coverage, outlines their respective measurement methods, compares their advantages and disadvantages, and provides guidance on selecting appropriate tools and practices for effective software quality assurance.
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 examines the shortcomings of traditional regression testing, introduces a precise testing framework that combines black‑box and white‑box techniques, outlines its core principles, evolution steps, and measurement methods, and shares practical outcomes and future directions for server‑side quality assurance.
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 explains five typical pitfalls that make unit tests ineffective—testing per function instead of behavior, chasing code‑coverage, over‑reliance on mocks, writing tests that never fail, and allowing nondeterminism—while offering practical guidance on how to avoid each issue.
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 why unit testing is essential for reducing code complexity, outlines common testing models, provides language‑specific best practices for Java, C++, and Python, and describes how to measure test coverage and effectiveness across large‑scale projects.
This article explains the concepts, benefits, and practical steps for implementing unit tests and generating code‑coverage reports in iOS projects using Xcode, XcodeCoverage, OCMock, and CI tools such as Bamboo and iBiu, while also covering common pitfalls and best practices.
The article outlines Google’s best‑practice guidelines for code coverage, emphasizing its workflow benefits, the cultural impact of increasing coverage, the limits of high percentages, the importance of uncovering uncovered code, and practical steps for progressively improving coverage across projects.
This article explains how to measure code coverage for C/C++ projects using GCC's built‑in Gcov tool and the LCOV utility, covering prerequisite setup, compilation with profiling flags, running tests, generating .gcno/.gcda files, producing .gcov reports, creating HTML visualizations, and cautions against over‑relying on coverage percentages.
This article demonstrates how to create unit tests for .NET Core methods using xUnit, measure code coverage with Coverlet, generate readable reports with ReportGenerator, and automate testing and coverage analysis in Azure DevOps pipelines, while also showing how to display project badges.
This article details iQIYI's precise testing framework, explaining why traditional regression testing falls short, how a custom code‑coverage tool and knowledge‑base enable fine‑grained test‑case selection across client, server and micro‑service layers, and the measurable impact on test speed and reliability.
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 explains how to determine the right amount of testing for a software product by providing evaluation criteria, a step‑by‑step testing strategy—including recording processes, unit, integration and end‑to‑end tests—coverage types, tools, and how to incorporate field feedback for continuous improvement.
This article describes how the PC teacher desktop client adopts a layered MVL architecture, introduces unit testing with GoogleTest and GoogleMock, explains the underlying TEST and RUN_ALL_TESTS macro mechanisms, demonstrates mock view implementation, and shows how code coverage is measured to achieve targeted test coverage levels.
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 details the design and implementation of a Flutter code coverage tool that instruments Dart's intermediate Dill files using AspectD, covering its background, instrumentation principles, code snippets, data collection, analysis, reporting, and observed improvements in testing efficiency.
This article explains how Go's built‑in testing tool gathers code coverage, detailing the relevant go test flags, configuration steps for unit and integration testing, instrumentation mechanics, output formats, and practical solutions used in real‑world projects.
This article explains the fundamental concept of code coverage, its basic classifications, the various metrics such as function, line, branch, and condition coverage, factors that affect coverage, its significance for software quality, and practical ways to measure and improve it.
This article introduces JD's code coverage statistics platform, detailing its concepts, significance, implementation approaches for Android and iOS—including Jacoco and Xcode configurations—its SDKs, data collection, reporting mechanisms, and how it enhances testing quality and development efficiency.
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.
The article details Youku’s effort to build a test‑effectiveness evaluation system for its client by prioritizing data‑driven code‑coverage metrics, comparing JaCoCo with an internal tool, outlining the native class‑loading architecture, Python‑based analysis pipeline, achieved coverage insights, and plans to expand automation and visualization across modules.
This article explains the importance of unit testing for reliable software, introduces Go's built‑in testing framework, demonstrates how to write test files, use TestMain, benchmark code, and employ the httptest package for HTTP server testing, all illustrated with complete code examples.
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.
The article outlines why code coverage is valuable for developers, warns against chasing high percentages without quality, emphasizes risk‑based assessment of uncovered code, and provides practical guidelines for incrementally improving coverage, integrating it into reviews, and setting sensible thresholds.
This article explains how to use LLVM and SanitizerCoverage to insert BasicBlock‑level instrumentation into iOS binaries such as the WeChat SDK, covering the theory of code‑coverage metrics, compilation steps, bitcode extraction, and a practical demo that visualizes runtime execution paths.
Traditional testing suffers from low efficiency, unclear scope, and unquantifiable quality standards, especially in fast‑paced agile and microservice architectures; the article introduces a Precise Testing system that leverages bidirectional traceability, intelligent test case selection, incremental coverage analysis, and recommendation algorithms to make testing more accurate, automated, and data‑driven.
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 article describes the purpose, design choices, instrumentation technique, data collection, reporting, merging strategies, platform features, and future plans of a custom code‑coverage system built for the Android and iOS versions of the Zhuanzhuan app, highlighting challenges such as accurate instrumentation, performance impact, and multi‑tag data aggregation.
This article describes the design and implementation of a precise traffic filtering system integrated with Ctrip's automated comparison platform, detailing manual and automatic filtering modules, Jaccard‑based similarity calculations, smart test case recommendation, and the resulting improvements in coverage, stability, and efficiency.
This article explains how to measure Python code coverage using the Coverage tool, covering installation, command‑line and API usage, and provides a complete example with a simple function, unit tests, and generated HTML reports to visualize covered and missed statements.
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.
FlutterCodeX introduces a non‑intrusive, cross‑platform runtime code‑coverage SDK that instruments iOS, Android and Flutter apps—using meta‑class flags, Gradle‑injected static blocks, and the Dart AOP framework AspectD—to automatically record class‑initialization events, upload compressed data to Alibaba Cloud, and provide precise online coverage metrics for dead‑code removal and package‑size reduction in Xianyu.
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 article explains how to instrument legacy Node.js back‑end projects with IstanbulJS, collect coverage data via memory sharing or file storage, and generate detailed reports, providing a practical solution for assessing system functionality without writing new unit tests.
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.
White-box testing examines a program’s internal structure, code, and logic by creating and executing test cases that cover all paths, conditions, and statements, enhancing security, reliability, and code quality, while outlining its steps, techniques, examples, advantages, and drawbacks.
The article details Youzan Retail’s precise iOS testing platform, which instruments Objective‑C code via GCC/LLVM to generate .gcno/.gcda files, processes them with LCOV, and provides both full and git‑diff‑based incremental coverage visualizations across CI, data collection, parsing, and reporting layers to improve manual and automated test quality.
CocoaPods 1.9 introduces XCFramework support, configuration‑based podspec dependencies, test‑spec code coverage, Swift version variant handling, and a static‑linkage option for use_frameworks!, providing iOS developers with enhanced dependency management and build flexibility.
On December 7, Youzan’s Mobile Technology Salon gathered over 100 participants and six speakers to showcase the company’s quality‑and‑efficiency initiatives, including a mobile basic guarantee system and code‑coverage‑driven testing practices, with session videos released, full PPTs available, and a follow‑up PaaS meetup announced for December 21.
This article examines Etsy's engineering culture and operational practices, covering diversity and inclusion, the "Code as Craft" philosophy, blameless postmortems, the engineering rotation program, and the measurement of code coverage as a quality‑driving metric, illustrating how these initiatives foster continuous improvement and resilience.
This article provides a step‑by‑step tutorial on performing C++ code‑coverage testing using gcov, covering compilation flags, running the instrumented program, generating gcov reports, and creating detailed HTML reports with lcov, including command examples and configuration details.
To meet strict quality goals for iOS projects, the article describes adopting intermediate‑file code‑coverage instrumentation, generating gcno/gcda files, using lcov for full and incremental analysis, and integrating the process into builds and CI to enforce coverage thresholds and guide test‑case design.
This article explains gcov, the GCC‑bundled C/C++ code coverage tool, covering its basic concepts, the workflow for generating coverage data, and the instrumentation technique using basic blocks and arcs to record execution counts.
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 examines why test coverage matters, how Google and Facebook approach automated testing, the cultural emphasis on code ownership, and the practical limits of achieving 100% coverage in large-scale software projects.