Testing
Catch2 is popular for desktop C++ testing, but embedded developers often hit its limits when dealing with constrained targets. This guide covers advanced Catch2 configurations for bare-metal systems, cross-compilation pipelines, and testing on real or emulated hardware. Catch2 v3 vs v2 for Embedded Catch2 v3 is a header
Testing
Embedded C++ development presents unique testing challenges: hardware dependencies, limited resources, and real-time constraints make traditional unit testing difficult. GoogleTest, when configured correctly, handles all of these—letting you test firmware logic on your development machine before it ever touches silicon. Why GoogleTest for Embedded C++ GoogleTest (GTest) is
Testing
Hardware-in-the-Loop (HIL) testing puts real firmware under test by simulating the physical environment it would operate in. While basic HIL setups test simple I/O, production-grade HIL rigs implement sophisticated patterns for automotive ECUs, industrial controllers, and IoT devices. This guide covers the architectural patterns that
Testing
Arduino and ESP32 projects often lack automated testing, relying on manual "flash and observe" workflows. This guide builds a complete CI pipeline: unit tests that run on your host machine in milliseconds, integration tests that run on real hardware, and GitHub Actions that tie everything together. The Testing
C++
ThreadSanitizer (TSan) is a dynamic analysis tool built into Clang and GCC that detects data races, deadlocks, and other concurrency bugs in C++ programs. It instruments your binary at compile time and reports races with precise stack traces. Enabling TSan Compile with -fsanitize=thread and link with the same flag:
Go
Go's race detector is a built-in tool that instruments your program to detect concurrent access to shared memory without synchronization. It's one of the most effective dynamic analysis tools available in any language — and it ships with the standard Go toolchain. Enabling the Race Detector
Rust
Testing async Rust code requires an async runtime. Tokio provides the #[tokio::test] attribute macro that wraps your test in an async executor. This post covers patterns for testing futures, concurrent tasks, timeouts, and async traits. Basic Async Tests Use #[tokio::test] instead of #[test] for async test functions: #[tokio:
Java
Testing concurrent Java code is harder than testing single-threaded code because race conditions and deadlocks are non-deterministic. This post covers advanced patterns: stress testing with JCStress, testing thread-safe collections, detecting deadlocks, and asserting asynchronous results. The Problem with Basic Thread Tests A naive test that starts threads
Node.js
uvu is an extremely fast Node.js test runner with a minimal API and near-zero overhead. It runs tests as plain Node.js scripts — no CLI magic, no configuration files. If you need a lightweight alternative to Jest or Vitest for a library or small project, uvu is worth
Node.js
Node.js has shipped a built-in test runner since v18 (stable in v20). It requires zero dependencies — no Jest, no Mocha, nothing to install. The API is familiar if you've used any other test framework. Basic Test Structure import { test, describe, it } from 'node:test'
Node.js
node-tap is a TAP-producing test runner for Node.js. TAP (Test Anything Protocol) is a text-based protocol for reporting test results that's been around since Perl — node-tap implements it with a rich assertion library, subtests, parallel execution, and built-in code coverage. Installing node-
Node.js
c8 (coverage using V8) measures code coverage by reading the coverage data that Node.js's V8 engine generates natively. Unlike Istanbul/nyc, it requires no code transformation or instrumentation — your source runs as-is, making it compatible with ES modules and faster to execute. How c8 Differs from