Your browser does not support JavaScript! Skip to main content
Free 30-day trial DO-178C Handbook RapiCoupling Preview DO-178C Multicore Training Multicore Resources
Rapita Systems
 

Industry leading verification tools

Rapita Verification Suite (RVS)

RapiTest - Functional testing for critical software RapiCover - Low-overhead coverage analysis for critical software RapiTime - In-depth execution time analysis for critical software RapiTask - RTOS scheduling visualization RapiCoverZero - Zero-footprint coverage analysis RapiTimeZero - Zero-footprint timing analysis RapiTaskZero - Zero-footprint event-level scheduling analysis RVS Qualification Kits - Tool qualification for DO-178 B/C and ISO 26262 projects RapiCouplingPreview - DCCC analysis

Multicore Verification

MACH178 - Multicore Avionics Certification for High-integrity DO-178C projects MACH178 Foundations - Lay the groundwork for A(M)C 20-193 compliance RapiDaemons - Analyze interference in multicore systems

Other

RTBx - The ultimate data logging solution Sim68020 - Simulation for the Motorola 68020 microprocessor

RVS Software Policy

Software licensing Product life cycle policy RVS Assurance issue policy RVS development roadmap

Industry leading verification services

Engineering Services

Data Coupling & Control Coupling Object code verification Qualification Training Consultancy Tool Integration Support

Latest from Rapita HQ

Latest news

RVS 3.24 accelerates multicore software verification
Rapita Systems and Avionyx Announce Strategic Partnership to Offer Best-in-class Avionics Solutions
RVS 3.23 Launched
Rapita System Announces New Distribution Partnership with COONTEC
View News

Latest from the Rapita blog

RVS gets a new timing analysis engine
How to measure stack usage through stack painting with RapiTest
What does AMACC Rev B mean for multicore certification?
How emulation can reduce avionics verification costs: Sim68020
View Blog

Latest discovery pages

Processor How to achieve multicore DO-178C certification with Rapita Systems
Plane How to achieve DO-178C certification with Rapita Systems
Military Drone Certifying Unmanned Aircraft Systems
control_tower DO-278A Guidance: Introduction to RTCA DO-278 approval
View Discovery pages

Upcoming events

Test what you fly - Real code, Real Conditions Webinar
2026-04-14
Avionics Certification Q&A: CERT TALK
2026-05-06
XPONENTIAL 2026
2026-05-11
DO-178C Multicore In-person Training (Heathrow)
2026-05-12
View Events

Technical resources for industry professionals

Latest White papers

Mitigation of interference in multicore processors for A(M)C 20-193
Sysgo WP
Developing DO-178C and ED-12C-certifiable multicore software
DO178C Handbook
Efficient Verification Through the DO-178C Life Cycle
View White papers

Latest Videos

Certification-Ready Rust: GNAT Pro & RVS for Avionics Standards
Accelerated software verification with RVS 3.23
Getting started with RVS
Test what you fly - Real code, Real Conditions Webinar
View Videos

Latest Case studies

Case Study Front Cover
Multicore timing analysis support for ECSS-E-ST-40C R&D with MACH178
GMV case study front cover
GMV verify ISO26262 automotive software with RVS
Kappa: Verifying Airborne Video Systems for Air-to-Air Refueling using RVS
View Case studies

Other Resources

 Webinars

 Brochures

 Product briefs

 Technical notes

 Research projects

 Flyers

 Multicore resources

Discover Rapita

About us

The company menu

  • Customers
  • Partners & Distributors
  • Research projects
  • Contact us
  • Careers
  • Working at Rapita
  • Subscribe to newsletter

Industries

  Civil Aviation (DO-178C)   Military & Defense   Automotive (ISO 26262)   Space

Standards

  DO-178C   A(M)C 20-193

US office


info@rapitasystems.com Rapita Systems, Inc., 41131 Vincenti Ct., Novi, MI 48375, USA

UK office

+44 (0)1904 413945
info@rapitasystems.com Rapita Systems Ltd., Atlas House, Osbaldwick Link Road, York, YO10 3JB, UK

Spain office

+34 93 351 02 05
info@rapitasystems.com Rapita Systems S.L., Parc UPC, Edificio K2M, c/ Jordi Girona, 1-3, Barcelona 08034, Spain
Back to Top
RapiTest

Functional testing for critical software

