3 Tips to Automating Tests for Embedded Systems

Test automation allows developers to focus on development while allowing the quality of the product to be continuously tested and monitored.

Jacob Beningo

June 25, 2024

6 Min Read
An example of a Continuous Integration/Continuous Delivery (CI/CD) pipeline for testing embedded systems.
An example of a Continuous Integration/Continuous Delivery (CI/CD) pipeline for testing embedded systems.Jacob Beningo

At a Glance

  • Adopt SOLID principles for arranging functions and data structures into modules and classes.
  • Use Test-Driven Development to incrementally build software that allows test cases to drive production code development.
  • Integrate your testing processes with a Continuous Integration/Continuous Delivery (CI/CD) pipeline.

No matter what type of embedded system you build, you must test it. Tests give us a warm fuzzy feeling that our system works correctly under specific environmental and operational conditions. While they can’t prove the absence of bugs, they can improve our confidence that the system will work as expected. 

Traditionally, embedded systems teams haven’t done a great job with testing. They tend to focus on manual testing or spot-checking, which often leaves holes in the test process. Sometimes defects can find their way into production, or if they are caught beforehand, they can result in significant time investment to make the system work correctly. 

A solution to this problem is to adopt test automation. Test automation uses specialized software tools and scripts to execute pre-defined test procedures automatically without human intervention. Ultimately, it frees up developers to focus on development while allowing the quality of the product to be continuously tested and monitored. 

Let’s examine three tips for automating embedded systems testing. These tips will help you easily test your software. 

Tip #1: Adopt SOLID Principles

If you are going to automate your tests, you must write software that is testable. Sure, you can automate system-level tests, but you also need tests that can check individual functions, modules, integration, system performance, and much more. To do that, you must write modular and loosely coupled software through abstractions. 

Related:5 Must-Have Tests for Robust Embedded Systems

SOLID principles tell developers how to arrange functions and data structures into modules and classes and how they should be interconnected. The goal of these principles is to create software that:

  • Easily tested

  • Tolerates change

  • Understandable

SOLID is broken up into five principles that can be summarized as:

  1. SRP: The Single Responsibility Principle. Each software module has one, and only one, reason to change.

  2. OCP: The Open-Closed Principle. For software systems to be easily changed, they must add new code rather than change existing code. 

  3. LSP: The Liskov Substitution Principle. To build software systems from interchangeable parts, those parts must adhere to a contract allowing substitution.

  4. ISP: The Interface Segregation Principle. Software designers are advised to avoid depending on things they don’t use.

  5. DIP: The Dependency Inversion Principle. High-level application code should not be dependent on low-level implementation details. 

If you follow these principles, you’ll find that the software you write can easily be unit-tested, integration-tested, simulated, and regression-tested. If you don’t follow these principles, well, you’ll find that it will take a lot of work to get your software in a state that makes test automation possible. 

Related:3 Tips for Getting Started with CI/CD

Tip #2: Use Test-Driven Development

Our next tip to help you adopt test automation is to use Test-Driven Development (TDD). TDD is a technique for incrementally building software that allows the test cases to drive the development of production code.

There are many advantages to using TDD such as:

  • Improved code quality through cleaner, less buggy code.

  • Better design due to developers thinking more carefully about what they are doing.

  • Code that is debugged more efficiently due to failing tests that pinpoint exactly what the problem is.

  • Reduced development time and cost by catching issues earlier in the development cycle.

  • Developers can refactor with confidence due to existing tests.

If you will use TDD, the first step is to set up a unit test harness like cpputest. The test harness itself is already a stepping stone for automating tests! You can configure the test harness to run all previous tests, which it will do automatically! 

Once you have the unit test harness in place, you can scale that solution with a continuous integration/continuous delivery (CI/CD) framework to ensure your tests are run automatically. 

Tip #3: Implement a CI/CD Solution

A key component of successful test automation is integrating your testing processes with a Continuous Integration/Continuous Delivery (CI/CD) pipeline. CI/CD is a method to frequently deliver apps to customers by introducing automation into the stages of app development. The main concepts attributed to CI/CD are continuous integration, delivery, and deployment.

Implementing a CI/CD solution can provide numerous benefits, including:

  • Early detection of issues by integrating and testing code regularly, which allows you to catch and address issues early in the development process, reducing the risk of significant bugs being discovered later.

  • Faster feedback loops by automating tests run in the CI/CD pipeline; these loops can provide immediate feedback to developers, allowing them to make necessary changes before their code is merged into the main branch.

  • Increased deployment frequency by enabling more frequent releases and quicker delivery of new features and fixes to end-users.

  • Consistency and reliability through automated processes that ensure builds and deployments are consistent and reliable, reducing human error and increasing confidence in the deployed software.

An example CI/CD pipeline might look something like the following:


To implement a CI/CD solution, you can follow these steps:

  1. Choose a CI/CD tool. There are many CI/CD tools available, such as Jenkins, GitLab CI, Travis CI, and others. Choose one that fits your team's needs and integrates well with your existing tools and workflows.

  2. Design your CI/CD pipeline. Define the stages of your pipeline, such as build, test, and deploy.

  3. Set up your CI/CD pipeline. Use your design and configure your chosen CI/CD tool to automatically trigger these stages whenever code is committed to the repository.

  4. Automate tests. Integrate your unit tests, integration tests, and other automated tests into the CI/CD pipeline. Ensure that these tests run automatically as part of the pipeline and provide immediate feedback.

  5. Continuous deployment. Configure your CI/CD pipeline to automatically deploy the application to a staging environment for further testing. Once the software passes all tests, it can be automatically or manually deployed to production.

Don’t let the Continuous Deployment stage concern you either. A lot of teams I work with don’t directly deliver to their end customers. Instead, they deliver internally until pushing something to the customer makes sense. 

By implementing a CI/CD solution, you automate your testing process and streamline your entire development workflow, enabling faster and more reliable software delivery.

Taking Your Next Steps

In today’s post, we’ve explored several tips to get you started with test automation for embedded systems. How you get started will depend on your experience and how far down the rabbit hole your team wants to go. 

At a minimum, there are a few simple steps you can follow to get started:

  1. Identify repetitive test activities.

  2. Design a CI/CD pipeline to run those repetitive activities.

  3. Install and configure a test harness.

  4. Write tests for those activities.

  5. Repeat the process.

Your testing process doesn’t have to start out perfect. Instead, identify a few small incremental steps you can take today. Make sure that you actually take those steps! Small improvements over time can create huge results! So don’t let some complex pipeline or test automation system scare you. 

By automating your testing, you’ll find that your system will become more robust, your architecture will be more scalable, and you’ll spend far less time debugging your code. Adopting test automation has very little for you to lose and much to gain. 

Be sure to view Jacob Beningo's week-long course on Test Automation Design for Embedded Systems, originally broadcast in May 2024 and available on demand here.

About the Author(s)

Jacob Beningo

Jacob Beningo is an embedded software consultant who currently works with clients in more than a dozen countries to dramatically transform their businesses by improving product quality, cost and time to market. He has published more than 300 articles on embedded software development techniques, has published several books, is a sought-after speaker and technical trainer and holds three degrees which include a Masters of Engineering from the University of Michigan.

Sign up for the Design News Daily newsletter.

You May Also Like