ABSTRACT
Under DO-178C, structural coverage analysis shows whether requirements-based tests have exercised airborne software as thoroughly as its software level demands. This article explains what each level requires. Levels A to C must achieve statement coverage and cover data and control coupling, Levels A and B also need decision coverage, and Level A adds MC/DC and verification of compiler-generated code that cannot be traced to source. It covers the details that most often trip teams up, including how DO-178C defines a decision, how to choose and document an MC/DC variant, and when structural coverage alone is not enough evidence for data and control coupling. It also explains how to resolve coverage gaps caused by missing tests, inadequate requirements, dead code or deactivated code. The article ends with how Cantata from QA Systems helps collect and combine coverage evidence, what tool qualification involves, and a checklist of decisions to settle in the certification and verification plans before testing starts.
For teams developing airborne software, a coverage percentage on its own tells you very little. Which requirements did the tests verify? Which parts of the code did they actually exercise? And can you justify whatever is left uncovered?
DO-178C test coverage analysis answers these questions in two steps. First, requirements-based coverage analysis confirms that the tests cover the software requirements. Then structural coverage analysis confirms that those same tests have exercised the code structure to the degree required by the software level. If you know your level's objectives early, it's easier to plan tests, resolve gaps and produce evidence that holds up in certification.
Start with requirements, not code
In DO-178C, verification starts with requirements. Test cases are derived from the high-level and low-level requirements and cover both normal-range and robustness (abnormal) conditions. They are run as low-level tests, software integration tests and hardware/software integration tests.
Coverage analysis then happens in two stages, as Figure 1 shows. Requirements-based coverage analysis (section 6.4.4.1) checks that every requirement has been tested. Structural coverage analysis (section 6.4.4.2) then shows which parts of the implementation those tests exercised. Any gap feeds back into the process, either as new or improved tests or as a change to the requirements or the code.

Figure 1. Where structural coverage analysis sits in the DO-178C testing process. Section numbers refer to DO-178C.
The order matters. Coverage is measured from requirements-based tests. Writing tests against the code just to reach a coverage target defeats the purpose, because such a test only shows that a line ran. It doesn't show that the line does what a requirement says.
The same caution applies to the coverage figure itself. A test can execute a statement without checking its result. A test suite can also verify every documented requirement while the code still contains behaviour that no requirement describes. Structural coverage analysis is designed to expose exactly that kind of gap.
What structural coverage analysis must show
DO-178C section 6.4.4.2 sets out four things the analysis must achieve:
- Degree of coverage. The structural coverage collected during requirements-based testing must be appropriate to the software level.
- Level of analysis. The analysis may be performed on the source code, the object code or the Executable Object Code. If it is done at source level for Level A, any additional code the compiler generates needs separate verification (see below).
- Component interactions. The analysis must confirm that the requirements-based tests exercised the data and control coupling between code components.
- Resolution. Every part of the code that wasn't exercised must be explained and resolved (section 6.4.4.3).
What each software level requires
The software level is assigned through the system safety assessment, based on the most severe failure condition the software can contribute to. The more severe the consequence, the more demanding the verification objectives. Table 1 summarizes the structural coverage objectives in DO-178C Table A-7.
| Objective | Level A | Level B | Level C | Level D | Level E |
|---|---|---|---|---|---|
| Statement coverage | ● | ● | ○ | – | – |
| Decision coverage | ● | ● | – | – | – |
| MC/DC | ● | – | – | – | – |
| Data coupling coverage | ● | ● | ○ | – | – |
| Control coupling coverage | ● | ● | ○ | – | – |
| Verification of additional code not traceable to source | ● | – | – | – | – |
Table 1. Structural coverage objectives by software level. ● = applies, with independence. ○ = applies, without independence. – = no objective.
Independence generally means that the verification is performed by person(s) or tools not responsible for developing the item being verified. At Levels A and B, every structural coverage objective needs it. At Level C the objectives still apply, but without that requirement.
Level D has no structural coverage objectives, but it still requires requirements-based testing against the high-level requirements. Level E software has no DO-178C objectives at all. Figure 2 shows how the objectives build up from Level C to Level A.