Why choose RapiTest?

  •  Requirements-based testing for Ada, C & C++ on-host & target
  •  Reduce test authoring effort through easy-to-use test formats
  •  Manage project artifacts with requirements traceability
  •  Simplify verification through integration with your CI tool
  •  Produce evidence for DO-178 and ISO 26262 certification
Request a demo
  • Overview
  • Features
  • Resources
  • Compatibility
  • FAQs

Requirements-based testing for Ada, C & C++ on-host & target

By automating test harness generation, execution, and results collection, RapiTest reduces the effort needed to apply requirements-based tests to your code. Flexible integration strategies ensure efficient verification, regardless of your target hardware.

RapiTest makes it easy to test your code in ways that other tools don’t, automatically handling testing for code elements such as private types and generics, and letting you write multithreaded tests that help you identify race conditions in your code.

reduce testing effort
easy test formats

Reduce test authoring effort through easy-to-use test formats

We believe that your time should be spent writing more tests, not debugging them. RapiTest makes it easy to write and review your tests through simple and easy-to-use testing formats. While easy to use, these let you write complex tests including structures such as loops or multithreading with ease.

It’s easy to get started writing tests for RapiTest with our range of tutorials, extensive documentation, and hands-on training.

Manage project artifacts with requirements traceability

Keep on top of your requirements coverage by linking your tests to their requirements. After importing requirements from your existing requirements management software, you can link each test to the requirements it addresses, letting you track your results against them.

Handy results views and exports let you keep track of which requirements your tests are passing for, which they’re failing for, and which you haven’t yet added tests for.

Requirements taceability
CI integration

Simplify verification through integration with your continuous integration tool

Keep your verification on track by using RapiTest alongside your continuous integration tool. Collect unit test results and track your project’s progress over time with our integrations for Jenkins and Bamboo.

By analyzing your code with RapiTest on every new build, you can easily identify anomalies in execution time results as they happen.

Produce evidence for DO-178 and ISO 26262 certification

Get ready for DO-178C and ISO 26262 certification with our qualification kits. Our off-the-shelf qualification kits and qualified target integration service helps you on the road to qualifying your use of RVS.

Many features of RVS are qualified, including our instrumentation and coverage merging, which has saved customers like Collins Aerospace a huge amount of manual effort.

produce certification evidence

