# How to Handle and Test Exceptions in GoogleTest: Complete Guide to Exception Assertions

> Learn to handle and test C++ exceptions in GoogleTest with EXPECT_THROW and ASSERT_THROW macros. Verify exception behavior efficiently and improve your test coverage.

- Repository: [Google/googletest](https://github.com/google/googletest)
- Tags: how-to-guide
- Published: 2026-09-02

---

**GoogleTest provides `EXPECT_THROW`, `ASSERT_THROW`, `EXPECT_NO_THROW`, and `EXPECT_ANY_THROW` macros in [`googletest/include/gtest/gtest.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/gtest.h) to verify C++ exception behavior, along with internal helper templates that validate exception types using `typeid` comparisons.**

Robust C++ applications require comprehensive error-handling verification. The GoogleTest framework offers dedicated assertion macros that let you verify whether code throws specific exceptions, remains exception-free, or throws any exception type. This guide demonstrates how to handle and test exceptions in GoogleTest using the actual implementation details from the `google/googletest` repository.

## Exception Assertion Macros in GoogleTest

The public interface for exception testing is defined in [`googletest/include/gtest/gtest.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/gtest.h) and documented in [`docs/reference/assertions.md`](https://github.com/google/googletest/blob/main/docs/reference/assertions.md). These macros wrap your code in try/catch blocks and validate the caught exceptions against your expectations.

### Testing for Specific Exception Types with EXPECT_THROW and ASSERT_THROW

Use `EXPECT_THROW(statement, exception_type)` to verify that a code block throws an exception of the exact specified type. The test continues execution even if the assertion fails. For fatal failures that immediately abort the current test function, use `ASSERT_THROW(statement, exception_type)`.

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

void DoSomethingDangerous() {
  throw std::runtime_error("System failure");
}

TEST(MyExceptionTest, ThrowsSpecificError) {
  // Non-fatal: test continues if this fails
  EXPECT_THROW(DoSomethingDangerous(), std::runtime_error);
  
  // Fatal: test aborts immediately if wrong type thrown
  ASSERT_THROW(DoSomethingDangerous(), std::logic_error);
  // This line never executes if the above ASSERT fails
}

```

### Verifying Code Does Not Throw with EXPECT_NO_THROW

The `EXPECT_NO_THROW(statement)` macro confirms that a statement completes without throwing any exception. Use `ASSERT_NO_THROW` for fatal failures. These are essential for testing normal execution paths where exceptions indicate bugs.

```cpp
int ComputeSafeValue() {
  return 42;
}

TEST(MyExceptionTest, NoExceptionPath) {
  EXPECT_NO_THROW(ComputeSafeValue());
  
  // Fatal variant
  ASSERT_NO_THROW(ComputeSafeValue());
}

```

### Accepting Any Exception Type with EXPECT_ANY_THROW

When the specific exception type matters less than the fact that an error occurred, use `EXPECT_ANY_THROW(statement)` or `ASSERT_ANY_THROW(statement)`. These macros pass if the statement throws any C++ exception regardless of type.

```cpp
void FunctionThatMayFail() {
  throw 42;  // Throws int, not std::exception
}

TEST(MyExceptionTest, AnyExceptionAccepted) {
  EXPECT_ANY_THROW(FunctionThatMayFail());
}

```

## Internal Implementation in gtest.h

According to the GoogleTest source code, the public macros expand to internal helper templates defined around lines 1797-1818 of [`googletest/include/gtest/gtest.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/gtest.h). The helpers `GTEST_TEST_THROW_`, `GTEST_TEST_NO_THROW_`, and `GTEST_TEST_ANY_THROW_` implement the actual exception handling logic. They catch exceptions, compare the caught type with the expected type using `typeid`, and report failures through GoogleTest's assertion result system when expectations are not met.

## Precision Testing with GoogleMock Matchers

For scenarios requiring inspection of exception values or messages, GoogleMock provides specialized matchers documented in [`docs/reference/matchers.md`](https://github.com/google/googletest/blob/main/docs/reference/matchers.md). The `Throws<E>(matcher)` and `ThrowsMessage<E>(matcher)` matchers allow you to assert on the actual content of the thrown exception.

```cpp
#include <gmock/gmock.h>
#include <vector>

using ::testing::Throws;
using ::testing::ElementsAre;

TEST(MyExceptionTest, ExceptionValueInspection) {
  EXPECT_THAT(
    []() { throw std::vector<int>{1, 2, 3}; },
    Throws<std::vector<int>>(ElementsAre(1, 2, 3))
  );
}

```

## Build Configuration and C++ Exceptions

Exception testing requires that C++ exceptions are enabled in your build. The GoogleTest source code checks the `GTEST_HAS_EXCEPTIONS` preprocessor flag to determine support. If exceptions are disabled, the exception macros become no-ops and may generate compile-time warnings. Ensure your compiler flags enable exceptions (e.g., `-fexceptions` for GCC/Clang or `/EHsc` for MSVC) when using these features.

## Summary

- **`EXPECT_THROW`** and **`ASSERT_THROW`** verify that code throws a specific exception type, with the latter aborting the test immediately on failure.
- **`EXPECT_NO_THROW`** and **`ASSERT_NO_THROW`** confirm that statements execute without throwing any exceptions.
- **`EXPECT_ANY_THROW`** and **`ASSERT_ANY_THROW`** accept any exception type when only the throw behavior matters, not the specific type.
- The implementation resides in [`googletest/include/gtest/gtest.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/gtest.h) using internal helpers like `GTEST_TEST_THROW_` that perform `typeid` comparisons.
- GoogleMock matchers (**`Throws<E>()`**, **`ThrowsMessage<E>()`**) provide fine-grained assertions on exception values and messages.
- These features require `GTEST_HAS_EXCEPTIONS` to be enabled; builds with disabled exceptions will produce no-op macros.

## Frequently Asked Questions

### What is the difference between EXPECT_THROW and ASSERT_THROW in GoogleTest?

`EXPECT_THROW` generates a non-fatal failure that records the error but allows the test function to continue executing subsequent assertions. `ASSERT_THROW` generates a fatal failure that immediately returns from the current test function, preventing any following code from running. Use `ASSERT_THROW` when subsequent test logic depends on the exception having occurred.

### How do I test that a function does not throw any exception?

Use `EXPECT_NO_THROW(statement)` or `ASSERT_NO_THROW(statement)` from [`googletest/include/gtest/gtest.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/gtest.h). These macros wrap your statement in a try block and fail the test if any exception is caught. This is particularly useful for verifying that "happy path" code remains exception-free during refactoring.

### Can I test exceptions if my build has C++ exceptions disabled?

No. According to the GoogleTest source code, when `GTEST_HAS_EXCEPTIONS` is false (exceptions disabled), the exception testing macros become no-ops and may emit compile-time warnings. You must compile with exceptions enabled (e.g., `-fexceptions` on GCC/Clang, `/EHsc` on MSVC) to use `EXPECT_THROW`, `ASSERT_NO_THROW`, or related macros.

### How do I verify the message or value of a thrown exception?

Use GoogleMock matchers from [`docs/reference/matchers.md`](https://github.com/google/googletest/blob/main/docs/reference/matchers.md). The `Throws<E>(matcher)` matcher lets you apply any matcher to the thrown exception object, while `ThrowsMessage<E>(matcher)` specifically checks the exception's `what()` string. Include `<gmock/gmock.h>` and use these within `EXPECT_THAT()` statements for granular exception inspection.