CT

Dynamic Testing for Mission-Critical C/C++ Software

For functional safety projects, CT supports C/C++ unit and integration verification. DVERA connects coding agents to CT through MCP and Skills.

Overview

Suresoft CT (Controller Tester) is a test automation solution for unit, integration, and code-based testing of mission-critical C/C++ software. CT brings together test-environment setup, test design and generation, execution, code coverage analysis, reporting, and traceability management to help teams reach coverage goals.

CT helps teams in automotive, aerospace, defense, railway, nuclear, and medical software improve test productivity while retaining reviewable verification evidence.

  • C/C++Supported languages
  • Statement, Branch, and MC/DCCode coverage
  • GCC · MSVC · Clang · Arm · Green Hills · Keil · Renesas and moreSupported toolchains

    The supported scope depends on compiler version, build options, target board, and debugger combinations.

  • IEC 61508 · ISO 26262 · IEC 62304 · IEC 60880 · IEC 62279/EN 50128 · EN 50716TÜV SÜD tool certification

    The certification applies to specific CT versions and functions defined in the certification report.

View supported versions and environments

Why CT for safety-critical software development?

Although wording differs by industry, standards for mission-critical domains consistently emphasize software unit and integration verification, confirmation of test sufficiency, and traceable verification results. Safety-critical teams therefore need more than a large number of tests: they need to design and execute relevant tests, review code coverage, and retain evidence of what was verified and how.

CT connects these activities through test design and execution, code coverage analysis, reporting, and traceability. The following example shows how the automotive standard ISO 26262-6:2018 addresses these activities.

Automotive example

ISO 26262-6

ISO 26262-6 treats software unit verification and software integration and verification as separate activities in software-level development.

ISO 26262-6 activity Meaning of the activity
9.4.2 Software unit verification Verifies individual software units using an appropriate combination of methods, including requirements-based testing, interface testing, control and data flow analysis, and fault injection. Function- or module-level testing is a practical interpretation of this activity.
10.4.2 Software integration and verification Verifies that integrated software units and components behave according to defined interfaces and interactions. Integration testing is a representative way to perform this activity.

Safety-critical projects need to repeat these activities and retain test conditions, expected results, execution results, code coverage, and requirement links in a reviewable form. CT manages these verification tasks in one workflow rather than splitting them between separate tools and manual work.

Verification need How CT supports it
Unit and integration testing Designs and executes tests at function, module, and interface levels while managing test conditions and data
Requirements- and structure-based verification Supports requirements-based test design and generation, together with test design based on code structure
Code coverage review Reviews statement, branch, and MC/DC results with source code and control-flow information to identify tests to improve
Verification evidence management Connects requirements, tests, execution results, and coverage for review reports and traceability records

Code coverage

Code coverage indicates which code and decision conditions were executed by tests. ISO 26262-6 recommends statement, branch, and MC/DC coverage according to ASIL, and the aerospace software standard DO-178C also treats structural coverage analysis as a verification activity according to software level. The applicable metric and target are determined by the domain standard, safety plan, and project requirements.

Automotive example

ISO 26262 coverage by ASIL

ISO 26262-6:2018 Table 9 recommends code coverage metrics for software units by ASIL. CT supports all three metrics below.

Code coverage metric ASIL A ASIL B ASIL C ASIL D CT support
Statement++++++Supported
Branch+++++++Supported
MC/DC+++++Supported

++ means highly recommended and + means recommended. The table above is an automotive example; the actual method and target are determined by the safety plan, requirements, and assessment criteria of each project.

CT enables teams to review source-line execution status, function-level statement, branch, and MC/DC coverage, test cases, and control-flow information together to identify insufficiently covered code and execution paths, then design and manage the tests needed to improve them.

Example CT code coverage results — C/C++ source code, function-level statement, branch, and MC/DC coverage, and control-flow graph
An explanatory visual reconstructed from the CT interface to show source-, function-, and control-flow-level coverage information together. Values shown are examples.

Key features