Product features

  • Functional testing
  • Test formats
  • Integrated testing environment
  • Project navigation
  • Integration with build systems
  • Integration with embedded targets
  • Integration with third party tools
  • Language support
  • Licensing
  • Support and training
  • Qualification
  • Analyze results from multicore timing analysis Capture and easily analyze results from tests for timing behavior in multicore software.
    Discover this feature
  • Functional testing Run functional tests of software at the unit, integration and system level.
    Discover this feature
  • Multicore testing Run tests to generate interference and verify the behavior of multicore software.
    Discover this feature
  • Efficient test generation Reduce the time needed to write and execute tests.
    Discover this feature
  • Flexible test authoring Write simple and complex tests easily using a range of formats.
    Discover this feature
  • Requirements traceability Traceability between testing artifacts including requirements and tests.
    Discover this feature
  • Flexible stubbing Apply stub, mock, spy, fake and dummy behavior to functions.
    Discover this feature
  • White box testing Observe and test behavior while functions execute, not just at function boundaries.
    Discover this feature
  • Black box testing Run functional tests without modifying object code.
    Discover this feature
  • Success criteria Check your multicore tests against custom defined success criteria.
    Discover this feature
  • Support functions Write C or C++ support functions that are reusable across tests.
    Discover this feature
  • Access private objects Test and stub private objects without needing specific test code to expose them.
    Discover this feature
  • Race condition testing Test multithreaded, non-deterministic software and identify potential race conditions in your code.
    Discover this feature
  • Integrated testing format Write tests easily in a graphical editor that includes interactive help.
    Discover this feature
  • Spreadsheet format Write tests easily using a powerful spreadsheet format.
    Discover this feature
  • Scripting format Solve advanced testing problems by writing tests using a scripting format.
    Discover this feature
  • Multicore test formats Write tests to apply interference and verify the behavior of multicore software. 
    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
  • Easily manage test runs Easily manage test runs to reduce testing effort.
    Discover this feature
  • Generate test templates Get started writing tests easily using a template test generator.
    Discover this feature
  • Automatically generate test vectors Automatically generate test vectors for C and C++ functions that handle numeric inputs.
    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
  • 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
  • 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
  • Configurable export formats Export test results in a variety of formats.
    Discover this feature
  • Compare reports Compare reports from different builds to track project progress over time.
    Discover this feature
  • Customizable workflow Customize the RVS workflow to best meet your needs.
    Discover this feature
  • Automatically reformat spreadsheet tests Ensure that your spreadsheet tests maintain a consistent style with an automatic reformatting tool.
    Discover this feature
  • Template integrations Create and use template integrations to reduce your effort integrating RVS with your system.
    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
  • Timing analysis during unit testing Collect execution time metrics during unit testing to support timing optimization throughout the software life cycle. 
    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
  • View trends over time Follow verification results over time in CI servers and beyond.
    Discover this feature
  • Advanced search function Search reports for specific elements using advanced queries. 
    Discover this feature
  • Treemaps View coverage and hierarchy of code at a glance.
    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
  • Test what you compile Test code without modifying your existing executable code.
    Discover 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
  • GitLab Run RVS automatically through GitLab automatically to collect and archive results.
    Discover this feature
  • JUnit Display RapiTest results in Continuous Integration systems supporting JUnit.
    Discover this feature
  • Polarion® ALM™ Integrates with your Polarion® ALM™ traceability workflow
    Discover this feature
  • Jama Connect® Integrates with your Jama Connect® traceability workflow
    Discover this feature
  • Migrate tests from other tools Migrate tests from your existing test tool to use in RapiTest.
    Discover this feature
  • VectorCAST Migrate VectorCAST tests to use in RapiTest.
    Discover this feature
  • ANSYS® SCADE® Test your SCADE® models on-host and on-target through all phases of the verification lifecycle.
    Discover this feature
  • Legacy testing tool for Ada A straightforward migration path helps you upgrade from a popular Legacy testing tool for Ada.
    Discover this feature
  • Software Configuration Management Integration with Software Configuration Management tools ensures that files can be used across a team.
    Discover this feature
  • ReqIF format requirements Import requirements in ReqIF formats and export test pass/fail status and requirements coverage. 
    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
  • Lauterbach debugger Collect verification data from Lauterbach debuggers.
    Discover this feature
  • iSYSTEM debugger Collect verification data from iSYSTEM debuggers.
    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
  • Test authoring help and examples Dedicated help for test authoring with guidance and examples.
    Discover this feature
  • Examples and sandbox projects Examples and sandbox projects help you get started quickly.
    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
  • Help search Search the help system to find the most relevant resources quickly.
    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
  • 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

Videos

 

Testing using the RapiTest Editor
00:02:39 | Feature
 
Analyze code complexity thumbnail
Analyze code complexity with RVS
00:00:59 | Feature
 
Functional testing with RapiTest Thumbnail
Functional testing with RapiTest
00:01:49 | Overview
 
Requirements traceability with RapiTest Thumbnail
Requirements traceability with RapiTest
00:02:11 | Feature
 

Pagination

  • First page « First
  • Previous page ‹
  • …
  • Page 2
  • Current page 3

Downloads

  Webinar
Mitigation of Interference in Multicore Processors
  Webinar
AI-driven Requirements Traceability for Faster Testing and Certification
  Flyer
Verifying model-based software for DO-178C with RVS
  Flyer
Software verification for space projects
  Flyer
Using RVS to support multicore timing analysis
  Webinar
Efficient testing with RVS and ANSYS® SCADE® Test™

Pagination

  • Current page 1
  • Page 2
  • Page 3
  • Next page ›
  • Last page Last »

News & Blog

Blog
The ‘A’ Team comes to the rescue of code coverage analysis
Blog
Flexible licensing software fit for modern working
News
NASA selects Rapita Verification Suite for the Lunar Gateway
Blog
Introducing the RapiTest Editor
News
Rapita hosts SCADE webinar with ANSYS
Blog
Software verification on the Solar Orbiter

Pagination

  • Current page 1
  • Page 2
  • Page 3
  • Next page ›
  • Last page Last »

Ada

Programming languages

RVS can be used to verify Ada code for requirements-based testing, structural coverage, execution time and scheduling behavior.

AdaCore Ravenscar Profile

RTOS

RVS supports the verification of code using AdaCore Ravenscar Profile.

AdaMULTI

Compilers

RVS supports the AdaMULTI compiler.

Analog Devices

CPU

