Mastering Embedded Testing in ESP-IDF: Unity and pytest-embedded with the Button Component Example

Embedded Systems


In the intricate world of embedded systems, ensuring the reliability and functionality of software is paramount. Embedded systems are often deployed in critical applications where a failure can have significant consequences. This is where the role of rigorous testing becomes undeniable. Testing not only helps in identifying and fixing bugs before deployment but also ensures that the system meets all the specified requirements and functions as expected in the real world.

Enter the Espressif IoT Development Framework (ESP-IDF), a popular choice for developing applications on ESP32 and other ESP-series microcontrollers. ESP-IDF not only provides a rich set of libraries and APIs for building complex applications but also offers robust tools for testing these applications. Among these tools, the Unity Testing Framework and pytest-embedded stand out for their effectiveness in testing embedded systems.

Unity is a lightweight, powerful unit testing framework designed for C programming, which is the bedrock of embedded system development. It provides a set of assertions for testing code and generates clear and concise results about test passes and failures. This simplicity and power make Unity an ideal choice for testing the logic of individual components in embedded systems.

Complementing Unity, pytest-embedded is a pytest plugin that extends the capabilities of unit testing to include the hardware layer. It allows developers to write test scripts in Python, which interact with the hardware and the Unity tests running on the device. This integration enables a comprehensive testing process, covering both the software logic and the interaction with the hardware.

Understanding the Button Component in Espressif IoT Solution

The button component in the Espressif IoT Solution serves as an excellent example to demonstrate the integration and functionality of testing frameworks in embedded systems. This component is a part of the Espressif IoT Solution’s extensive library, designed to handle button inputs in embedded applications. It simplifies the process of detecting various button events like single press, long press, and double press, which are common in user interfaces for embedded devices.

The button component abstracts the complexity involved in handling physical button inputs on ESP32-based devices. It provides a convenient way to manage debouncing and interpret different types of button presses, which are essential for creating responsive and reliable user interfaces. The component supports various button types, including GPIO (General Purpose Input/Output) based buttons and touch sensor buttons, offering versatility for different hardware setups.

Structure of the Button Component

In the Espressif IoT Solution repository, the button component is organized in a structured manner, typical of ESP-IDF components. The structure is as follows:

  • Source Files: The core functionality of the button component is encapsulated in C source files. These files contain the logic for handling button inputs, debouncing algorithms, and event detection mechanisms.

  • Header Files: Accompanying the source files are header files, which declare the functions, macros, and data structures used by the button component. These files provide the necessary interface for other parts of an application to interact with the button component.

  • Example Applications: The component includes example applications demonstrating its usage. These examples serve as a practical guide for developers to understand how to integrate the button component into their projects.

  • Test Directory: Crucially, the component contains a test directory, which is the focal point for our exploration of testing frameworks. This directory houses the test code written specifically for the button component.

    • Unity Test Files: Inside the test directory, you’ll find C files containing Unity tests. These files (button_test.c, for example) include a series of unit tests written in C, using Unity’s assertions to validate the functionality of the button component.

    • pytest-embedded Test Scripts: Alongside the Unity tests, there are Python test scripts designed for pytest-embedded. These scripts (, for instance) are used to automate the testing process, including flashing the test firmware to the device, running the Unity tests, and handling the interaction between the test code and the hardware.

The button component’s structure in the Espressif IoT Solution repository not only reflects the standard organization of components within the framework but also illustrates how embedded testing is seamlessly integrated into the development process. This integration is key to ensuring that each component of the Espressif IoT Solution is reliable and performs as expected in various scenarios.

Unity Testing Framework: Basics and Integration

Unity is a versatile and straightforward unit testing framework designed for C, the primary language used in embedded system programming. Its simplicity and ease of use make it an ideal choice for developers looking to implement unit tests in their embedded projects. Unity provides a set of assert macros for various data types and conditions, enabling developers to write comprehensive test cases that check the functionality of their code.

How Unity is Integrated into the Espressif IoT Solution Button Component

In the ESP-IDF framework, Unity is seamlessly integrated to facilitate unit testing of individual components like the button component. This integration is evident in the structure of the component’s directory, particularly within the test folder. Here, Unity tests are written as C files, which are then compiled and executed as part of the testing process. This approach allows for testing the internal logic of the component in isolation, ensuring that each function behaves as expected.

Exploring the button_test.c File: Understanding Test Cases and Assertions

