30 open-source projects similar to simplecov-ruby/simplecov, ranked by shared indexed features. Tags may describe platforms or build tools rather than the same primary purpose. Check each project’s use case, license, and deployment requirements before treating it as a replacement.
SimpleCov is a Ruby code coverage tool and analysis engine used to track which lines, branches, and methods of code execute during tests. It functions as a coverage threshold enforcer and test suite aggregator, recording execution data to identify untested areas of an application. The tool distinguishes itself through the ability to merge coverage results from parallel worker processes and subprocesses into a single unified report. It supports baseline comparison to detect coverage regressions and can gather data from code executed via dynamic evaluation methods, such as those used in templat
JaCoCo is a Java code coverage tool and bytecode instrumenter that measures which parts of source code are executed during tests. It functions as a runtime agent to monitor application execution on the fly or as a library for offline bytecode instrumentation, allowing it to capture execution data in environments where runtime agents are restricted. The project distinguishes itself by providing both dynamic and static instrumentation paths to track execution. It includes a runtime agent for on-the-fly monitoring and the ability to modify compiled class files before execution. It further enable
Istanbul is a JavaScript code coverage tool and instrumentation engine that measures the execution of statements, lines, functions, and branches. It functions as a test coverage analysis tool capable of monitoring code across unit, functional, and browser tests to identify untested areas of a codebase. The project distinguishes itself through a transparent instrumentation engine that uses module loader hooks to inject tracking code without requiring manual source modifications. It supports distributed test reporting by aggregating fragmented coverage data from multiple concurrent processes in
Ava is a test runner for JavaScript and TypeScript designed to execute test suites with a focus on concurrency and isolation. It serves as a concurrent test executor that runs test files in parallel across multiple processes to reduce total runtime and prevent state leakage between suites. The project features a built-in snapshot testing framework that saves large data structures to disk and compares subsequent executions to detect regressions via diffs. It is also compatible with the Test Anything Protocol, allowing it to export results for use with external reporting tools. Its capability
JSLint is a JavaScript code-quality tool that scans source text and reports errors, risky constructs, and style violations as warnings, each with a line and column position and a short explanation. It ships as a single plain JavaScript file that works as both a CommonJS and an ES module, and the same file also runs inside a web page. What sets it apart is how it is configured and used. Comment directives placed in the source turn individual checks on or off, declare the assumed runtime environment and global variables, restrict permitted property names, and skip chosen lines or regions of cod
ub-mode is a set of instruction files and command-line checks that steer AI coding agents toward disciplined engineering. The instructions are plain-text files loaded into each coding session, and they are paired with deterministic tools whose pass or fail results block work until numeric limits for complexity, duplication, and test thoroughness are met. The practices they encode include test-driven development, root-cause fixes, and small ordered commits. The quality checks are what set it apart. One tool combines each function's cyclomatic complexity with its test coverage into a single ris
ClusterFuzz is an automated platform that runs coverage-guided fuzzers at scale to find security and stability bugs in software. It orchestrates libFuzzer and AFL++ across distributed clusters of worker bots, collecting coverage feedback to guide input mutation and discover crashes. The platform provides a web-based dashboard for configuring fuzzing jobs, monitoring progress, and inspecting crash reports, with role-based access control to restrict sensitive features. The system automates the full fuzzing lifecycle, from build pipeline integration and corpus management to crash triage and bug
GoConvey is a behavioral testing framework for the Go programming language that provides a test runner, a code coverage tool, and a web-based monitoring dashboard. It integrates with the standard Go test command to organize tests into behavioral stories and conveyors. The project features a web interface that monitors the file system for source code changes and automatically triggers test execution to provide real-time feedback. This dashboard displays test results, failures, and a chronological history of execution status. The framework includes a state assertion system for verifying values
OSS-Fuzz is a distributed, containerized platform for continuous fuzzing and memory safety analysis. It functions as a bug hunting infrastructure that identifies security vulnerabilities and stability bugs through automated, coverage-guided fuzz testing across a scalable cluster of containers. The system provides a continuous security testing pipeline that manages the entire lifecycle of vulnerability discovery, from bootstrapping project templates and compiling targets to executing long-running batch tests. It specifically focuses on memory safety, utilizing sanitizers to detect buffer overf
The Cypress Real-World App is a payment application designed to demonstrate real-world Cypress testing patterns, workflows, and best practices. It serves as a demo application that validates Cypress testing methods through end-to-end tests on a realistic application, while also generating frontend and backend code coverage reports from test executions. The application showcases authentication and identity management through multiple approaches, including a built-in local authentication mechanism that does not rely on external providers, and integration with third-party providers such as Googl
This project is a language extension for VS Code that provides comprehensive Go language support. It functions as a language server client, a debugger interface, and a toolchain manager to facilitate Go application development. The extension distinguishes itself by integrating a full suite of toolchain management capabilities, allowing for the installation and configuration of required binaries, linters, and compiler versions directly within the editor. It also provides deep integration for interactive debugging via Delve, supporting remote target debugging, process attachment, and program st
Codeception is a full-stack testing framework for PHP applications that provides a unified interface for unit, functional, and acceptance testing. It serves as a tool for automating real desktop and mobile browsers via the WebDriver protocol and acts as a client for testing REST and SOAP APIs. The framework is distinguished by its support for Behavior-Driven Development, allowing users to write human-readable test specifications in Gherkin language to align technical tests with business requirements. It implements actor-based action mapping to connect these natural language steps to executabl
This repository provides a collection of reference implementations and patterns for testing Android applications. It serves as a guide for developers to integrate standard testing libraries and frameworks into their projects, covering the full spectrum of verification from local business logic to complex interface interactions. The project distinguishes itself by demonstrating how to configure and execute tests across diverse environments, including local virtual machines and physical devices or emulators. It provides specific patterns for validating inter-application communication, automatin
This project is a comprehensive front-end development guide and roadmap designed to help engineers master the skills and professional standards required for modern web development. It serves as a technical reference for mastering HTML, CSS, and JavaScript, providing structured learning paths and a map of the professional competencies needed to transition from a beginner to a professional web engineer. The resource functions as a categorized directory and ecosystem overview of the JavaScript landscape. It catalogs industry-standard frameworks, libraries, and utilities, offering specific recomm
This project is a pre-configured starter template and development environment for building web applications using TypeScript and React. It provides a project scaffold that automates the initial setup of build configurations and type safety. The environment includes a build pipeline for compiling and bundling React components, alongside a local development server featuring live reloading and integrated linting. It also provides a boilerplate for Progressive Web Apps, incorporating service worker support for offline asset caching. Broad capability areas cover frontend build automation, web app
This project is a refactoring kata collection and software design education resource. It provides a set of intentionally messy codebases and multi-language code samples designed for practicing incremental design, legacy code modernization, and software restructuring. The collection serves as a training material for test-driven development, focusing on the use of golden master testing suites and approval testing to ensure functional parity while evolving source code. It includes a universal learning baseline by implementing identical complex business rules across several different programming
danger-js is an automated code review tool and CI pipeline plugin that functions as a pull request linter. It verifies commit messages, tracks dependency changes, and ensures pull requests meet project standards by posting automated feedback and comments directly into the version control interface. The system integrates with various Git providers, including GitHub, GitLab, and BitBucket, to retrieve pull request metadata and execute custom review rules. It allows teams to package and distribute review conventions as shareable modules and supports the execution of rules written in transpiled l
QUnit is a JavaScript unit testing framework for client-side and server-side code. It combines an assertion library with a test runner that executes the same suites in major desktop and mobile browsers, web workers, sandboxed iframes, Node.js, and SpiderMonkey. A command-line runner can rerun tests when files change, use a seeded random order, and switch between reporters. Assertions cover strict and loose comparisons, numbers within a tolerance, partial object matching, thrown errors, and the order in which steps are executed. Tests that return promises or async functions are awaited automat
php-code-coverage is a PHP library and analysis tool designed to track runtime execution and determine which parts of a codebase are exercised by automated tests. It monitors executed lines and branches during a test run to identify gaps in test coverage and evaluate the effectiveness of a test suite. The tool functions as an execution tracker and report generator that transforms raw PHP execution data into human-readable formats. It serializes collected metrics for storage and utilizes a processing system to calculate the total percentage of code covered. Its capability surface covers the e
Majestic is a graphical user interface for executing and managing Jest test suites. It serves as a test runner GUI that allows for the execution of all tests or specific files, providing a visual environment for monitoring results in real time. The tool includes a code coverage visualizer to identify untested parts of a codebase by reviewing detailed coverage reports. It also provides a debugging interface for troubleshooting test failures through direct access to console output and error details, and a visual interface for managing and aligning test snapshots. Additional capabilities cover
This project serves as a comprehensive handbook and architectural guide for software engineering best practices. It provides a curated set of principles and technical guidelines focused on maintaining long-term code health, reducing complexity, and ensuring that software systems remain readable and manageable as they grow. The core philosophy centers on modularity and domain-driven design, encouraging developers to structure applications around specific business use cases rather than the constraints of external frameworks. By prioritizing interface-based contracts and dependency injection, th
lakeFS is a data lake versioning system that provides Git-like branching and commits for large datasets stored in object storage. It functions as a version control layer, enabling the creation of immutable snapshots, atomic commits, and zero-copy branching to create isolated environments for data experimentation without duplicating physical files. The system serves as an S3-compatible storage gateway and an Iceberg REST catalog, allowing standard cloud storage protocols and compatible clients to manage versioned tables. It acts as a data quality gatekeeper by using an event-driven hook system
This project provides a standardized development environment and infrastructure for creating, testing, and publishing JavaScript and TypeScript libraries. It serves as a comprehensive toolkit for managing the entire software lifecycle, from initial project scaffolding to the final distribution of production-ready code. The project distinguishes itself by integrating automated release pipelines and continuous integration workflows directly into the development process. It enforces strict quality standards through pre-configured hooks that handle linting, formatting, and commit message validati
Shuohao Skills is a collection of agent skills for Claude Code and Codex that guides an AI-assisted short-drama pipeline. Each skill handles one stage of the workflow: it takes a source novel through an adaptation outline, character and art bibles, a screenplay, and a storyboard, and ends with prompts and reference images ready for video generation. Work moves through ordered stages, each seeding the next with the names, cast tiers, and story beats already settled, and a quick skeleton draft needs the user's approval before episode writing begins. What sets it apart is that outputs are checke
Gatling is a load testing framework and traffic generation engine used to measure response times and error rates under heavy load. It functions as an as-code testing library, allowing users to define high-volume traffic simulations and performance tests through programming languages rather than graphical interfaces. The system enables multi-language load simulation and the ability to model concurrent user traffic to identify infrastructure bottlenecks and stability limits. It supports a test-as-code workflow, where version-controlled scripts are integrated into build pipelines as performance
Lighthouse CI is a continuous integration tool designed to automate web audits and detect performance, accessibility, and SEO regressions between code commits. It functions as a web performance regression suite that enforces resource budgets and runs automated quality checks during the software development lifecycle. The system distinguishes itself through the ability to block code merges if performance metrics fall below defined quality thresholds. It provides mechanisms for commit-to-commit comparison and cross-version site analysis to pinpoint specific resource improvements or regressions.
Allure is a test reporting framework that normalizes execution data from multiple test frameworks across different programming languages into a common intermediate format. It aggregates results from multiple sources into a shared directory of JSON files and generates self-contained HTML reports through a modular plugin pipeline. The architecture includes a hierarchical step tree model to represent test execution, metadata annotation injection to enrich results at runtime, and directory-watch incremental rendering that regenerates reports in real time as new data arrives. Unlike generic report
cmake-init is a project generator and build system boilerplate designed to automate the initialization of C++ projects. It provides a framework for creating standardized project layouts and build configurations through template-based generation and user-defined prompts. The project functions as a development workflow automator, integrating static analysis, code formatting, and documentation generation directly into the build pipeline. It includes a dependency management system for vendoring external libraries and managing transitive dependencies to ensure consistent package discovery for down
This project is a comprehensive software fuzzing knowledge base and technical guide designed for discovering software bugs and vulnerabilities. It serves as a resource for implementing coverage-guided, structure-aware, and hybrid fuzzing across various targets, including compiled binaries and hardware kernels. The resource provides specialized guidance on using grammars and defined data formats to generate syntactically valid inputs for complex APIs. It also details methods for combining grey-box fuzzing with symbolic execution to reach deep execution paths and utilizes binary instrumentation
This project is a curated collection of guidelines and technical resources designed to improve C++ code safety, maintainability, and performance. It provides a comprehensive set of coding standards and best practices for establishing consistent naming, formatting, and structural patterns across C++ codebases. The guide offers specific technical advice on performance optimization, including methods for minimizing object copying, optimizing memory allocation, and reducing compilation cycles. It also provides a directory of tooling recommendations for implementing static analysis, fuzz testing,