CT helps teams design and execute unit, integration, and code-based tests, then connect verification evidence with repeated verification.

Unit and integration test design and execution

CT supports the design and execution of tests at function, module, and interface levels, along with test conditions and data. Teams can consistently review test intent and results from individual functions through interactions between modules.

Code-based testing in CT uses code structure and analysis information to support test design, then verifies the outcome with actual execution results and code coverage.

CT can generate and manage Google Test-based tests, and it can also import and reuse existing Google Test projects and test code. New tests and existing test assets can be managed and executed in the same CT project.

AI-assisted test design and coding-agent-based verification

Unit and integration testing requires teams to adapt tests to requirements and code changes, then repeatedly review execution results and coverage gaps. CT AI features support draft test design based on requirements, source code, and existing tests, and help identify areas that need improvement through structural analysis. Generated results are reviewed for test intent and expected results, then confirmed with actual execution results and code coverage.

CT provides CT ALIRA AI for test design inside CT and DVERA, a verification agent inside your coding agent. The two are complementary: the work location and the way CT functions are invoked are different.

Comparison CT ALIRA AI DVERA
Primary workspace CT product interface AI coding agents such as Claude Code, Codex CLI, Cursor, and GitHub Copilot
Who invokes CT functions A CT user uses AI functions in the CT interface A coding agent requests CT verification work through MCP- and Skill-based workflows
Primary role Assists test design, generation, and error analysis from requirements and code structure Connects CT analysis, build, execution, and result aggregation to the working context of code, requirements, and changes
How results are used Reviews and improves test assets and execution results in CT Uses CT results in later code changes, test improvements, and regression verification tasks

Both CT ALIRA AI and DVERA assist test work, but CT performs the actual analysis, build, execution, and result aggregation. Final verification results are confirmed through actual execution results and code coverage.

CT ALIRA AI AI-powered test generation built into CT

In functional safety development, including ISO 26262-6, requirements-based testing and structure-based testing provide different kinds of verification evidence. CT ALIRA AI supports test design and generation from both perspectives.

Test design approach What CT ALIRA AI supports What CT confirms
Requirements-based testing Organizes test intent and scope from requirements and supports test design and generation. When requirements are registered in CT, links between requirements and tests can also be managed. Requirement interpretation, test intent, and traceability links
Structure-based testing Supports test design and generation from code structure, and improves tests needed for code coverage review. Execution results and statement, branch, and MC/DC coverage

DVERA C/C++ unit and integration verification from coding agents

DVERA (Dynamic Verification Agent) connects AI coding agents to CT for C/C++ unit and integration verification. Suresofttech Inc. provides the Model Context Protocol (MCP) server and Skills for this integration. DVERA uses the working context of code, requirements, and change history to request CT analysis, build, execution, and result aggregation. Supported coding agents include Claude Code, Codex CLI, Cursor, and GitHub Copilot.

Official DVERA MCP server and Skills: installation and connection

In the published Code Composer Studio setup demo, the user asks, “Set up this project for validation using CT.” DVERA helps configure the test environment and requests test execution. CT then displays coverage and a timeout result for an infinite loop. Successful environment setup does not mean every test passes. Watch the environment setup demo.

Task Role of DVERA and CT
Context-based test design and generation A coding agent considers requirements, source code, and changes together, then designs tests and requests CT work.
CT function requests and result use A coding agent requests CT analysis, execution, and coverage functions, then uses execution and coverage information for later test improvement and regression verification.

The detailed integration scope and automation level of DVERA depend on the CT version, coding agent, and customer environment. The scope of result updates in external ALM tools also depends on the integrated tool, version, and project process.

CI-based repeated verification and review-record linkage

Area Support
Repeated verification automation Provides a Jenkins plugin. CLI- and Docker-based execution enables CT verification jobs in CI environments including Jenkins, GitHub Actions, GitLab CI/CD, Azure Pipelines, TeamCity, and Bamboo; regression tests and code coverage analysis can run repeatedly after code changes.
Team collaboration Team Testing for sharing test assets and results across multiple PCs
Requirements traceability Connects requirements, tests, and results through Polarion, codebeamer, and V-SPICE, our in-house ASPICE assessment support tool
Result use Provides test and coverage results as review reports and CI integration results in JUnit format

