<!--
CT product overview web page copy (ct_contents.md) [EN]
- Publication-ready copy, tables, and figures written in web page section order
- [Section n | Component] comments: screen composition notes for that block (design reference only, not published)
- Source of facts: CT product manual, product brochures, TÜV SÜD certification material, and publicly approved white papers
- The Korean counterpart is ct_contents_kr.md. Use the matching image and resource language for each page.
-->

<!-- [Section 1 | Hero: H1 + product definition + CTA] -->

# CT | Dynamic Testing for Mission-Critical C/C++ Software

Automated unit, integration, and code-based testing to help teams reach coverage goals for mission-critical C/C++ software

## 1. What is CT?

**CT is a test automation solution for unit, integration, and code-based testing of mission-critical C/C++ software.** Provided by Suresofttech, CT brings together test-environment setup, test design and generation, execution, code coverage analysis, reporting, and traceability management.

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

**[Request a product demo](https://www.suresofttech.com/customer/inquiry.php)** · **[Discuss your environment](https://www.suresofttech.com/customer/inquiry.php)**

---

<!-- [Section 2 | Why CT: unit and integration verification required in safety-critical development] -->

## 2. 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](https://www.iso.org/standard/68388.html) 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. This table 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. This helps identify insufficiently covered code and execution paths, then design and manage the tests needed to improve them.

<!-- English page asset: images/ct-code-coverage-ui-en.png -->
![Example CT code coverage results — C/C++ source code, function-level statement, branch, and MC/DC coverage, and control-flow graph](images/ct-code-coverage-ui-en.png)

*An explanatory visual reconstructed from the CT interface to show source-, function-, and control-flow-level coverage information together. Values shown are examples.*

---

<!-- [Section 3 | Core capabilities: unit/integration/code-based testing, AI collaboration, and CI-based repeated verification] -->

## 3. CT capabilities for verification work

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

### 3-1. 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 wording principle: Do not treat AI output as automatic certification evidence. Confirm it through actual execution results and code coverage. -->
### 3-2. 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 **CT DVERA, a verification agent inside your coding agent**. They are complementary: the work location and the way CT functions are invoked are different.

| Comparison | CT ALIRA AI | CT 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 CT 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 |

#### CT DVERA — a verification agent inside your coding agent

CT DVERA (Dynamic Verification Agent) is a verification agent inside your coding agent. It connects **AI coding agents to CT verification tasks using the working context of code, requirements, and change history**. It uses MCP- and Skill-based connections with CT engine functions for analysis, build, execution, and result aggregation. It can be used with **Claude Code, Codex CLI, Cursor, and GitHub Copilot**.

| Task | Role of CT 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 CT 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 wording principle: The scope of JUnit format CI results must be confirmed for the applicable CT version and integration environment. -->
### 3-3. 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, Suresofttech's ASPICE assessment support tool |
| Result use | Provides test and coverage results as review reports and JUnit format CI integration results |

#### CI-based verification workflow

<!-- English page asset: images/ct-cicd-product-flow-enhanced-en.png -->
![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](images/ct-cicd-product-flow-enhanced-en.png)

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

---

<!-- [Section 4 | Tool certification and application scope: distinguish TÜV SÜD certification from aerospace tool qualification] -->

## 4. CT tool certification and application scope

### CT 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. It is 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.

---

<!-- [Section 5 | FAQ: adoption, integration, and operation decisions without repeating the main text] -->

## 5. 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 CT DVERA be used immediately as verification evidence?

No. CT ALIRA AI and CT 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. JUnit format CI integration results 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.

---

<!-- [Section 6 | Resource library: only publicly approved white papers, product materials, and demo videos] -->

## 6. CT resource library

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

### White papers

<!-- WHITEPAPER-LIST:START | This section is updated from source metadata and generated HTML/PDF outputs. Link the title to the web reading page when the HTML is published. -->
| White paper | Summary | PDF download |
|---|---|---|
| Code-Based Test of CT | Explains how CT connects existing Google Test assets with code-based testing, code coverage, requirements traceability, and AI-assisted test code generation. | [Download PDF](whitepapers/en/Whitepaper_Code-Based_Test_of_CT.pdf) |
| CT's Analysis-Enriched AI Test Generation | Explains how CT uses C/C++ project analysis and build context for AI test generation, then improves tests with compilation, execution, and coverage feedback. | [Download PDF](whitepapers/en/Whitepaper_CTs_Analysis-Enriched_AI_Test_Generation.pdf) |
| AI-Powered Software Testing: CT's AI Assistant Feature | Introduces how CT's AI Assistant supports C/C++ test environment setup, test generation, error analysis and correction, and requirements-based testing. | [Download PDF](whitepapers/en/Whitepaper_AI-Powered_Software_Testing_-_CTs_AI_Assistant_Feature.pdf) |
| Verifying ISO 26262 Software Using CT | Explains how CT supports software unit and integration testing, structural coverage, execution environments, traceability, and documentation for ISO 26262 projects. | [Download PDF](whitepapers/en/Whitepaper_Verifying_ISO_26262_Software_Using_CT.pdf) |
| Using CT for DO-178C Software Verification | Explains how CT supports requirements-based testing, structural coverage, result review, and tool-qualification considerations for DO-178C software verification. | [Download PDF](whitepapers/en/Whitepaper_Using_CT_for_DO-178C_Software_Verification.pdf) |
| Efficient Testing Strategies with Team Testing and CI/CD in CT | Describes how teams share test assets and results, repeatedly execute tests in CI/CD pipelines, and manage the results with CT. | [Download PDF](whitepapers/en/Whitepaper_Efficient_Testing_Strategies_with_Team_Testing_and_CICD_in_CT.pdf) |
| Source Code Changes in Regression Testing: Adapting with Self-Healing Technology | Explains CT's self-healing approach for adapting and reusing existing tests after source code changes to reduce regression-test maintenance effort. | [Download PDF](whitepapers/en/Whitepaper_Source_Code_Changes_in_Regression_Testing_-_Adapting_with_Self-healing_Technology.pdf) |
<!-- WHITEPAPER-LIST:END -->

> **Note:** The DO-178C white paper is reference material for aviation projects and is separate from CT's TÜV SÜD certification scope.

### Product materials

| Material | Summary |
|---|---|
| [CT AI Test Generation Product Brochure](product-materials/en/CT2026.06-AI-Test-Generation.pdf) | Introduces the overall CT AI test-generation configuration, including embedded C support, structure-, requirement-, and specification-based generation, AI-assisted correction, and DVERA integration. |
| [CT AI Test Generation Product Brief](product-materials/en/CT2026.06-AI-Test-Generation-Brief.pdf) | Summarizes CT AI test generation for closed-network and on-premises LLM environments, including DVERA integration. |

### Demo videos

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

<!-- DEMO-VIDEO-LIST:START | Complete CodeScroll YouTube list. Preserve newest-first order; show 10 entries per web page. -->
| # | Demo video | Focus |
|---:|---|---|
| 1 | [Meet CT DVERA \| AI Test Generation for Safety-Critical C/C++ Inside Your Coding Agent](https://youtu.be/z6pcroUoKbQ) | DVERA concept and CT verification requests from coding agents |
| 2 | [Requirements-Based Test Generation with CT ALIRA AI](https://youtu.be/-AQCfk3h8pc) | Requirements-based test generation with ALIRA AI |
| 3 | [Self-Hosted Models, Mission-Critical Ready — CT ALIRA AI](https://youtu.be/fodXm5B0cFg) | Self-hosted model use with ALIRA AI |
| 4 | [Test Reconfiguration with CT ALIRA AI](https://youtu.be/nV056hK79jw) | Test reconfiguration with ALIRA AI |
| 5 | [Test Environment Setup with CT DVERA](https://youtu.be/uRfUqfWCmEY) | DVERA-based test environment setup |
| 6 | [Requirements-Based Test Generation with CT DVERA](https://youtu.be/wCdB96JE0Ug) | Requirements-based test generation with DVERA |
| 7 | [Automating Unit Tests with AI & MCP: From Natural Language to Execution](https://youtu.be/eUbzt9NBEuk) | AI and MCP workflow from natural language to unit-test execution |
| 8 | [Self-Healing Tests in Jenkins: AI Fixes Compilation Errors Automatically](https://youtu.be/EwqOzhq1m4M) | AI-assisted compilation-error recovery in Jenkins |
| 9 | [Auto-Generate Code-Based Tests & Reach Target Coverage (Jenkins AI Plugin)](https://youtu.be/yTCDPmLYAlA) | Code-based test generation and coverage improvement in Jenkins |
| 10 | [How AI Masters Complex C++ Testing: CT's Analysis-Enriched Generation Demo](https://youtu.be/jbRgSzh_J-U) | Analysis-enriched C++ test generation |
| 11 | [Code-Based Testing: Write Tests Your Way in CT](https://youtu.be/yO01dcgJKl4) | Code-based test authoring and management |
| 12 | [Docker Container Testing: Reliable Results Every Time in CT](https://youtu.be/fQuAmrs7KGs) | Docker-based CT test execution |
| 13 | [AI Chatbot for Instant Feature Guidance in CT](https://youtu.be/AaS7fvOysdA) | CT AI chatbot guidance |
| 14 | [Synchronizing Source Changes to CT](https://youtu.be/WN5o2X8F30c) | Source-change synchronization |
| 15 | [Debugging with VS Code](https://youtu.be/wV9uHKw1FjE) | VS Code debugging |
| 16 | [CT and Codebeamer Integration](https://youtu.be/aAydzxQOyh4) | codebeamer integration |
| 17 | [Stub Troubleshooting Guide](https://youtu.be/0iDXFjJK_r4) | Stub troubleshooting |
| 18 | [How to fix Testcase Error using AI Assistant](https://youtu.be/pDDJKPp-n-w) | AI-assisted test-case error correction |
| 19 | [How to fix Stub Error using AI Assistant](https://youtu.be/Dk46pYR_KTo) | AI-assisted stub error correction |
| 20 | [CT Jenkins Plugin on Linux - Integrating CT into CI/CD Environments](https://youtu.be/eLaFuDcjLls) | Jenkins plugin setup on Linux |
| 21 | [CT Jenkins Plugin (Self-healing)](https://youtu.be/eVcWqIMxrkE) | Self-healing with the Jenkins plugin |
| 22 | [CT Jenkins Plugin](https://youtu.be/fIEAqIiJGQ4) | Jenkins plugin overview |
| 23 | [Scenario Test (Time-based Test Design)](https://youtu.be/YnxF6nIeb38) | Time-based scenario-test design |
| 24 | [Scenario Test (Checking Variable Values at Specific Times)](https://youtu.be/ei33x2zq9O4) | Variable-value checks at specified times |
| 25 | [Team Testing - Checking Coverage in Dashboard](https://youtu.be/jzGOaGfsXH0) | Coverage review in Team Testing dashboard |
| 26 | [Team Testing - Resolving Conflicts (User Stubs)](https://youtu.be/67QPhrysG5k) | User-stub conflict resolution |
| 27 | [Team Testing - Committing & Updating User Stubs](https://youtu.be/77Dpg8CYoeo) | User-stub commit and update |
| 28 | [Team Testing - Committing & Updating Source Code Changes](https://youtu.be/k6801k-71BQ) | Source-code change commit and update |
| 29 | [Team Testing - Creating and Importing Team Projects](https://youtu.be/Enyc5AFeTho) | Team project creation and import |
| 30 | [C++ Test Reuse](https://youtu.be/zN5j44T8IHo) | C++ test reuse |
| 31 | [Controller Tester Mock](https://youtu.be/aZR_Zi3pclA) | Mock-based testing |
| 32 | [Setting Expectations for Class Functions Used in Tests with Mock Feature](https://youtu.be/sWG40v5LYx0) | Expectations for mocked class functions |
| 33 | [Testing Functions Dependent on Abstract Classes Using Mock Feature](https://youtu.be/5Zh80Qt8Ty0) | Testing abstract-class dependencies with mocks |
| 34 | [Testing Unreachable Defense Code](https://youtu.be/_5Fz4tezMpI) | Testing unreachable defensive code |
| 35 | [Variable Capture and Debugging](https://youtu.be/1eC2ylOw96w) | Variable capture and debugging |
| 36 | [Importing Projects with Requirement Traceability Information](https://youtu.be/d3hToifvifA) | Project import with requirement traceability |
| 37 | [Requirements Test Coverage Report](https://youtu.be/i90RzWeFTIs) | Requirements test coverage reporting |
| 38 | [Testing Based on Requirements Imported from CSV Files](https://youtu.be/WrSR57DZ24U) | Testing from CSV-imported requirements |
| 39 | [Batch Input of Test Case IDs](https://youtu.be/OaNEwS3xzfM) | Batch test-case ID input |
| 40 | [Reviewing Tests When Requirements Change](https://youtu.be/_JvBqHNwZzg) | Test review after requirement changes |
| 41 | [Automatic Linking of Requirements and Tests](https://youtu.be/ObQ6YKvT_eQ) | Automatic requirement-to-test linking |
| 42 | [Requirements-Based Testing with Polarion](https://youtu.be/1F_p4nzfQBc) | Requirements-based testing with Polarion |
| 43 | [Identifying Causes of Test Execution Errors](https://youtu.be/gUE7k0lVjrI) | Test execution error analysis |
| 44 | [Streamlined Project Export: Save and Share Your Test Environment](https://youtu.be/L8qqalGCW90) | Project export and test-environment sharing |
| 45 | [Quick Project Import: Seamlessly Continue Your Testing Journey](https://youtu.be/qIeC_bD2kWA) | Project import |
| 46 | [CT Tutorial](https://youtu.be/SmOkWjx0JH0) | CT tutorial |
| 47 | [CT Performance: Handling One Million Test Cases Effortlessly](https://youtu.be/ZKxtRhKRxe8) | Large-scale test-case management |
| 48 | [CT: Target Environment Setup for Automated Testing](https://youtu.be/qrxyeIPoeHA) | Target-environment setup |
| 49 | [CT in Action: Running Tests on Real Target Hardware](https://youtu.be/tdGq3xJJq-E) | Test execution on real target hardware |
| 50 | [CT Tutorial](https://youtu.be/AIGbpDwn1Ko) | CT tutorial |
| 51 | [CT 3.3 Debug Information](https://youtu.be/Uj-txYDnnqQ) | Debug information review |
| 52 | [CT 3.3 Export Project](https://youtu.be/fUKgMYG6soE) | Project export |
| 53 | [CT 3.3 Import Project](https://youtu.be/k17M0b-4a6w) | Project import |
| 54 | [Checking Variable / Expression Values](https://youtu.be/eadBSSvMSw8) | Variable and expression values |
| 55 | [Online Help](https://youtu.be/zgGoBwagf60) | Online help |
| 56 | [Tool Language Settings](https://youtu.be/9fNDj9z_6H8) | Interface language settings |
| 57 | [Test Reuse (Target Function Changed)](https://youtu.be/8XSmLxX59eQ) | Test reuse after target-function changes |
| 58 | [CT 3.4 Linux Build Target Testing](https://youtu.be/ShPfSjoprhQ) | Target testing in a Linux build environment |
| 59 | [Test Reuse (Global Variable Changed)](https://youtu.be/wWTSY8WMBew) | Test reuse after global-variable changes |
| 60 | [Controller Tester Test Reuse](https://youtu.be/eGfac1NPk24) | Legacy Controller Tester test reuse |
| 61 | [CT 3.2 Target Environment Setup](https://youtu.be/-jpHIv3SVsE) | Target-environment setup |
| 62 | [CT 3.2 Run Target Tests](https://youtu.be/XhI0RfJtG9s) | Target-test execution |
<!-- DEMO-VIDEO-LIST:END -->

---

<!-- [Section 7 | CTA: connect to product demo and environment consultation] -->

## 7. Next step

**Discuss the CT test scope and integration approach for your project environment.**

- **[Request a product demo](https://www.suresofttech.com/customer/inquiry.php)**
- **[Discuss your environment](https://www.suresofttech.com/customer/inquiry.php)**

More CT demos are available on the [CodeScroll YouTube channel](https://www.youtube.com/@codescroll/videos).

---

Last updated: 2026-09-21