Testing & Automation

Ship with confidence. Catch bugs before your customers do.

Slow, manual testing holds teams back, and the bugs that slip through reach real users. We set up automated testing and wire it into your pipeline, so every change is checked on its own. You release faster, and you sleep better.

ISO 9001:2015 certified · TÜV SÜD-certified coverage tooling · safety-standard experience (ISO 26262, DO-178C, IEC 62304) · up to 100% MC/DC coverage

What we do.

Every change runs the gauntlet. Almost no bugs reach your customers.

Test automation

We turn slow, manual checks into automated tests that run on their own, for your software and your hardware. Less busywork, more coverage.

Unit testing

Tests around each part of your code, so problems show up early, at the smallest level, instead of late in the field.

Coverage toward 100%

We track coverage two ways: how many of your requirements are verified by tests, and how much of the code is exercised. You know exactly what is proven.

CI/CD regression testing

Tests run automatically on every change in your pipeline. If something breaks, you know right away, not after release.

Testing on real hardware

Tests that run against your actual target device, not just a PC. The behavior you verify is the behavior your customers get.

Setup & tooling

We set up the test framework, runners and reports, and leave you with a clean, repeatable system your team can own.

Types of tests we do

We test at every level, not just one.

Each level answers a different question. Together they catch the bugs a single layer would miss.

01

Unit testing

Individual functions and modules, in isolation.

Catches defects at the smallest level, early, and pinpoints the cause.
02

Integration testing

Modules working together: interfaces and data flow.

Finds the defects that live in the seams between components.
03

System testing

The whole product against its requirements, end to end.

Confirms it does what it should, as a complete product.
04

Regression testing

That new changes did not break what already worked.

Lets you change code confidently and release often.

How we test

Black-box and white-box, manual and automated.

We test from two angles, and run them whichever way fits your team and your product.

Black-box tests

Written from your requirements, without looking at the code. They check what the software should do, so they prove the product behaves the way it was specified. This is what drives requirements coverage.

White-box tests

Written with knowledge of the internal code, to reach specific paths and push code coverage. They prove how the software does it, down to the branch.

We deliver these as manual test procedures your team can run, or as automated tests that run on their own and inside your CI/CD pipeline.

Coverage

Coverage, measured two ways.

Two questions decide whether your software is proven: is every requirement verified by a test, and is the code itself exercised. We measure and report both.

Requirements coverage

Every requirement, proven by a test.

How many of your requirements are actually verified. We track it as a number, not a feeling, and link each requirement to the test that proves it.

Each requirement traced to the test that verifies it
Verification completeness tracked as a percentage
A traceability matrix for audits and reviews

Code coverage

And the code itself, to the right level.

We match code coverage to what your product needs, using the right tool for your project.

MC/DC

Highest rigour, for the most critical code
Decision

Every branch taken
Statement

Every line executed

Among the coverage tools we work with

