Low-overhead coverage analysis for critical software
Why choose RapiCover?
Product features
-
Structural coverage analysis Analyze the code coverage achieved by software tests up to and including the MC/DC level.Discover this feature
-
Advanced MC/DC analysis Advanced MC/DC analysis.Discover this feature
-
Highlight missing MC/DC vectors RapiCover highlights missing MC/DC vectors to help you refine test cases.Discover this feature
-
Collect coverage incrementally Collect coverage incrementally on resource-constrained targets.Discover this feature
-
Automatically merge coverage Merge coverage from different builds automatically, such as system and unit tests.Discover this feature
-
Automate testing on host and target Run tests on host computers and test rigs in continuous build environments.Discover this feature
-
Analyze code complexity Analyze the complexity of your source code.Discover this feature
-
Efficient integration workflow Configure integrations of RVS into your development environment quickly and easily.Discover this feature
-
RVS Project Manager Take your test project from creation to completion with an intuitive user-interface.Discover this feature
-
Shared integration with instrumentation-based RVS tools After integrating one RVS tool to work a development environment, it is trivial to use others.Discover this feature
-
Redact source code for confidentiality Verification can be performed while source code is redacted to support verification by third-party suppliers.Discover this feature
-
Portable test environments Multiple users can share the same test environment.Discover this feature
-
Easily configurable analysis Apply analysis settings easily using a friendly user interface.Discover this feature
-
Identify tests that hit each element Identify tests that "hit" each tested element in your source code.Discover this feature
-
Remove coverage from reports Remove selected coverage from reports to support continuous development.Discover this feature
-
Optimal Dataset Calculator Calculate and run the minimum set of tests to achieve identical coverage to a previous set of tests.Discover this feature
-
Customizable workflow Customize the RVS workflow to best meet your needs.Discover this feature
-
Template integrations Create and use template integrations to reduce your effort integrating RVS with your system.Discover this feature
-
Compare reports Compare reports from different builds to track project progress over time.Discover this feature
-
Merge Coverage utility Easily merge coverage from multiple test runs.Discover this feature
-
Customizable color scheme Customize the color scheme used to display your results.Discover this feature
-
Comprehensive verification toolsuite One tool to meet all your software verification needs.Discover this feature
-
Configurable export formats Export coverage results in a variety of formats.Discover this feature
-
Justify untestable code Mark code as covered by manual analysis to justify not covering it during tests.Discover this feature
-
Migrate justifications when code changes Justifications migrate; when code changes, automatically or after manual review.Discover this feature
-
Portable justification library A single store of justifications can be used by all users working on a project.Discover this feature
-
Multi-justifications Apply a single justification to multiple locations to reduce justification effort.Discover this feature
-
Justification templates Create and apply templates to add new justifications more easily.Discover this feature
-
Custom fields Apply and use custom fields for your justifications.Discover this feature
-
Treemaps View coverage and hierarchy of code at a glance.Discover this feature
-
Code viewer View code with syntax highlighting and color-coding of results.Discover this feature
-
Easily filter results Easily filter results to focus your analysis.Discover this feature
-
Visualize call dependencies Visualize the call dependencies in your code.Discover this feature
-
Datasets for managing tests Assign tests to datasets to support easy filtering of results.Discover this feature
-
Filter by datasets Apply test datasets, which you can use to filter results and calculate the optimal tests to run when code changes.Discover this feature
-
Filter by scopes Filter results by specific files and functions.Discover this feature
-
Advanced search function Search reports for specific elements using advanced queries.Discover this feature
-
Integrate with existing build systems Collect data from almost any build system.Discover this feature
-
Compiler wrappers The recommended build integration strategy requires little if any change to the development environment.Discover this feature
-
Clone integration Copy the build system to build and test code with RVS.Discover this feature
-
Flexible integration strategies Collect data from almost any embedded target with flexible collection strategies.Discover this feature
-
Multicore support Verify critical multicore systems.Discover this feature
-
Low target overheads Fit more tests on your target and reduce the number of builds you need to run.Discover this feature
-
Collect coverage across power cycles Stream coverage data to collect it across target power cycles.Discover this feature
-
Lauterbach debugger Collect verification data from Lauterbach debuggers.Discover this feature
-
iSYSTEM debugger Collect verification data from iSYSTEM debuggers.Discover this feature
-
Efficient MC/DC target library Test an almost unlimited number of conditions per decision and get more from the space on your target.Discover this feature
-
MATLAB® Simulink® RVS can enhance PIL and HIL testing in Simulink® model-based development workflowsDiscover this feature
-
Jenkins Run RVS automatically through Jenkins to collect and archive results.Discover this feature
-
Bamboo Run RVS automatically through Bamboo to collect and archive results.Discover this feature
-
Cobertura Display RapiCover results in Continuous Integration systems supporting Cobertura.Discover this feature
-
Deos Out-of-the-box integration with DDCI-I's Deos operating system.Discover this feature
-
Software Configuration Management Integration with Software Configuration Management tools ensures that files can be used across a team.Discover this feature
-
C Support for verification of code written in C.Discover this feature
-
C++ Support for verification of C++ code.Discover this feature
-
Ada Support for verification of code written in Ada.Discover this feature
-
Mixed language support Support for verification of code written in multiple languages.Discover this feature
-
Assembly Support for verification of Assembly code.Discover this feature
-
Compiler extension editor Manage extensions to support non-standard programming languages with an interactive editor.Discover this feature
-
Flexible licensing options Select floating or node-locked licenses with annual or perpetual duration.Discover this feature
-
Floating licenses Floating licenses support multiple users and shared working environments.Discover this feature
-
Node-locked licenses Node-locked licenses support the use of RVS on a single machine.Discover this feature
-
Perpetual licenses License RVS for use indefinitely.Discover this feature
-
Annual licenses License RVS in annual increments.Discover this feature
-
Easy to get started Integration and learning resources help you get started verifying your code in no time.Discover this feature
-
Support Dedicated support service to resolve technical issues quickly.Discover this feature
-
Tutorials Learn how to get the most from our verification solutions with simple, interactive tutorials.Discover this feature
-
Training Get up to speed with custom training courses delivered by expert engineers.Discover this feature
-
Documentation Learn how to use RVS features with comprehensive documentation in both printed and electronic formats.Discover this feature
-
Easily migrate to new versions Easily migrate to new RVS versions with guided migration help.Discover this feature
-
DO-178B/C qualification kit Qualification kits for RVS qualification in DO-178B/C projects.Discover this feature
-
DO-278A qualification kit Qualification kits for RVS qualification in DO-278A projects.Discover this feature
-
ISO 26262 qualification kit Qualification kits for RVS qualification in ISO 26262 projects.Discover this feature
-
Qualified Target Integration Service Additional evidence to qualify the use of RVS in your development environment.Discover this feature
-
Qualified instrumenters Qualified instrumentation that doesn't require manual review.Discover this feature
-
Assurance issue notification We notify you of issues that may affect the validity of your results as soon as we identify them.Discover this feature
Operating Systems
Type | Operating System |
---|---|
On-target deployment | RVS tools can be used to analyze software run on any host operating system or embedded target (as long as a communication channel is available). |
On-host tool | Windows 10 and 11 |
Windows Server 2019+ | |
Variety of Linux distributions (including Ubuntu and Red Hat) | |
For older operating systems, contact us. | |
RVS tools can be qualified for use on all supported platforms. |
Programming languages
Language |
---|
Ada |
C |
C++ |
Mixed languages |
Compilers
RVS is designed to be independent of the target compiler. We have already deployed with the compilers in the list below and can quickly add new compilers as required by our customers.
Vendor | Compiler |
---|---|
AdaCore | GNAT GPL |
GNAT Pro | |
Arm | DS-5 |
armcl | |
Borland | Borland C++ |
Cosmic Software | -- |
GNU | GCC |
G++ | |
Greenhills | Ada MULTI |
C Multi | |
IAR Systems | Embedded Workbench |
Keil | C51 |
Microsoft | Visual Studio |
NXP | CodeWarrior HCS12 |
TASKING | CC166 |
Texas Instruments | CL500 |
CL2000 | |
Wind River | Diab |
CCPPC |
RTOSs
RVS can be used on RTOSs used in the critical software industry. RVS has been used on RTOSs including the following:
RTOS |
---|
AUTOSAR Adaptive Platform |
AdaCore Ravenscar Profile |
Blackberry QNX |
DDC-I Deos |
ERIKA Enterprise |
ESOL eMCOS - AUTOSAR Classic Platform & AUTOSAR Adaptive Platform |
FreeRTOS |
Green Hills Integrity |
Kronosafe Asterios |
LynxOS |
LynxSecure |
MaRTE OS |
MICROSAR - AUTOSAR Classic Platform |
MicroC/OS |
RTXC Quadros |
RI850V4 - micro ITRON v4.0 OS |
RTEMS |
SafeRTOS |
SYSGO PikeOS |
Vector MICROSAR |
Wind River Helix & VxWorks |
CPUs
RVS tools can be used to analyze software run on any host operating system or embedded target (as long as a communication channel is available). The following is a non-exhaustive list of CPUs we have worked with.
Vendor | Platform |
---|---|
Arm | ARM7 |
ARM9 | |
ARM10 | |
ARM11 | |
Cortex-M | |
Cortex-R | |
Cortex-A | |
Analog Devices | Blackfin |
SHARC | |
SigmaDSP | |
TigerSHARC | |
ADSP-21xx | |
Atmel | AT90CAN128 |
Cobham Gaisler | LEON3 |
LEON4 | |
ESA | LEON2 |
Freescale (NXP) | 68000 |
680x0 | |
ColdFire | |
M-CORE | |
Power Architecture (MPC5xx, MPC55xx, MPC56xx) | |
ARM Cortex-M microcontrollers (Kinetis E series, Kinetis K series, Kinetis L series, Kinetis M series, Kinetis W series). | |
56k DSP family | |
QorIQ (P2010, P2020, P4080, P5010, P5020, P5021, P5040, T2080) | |
IBM | PowerPC (PPC) implementations: |
G1 (601) | |
G2 (602, 603, 604, 620) | |
G3 (740/750) | |
7xx/750 family | |
G5/970 series | |
401 | |
403 | |
405 | |
440 range | |
Infineon | |
XE166 family | |
XC 2000 family | |
C166 family | |
TriCore | |
Tricore Aurix | |
Tricore Aurix Gen2 | |
XMC1000 | |
Texas Instruments | TMS320C6x family |
TMS320C28x family | |
TMS570 family |
Frequently asked questions
-
What is the difference between decision coverage and branch coverage?
Decision coverage and branch coverage are closely-related forms of structural coverage analysis. Decision coverage is referenced by DO-178B/DO-178C whereas branch coverage is referenced by ISO 26262. Branch coverage requires every exit from a conditional source code statement to be executed. Thus, for an
if
statement, branch coverage requires thethen
part and theelse
part to be executed (if there is noelse
part, the if statement should still execute the decision as true and false). For decision coverage, the DO-178B/DO-178C definition of decision covers conditional statements, in the same way as branch coverage, but it also includes assignments of Boolean variables, for example:a := b or (c and d); (Ada) a = b || (c && d); (C/C++)
In this case, decision coverage would require tests for the above assignment making
a
both true and false.Moreover, given the same source code and tests to exercise it, the percentage of coverage reported may be different between branch and decision coverage. For example, if 3 out of the 4 branches of a
switch
statement are executed, the branch coverage would be reported as75%
, but for decision coverage, a decision is considered covered only if all its branches are covered, so the coverage of the switch statement would be reported as0%
.Find out more about structural coverage in our white paper.
-
How do I learn more about RapiCover?
You can request a trial version of RVS, which includes RapiCover. You can also arrange a demonstration, where a member of our team will work with you to show the benefits RapiCover can offer you.
If you're interested in RapiCover in academia, you can search for it in the academic press.
-
What is RapiCover?
RapiCover is the leading tool for structural code coverage analysis of critical software.
Used globally in the aerospace and automotive industries, it reduces the cost of analyzing structural code coverage analysis up to and including MC/DC.
As part of the RVS toolsuite, it forms part of a software verification solution that also includes tools for functional testing and worst-case execution time analysis.
-
How does RapiCover work?
RapiCover works by injecting instrumentation code into source code and executing the native build system so that coverage results are collected during program execution. Data can be collected from almost any target hardware by a variety of approaches.
-
Which host operating systems can RVS be used on?
RVS tools can be run on the following x86-64 operating systems:
- Windows 10 and 11
- Windows Server 2019+
- Variety of Linux distributions (including Ubuntu and Red Hat)
RVS tools can be used on projects with unsupported operating systems by using a clone integration to split the process and delegate parts of it to the unsupported machine.
-
Which hardware architectures do RVS tools support?
RVS tools can be integrated to work with almost any embedded target. Our engineers can work with you to determine the optimal strategy for integrating the tool with your target, even for multi-core architectures. For more information on the hardware architectures we have integrated RVS tools with, see the compatibility information on our RVS product pages.
-
Can I use RapiCover with my build system?
RapiCover can be integrated to work with almost any compiler and target hardware. Our integration service promises to deliver a robust integration of RapiCover into your build system.
-
Which languages does RapiCover support?
RapiCover supports C, C++ and Ada projects, including mixed-language ones.
-
My software is part of a product that must be certified against a safety guideline. Can RapiCover be qualified for use in my project?
RapiCover is designed to meet the most stringent needs of certification processes, such as the DO-178B/C process used in the aerospace industry and the ISO 26262 process used in the automotive industry. We can provide developer qualification documents, a template integration qualification report and on-site tests to support you in qualifying RapiCover tools in projects requiring certification.
-
Can I collect coverage data across power cycles and reset sequences?
RapiCover can be configured to collect data in real-time while your software runs. By writing data to an external device, the data will remain in place while your system reboots, and collection can be reinitialized when it restarts. This means that you can collect coverage data across a shutdown or reset sequence. This is subject to your target hardware architecture.
-
Can I determine coverage for a decision containing large numbers of conditions?
By default, RapiCover supports 30 conditions per decision, and includes support for up to 1000 conditions per decision using an alternate, inbuilt instrumentation strategy.
-
Can I collect coverage incrementally from multiple builds?
While RapiCover has very low instrumentation overheads, it may not be possible to collect all coverage from the same build or run due to code size or timing-related constraints.
RapiCover lets you collect coverage incrementally from multiple builds, allowing you to generate full coverage reports efficiently, even on resource-constrained systems.
-
Which coverage criteria can I measure using RapiCover?
You can measure the most common coverage criteria required to support DO-178B/ED-12B, DO-178C/ED-12C and ISO 26262 certification using RapiCover. This includes function, call, statement, branch, decision and condition coverage, and MC/DC.
-
How large a code base can RVS tools handle?
RVS tools are designed to handle very large code bases. Because of the efficient algorithms used by RVS tools, there is no fundamental limitation to the number of lines of code that RVS can process, and our RVS tools have been used on projects with millions of lines of code.
-
How are RVS products licensed?
We offer both “Node-locked” and “Floating” licenses, and a license server to support use of our tools in your specific development environment.
For more information on our licensing models, see our RVS licensing FAQs.
-
What happens if I encounter an issue while using an RVS tool?
All RVS licenses include access to our dedicated in-house support team, who will work with you to provide a rapid fix to your issue. This is a critical part of our vision. During 2021, we resolved 63% of our support requests within 7 working days and 93% within 30 working days. We also inform our customers of known issues via our website and email.
-
How do you support RVS users?
We provide an extensive set of RVS documentation with each of our products, and offer training courses guiding you through the most effective use of RVS tools. All our users can benefit from privileged access to our website, which includes downloads for new product releases.
-
Can I add manual configurations that flag my code as being exempt/uncoverable?
RapiCover and RapiCoverZero include a powerful “justification” mechanism that lets you mark code as covered. Using this feature, you can provide a rationale for justifying the code and create templates to justify code more easily. When your code changes, justifications are automatically migrated to represent the new location of your justified code.
For more information on using justifications, see our white paper.
-
What happens when I change my code?
RapiCover and RapiCoverZero retain information about the revision of your code it used to generate results. The tool will report an error if you try to merge coverage from incompatible revisions. RapiCover includes an Optimal Dataset Calculator feature you can use to calculate the least expensive tests you need to run again when your code changes, saving you valuable testing effort.
-
How are my results presented?
All RVS tools include a friendly user-interface that presents your results in both tabular and graphical formats. Using this interface, you can filter your results to zoom in on target functions, making it easy to find the information you are looking for.
Treemaps provide a high-level overview of your code base and help you understand the coverage of your code at a glance.
You can view RapiCover and RapiCoverZero results in continuous integration software, allowing you to track your verification progress over time.
-
Can I use RVS tools with my continuous integration environment?
RVS integrates with a range of continuous integration tools, allowing you to collect unit test, coverage and execution time results with every new build, track your verification progress over time and easily identify anomalies in your software's behavior as they are introduced.
RapiTest, RapiCover and RapiTime (including zero-footprint versions) include custom plugins to integrate with Jenkins and Bamboo. RapiTest and RapiCover results can also be displayed in a range of other continuous integration tools through the JUnit and Cobertura plugins, which are compatible with most continuous integration software.
-
How do I verify my software’s functional and temporal behavior when instrumentation has been applied?
We recommend that, when performing functional testing of safety-critical applications for a final run-for-score, you run your full test suite both with and without coverage instrumentation applied, then confirm that the results match. This provides evidence that RVS instrumentation has not changed the functional behavior of your code.
-
How long has RVS been used for software verification?
The Rapita Verification Suite (RVS) has been used in the critical embedded industry for over 15 years and supported a number of avionics projects globally. Qualification kits for qualified RVS products have supported more than 20 DO-178B and C certification projects up to and including DAL A.
-
Can I collect RapiCover results from tests run by a third-party test framework?
Yes, you do not need to use RapiTest to collect coverage results. RapiCover can instrument your test code so coverage results can be automatically collected as your tests as run, then displayed for analysis.
-
My project includes subcontracting organization(s) and I have confidentiality concerns. Can RVS help me?
To support verification, RVS stores a copy of your source code in your verification results. RVS lets you remove this copy of your source code from your RVS project, so any subcontracting organizations you’re working with can’t see your proprietary information. A subcontracting organization can then verify aspects of your software using the redacted results, and you can later restore the copy of your source code for your internal use by merging your results.
Note that, as running functional tests requires access to the source code under test, this feature is not available for RapiTest.
-
How does RVS support Enterprise licensing?
Floating RVS licenses follow an “Enterprise” model. You can use them across geographical boundaries*, in different projects, with different users, and share them with suppliers working on the same project.
*Some floating licenses may be restricted to use within a specific geographical region. Where this is the case, this is agreed before licenses are issued.
-
Can I create and manage groups for my floating RVS licenses?
Yes, you can create and manage groups of users for your floating RVS licenses. You can restrict each group to only serve licenses to specific hostnames or IP addresses. This allows you to reserve licenses for specific groups or specific purposes such as supporting the use of RVS on a continuous integration server.
Any licenses that you don’t reserve will remain available as floating licenses that can be shared among different users and geographic locations.
-
Can I use RapiCover to verify my code that runs on Deos?
Yes. RVS has an out-of-the-box integration with Deos, which makes it possible to generate an RVS project including a RapiCover integration in just 3 clicks from an existing OpenArbor project.
This benefits from the debug capabilities offered by Deos to automatically apply configuration settings needed for your project and RapiCover integration.
In addition to supporting on-target structural coverage analysis, the generated integration lets you perform on-target worst-case execution time analysis with RapiTime and visualize the scheduling behavior of your code with RapiTask.
-
How does RVS support the analysis of shared code compiled by build systems with multiple executables?
RVS supports the analysis of shared code compiled by build systems with multiple executables by letting you specify the source files that will be compiled in each executable.
If you have functions that are declared in multiple components with the same name but have different definitions, RVS can treat each such function uniquely, for example to provide separate coverage in RapiCover and separate execution time results in RapiTime.
-
How can RVS help me understand my code base?
RVS analyzes the structure of your code and presents information on your code’s structure, helping you understand your code and its dependencies in a variety of forms such as the following:
- RVS analyzes the McCabe complexity of your code and presents the complexity of each code element, letting you easily identify code with high complexity.
- RVS Treemaps present the hierarchy of your code’s components and source files graphically.
- RVS lets you view and explore the call dependencies in your code.
-
How does RVS supplement my Simulink model-based development workflow?
RVS can supplement model-based development workflows using MATLAB® Simulink® to support on-target verification of model-based code and verification of handwritten code.
RapiCover supports generating structural coverage metrics for model-based code in SIL, PIL and HIL testing environments, while RapiTime supports execution time analysis including WCET analysis of model-based code from on-target testing in PIL and HIL environments.
RVS can be used to support functional testing, structural coverage analysis and execution time/WCET analysis of additional handwritten code used in projects that use Simulink.
-
How is RapiCover optimized to support my industry?
Different variants of RapiCover are available, each of which is optimized to best meet the verification needs of specific software industries:
- RapiCover Aero includes example projects, tutorials and analysis profiles optimized for engineers working on DO-178C/ED-12C projects. Coverage analysis profiles are available based on verification requirements for DAL A-C software.
- RapiCover Auto includes example projects, tutorials and analysis profiles optimized for engineers working on ISO 26262 projects. Coverage analysis profiles are available based on verification requirements for ASIL A-D software.
- RapiCover Space includes example projects, tutorials and analysis profiles optimized for engineers working on NASA NPR 7150.2D and ECSS-E-ST-40C projects. For ECSS-E-ST-40C, coverage analysis profiles are available based on verification requirements for software Criticality Category.
-
Which certification standards and guidelines does RVS help to meet?
RVS supports meeting standards and guidelines for verification of mission and safety-critical applications including:
- Civil aerospace software guidelines DO-178C (ED-12C), DO-278A (ED-109), AC 20-193 & AMC 20-193
- Military & defense aerospace standards MIL-HDBK-516C, AA-22-01 AMACC, EMACC, ADSM, Def Stan 00-55 & Def Stan 00-56
- Automotive standard ISO 26262
- Space software standards NASA NPR 7150.2D, ECSS-E-ST-40C
- Other standards based on IEC 61508, including IEC 62279 (rail), IEC 61511 (industrial processes), IEC 61513 (power), IEC 60880 (nuclear) & IEC 62061 (machinery)
-
Can I use RapiCover if I don’t have access to my project source code?
No, but you can use RapiCoverZero for your structural coverage analysis.
-
Is instrumentation-based or instrumentation-free analysis best for me?
Both RapiCover and RapiCoverZero support on-target structural coverage analysis for critical software.
Depending on your project and needs, one or both solutions may be better for you. Consult the table below to determine which is best for your project.
Feature
RapiCover
RapiCoverZero
Works without source code
No
Yes
Works without instrumentation
No
Yes
Integration with development environment
Integration needed
No integration needed
MC/DC analysis (e.g. for DO-178C DAL A)
Yes
No
Tool qualification support
Yes
In development - contact us for details
Trace size and data processing time
Depends on applied instrumentation
Typically larger trace and longer data processing times
Supported platforms (target, data collection mechanism)
Flexible, almost any platform supported (see compatibility)
Requirements on platform (branch trace and context switch information must be available), PSP needed (see compatibility)