Figure 2. Each level adds coverage objectives on top of those of the level below.
Level A: code not traceable to source
Level A adds one more objective. The compiler, linker or other tools may generate code that can't be traced directly to source statements, such as inserted range checks, exception handling or library routines. In that case, additional verification must show that those generated code sequences are correct.
This objective is about the correctness of the generated code, not about coverage. A common approach is a source-to-object code traceability analysis for the specific compiler, version and options used. The approach should be described in the plans and agreed with the certification authority.
Statement, decision and MC/DC coverage
Statement coverage shows that every statement in the program has been executed at least once.
Decision coverage shows that every decision has taken every possible outcome at least once, and that every entry and exit point has been invoked. Two details often catch teams out:
- DO-178C defines a decision as any Boolean expression, not only an expression that controls a branch. An assignment such as x = a && b; is therefore a decision too.
- Entry and exit points are part of the objective.
Many tools' standard "decision" or "branch" coverage measures neither of these. DO-178C decision coverage is therefore not the same as ordinary decision outcome coverage. Tools may close the gap by combining decision coverage with Boolean operator coverage, so that every Boolean expression is measured, not only those at branch points. Check your tool's definitions and configuration against DO-178C rather than assuming the metrics are interchangeable.
MC/DC goes further. It requires each condition in a decision to be shown to independently affect the decision's outcome.
A worked MC/DC example
Take a decision that enables an output only when both systemReady and commandActive are true:
enableOutput = systemReady && commandActive;
Two tests, one with both conditions true and one with both false, achieve decision coverage. They don't show which condition caused the outcome to change. MC/DC needs pairs of tests in which only one condition changes and the outcome changes with it:
| Test | systemReady | commandActive | enableOutput |
|---|---|---|---|
| 1 | true | true | true |
| 2 | false | true | false |
| 3 | true | false | false |
Table 2. A minimal MC/DC test set for a two-condition AND decision.
Tests 1 and 2 show the independent effect of systemReady. Tests 1 and 3 show the independent effect of commandActive. Table 3 compares what each metric demands for this same decision.
| Metric | What it shows | Minimum tests | Required at |
|---|---|---|---|
| Statement | Every statement has executed | 1 | Levels A, B, C |
| Decision | Every decision has been both true and false; every entry and exit invoked | 2 | Levels A, B |
| MC/DC | Each condition independently changes the outcome | 3 (N+1) | Level A |
Table 3. Coverage metrics compared for enableOutput = systemReady && commandActive.
For a decision with N conditions, MC/DC usually needs at least N+1 tests, whereas exhaustive testing needs up to 2N. For a decision with six conditions, that is 7 tests instead of 64.
Choose and document your MC/DC variant
There is more than one accepted way to demonstrate MC/DC:
- Unique-cause MC/DC. Only the condition under study changes between the two tests in a pair. All other conditions stay fixed.
- Masking MC/DC. Other conditions may also change, as long as the analysis shows that they cannot affect the outcome (they are "masked"). This often makes MC/DC achievable for coupled conditions, where unique-cause pairs are impossible.
State the chosen variant in the Plan for Software Aspects of Certification (PSAC) or the Software Verification Plan (SVP), together with how the tool handles short-circuit evaluation. That way, nobody has to argue later about what the reported percentage means.
Why interactions between components matter
Statement, decision and MC/DC coverage show what happened inside each component. They don't show that the components were exercised together as the architecture intends. That's the purpose of data and control coupling analysis, which applies at Levels A, B and C.
Data coupling is a component's dependence on data that isn't exclusively under its control. The analysis needs to include function parameters, global variables, external data, stored data and resource contention.
Control coupling is the way one component influences the execution of another. The analysis needs to include function calls whose controlling parameter or pointer is fixed at compile time, as well as calls whose control can change at run time.
For example, two components may each reach 100% statement coverage in isolated unit tests. That still doesn't show that one passes the correct data to the other once they're integrated.
When is structural coverage enough?
There is no separate coverage metric for data or control coupling. Whether ordinary structural coverage is enough evidence depends on whether the data or control is fixed or determined at run time, as Table 4 shows.
| Situation | Structural coverage alone? | Additional evidence needed |
|---|---|---|
| Control parameters constant or set at compile time | Sufficient | None beyond normal structural coverage |
| Control paths determined at run time, e.g. function pointers | Not sufficient | Tests that cover each intended target, plus pointers both initialized and not initialized before use |
| Coupled data that is constant | Sufficient | None beyond normal structural coverage |
| Coupled data that is determined at run time | Not sufficient | Tests that cover all equivalence classes of the data's possible states and legal transitions |
| Data read or written outside the component's control | Partly | Checks on each read from and write to that data, confirming the expected values pass across the interface |
Table 4. Evidence needed for data and control coupling analysis.
Control flow can also be verified directly. Within a function, a test can check the data a statement modifies at defined control points. Between functions, a test can check that calls happen in exactly the expected order. Where interrupts or exceptions break the normal flow, these can be simulated and verified in the test as well.
Investigating coverage gaps
A coverage gap is a finding to investigate, not just a prompt to write another test. DO-178C section 6.4.4.3 identifies four possible causes, each with its own resolution (Table 5).
| Cause of the gap | Typical resolution |
|---|---|
| Shortcomings in the requirements-based tests | Add or improve tests, traced to the requirements they verify. |
| Inadequate software requirements | Correct the requirement first, then define the test that verifies it. |
| Extraneous code, including dead code | Remove the code, then assess the effect and whether reverification is needed. |
| Deactivated code (present on purpose, but not meant to run in a given configuration) | Keep it, but show that it can't be executed inadvertently, or verify it with requirements-based tests in the configurations where it is used. |
Table 5. Causes of structural coverage gaps and how to resolve them.
Any test added to close a gap must still trace to a requirement. The goal is a complete, justified body of verification evidence, not a green dashboard.
Collecting coverage evidence with Cantata
Cantata from QA Systems supports unit and integration testing of C and C++ software on both host and embedded target platforms.
How coverage is measured
- Cantata instruments a copy of the source code, so the delivered source is never modified.
- Coverage data is collected while the Executable Object Code runs, including on the target platform.
- The analysis is presented against the source code, with diagnostics in the GUI and certification evidence in report files.
- Coverage is recorded per test case, so every covered line can be linked to the test, and therefore the requirement, that exercised it.
DO-178C coverage rule sets
Cantata measures statement, decision and MC/DC coverage. To match the DO-178C definition of a decision, its DO-178 rule sets combine decision coverage with Boolean operator coverage. For MC/DC, teams can choose either unique-cause or masking MC/DC. The choice should then be recorded in the PSAC or SVP.
Combining coverage
Coverage data can be exported, imported and combined. This lets teams merge results across multiple test executables and across test stages, such as low-level, software integration and hardware/software integration testing. It shows what each activity contributes and where further investigation is needed.
Combined reports still have to be read in context. They should relate to a controlled software configuration and a defined verification approach. Adding up percentages doesn't replace the coupling analysis or the justification of uncovered code.
Support for coupling analysis
There is no single structural-coverage metric for data or control coupling. Cantata supports the analysis through requirements-based integration testing, checks on data at control points, checks on reads and writes to shared data, call-sequence verification and, where the Software Verification Plan requires it, the CPPDCCR control-coupling reporting tool.
Checks on data at control points and on reads and writes to shared data help demonstrate data coupling. Checks on the expected order of function calls help demonstrate control coupling. User-defined context coverage can show that code was exercised in specific states, for example with each possible function-pointer target.
CPPDCCR analyses coverage data from call-return instrumented source code, together with Cantata static information and a reviewed component-definition file. It reports the selected component scope, cross-component calls, call locations, called functions or methods, execution status and summary results, which supports control-coupling analysis.
CPPDCCR does not provide a data-coupling metric. Its report should therefore be reviewed together with the requirements-based test results, structural-coverage results, software-architecture information and the separate data-coupling analysis.
Plan tool qualification early
If a verification tool's output is used to eliminate, reduce or automate a DO-178C process without its output being verified, you need to assess whether the tool must be qualified.
That assessment depends on how the tool is used and what certification credit you claim. A structural coverage tool typically falls under Criteria 3, which means Tool Qualification Level 5 (TQL-5) under DO-330 at every software level.
QA Systems offers qualification kits to support this work. A kit provides the supporting material. It doesn't qualify every use of the tool on every project automatically. Your project still has to show that the tool is used as qualified.
Planning checklist
Settle these points in the PSAC and SVP before testing starts, so that you don't find evidence gaps late in the project:
- The software level of each component, and the coverage objectives that follow from it.
- Whether coverage is analysed on source, object or Executable Object Code, and how any code not traceable to source is verified at Level A.
- How the tool's decision coverage matches the DO-178C definition, including Boolean expressions outside branches.
- The MC/DC variant (unique-cause or masking) and how short-circuit evaluation is handled.
- How data and control coupling will be demonstrated, including the run-time cases in Table 4.
- How results from different test stages and executables will be combined, and for which software configuration.
- How uncovered code will be classified, resolved and recorded.
- Which tools need qualification, at which TQL, and with which kit.
Build evidence you can explain
A good coverage report lets an engineer explain what was tested, which requirements were verified and how each remaining gap was resolved.
Agree on the coverage approach early and keep the links between requirements, tests, results and code up to date. Then that explanation stays straightforward throughout development and certification.
Nohau can help you explore how Cantata fits into your C and C++ verification workflow.
For more information, please contact us.
© QA Systems GmbH and Nohau Solutions 2026