RVS can be used to analyze software running on Analog Devices CPUs.

Learn More

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 Analog Devices CPUs we have worked with:

  • Blackfin
  • SHARC
  • SigmaDSP
  • TigerSHARC
  • ADSP-21xx
Arm

CPU

RVS can be used to analyze software running on Arm CPUs.

Learn More

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 Arm CPUs we have worked with:

  • ARM7
  • ARM9
  • ARM10
  • ARM11
  • Cortex-M
  • Cortex-R
  • Cortex-A
Arm DS-5

Compilers

RVS supports the Arm DS-5 compiler.

Assembly

Programming languages

RVS can be used to verify Assembly code for structural coverage, execution time and scheduling behavior.

ASTERIOS

RTOS

RVS supports the verification of code using ASTERIOS (previously known as Krono-Safe ASTERIOS).

Atmel

CPU

RVS can be used to analyze software running on Atmel CPUs.

Learn More

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 Atmel CPUs we have worked with:

  • AT90CAN128

AUTOSAR Adaptive Platform

RTOS

RVS supports the verification of code using AUTOSAR Adaptive Platform.

Azure DevOps

Software Configuration Management (SCM)

RVS tools are designed to work in Software Configuration Management tools such as Azure DevOps.

Bamboo

Software Configuration Management (SCM)

You can run RVS automatically through the Bamboo continuous integration server.

Bare Metal

RTOS

RVS (including zero-footprint tools) supports the verification of code running on Bare Metal (no OS)

Blackberry QNX

RTOS

RVS supports the verification of code using Blackberry QNX.

Borland C++

Compilers

RVS supports the Borland C++ compiler.

C

Programming languages

RVS can be used to verify C code for requirements-based testing, structural coverage, execution time and scheduling behavior.

C++

Programming languages

RVS can be used to verify C++ code for requirements-based testing, structural coverage, execution time and scheduling behavior.

Cobertura

Software Configuration Management (SCM)

RapiCover lets you export structural coverage results in a Cobertura format.

DDC-I Deos

RTOS

RVS has an out-of-the-box integration with DDC-I's Deos operating system.

DOORS Classic

Requirements traceability

RapiTest lets you import requirements from DOORS through ReqIF.

ERIKA Enterprise

RTOS

RVS supports the verification of code using ERIKA Enterprise.

ESA

CPU

RVS can be used to analyze software running on ESA CPUs.

Learn More

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 ESA CPUs we have worked with:

  • LEON2
ESOL eMCOS

RTOS

RVS (including zero-footprint tools) support the verification of code using ESOL eMCOS.

Learn More

For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect information on context switches made during software execution. Whether this is possible or not depends on the real-time operating system (RTOS) used and its configuration. Platform Support Packages must be able to understand context switch information to support further analysis of an executable by zero-footprint RVS tools.

We can develop support for other real-time operating systems. For more information, contact us at

info@rapitasystems.com.

FreeRTOS

RTOS

RVS (including zero-footprint tools) supports the verification of code using FreeRTOS.

Learn More

For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect information on context switches made during software execution. Whether this is possible or not depends on the real-time operating system (RTOS) used and its configuration. Platform Support Packages must be able to understand context switch information to support further analysis of an executable by zero-footprint RVS tools.

We can develop support for other real-time operating systems. For more information, contact us at

info@rapitasystems.com.

FRONTGRADE Gaisler

CPU

RVS can be used to analyze software running on FRONTGRADE Gaisler (previously known as Cobham Gaisler) CPUs.

Learn More

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 FRONTGRADE Gaisler CPUs we have worked with:

  • LEON3
  • LEON4

G++

Compilers

RVS supports the G++ compiler.

GCC

Compilers

RVS supports the GCC.

GitHub

Software Configuration Management (SCM)

RVS tools are designed to work in Software Configuration Management tools such as GitHub.

GitLab

Software Configuration Management (SCM)

You can run RVS automatically through continuous integration pipelines in GitLab.

GNAT GPL

Compilers

RVS supports the AdaCore GNAT GPL compiler.

GNAT Pro

Compilers

RVS supports the AdaCore GNAT Pro compiler.

Green Hills Integrity

RTOS

RVS supports the verification of code using Green Hills Integrity.

IBM

CPU

RVS can be used to analyze software running on IBM CPUs.