The button_test.c file within the button component’s test directory is a concrete example of Unity in action. This file contains multiple test functions, each designed to test a specific aspect of the button component.

#include "unity.h"
#include "iot_button.h"

// Example setup function
void setUp(void) {
    // Code to set up test environment

// Example teardown function
void tearDown(void) {
    // Code to clean up after tests

// Example test function for button press
void test_button_press(void) {
    // Initialize the button
    button_handle_t btn_handle = iot_button_create(...);

    // Simulate a button press

    // Assert that the button state is as expected
    TEST_ASSERT_EQUAL(expected_state, actual_state);

    // Clean up

// Main function to run all tests
int main(void) {
    // Add more RUN_TEST calls for other test functions

Let’s break down the key elements of this file:

  • Test Functions: Each test function in button_test.c is structured to test a particular functionality of the button component. For instance, a test function might check how the component handles a button press event.

    void test_button_press(void) {
        // Test code here
  • Setup and Teardown: Unity allows for setup and teardown routines, which are executed before and after each test function, respectively. These routines are used to initialize the necessary environment for the test and clean up afterwards.

    // Example setup function
    void setUp(void) {
        // Code to set up test environment
    // Example teardown function
    void tearDown(void) {
        // Code to clean up after tests
  • Assertions: The core of Unity’s testing capability lies in its assertions. In button_test.c, you’ll find various assert macros being used, such as TEST_ASSERT, TEST_ASSERT_EQUAL, and TEST_ASSERT_NOT_NULL. These assertions validate the outcomes of different operations performed by the button component. For example, an assertion might check if the button state is correctly updated after a simulated press event.

    TEST_ASSERT_EQUAL(expected_state, actual_state);
  • Running Tests: The Unity framework provides a mechanism to execute all the test functions in the file. This is typically done through a main function that calls UNITY_BEGIN(), followed by calls to each test function, and concludes with UNITY_END(). This process executes each test and outputs the results, indicating success or failure.

    void app_main(void) {

The button_test.c file is a testament to how Unity can be effectively used to ensure the reliability of individual components in embedded systems. By writing targeted test cases and utilizing a variety of assertions, developers can confidently verify the functionality of their code, leading to more robust and error-free applications.

Automating Tests with pytest-embedded

pytest-embedded is a significant extension to the traditional testing approach in embedded systems. It’s a pytest plugin specifically designed to bridge the gap between software and hardware testing in the embedded domain. In the context of ESP-IDF, pytest-embedded plays a crucial role by enabling automated testing that involves both the software components and the actual hardware they run on. This tool brings the convenience and power of Python’s pytest framework to the embedded world, allowing for sophisticated test automation, hardware interaction, and comprehensive test coverage.

Setting up pytest-embedded for the Button Component

Integrating pytest-embedded with a component like the button in Espressif IoT Solution involves a few key steps. Firstly, the necessary Python dependencies, including pytest and pytest-embedded, must be installed. This setup enables the execution of pytest scripts that are written to test the button components.

In the button component’s test directory, alongside the Unity test files, there’s a specific setup for pytest-embedded. This setup typically includes a Python script (like that is responsible for automating the testing process. This script is configured to communicate with the ESP-IDF build system, ensuring that the correct firmware is compiled and flashed onto the target hardware for testing.

Writing Test Scripts: A Look at

The script is a prime example of how pytest-embedded is utilized in practice. This script contains Python code that defines the test environment, prepares the device under test (DUT), and specifies the test cases to be run. It uses various pytest-embedded functionalities to control the hardware, such as flashing the device, resetting it, and monitoring its output.

import pytest
from pytest_embedded import Dut'esp32s3')
def test_usb_stream(dut: Dut)-> None:
    dut.expect_exact('Press ENTER to see the list of tests.')
    dut.expect_unity_test_output(timeout = 300)

In this script, test cases are written as functions in Python. These functions can send commands to the DUT, receive and analyze its responses, and assert conditions based on the output. The script can interact with the Unity tests running on the device, parse their results, and report back in a structured format that’s easy to analyze.

How pytest-embedded Interacts with the Hardware and the Unity Framework

pytest-embedded shines in its ability to interact directly with the hardware. When a test script is executed, pytest-embedded takes care of establishing a communication link with the DUT, typically via a serial connection. It then handles the process of flashing the device with the firmware that includes the Unity tests.

def test_usb_stream(dut: Dut)-> None:
    dut.expect_exact('Press ENTER to see the list of tests.')
    dut.expect_unity_test_output(timeout = 300)

During test execution, pytest-embedded sends commands to the DUT and reads its serial output (using expect_exact() and expect_unity_test_output()). This interaction is crucial for tests that require hardware manipulation or rely on hardware states. For instance, in the case of the button component, pytest-embedded can simulate button presses and releases, and then use the output from the Unity tests to verify the correct behavior of the button handling code.

Furthermore, pytest-embedded integrates smoothly with the Unity framework running on the ESP32. It captures the test results output by Unity over the serial connection, interprets them, and presents them in the pytest format. This integration allows developers to leverage the strengths of both Unity and pytest-embedded, combining detailed unit testing with high-level test automation and hardware interaction.

In summary, pytest-embedded provides a powerful and flexible way to automate testing in ESP-IDF projects. By enabling direct interaction with the hardware and seamless integration with the Unity framework, it opens up new possibilities for thorough and efficient testing of embedded systems.

Running and Interpreting Test Results

Running tests in an ESP-IDF project using Unity and pytest-embedded involves a series of steps that ensure the software and hardware components work together seamlessly. Here’s how you can execute these tests, particularly for the button component:

  1. Build the Test Firmware: First, use the ESP-IDF build system to compile the test firmware. This firmware includes the Unity tests written for the button component.

  2. Flash the Firmware: Once the firmware is built, it needs to be flashed onto the ESP32 device. This step is crucial as it loads the test code onto the hardware.

  3. Execute pytest Script: Run the script using pytest. This script automates the process of initializing the test, interacting with the device, and executing the Unity tests.

    collected 1 item .                                                        [100%]
    ============================= 1 passed in 0.01s =============================
  4. Monitor the Test Execution: As the tests run, pytest-embedded communicates with the ESP32 through a serial connection, sending commands, and receiving outputs.

  5. View Results: Upon completion, the test results are displayed. pytest-embedded formats these results, making them easy to read and understand.

The output from running the tests is a combination of Unity’s detailed test results and pytest’s high-level summary. Unity’s output typically includes information about each test case, such as the name of the test, whether it passed or failed, and any relevant messages or values. pytest-embedded captures this output and integrates it into its own reporting system, providing a comprehensive view of the test results.

The pytest summary includes the number of tests run, the number of assertions made, and a tally of passed and failed tests. It may also include details about any errors or exceptions that occurred during testing.

Debugging Common Issues in Test Cases

When tests fail or produce unexpected results, debugging is essential to identify and resolve the underlying issues. Here are some common strategies for debugging test cases in Unity and pytest-embedded:

  • Review Test Assertions: Check if the assertions in your Unity tests accurately reflect the expected behavior of the component. Incorrect assertions can lead to false positives or negatives.

  • Analyze Serial Outputs: Look at the serial output from the ESP32 during the test. This output can provide insights into what the device was doing at the time of the test and can help pinpoint where things went wrong.

  • Check Hardware Setup: Ensure that the ESP32 device and any connected hardware are set up correctly. Hardware issues can often lead to failed tests.

  • Utilize Logging: Both Unity and pytest-embedded offer logging capabilities. Use these logs to track the flow of the test execution and to capture detailed information about the test environment and operations.

  • Isolate Test Cases: If you’re facing issues with a specific part of your test suite, isolate and run individual test cases. This can help in identifying the exact source of the problem.

By following these steps and utilizing these debugging strategies, developers can effectively run and interpret test results, ensuring that their ESP-IDF projects are robust and reliable.

Best Practices for Writing Effective Tests

  1. Focus on One Aspect per Test: Each test case should focus on a single functionality or aspect of the code. This approach makes it easier to identify the cause of failures and enhances the readability of your tests.

  2. Use Descriptive Test Names: Name your test functions descriptively. The name should convey what the test is checking, making it easier to understand the purpose of the test at a glance.

  3. Keep Tests Independent: Ensure that each test is independent and can run on its own. Tests should not rely on the state left by previous tests or external factors.

  4. Utilize Setup and Teardown Functions: Use setup functions to prepare the environment for each test and teardown functions to clean up afterward. This practice helps maintain a consistent state across tests.

  5. Assert with Precision: Use the most specific assertion possible. For example, instead of using TEST_ASSERT, use TEST_ASSERT_EQUAL if you are checking for equality. Precise assertions give clearer feedback when a test fails.

  6. Check for Both Positive and Negative Cases: Test not only for the expected behavior (positive testing) but also for how the code handles invalid or unexpected inputs (negative testing).

  7. Regularly Run Your Tests: Integrate testing into your regular development workflow. Regular testing helps catch issues early in the development process.

Strategies for Automating Tests with pytest-embedded

  1. Automate Repetitive Tasks: Use pytest-embedded to automate tasks that are repetitive and common across tests, such as flashing the device, resetting it, and standard output checks.

  2. Parameterize Tests for Different Conditions: Utilize pytest’s parameterization feature to run the same test under different conditions. This approach is efficient for testing various scenarios with minimal code duplication.'esp32s3')
  3. Simulate Real-world Scenarios: Design your tests to simulate real-world usage as closely as possible. This includes testing various hardware states and interactions.

  4. Handle Hardware Interactions Gracefully: When writing tests that interact with hardware, ensure that your test scripts can handle hardware variability and potential communication issues gracefully.

  5. Integrate Continuous Testing: Incorporate pytest-embedded tests into your continuous integration (CI) pipeline. This integration ensures that tests are run automatically on every code change, helping to maintain code quality.

  6. Use Logging for Debugging: Implement logging within your pytest scripts. Logs can be invaluable for debugging issues, especially when tests are run in an automated CI environment.

  7. Keep Test Scripts Maintainable: Write clean, readable, and maintainable test scripts. This practice is crucial as the complexity of tests grows and more people collaborate on the project.

By following these best practices, developers can create robust and efficient test suites using Unity and pytest-embedded, leading to higher quality and more reliable ESP-IDF projects.


As we reach the end of our exploration into the world of embedded testing with Unity and pytest-embedded in ESP-IDF, let’s recap the key takeaways from our journey. We delved into the intricacies of the button component, using it as a lens to understand how testing frameworks are integrated and utilized in ESP-IDF projects. We saw how Unity provides a solid foundation for writing unit tests in C, allowing us to verify the functionality of individual components. Complementing this, pytest-embedded brings the power of Python’s pytest framework to the embedded domain, enabling automated testing that encompasses both software and hardware aspects.

The importance of testing in the development cycle of embedded systems cannot be overstated. In a field where reliability and precision are paramount, rigorous testing ensures that the software not only meets its functional requirements but also behaves predictably in real-world scenarios. The combination of Unity and pytest-embedded in ESP-IDF projects represents a robust approach to achieving this reliability. Unity allows for detailed unit testing at the code level, while pytest-embedded extends these tests to the realm of hardware, ensuring that the software interacts correctly with the physical world.

For developers working with ESP-IDF, embracing these testing frameworks is not just a best practice but a pathway to building more reliable, efficient, and high-quality embedded applications. Whether you are developing a simple IoT device or a complex embedded system, the principles and practices of testing covered here are invaluable.

As you continue your journey in embedded development with ESP-IDF, I encourage you to integrate these testing methodologies into your workflow. Experiment with writing your own test cases, automate your testing processes, and observe how this elevates the quality and robustness of your projects. Remember, every test you write is a step towards a more reliable and robust application. Happy testing!


For those who wish to delve deeper into the topics discussed in this blog post, the following resources will prove invaluable. They provide detailed information and insights into the implementation and usage of Unity and pytest-embedded in ESP-IDF, particularly with respect to the button component.

  1. Button Component Source Code:

    • Button Component
      • This link directs you to the GitHub repository of the Espressif IoT Solution, where you can explore the source code of the button component, including its implementation and test cases.
    • LED Indicator Component
      • This link directs you to the GitHub repository of the Espressif IoT Solution, where you can explore the source code of the LED Indicator component, including its implementation and test cases.
  2. ESP-IDF Documentation:

    • Unit Testing in ESP32
      • This documentation provides a comprehensive guide on unit testing in ESP32, covering the basics of the Unity framework and how it is integrated into the ESP-IDF.
    • pytest in ESP-IDF
      • Here, you can find detailed information about using pytest-embedded in ESP-IDF. It offers insights into automating tests, handling hardware interactions, and integrating tests into the development cycle.

These resources are essential for anyone looking to understand and implement effective testing strategies in their ESP-IDF projects. They offer a wealth of information that ranges from basic concepts to advanced techniques, catering to both beginners and experienced developers in the field of embedded systems.