# How the GoogleTest Death Test Style Flag Affects Test Execution: threadsafe vs fast

> Discover how GoogleTest death test styles threadsafe vs fast impact execution speed and thread safety. Learn when to use each for optimal test performance.

- Repository: [Google/googletest](https://github.com/google/googletest)
- Tags: deep-dive
- Published: 2026-08-30

---

**The `--gtest_death_test_style` flag (or `FLAGS_gtest_death_test_style` variable) selects between "fast" mode, which forks the current process and inherits threads for speed, and "threadsafe" mode, which spawns a pristine process for isolation, directly impacting both execution speed and thread safety.**

The `google/googletest` repository provides the **death test style flag** to control how `ASSERT_DEATH` and related macros spawn child processes for crash verification. Defined in the internal portability headers and implemented in the death test source files, this flag selects between two distinct execution models that handle process forking and thread inheritance differently according to the target platform.

## What Is the Death Test Style Flag?

The **death test style flag**, accessible via the command-line argument `--gtest_death_test_style` or the global variable `FLAGS_gtest_death_test_style`, selects between two execution strategies: **fast** and **threadsafe**. The default value is defined in [`googletest/include/gtest/internal/gtest-port.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/internal/gtest-port.h) via the macro `GTEST_DEFAULT_DEATH_TEST_STYLE`, which evaluates to `"fast"` unless overridden at compile time.

In `googletest/src/gtest-death-test.cc`, the framework reads this flag during death test instantiation to determine whether to use the `DeathTestFactory` (fast) or the `ThreadSafeDeathTestFactory` (threadsafe) when creating the subprocess that executes the crash scenario.

## How the Fast Style Works

Under the **fast** style, GoogleTest uses `fork()` on POSIX systems to create a child process that executes the death test code. As implemented in `googletest/src/gtest-death-test.cc`, this method duplicates the parent process address space, including all existing threads and memory state.

Because the child inherits the parent's threads, any mutexes held or background threads spawned before the fork may cause deadlocks or race conditions in the child. This approach minimizes overhead by avoiding full process initialization, but it assumes the test code does not interact with thread-local storage or spawn additional threads after the fork point.

## How the Threadsafe Style Works

The **threadsafe** style launches a completely new process rather than using `fork()`. According to the implementation in `googletest/src/gtest-death-test.cc`, this mode spawns a fresh process with cleaned global state and no inherited threads, using pipe communication to return the death test result to the parent.

This isolation prevents thread-related issues but incurs higher overhead due to process creation costs. The threadsafe mode is essential when testing code that creates threads, uses thread-local storage, or runs under sanitizers like ThreadSanitizer that cannot handle the thread inheritance of the fast style.

## Configuring the Death Test Style

You can configure the style at runtime via command line:

```bash
./test_executable --gtest_death_test_style=threadsafe

```

Or programmatically before calling `RUN_ALL_TESTS()`:

```cpp
#include <gtest/gtest.h>

int main(int argc, char **argv) {
  ::testing::InitGoogleTest(&argc, argv);
  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
  return RUN_ALL_TESTS();
}

```

## When to Use Each Style

Choose the appropriate mode based on your test characteristics:

- **Fast**: Select this default for single-threaded tests where execution speed matters and the code under test does not spawn threads or rely on thread-local storage. This mode uses minimal system resources by leveraging `fork()` semantics in `googletest/src/gtest-death-test.cc`.

- **Threadsafe**: Enable this mode when testing multi-threaded code, using thread-local variables, or running under dynamic analysis tools like ThreadSanitizer. The implementation in `googletest/src/gtest-death-test.cc` creates a pristine process environment that prevents inherited thread deadlocks.

## Summary

- The **death test style flag** (`--gtest_death_test_style`) selects between `fast` (fork-based, default) and `threadsafe` (fresh process) execution models defined in [`googletest/include/gtest/internal/gtest-port.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/internal/gtest-port.h).
- **Fast** mode in `googletest/src/gtest-death-test.cc` provides lower latency but inherits parent threads, risking deadlocks in multi-threaded tests.
- **Threadsafe** mode isolates each test in a new process via `googletest/src/gtest-death-test.cc` implementation, eliminating thread inheritance issues at the cost of performance.
- Set the flag via command line or `FLAGS_gtest_death_test_style` variable before test execution begins.

## Frequently Asked Questions

### What is the default death test style in GoogleTest?

The default style is **fast**, defined by the `GTEST_DEFAULT_DEATH_TEST_STYLE` macro in [`googletest/include/gtest/internal/gtest-port.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/internal/gtest-port.h). This setting uses `fork()` on POSIX systems for minimal overhead unless explicitly overridden.

### Can I mix fast and threadsafe death tests in the same executable?

No, the style flag applies globally to the entire test execution. You must set `FLAGS_gtest_death_test_style` before `RUN_ALL_TESTS()` or via command-line argument, and all death tests in that run use the same style determined by the initialization logic in `googletest/src/gtest-death-test.cc`.

### Why do my death tests hang when using the fast style with threads?

The **fast** style inherits all threads from the parent process via `fork()`. If a thread holds a mutex or the test creates background workers, the child process may deadlock when those threads vanish while locks remain held. Switch to **threadsafe** mode to spawn a process without inherited threads from `googletest/src/gtest-death-test.cc`.

### How does the death test style flag affect Windows execution?

On Windows, where `fork()` is unavailable, the fast style behavior differs from POSIX, but the **threadsafe** style remains the safest option for process isolation. The flag controls process creation logic in `googletest/src/gtest-death-test.cc` across all platforms, ensuring consistent behavior when explicitly set to `threadsafe`.