Learn More

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 IBM PowerPC implementations we have worked with:

  • G1 (601)
  • G2 (602, 603, 604, 620)
  • G3 (740/750)
  • 7xx/750 family
  • G5/970 series
  • 401
  • 403
  • 405
  • 440 range

IBM Engineering Rhapsody

Model-Based Design

Infineon

CPU

RVS can be used to analyze software running on Infineon CPUs.

Learn More

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 Infineon CPUs we have worked with:

  • XE166 family
  • XC 2000 family
  • C166 family
  • TriCore
  • TriCore Aurix
  • TriCore Aurix Gen2
  • XMC1000

iSYSTEM

Debuggers

RVS tools support software verification using branch traces collected from the iSYSTEM debuggers.

Learn More

Using a trace port (NEXUS or ARM‑ETM), RVS can collect traces via the following iSYSTEM debuggers, which monitor writes made to a specific register or memory location:

  • iC3000GT and iTRACE GT
  • iC5000
Jama Connect

Requirements traceability

RapiTest has a dedicated integration with the Jama Connect® requirements management and traceability tool

Jenkins

Software Configuration Management (SCM)

You can run RVS automatically through the Jenkins continuous integration server.

JUnit

Software Configuration Management (SCM)

RapiTest lets you export functional test results in the JUnit format

Linux

OS (Host)

RVS can run on variety of Linux distributions (including Ubuntu and Red Hat).

Learn More

For older operating systems, contact us.

LynxOS

RTOS

RVS supports the verification of code using LynxOS.

LynxSecure

RTOS

RVS supports the verification of code using LynxSecure.

MachineWare

Simulators

RVS tools support verifying code executed on MachineWare simulators.

Learn More

MachineWare simulators integrate with Rapita tools like physical hardware and can be used to gain deep insights even before first hardware prototypes are available. Such as:

  • SIM-A (Arm simulator)
  • SIM-V (RISC-V simulator)

MaRTE OS

RTOS

RVS supports the verification of code using MaRTE OS.

Mathworks Simulink

Model-Based Design

MicroC/OS

RTOS

RVS supports the verification of code using μC/OS.

MICROSAR

RTOS

RVS supports the verification of code using MICROSAR.

Microsoft TFS

Software Configuration Management (SCM)

RVS tools are designed to work in Software Configuration Management tools such as Microsoft TFS.

MULTI

Compilers

RVS supports the MULTI (C/C++) compiler.

NXP (Freescale)

CPU

RVS can be used to analyze software running on Freescale/NXP CPUs.

Learn More

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 Freescale (NXP) CPUs we have worked with:

  • 68000
  • 680x0
  • ColdFire
  • M-CORE
  • Power Architecture (MPC5xx, MPC55xx, MPC56xx, MPC57xx)
  • 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)
PikeOS

RTOS

RVS (including zero-footprint tools) supports the verification of code using SYSGO PikeOS.

Learn More

For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect information on context switches made during software execution. Whether this is possible or not depends on the real-time operating system (RTOS) used and its configuration. Platform Support Packages must be able to understand context switch information to support further analysis of an executable by zero-footprint RVS tools.

We can develop support for other real-time operating systems. For more information, contact us at

info@rapitasystems.com.

Polarion

Requirements traceability

RapiTest supports integration with the Polarion® ALM™ requirements management and traceability tool

ReqIF

Requirements traceability

RapiTest integrates with requirements management software that can produce ReqIF format results.

Reqtify

Requirements traceability

RapiTest lets you import requirements from Reqtify through ReqIF.

RI850V4

RTOS

RVS supports the verification of code using RI850V4.

RTEMS

RTOS

RVS supports the verification of code using RTEMS.

RTXC Quadros

RTOS

RVS supports the verification of code using RTXC Quadros.

SafeRTOS

RTOS

RVS (including zero-footprint tools) supports the verification of code using SafeRTOS.

Learn More

For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect information on context switches made during software execution. Whether this is possible or not depends on the real-time operating system (RTOS) used and its configuration. Platform Support Packages must be able to understand context switch information to support further analysis of an executable by zero-footprint RVS tools.

We can develop support for other real-time operating systems. For more information, contact us at

info@rapitasystems.com.

TeamCity

Software Configuration Management (SCM)

RVS tools are designed to work in Software Configuration Management tools such as TeamCity.

Texas Instruments

CPU

RVS can be used to analyze software running on Texas Instruments CPUs.