Testwell CTC++Parasoft C/C++testgcovBullseyeCoveragedotCover (C#)

These are examples, not the full list. We use whatever your project needs.

A closer look

How we make your testing stronger.

Each piece adds confidence on its own, together they catch the bugs that matter, early.

Unit testing

We find problems at the smallest level, early, long before they reach the field. Each function and module gets its own tests, so a bug has nowhere to hide.

Tests per function and per module
Mocking and stubbing for parts that are hard to reach
Tools like Cantata and Parasoft C/C++test

Requirements coverage

Not just how much code runs, but how much of your spec is proven. We link every requirement to the test that verifies it, so you can see what is covered and what is still open.

Every requirement traced to a test that verifies it
Verification completeness tracked as a percentage
A traceability matrix for audits and submissions

Code coverage toward 100%

You know exactly how much of the code your tests exercise, and nothing important is missed. We measure real coverage and push it up where it counts.

Line, decision, and MC/DC coverage
Clear, readable reports
Coverage tools like Testwell CTC++ and gcov for C/C++, and dotCover for C#

CI/CD regression testing

Every change is checked automatically, so breakage is caught before release, not by your customers. Your team gets fast feedback on every commit.

Pipeline setup with Jenkins or GitHub Actions
Automatic test runs on every change
Fast feedback the moment something breaks

Testing on real hardware

We verify on your actual target device, not just a PC, so the behavior you test is the behavior your customers get.

On-target test execution
Reading results back from the device

Static analysis & architecture

We catch bugs without running the code and keep the structure clean as it grows, so quality holds up version after version.

Static analysis with Klocwork, Parasoft and Axivion
Architecture analysis with Lattix and Axivion
MISRA coding-rule checks

ISO 9001:2015 certified. An audited quality management system, scoped to software development per ISO/IEC 90003:2018. See the certificate

We work with the tools you already use.

We fit into common testing frameworks, coverage tools and CI/CD pipelines, so the setup feels native to your team, not bolted on. The ones below are examples, not the full list.

Unit testing

CantataParasoft C/C++testGoogle TestUnityMSTestxUnitNUnitpytestJUnitJestCustom frameworks

Coverage

Testwell CTC++Parasoft C/C++testgcovBullseyeCoveragedotCover (C#)JaCoCo (Java)coverage.py (Python)Istanbul (JS)

Static analysis

Parasoft C/C++testKlocworkAxivion

Architecture analysis

AxivionLattix

UI & E2E

SeleniumAppium

CI/CD

JenkinsGitHub ActionsGitLab CI/CDAzure DevOps

Case studies

Testing work we have delivered.

Verification and validation for an implantable device, with complete submission-ready reports.

Read it

Firmware, real-time software and the full test and tooling stack for a precision drug-delivery device.

Read it

A Bluetooth Low Energy (BLE) communication layer in C, built to a high quality bar and documented for submission.

Read it

See all case studies

Already have developers?

You do not need us to build the whole product. Many teams build in-house and bring us in just for the testing and automation layer. We plug into your existing team, code and tools, add the tests, the coverage and the pipeline, and hand it back so your developers can keep moving.

What you get

You walk away with a system your team can run.

Everything we set up is documented and runs in your own pipeline.

Every test we write: the test cases and their execution reports

An automated test suite

Coverage reports that show exactly what is tested

A working CI/CD pipeline

A test plan and clear documentation

A knowledge handover to your team

How it works

A simple path, start to finish.

We assess, set up, integrate and hand over, with a clear walkthrough for your team.

Assess

We look at your code, find the gaps, and understand your targets.

Set up

We build the framework, write the tests, and measure coverage.

Integrate

We wire it into your pipeline so it runs on every change.

Hand over

We hand over the tests, the setup and the know-how, with a clear walkthrough.

Watch

A quick look at Novodes.

Our short company video, what we build and how we work.

Watch & learn

Demos and talks.

Talks and tool demos on unit testing, coverage and automation.

March 2025

Cantata: GUI, CLI and QA MISRA

A tour of Cantata's GUI and command-line, plus QA MISRA analysis, with Novodes.

Chapters

0:00 Introduction
6:08 Test script generation
16:41 Instance management
32:07 Command-line interface
38:42 QA MISRA analysis

July 2024

CTC++ Testwell coverage explainer

Measure your embedded software's test coverage with CTC++ Testwell, from installation to insightful reports.

Chapters

0:00 Introduction
1:55 Project setup
3:06 Instrumentation
7:21 Coverage types
17:03 Report generation

June 2023 Hebrew

Embedded software testing & DevOps (Hebrew)

How to dramatically improve embedded software quality and release faster: methodologies, unit tests, and automating the testing process.

Chapters

Developing embedded software
What unit tests are and how to implement them
Automating the testing process

See all webinars

White paper

Testing & Test Automation for mission-critical software.

A deeper read on how we build testing in: the levels and types of tests, requirements and code coverage, testing on the real target, CI/CD, and real case studies.

Questions

Common questions.

Can you work with our existing code and tools?

Yes. We plug into the code, frameworks and pipeline you already have. You do not need to switch tools or rebuild anything to work with us.

Do we have to commit long-term?

No. Many teams start with a focused setup, then decide whether they want ongoing help. You get a complete, documented setup either way.

Which languages and targets do you support?

We test across the whole stack, firmware to cloud, and match the language to the layer. For firmware and embedded that is C and C++, run on the real target device, not just a simulator. For desktop and PC apps, mobile, web and backend we work in C#, Java, Python and JavaScript / TypeScript, among others. We pick the right languages and tools for your product.

Do you only test, or fix bugs too?

Both. Tests find the problems, and we can fix them as well. The goal is working software with high coverage, not just a list of failures.

What does “coverage” actually mean?

Two things, and we track both. Requirements coverage is how many of your requirements are verified by a test. Code coverage is how much of the code those tests exercise, measured as Statement, Decision and where needed MC/DC. High code coverage alone does not prove the software meets its requirements, so we report both, which matters most for regulated and safety-critical work.

Who owns the tests and the setup?

You do. The test suite, the pipeline and the documentation all stay with you, and we hand over the knowledge so your team can keep it running.

Who provides embedded software testing and test automation in Israel?

Novodes sets up testing and test automation for mission-critical software, including for teams that build the product in-house and bring us in only for the quality layer. We plug into your existing code, frameworks and pipeline.

What is the difference between black-box and white-box testing?

Black-box tests are written from the requirements, without looking at the code, to prove the software does what it should; this drives requirements coverage. White-box tests are written from the internal code to reach specific paths and push code coverage. We deliver both, run manually or automatically in CI/CD.

Can you get my embedded C/C++ code to high code coverage?

Yes. We push line and decision coverage as high as it counts and can reach 100% line and decision coverage where a project needs it, measured with C/C++ tools such as Testwell CTC++, Parasoft C/C++test, gcov and BullseyeCoverage.

Is your testing backed by a certified quality system?

Yes. Novodes is ISO 9001:2015 certified, audited by IQC (the Institute of Quality & Control), with a scope covering software development per ISO/IEC 90003:2018 (certificate I33807A). The testing and verification work runs under an audited quality management system.

Which testing tools does Novodes work with?

We fit into the tools you already use: Cantata, Parasoft C/C++test, Google Test, Unity, MSTest, xUnit and NUnit for unit testing; Testwell CTC++, gcov and BullseyeCoverage for C/C++ coverage, dotCover for C# and tools like JaCoCo, coverage.py and Istanbul for Java, Python and JavaScript; Klocwork, Parasoft and Axivion for static and architecture analysis; Jenkins, GitHub Actions, GitLab CI/CD and Azure DevOps for pipelines.