Open Source Code Coverage Tools
Sort By:
Code Coverage Tools
View 64 business solutionsBrowse free open source Code Coverage tools and projects below. Use the toggles on the left to filter open source Code Coverage tools by OS, license, language, programming language, and project status.
-
Our Free Plans just got better! | Auth0You asked, we delivered! Auth0 is excited to expand our Free and Paid plans to include more options so you can focus on building, deploying, and scaling applications without having to worry about your security. Auth0 now, thank yourself later.
-
MongoDB Atlas runs apps anywhereMongoDB Atlas gives you the freedom to build and run modern applications anywhere—across AWS, Azure, and Google Cloud. With global availability in over 115 regions, Atlas lets you deploy close to your users, meet compliance needs, and scale with confidence across any geography.
-
1
Steel Bank Common Lisp
Common Lisp compiler and runtime
A high performance Common Lisp compiler. In addition to standard ANSI Common Lisp, it provides an interactive environment including an a debugger, a statistical profiler, a code coverage tool, and many other extensions. -
2
Solana
Web-scale blockchain for fast, secure, scalable, decentralized apps
Solana is the fastest blockchain in the world and the fastest-growing ecosystem in crypto, with thousands of projects spanning DeFi, NFTs, Web3 and more. Integrate once and never worry about scaling again. Solana ensures composability between ecosystem projects by maintaining a single global state as the network scales. Never deal with fragmented Layer 2 systems or sharded chains. Solana's scalability ensures transactions remain less than $0.01 for both developers and users. Solana is all about speed, with 400 millisecond block times. And as hardware gets faster, so does the network. Not only is Solana ultra-fast and low cost, but it is also censorship-resistant. This means the network will remain open for applications to run freely and transactions will never be stopped. Help secure the network by running decentralized infrastructure. Learn about operating a validator node. See the get started guide, videos, tutorials, SDKs, reference implementations, and more. -
3
NetworkX
Network analysis in Python
NetworkX is a Python package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks. Data structures for graphs, digraphs, and multigraphs. Many standard graph algorithms. Network structure and analysis measures. Generators for classic graphs, random graphs, and synthetic networks. Nodes can be "anything" (e.g., text, images, XML records). Edges can hold arbitrary data (e.g., weights, time-series). Open source 3-clause BSD license. Well tested with over 90% code coverage. Additional benefits from Python include fast prototyping, easy to teach, and multi-platform. Find the shortest path between two nodes in an undirected graph. Python’s None object is not allowed to be used as a node. It determines whether optional function arguments have been assigned in many functions. And it can be used as a sentinel object meaning “not a node”. -
4
SBCL
Mirror of Steel Bank Common Lisp (SBCL)'s repository
Steel Bank Common Lisp (SBCL) is a high-performance Common Lisp compiler. It is open-source/free software, with a permissive license. In addition to the compiler and runtime system for ANSI Common Lisp, it provides an interactive environment including a debugger, a statistical profiler, a code coverage tool, and many other extensions. SBCL runs on Linux, various BSDs, macOS, Solaris, and Windows. See the download page for supported platforms, and the getting started guide for additional help. SBCL is available in source and binary form for a number of different architectures. SBCL is available in binary form for many architectures. To obtain the latest binary release for your system, visit the platform support page and click on the green square which indicates your platform. You can install SBCL to a different directory prefix by setting the INSTALL_ROOT environment variable before running the installation script. -
Powering the best of the internet | FastlyEnsure your websites, applications and services can effortlessly handle the demands of your users with Fastly. Fastly’s portfolio is designed to be highly performant, personalized and secure while seamlessly scaling to support your growth.
-
5
OpenCover
Code coverage tool for .NET 2 and above
OpenCover is a free and open source code coverage tool for .NET 2 and above (Windows OSs only - no MONO), with support for 32 and 64 processes and covers both branch and sequence points. It uses the profiler API that is currently only available to .NET Frameworks running on the Windows platform. OpenCover is an attempt at building a code coverage utility that addresses certain issues in maintaining PartCover support for 64-bit processes. -
6
-
7
Boilerplate and Starter for Next JS 12+
Boilerplate and Starter for Next.js 12+, Tailwind CSS 3 and TypeScript
Boilerplate and Starter for Next JS 12+, Tailwind CSS 3 and TypeScript. Boilerplate and Starter for Next.js, Tailwind CSS and TypeScript. Made with developer experience first: Next.js, TypeScript, ESLint, Prettier, Husky, Lint-Staged, Jest, Testing Library, Commitlint, VSCode, Netlify, PostCSS, Tailwind CSS. If you are VSCode users, you can have a better integration with VSCode by installing the suggested extension in .vscode/extension.json. The starter code comes up with Settings for a seamless integration with VSCode. The Debug configuration is also provided for frontend and backend debugging experience. With the plugins installed on your VSCode, ESLint and Prettier can automatically fix the code and show you the errors. Same goes for testing, you can install VSCode Jest extension to automatically run your tests and it also show the code coverage in context. -
8
Jacoco Android Gradle Plugin
Gradle plugin that creates JaCoCo test reports for Android unit tests
A Gradle plugin that auto-creates and configures JaCoCo code coverage tasks for each Android app/module variant, saving you from manual setup across build types and flavors. -
9
EMMA is a fast Java code coverage tool based on bytecode instrumentation. It differs from the existing tools by enabling coverage profiling on large scale enterprise software projects with simultaneous emphasis on fast individual development.
-
No-Nonsense Code-to-Cloud Security for Devs | AikidoAikido provides a unified security platform for developers, combining 12 powerful scans like SAST, DAST, and CSPM. AI-driven AutoFix and AutoTriage streamline vulnerability management, while runtime protection blocks attacks.
-
10
CFONTS
Sexy fonts for the console
This is a silly little command line tool for sexy ANSI fonts in the console. Give your cli some love. cfonts detects what colors are supported on your platform. It sets a level of support automatically. In cfonts you can override this by passing in the FORCE_COLOR environment variable. All settings are optional and shown here with their default. You can use cfonts in your project without the direct output to the console. The package comes with a bunch of unit tests that aim to cover 100% of the code base. For more details about the code coverage check out coveralls. -
11
CSCore
An advanced audio library, written in C#. Provides tons of features
An advanced audio library, written in C#. Provides tons of features. From playing/recording audio to decoding/encoding audio streams/files to processing audio data in real-time (e.g. applying custom effects during playback, creating visualizations). The possibilities are nearly unlimited. CSCore is a free .NET audio library which is completely written in C#. Although it is still a rather young project, it offers tons of features like playing or capturing audio, en- or decoding many different codecs, effects and much more! CSCore is based on a very extensible architecture that allows you to make it fit to your needs without any major effort. You can build music players, voice chats, audio recorders and so on! Supported platforms, Windows only, Linux and mac experimental. Optimized performance though the usage of CLI instructions provided by a custom post compiler. -
12
Code Quality and Security for C#
Code analyzer for C# and VB.NET projects
Sonar offers a single cohesive solution with a consistent set of metrics and hundreds of static analysis rules to detect your coding issues early. Plus fast and high-precision analysis means high value, low noise, and reliable results always. A single solution for dozens of popular languages, development frameworks and IaC platforms. Our powerful language-specific analysis not only detects coding issues but also helps you understand what's wrong and how to fix it. Our publicly available ruleset includes thousands of rules covering various issue categories and language standards. Open the rule in SonarQube / SonarCloud, scroll down and (in case the rule has parameters), you can configure the parameters for each Quality Profile the rule is part of. Standalone NuGet packages can be configured the same way as SonarLint in connected mode. -
13
Coverlet
Cross platform code coverage for .NET
Coverlet is a cross-platform code coverage framework for .NET, with support for line, branch and method coverage. It works with .NET Framework on Windows and .NET Core on all supported platforms. Coverlet documentation reflect the current repository state of the features, not the released ones. Check the changelog to understand if the documented feature you want to use has been officially released. Coverlet is integrated into the Visual Studio Test Platform as a data collector. Coverlet also integrates with the build system to run code coverage after tests. Enabling code coverage is as simple as setting the CollectCoverage property to true. The coverlet tool is invoked by specifying the path to the assembly that contains the unit tests. You also need to specify the test runner and the arguments to pass to the test runner using the --target and --targetargs options respectively. -
14
Modern C++ Template
A template for modern C++ projects using CMake, Clang-Format
A quick C++ template for modern CMake projects aimed to be an easy-to-use starting point. This is my personal take on such a type of template, thus I might not use the best practices or you might disagree with how I do things. Any and all feedback is greatly appreciated! Modern CMake configuration and project, which, to the best of my knowledge, uses the best practices. An example of a Clang-Format config, inspired from the base Google model, with minor tweaks. This is aimed only as a starting point, as coding style is a subjective matter, everyone is free to either delete it (for the LLVM default) or supply their own alternative. Static analyzers integration, with Clang-Tidy and Cppcheck, the former being the default option. Doxygen support, through the ENABLE_DOXYGEN option, which you can enable if you wish to use it. Unit testing support, through GoogleTest (with an option to enable GoogleMock) or Catch2. Code coverage, enabled by using the ENABLE_CODE_COVERAGE op. -
15
asap
A modern cmake starter project for C++ with a complete build lifecycle
A modern cmake starter project for C++ with a complete build lifecycle, testing, dependency management, etc. Portable across Linux, OS X and Windows. Have you ever found yourself spending countless hours trying to figure out how to start a professional C++ project with unit tests, a robust dev workflow, change logs, code coverage, linting, formatting...? The C++ ecosystem is getting better but is still very far away from other ecosystems such as JavaScript, or even Rust. It's certainly easy to use CMake, a compiler and vscode to start a hello world project, but as soon as you start having multiple modules, with third party dependencies, testing, coverage, and other development things that a professional quality project needs, you start wasting hours and hours troubleshooting and configuring until you make it work. This starter project solves most of your problems, using the best practices for C++ development and modern CMake and allows you to get started in minutes rather than days. -
16
PHP - Net_RouterOS
A client for the MikroTik RouterOS API protocol, written in PHP.
A client for the MikroTik RouterOS API protocol, written in PHP. Easy, tested and documented. All feedback welcomed. -
17
Essential React
A minimal skeleton for building testable React apps using Babel
A minimal skeleton for building testable React apps using Babel. The design goals are to use fewer tools (no yeoman, gulp, bower, etc...) Babel 6 with Webpack and Hot Loader. Fast testing with mocked-out DOM. Import CSS files as class names. Separate smart and dumb components. No specific implementation of Flux or data fetching patterns. A core philosophy of this skeleton app is to keep the tooling to a minimum. For this reason, you can find all the commands in the scripts section of package.json. This leverages React Hot Loader to automatically start a local dev server and refresh file changes on the fly without reloading the page. It also automatically includes source maps, allowing you to browse code and set breakpoints on the original ES6 code. Build minified app for production using the production shortcut. -
18
Intern
A next-generation code testing stack for JavaScript
Intern is a complete test system for JavaScript designed to help you write and run consistent, high-quality test cases for your JavaScript libraries and applications. It can be used to test any JavaScript code. Intern is minimally prescriptive and enforces only a basic set of best practices designed to ensure your tests stay maintainable over time. Its extensible architecture allows you to write custom test interfaces, executors, and reporters to influence how your tests run & easily integrate with your existing coding environment. Intern also comes with Grunt tasks so it can be quickly added to existing Grunt-based workflows, and is designed to work out-of-the-box with popular continuous integration services like Jenkins and Travis CI. Intern can run unit tests in most browsers that support ECMAScript 5, including mobile browsers on Android and iOS, and in Node 6+. Note that Internet Explorer 9 is not supported. -
19
Jest
Delightful JavaScript Testing
Jest is a delightful, comprehensive JavaScript testing framework that works right out of the box for most JavaScript projects. It works on projects that use Babel, TypeScript, Angular, React, Node and so much more! It works fast and simple, capturing snapshots either alongside your tests or embedded inline to make testing and tracking changes over time a whole lot easier. Jest is designed to ensure the correctness of any JavaScript codebase. It has a great API, is well maintained and well documented, and can be extended to meet your exact requirements. Simply put, Jest just makes testing delightful! -
20
Keploy
Testing for Developers. Toolkit that creates test-cases and data mocks
Keploy is a functional testing toolkit for developers. It generates E2E tests for APIs (KTests) along with mocks or stubs(KMocks) by recording real API calls. KTests can be imported as mocks for consumers and vice-versa. Merge KTests with unit testing libraries(like Go-Test, JUnit..) to track combined test coverage. KMocks can also be referenced in existing tests or use anywhere (including any testing framework). KMocks can also be used as tests for the server. Keploy is added as a middleware to your application that captures and replays all network interaction served to the application from any source. Keploy has native interoperability as it integrates with popular testing libraries like go-test, junit. Code coverage will be reported with existing plus KTests. It'll also be integrated in CI pipelines/infrastructure automatically if you already have go-test, junit integrated. -
21
Setup PHP in GitHub Actions
GitHub action to set up PHP with extensions, php.ini configuration
GitHub action to set up PHP with extensions, php.ini configuration, coverage drivers, and various tools. Setup PHP with required extensions, php.ini configuration, code-coverage support and various tools like composer in GitHub Actions. This action gives you a cross-platform interface to set up the PHP environment you need to test your application. Refer to Usage section and examples to see how to use this. Refer to the self-hosted setup to use the action on self-hosted runners. Operating systems based on the above Ubuntu and Debian versions are also supported on best effort basis. If the requested PHP version is pre-installed, setup-PHP switches to it, otherwise it installs the PHP version. Specific versions of extensions available on PECL can be set up by suffixing the extension's name with the version. This is useful for installing old versions of extensions that support end-of-life PHP versions. -
22
EclEmma is a free Java code coverage tool for Eclipse, available under the Eclipse Public License. It brings code coverage analysis directly into the Eclipse workbench. The EclEmma project is also the home of the JaCoCo code coverage library which is the technical back-end for EclEmma and also has integrations with many other build and software quality tools.
-
23
Covered is a Verilog code coverage utility using VCD/LXT/FST dumpfiles (or VPI interface) and the design to generate line, toggle, memory, combinational logic, FSM state/arc and assertion coverage report metrics viewable via GUI or ASCII format. This project is ported to github and can be found at: https://github.com/chiphackers/covered
-
24
JSCover
JSCover - JavaScript code coverage
JSCover is a tool that measures code coverage for JavaScript programs. It is an enhanced Java implementation of the excellent JSCoverage tool. -
25
PHPCoverage is an open-source tool for measuring and reporting code coverage provided by the test suite of a PHP application. PHPCoverage can instrument and record the line coverage information for any PHP script at runtime.
Open Source Code Coverage Tools Guide
Open source code coverage tools are programs designed to measure and analyze the amount of code that has been tested by a given test suite, in order to determine how much of the application is actually being covered by tests. This type of tool is often used in software development projects to gain an understanding of which parts of the code are most often covered by tests, and which sections remain untested. By analyzing these results, developers can quickly identify areas that need additional testing or debugging.
The two main types of open source code coverage tools available today are command-line based and graphical user interfaces for use with an integrated development environment (IDE). Command-line based tools such as gcov or lcov are typically used on Linux/Unix systems, while IDE-based solutions such as Cobertura and JaCoCo exist for Java applications.
Both types of tools provide information about what percentage of lines have been tested (or "covered") by tests and where any uncovered sections may be located. Code coverage reports can also be generated in various visuals formats ranging from plain text documents to complex web pages containing interactive graphs. Additionally, many open source code coverage tools allow developers to define their own custom metrics either through plugins or built-in functions, allowing them greater insight into the test process itself.
Overall, using open source code coverage tools provides developers with invaluable feedback regarding their software project's progress and helps ensure high quality assurance standards are met before deployment. By providing detailed information about exactly which sections were covered during testing as well as identifying areas that still need additional attention, developers can ensure they have completed all necessary stages during their development process prior to release.
Open Source Code Coverage Tools Features
- Analysis of Code Coverage: Open source code coverage tools allow developers to measure the amount of their code that is being tested and how much is remaining untested. It can also provide metrics on the quality, effectiveness and reliability of tests, as well as identify areas where further development or testing is needed.
- Source-code Instrumentation: This feature allows for a detailed analysis of code execution so that developers can observe which paths are taken in order to complete a set task. Furthermore, developers can use this feature to pinpoint specific lines that are successful or failed, in order to analyze the causes and remedy any issues.
- Source Code Comparison: Open source code coverage tools provide developers with the ability to compare different versions of source code - for example, a pre-release version with the latest release. This allows accuracy in measuring how much of the source that is covered by testing and how much was added or removed over time.
- Test Reports Generation: Using this feature, developers can generate detailed reports on active test cases which provides information such as line coverage and branching coverage percentage. These reports serve to give an overall picture of where certain tests are succeeding and areas where improvements might be necessary.
- Automated Testing Support: Automated testing support provides a way to run tests repeatedly with minimal effort from developers - speeding up the workflow process significantly. It also can reduce chances of errors occurring as human interaction is greatly minimized throughout the development cycle.
Different Types of Open Source Code Coverage Tools
- Line coverage: This type of tool looks at how many lines of code have been executed and determines what percent of the total lines were covered.
- Function coverage: This type of tool looks at each function (or method) in the code, determining which ones have been exercised and which ones haven’t. It then correlates that with the percentage of functions that were exercised.
- Branch coverage: This type of tool looks at how conditions within source code are being evaluated, determining which branches are taken when program execution reaches a given part in the source code.
- Statement coverage: This type of tool records if a statement was partially or completely run, allowing for detailed analysis into the most-used parts in a program.
- Path coverage: Also known as all-uses testing, this type of open source code coverage tool evaluates whether every possible path has been tested – e.g., does the program take different paths for inputs ‘A’ and ‘B’? Does it always perform correctly along those paths?
- Mutation testing: Using mutations to deliberately make changes to working sources codes allows developers to find out if their tests can detect any problems within them. These kinds of open source tools can help point out weak test suites and provide feedback on any errors made during coding processes.
- Performance testing/Profiling tools: Open source performance testing tools record various metrics like execution time or memory usage when programs are running – helping developers pinpoint any bottlenecks or other issues that may need solving before releasing programs into production environments. Additionally, these types of open source tools often come equipped with profiling features that allow for deeper understanding into where time is spent inside applications under development.
Advantages of Open Source Code Coverage Tools
- Cost Effective: Open source code coverage tools are generally free, which means organizations can utilize them without having to make financial investments upfront. This ensures that resources remain available for other development activities, such as bug fixing and feature enhancements.
- Community Support: Using an open source code coverage tool allows developers to benefit from the knowledge and resources of a wide community, who have already tested the tool and provided feedback on its capabilities. As a result, developers can quickly access assistance with coding issues, making it easier to implement their own projects.
- Flexibility: Since open source code coverage tools are typically highly customizable, organizations can tailor the tool’s features in order to best meet their needs. This flexibility makes it possible to seamlessly integrate the tool into existing coding workflows while tackling specific programming tasks or creating new applications.
- Long-Term Compatibility: Generally speaking, open source products are designed with long-term compatibility in mind since they must be compatible with future versions of operating systems and hardware platforms in order to remain viable over time. By taking advantage of this approach early on, businesses can ensure greater continuity for their programs going forward.
- Security Benefits: Open source code coverage tools often come with built-in security measures which help protect sensitive data from unauthorized access or exploitation by malicious actors. Moreover, these safeguards also reduce the chances of vulnerabilities being introduced due to coding errors or deliberate malicious intent.
Who Uses Open Source Code Coverage Tools?
- Software developers: Use open source code coverage tools to track and measure their code execution, ensuring it is reliable and performs as expected.
- Quality Assurance (QA) professionals: Leverage open source code coverage tools to identify issues in the codebase before they cause problems with the user experience.
- Technical Writers: Utilize code coverage data to create detailed technical documentation that explains how a program works in clear terms.
- System Administrators: Rely on open source code coverage results to identify any areas of the system that could be improved for better performance and stability.
- Academic Researchers: Take advantage of these tools to analyze software systems from both theoretical and empirical perspectives.
- Security Specialists: Make use of open source code coverage data to strengthen security by pinpointing where additional protection may be needed.
- Business Analysts: Use open source code coverage information to inform decisions about product roadmaps, marketing efforts, or organizational changes.
How Much Do Open Source Code Coverage Tools Cost?
Open source code coverage tools are an incredibly cost-effective way to increase the quality and accuracy of your software development process. These tools are available to use at no charge, making them the perfect option for developers who want to ensure their code is running as expected without breaking the bank. With open source coverage tools, you can quickly analyze how much of your code is being tested and measure its effectiveness. You can also see which lines of code have been executed and identify any bugs or other issues in your program before releasing it publicly. Additionally, many of these tools come with features such as branch tracking, detailed reports, and customizable UI that make it easier to assess your application’s performance from a high level view. All of this makes open source coverage tools an invaluable resource for any developer looking for an affordable but powerful way to improve the quality of their end product.
What Software Can Integrate With Open Source Code Coverage Tools?
Software that is written in a language which best supports the open source code coverage tools can easily integrate with them. For example, Python, PHP and JavaScript are all languages which typically have extensive support for open source code coverage tools. Additionally, software applications and frameworks developed specifically for testing can easily be hooked up with these types of tools. One popular framework to use is the Selenium WebDriver toolkit, which allows users to create automated tests and execute them against an application or website. Through this integration process, developers can see how their code will fare under various conditions and ensure that it covers all of the expected scenarios that could arise when running a program or system in production.
What Are the Trends Relating to Open Source Code Coverage Tools?
- Increased Integration: Open source coverage tools have become more integrated with code editors and IDEs, allowing developers to more easily access such tools and view the results in their coding environment.
- Improved Quality: These tools have improved in terms of quality, providing developers with a more comprehensive view of their code coverage, including better reporting and more comprehensive metrics.
- Automation: More open source coverage tools are introducing automated testing capabilities, allowing developers to quickly and efficiently assess the test coverage of their codebase.
- Customization: Open source coverage tools can be customized to fit specific needs and requirements, making them more applicable for different projects.
- Cost-Effectiveness: Open source coverages tools are often much more cost-effective than proprietary solutions, making them an attractive option for smaller teams or projects.
- Platform Support: Open source coverage tools are becoming available on a wider range of platforms, giving developers the ability to use such tools no matter which operating system they are running.
How To Get Started With Open Source Code Coverage Tools
- Getting started with using open source code coverage tools is a relatively straightforward process. The first step is to identify and select the most suitable tool for your particular project needs.
- To do this, you can research existing open source frameworks and libraries available online, such as those hosted on GitHub or SourceForge. Reading user reviews and feedback from developers who have already used these tools can help you make an informed decision. For example, finding out which language the tool supports (e.g., Java, C#, etc.), whether there are any reported bugs or issues, as well as licensing information.
- Once you’ve chosen the right code coverage tool for your project requirements, you will need to download it onto your system along with any related dependencies or libraries that are necessary for proper setup and execution of the software. If a manual installation is required then ensure that all necessary steps are followed carefully in order to prevent any problems from occurring during use later down the line.
- The next step would be to examine the documentation supplied by the code coverage tool –paying particular attention to how it should be configured appropriately in accordance with your specific environment set-up–so that it can be successfully launched and tested against your application's codebase. Understanding what metrics and reports should be generated when running tests will also help immensely when looking at optimization opportunities within your project's overall development cycle.
- Finally once everything has been installed correctly users will want to integrate their chosen open source code coverage framework into their existing workflow so that they can reap maximum benefit from its usage going forward; which typically requires integrating its monitoring capabilities into other automated processes like continuous integration systems or build pipelines depending on the platform being utilized by your team.