CI-based verification workflow

CT CI-based verification workflow — code and test changes start CI, CT verification runs repeatedly, and results are used for reports, review records, and ALM traceability
Code and test changes start a CI run through a push or pull request. After CT testing and code coverage analysis, teams review verification criteria and connect results to reports, review records, and ALM traceability.

Tool certification and application scope

TÜV SÜD tool certification

CT holds TÜV SÜD tool certification. The certification applies to specific CT versions and functions defined in the certification report. Projects should confirm the applicable version and scope with the certificate and Certification Report.

Domain TÜV SÜD certified standard scope Verification activities CT supports in the project
Automotive ISO 26262 Unit and integration testing, statement/branch/MC/DC coverage, requirements traceability, and reporting
Railway IEC 62279 / EN 50128 and EN 50716 Unit and integration testing, code coverage, traceability, and reporting
Nuclear IEC 60880 Unit and integration testing, result, and report management
Medical devices IEC 62304 Test execution and result/traceability records
Electrical and electronic IEC 61508 Unit and integration testing, code coverage, and verification records

Note for aerospace projects

DO-178C and DO-330 are not within the scope of CT's TÜV SÜD tool certification. CT can support unit and integration testing, code coverage, requirements traceability, and reporting in aerospace projects, but this must not be represented as “DO-178C certification” of CT.

DO-330 is not a general certification granted to a tool once, but a framework for determining tool qualification according to how a tool is used in a project and which verification activities it reduces or automates. The required qualification level and evidence are determined project by project from the safety plan, intended use, and consultation with the certification authority.

Frequently asked questions

Which compiler and target environments can CT support?

CT supports a range of C/C++ environments, including widely used toolchains such as GCC, MSVC, Clang, Arm, Green Hills, Keil, and Renesas. Behavior that cannot be confirmed only in a host environment can be verified on real targets through Ethernet, Serial, or JTAG connections. The supported scope depends on compiler version, build options, target board, and debugger combinations.

How are requirements connected to tests and results?

CT connects requirements and tests, and manages execution results and coverage information together. Polarion, codebeamer, and V-SPICE integrations can import requirements or export linked result and design data. The connection method and automatic-update scope depend on the integrated tool, version, and project process.

How can CT be applied to functional safety and aerospace-standard projects?

CT has TÜV SÜD tool certification scope for IEC 61508, ISO 26262, IEC 62304, IEC 60880, IEC 62279/EN 50128, and EN 50716. The certification applies to the functions defined for a specific CT version in the Certification Report. Each project applies CT according to its safety plan, including test level, coverage target, traceability, and reporting format. DO-178C and DO-330 are not within CT's TÜV SÜD certification scope; aerospace tool qualification is determined for each project according to intended use and the use of verification evidence.

Can tests created with CT ALIRA AI or DVERA be used immediately as verification evidence?

No. CT ALIRA AI and DVERA support test design and improvement work. Generated tests are reviewed for test intent, data, and expected results, then verified through actual execution results and code coverage. CT performs the actual analysis, build, execution, and result aggregation, so the verification evidence a project reviews comes from CT execution results and statement, branch, and MC/DC coverage rather than from the generated test code itself.

How are CT reports and CI integration results used differently?

CT reports collect test results, coverage, and traceability information for project reviews and certification evidence. CI integration results in JUnit format are used for automated pipeline decisions and integration with other development tools. Available formats and detailed scope depend on the CT version and integration environment.

Resource library

Select CT materials about functional safety, AI-assisted testing, and CI-based test operations.

White papers

Demo videos

Demo videos below are listed in newest-first order. The web page displays 5 videos per page.

More CT demos are available on the CodeScroll YouTube channel.

Contact us

For questions about CT’s features or supported environments, contact us using the button below.