Learn More

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 TI CPUs we have worked with:

  • TMS320C6x family
  • TMS320C28x family
  • TMS320F28x family
  • TMS570 family
Visure

Requirements traceability

RapiTest lets you import requirements from Visure through ReqIF.

Wind River Helix & VxWorks

RTOS

RVS supports the verification of code using Wind River Helix & VxWorks.

Windows

OS (Host)

RVS can run on Windows 10 and 11.

Learn More

For older operating systems, contact us.

Windows Server

OS (Host)

RVS can run on Windows Server 2019 and above.

Learn More

For older operating systems, contact us.

Frequently asked questions

  • General
  • Certification and qualification
  • Compatibility
  • Licensing and support
Expand All
  • What is RapiTest? 
  • How does RapiTest work? 
  • What types of testing does RapiTest support? 
  • How do I write tests for use with RapiTest? 
  • How does RapiTest help me write tests? 
  • How does RapiTest support multicore timing analysis? 
  • What kind of stubbing behavior does RapiTest support?  
  • How does RapiTest help me write complex or reusable test logic in my tests? 
  • How many tests can RapiTest run at once? 
  • How does RapiTest help me select which tests to run? 
  • How can RapiTest let me test my unmodified object code? 
  • How are my results presented? 
  • How does RVS help me get started? 
  • How does RapiTest support my traceability workflow?  
  • How can RVS help me understand my code base? 
  • Which certification standards and guidelines can RVS help me to achieve? 
  • Which DO-178C objectives can RapiTest help me to achieve? 
  • My software is part of a product that must be certified against a safety guideline. Can RapiTest be qualified for use in my project? 
  • How do I verify my software’s functional and temporal behavior when instrumentation has been applied? 
  • Which languages does RapiTest support? 
  • How large a code base can RVS tools handle? 
  • Which host operating systems can RVS be used on? 
  • Can I use RapiTest with my build system? 
  • Can you help me migrate my existing tests so they work in RapiTest? 
  • Can I use RVS tools with my continuous integration environment? 
  • Which hardware architectures do RVS tools support? 
  • Can I use RapiTest to test my SCADE Test tests on target? 
  • How does RVS support the analysis of shared code compiled by build systems with multiple executables? 
  • How are RVS products licensed? 
  • How does RVS support Enterprise licensing? 
  • Can I create and manage groups for my floating RVS licenses? 
  • What happens if I encounter an issue while using an RVS tool? 
  • Can you provide samples of tests written in different RapiTest formats? 
  • How do you support RVS users? 
  • How long has RVS been used for software verification? 
  • How do I learn more about RapiTest? 
  • What is RapiTest?

    RapiTest is the leading tool for functional testing of critical software.

    Used globally in the aerospace and automotive industries, it reduces the cost of functional testing at all levels, including system, integration and unit testing. 

    As part of the RVS toolsuite, it forms part of a software verification solution that also includes tools for structural coverage analysis and worst-case execution time analysis. 

  • How does RapiTest work?

    RapiTest works by using input tests in a variety of formats and an understanding of the program structure achieved through dynamic analysis to produce test harnesses that it executes on the native build system to collect test results. When collecting data from hardware targets, 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 RapiTest with my build system?

    RapiTest can be integrated to work with almost any compiler and target hardware. Our integration service promises to deliver a robust integration of RapiTest into your build system.

  • Which languages does RapiTest support?

    RapiTest 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 RapiTest be qualified for use in my project?

    RapiTest 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 RapiTest in projects requiring certification.

  • How are my results presented?

    RapiTest results are presented in a friendly user-interface. When you run a test, your results are displayed based on just the subprograms you tested, letting you quickly check your results against requirements. 

    You can also view RapiTest results in continuous integration software, allowing you to track your verification process over time. 

  • How many tests can RapiTest run at once?

    You can include as many tests as you want to in a single build on your target, subject to the resources available on your target and your data collection strategy. As with all our RVS tools, RapiTest has a very low overhead, meaning you can complete your test cycle in fewer builds than using other tools.

  • What kind of stubbing behavior does RapiTest support?

    The test generation algorithms RapiTest uses are powerful and support generation of all types of stubs used in the industry, including stubs, mocks, fakes, spies and dummies. 

  • How do I write tests for use with RapiTest?

    RapiTest provides flexibility in test authoring by letting you write tests in one of three formats. These are the RapiTest Editor (an integrated testing interface), spreadsheets, and scripts, with each format having its advantages. You can also convert tests at any time between formats (though you cannot convert test scripts to other formats as they include more complex features). 

    RapiTest is customizable to support existing or alternative test formats. If necessary, we can develop a converter for RapiTest to interpret tests written in your existing non-RapiTest format.

  • What types of testing does RapiTest support?

    You can use RapiTest to generate code for testing both high- and low-level requirements, and it supports the generation of tests for various levels and definitions understood in the industry, such as unit, module, integration and system tests.  

  • How do I learn more about RapiTest?

    You can request a trial version of RVS, which includes RapiTest. You can also arrange a demonstration, where a member of our team will work with you to show the benefits RapiTest can offer you.

    If you're interested in RapiTest in academia, you can search for it in the academic press. 

  • 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. 

  • How does RapiTest support my traceability workflow?

    RapiTest supports your traceability workflow by interfacing with your requirements management and traceability software, allowing you to reuse information about requirements and test artifacts that you have already defined.   

    RapiTest’s part in the traceability workflow is simple, involving import, assignment, reporting and export. 

    You can import information about requirements and test artifacts in formats including Word, Excel, and the Requirements Interchange Format (ReqIF), which is compatible with many requirements traceability tools. If you’re using Jama Connect®, you can configure RVS to automatically pull in information on requirements or test artifacts from the software. 

    With this information in your project, you can tag your tests with the requirements they test and/or assign the test artifact IDs you use to identify each test uniquely.  

    After running your tests, RapiTest displays your requirements coverage and the status of each test tagged with each requirement, and lets you export your results in RapiTest exports. If you're using Jenkins or Bamboo, you can view your requirements coverage in each build and follow the trend in requirements coverage throughout your project. 

    If you’re using Jama Connect®, you can automatically export key information such as test pass/fail status back into the software, so you can continue to monitor your project’s traceability from Jama Connect. 

  • 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 using RVS tools to perform 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 coverage instrumentation has not changed the functional behavior of your code.

  • Can I use RapiTest to test my SCADE Test tests on target?

    Yes. RapiTest integrates with ANSYS® SCADE® Test™, letting you perform back-to-back testing of your SCADE models. By interpreting and executing your model-based tests against generated source code for both on-host and on-target testing, RapiTest improves efficiency by letting you reuse your SCADE tests through all phases of the verification lifecycle.

  • How does RapiTest help me write tests?

    If you’re using the RapiTest Editor, RapiTest’s integrated testing interface, this provides guidance throughout the test authoring process, making it easy to set up new test vectors and stubs and including real-time error reporting and context-sensitive links to RapiTest’s user documentation. If you have any questions on specific topics, this is available through a dedicated help system, which also highlights relevant example projects and tests for the task at hand. 

    RapiTest lets you quickly generate templates that you can use to write your tests. When generating templates, you can quickly link requirements to your tests, set input and expected output values for units under test and stubbed functions, and set configuration options. 

    RapiTest can also automatically generate test vectors to test functions that handle numeric inputs – this generates tests for the min, max, and optionally step values of the function under test. 

  • How does RapiTest help me select which tests to run?

    RapiTest makes it easy to select the tests you run with each build of the test harness. Test selection options in the RVS Project Manager help you to quickly select to run only new or modified tests, tests that are failing, tests for specific requirements, or any combination thereof.

    If your code has changed, you can use the Optimal Dataset Calculator to automatically select the most efficient set of tests to run to achieve the same coverage you did in a previous report. This helps you quickly ensure that your coverage hasn’t been affected by the code changes before committing to running your full test suite.

  • Can you help me migrate my existing tests so they work in RapiTest?

    We support the migration of unit tests produced for use with a variety of unit testing tools, including both commercial and internally developed tools, into RapiTest tests. We work with you to create a solution, which may be a combination of automatic test conversion, manual conversion by our engineers, and review.

    The formats we can migrate unit tests from include, but are not limited to:

    • VectorCAST® tests
    • Legacy Ada testing tool tests
    • Google® Test tests

    For more information and to see how we can help you, contact us at info@rapitasystems.com.

    Google® is the trade mark of Google LLC.
    VectorCAST® is the trade mark of Vector Software, Inc. registered in USA under number 4949992.

  • 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 you provide samples of tests written in different RapiTest formats?

    Yes, we can. Contact us if you want to learn more.

  • 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.

  • 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 RapiTest help me write complex or reusable test logic in my tests?

    RapiTest lets you write support functions in C or C++ code that you can include in your RapiTest tests. These let you define reusable test logic to perform functions such as initialization or teardown, defining complex sets of checks, implementing complex stubs, and instantiating templates.  

  • How can RapiTest let me test my unmodified object code?

    RapiTest can let you test your unmodified object code. This capability can be set up as part of an RVS integration. For more information, contact us.

  • Which certification standards and guidelines can RVS help me to achieve?

    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-STD-8739.8B, ECSS-E-ST-40C
    • Other standards based on IEC 61508, including IEC 62279, EN50128 & EN 50657 (rail), IEC 61511 (industrial processes), IEC 61513 (power), IEC 60880 (nuclear) & IEC 62061 (machinery)
  • Which DO-178C objectives can RapiTest help me to achieve?

    RapiTest can help you meet DO-178C objectives 6.4.a, 6.4.b, 6.4.c and 6.4.d, which indicate that requirements-based testing is performed on the DO-178C software against both high and low-level requirements.

    RapiTest helps you do the analysis needed to meet DO-178C objective 6.4.5.c. When a check fails, RapiTest provides the expected and actual results, making it easy to identify discrepancies, as required to meet the objective.

    As RapiTest is designed for on-target execution and supports integration with a wide variety of third-party requirements management software applications, it also helps you achieve DO-178C objectives 6.4.e, 6.4.4.a and 6.4.4.b.

    RapiTest is a key part of the MACH178 solution to provide verification results for multicore timing analysis. When used in this context, it can help you achieve AC 20-193 and AMC 20-193 objectives MCP_Resource_Usage_4 and MCP_Software_1.

    For a detailed description of how RVS tools including RapiTest can help you achieve DO-178C certification, see our web page on how to achieve DO-178C certification.

  • How does RVS help me get started?

    RVS make it easy to get started with a range of resources:

    • Interactive tutorials guide you through using each RVS tool.
    • Example projects, reports and tests let you explore using RVS with example code, while sandbox projects let you plug in Ada, C and C++ snippets and get started with on-host verification quickly.
    • If you’re looking for more detail about specific topics, the RVS documentation is at hand.  

    And no matter what your question, RVS’s help search can link you to the most helpful resources at the click of a button. 

  • How does RapiTest support multicore timing analysis?

    RapiTest, when used with RapiTime, lets you configure and review the results of tests to support multicore timing analysis. Using a dedicated test editor, RapiTest lets you write tests that configure the application of RapiDaemons to generate interference and the definition of success criteria for test outcomes. After your tests have run, RapiTest presents the pass/fail status of your tests against their success criteria. 


RapiTest success story

How RVS tools helped Kappa to verify an airborne video system.

How RVS tools helped Danlaw pass their customer’s Software Risk Assessment

How RVS supported verification of EasyMile's ASIL D autonomous driving solutions.

How Rapita’s V&V services produced evidence for DO-178C certification of Triumph’s actuation system software.

 

Request Demo

Times are in GMT

What happens next?
We aim to respond to demo requests within 1 working day. 

  • Solutions
    • Rapita Verification Suite
    • RapiTest
    • RapiCover
    • RapiTime
    • RapiTask
    • MACH178
  • Latest
  • Latest menu

    • News
    • Blog
    • Events
    • Videos
  • Success Stories
  • Success Stories Menu

    • Airbus Defence & Space
    • BAE Systems
    • Cobham
    • Collins Aerospace
    • Leonardo
  • Downloads
  • Downloads menu

    • Brochures
    • Webinars
    • White Papers
    • Case Studies
    • Product briefs
    • Technical notes
    • Software licensing
  • Company
  • Company menu

    • About Rapita
    • Careers
    • Customers
    • Industries
    • Locations
    • Partners
    • Research projects
    • Contact
  • Discover
    • Multicore Timing Analysis
    • Worst Case Execution Time
    • WCET Tools
    • Code coverage for Ada, C & C++
    • MC/DC Coverage
    • Verifying additional code for DO-178C
    • Data Coupling & Control Coupling
    • DO-178C
    • AC 20-193 and AMC 20-193
    • Certifying eVTOL
    • Certifying UAS

All materials © Rapita Systems Ltd. 2026 - All rights reserved | Privacy information | Trademark notice Subscribe to our newsletter