# How to Customize GoogleTest Output and Reporting: A Complete Guide to the Listener Architecture > Customize GoogleTest output and reporting by manipulating listeners and flags. Learn to add, remove, or replace reporters for enhanced test results. - Repository: [Google/googletest](https://github.com/google/googletest) - Tags: how-to-guide - Published: 2026-09-02 --- **You customize GoogleTest output and reporting by manipulating the TestEventListeners container to add, remove, or replace listeners such as the default console printer and XML/JSON generators, while using flags like --gtest_output to control built-in report formats.** The google/googletest framework provides a flexible **listener architecture** that allows you to intercept test events and redirect output to custom destinations. Whether you need to suppress console noise, generate specialized failure logs, or produce machine-readable reports in XML or JSON format, understanding how to customize GoogleTest output and reporting is essential for integrating GoogleTest into CI/CD pipelines and development workflows. The system centers around the `TestEventListeners` container defined in [`googletest/include/gtest/gtest.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/gtest.h), which manages the lifecycle of all output components. ## Understanding the Listener Architecture ### The TestEventListener Interface At the core of the system is the abstract base class `TestEventListener` declared in [`googletest/include/gtest/gtest.h`](https://github.com/google/googletest/blob/main/googletest/include/gtest/gtest.h) (line 930). This interface defines virtual callbacks for every stage of test execution, including `OnTestProgramStart`, `OnTestStart`, `OnTestPartResult`, and `OnTestEnd`. When you customize GoogleTest output and reporting, you implement these hooks to capture specific events. ### EmptyTestEventListener for Selective Overrides Rather than implementing all virtual methods, subclass `EmptyTestEventListener` (line 997 in [`gtest.h`](https://github.com/google/googletest/blob/main/gtest.h)). This no-op implementation provides empty overrides for every callback, allowing you to override only the events you care about, such as `OnTestPartResult` for failure logging. ### The TestEventListeners Container The concrete class `TestEventListeners`, implemented in `googletest/src/gtest.cc` (lines 5210-5250), acts as the registry for all active listeners. It maintains two built-in pointers: `default_result_printer_` (the console output) and `default_xml_generator_`/`default_json_generator_` (file reporters). The container owns a repeater that broadcasts events to every registered listener in sequence. ## Removing or Replacing the Default Console Printer To suppress the standard console output, remove the `default_result_printer` using the `Release` method. This transfers ownership to the caller, who must then delete the object to prevent memory leaks. ```cpp #include // Remove the built-in console printer so the test runs silently. int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); // `listeners()` returns the TestEventListeners singleton. ::testing::TestEventListeners& listeners = ::testing::UnitTest::GetInstance()->listeners(); // Release transfers ownership; we delete the object. delete listeners.Release(listeners.default_result_printer()); return RUN_ALL_TESTS(); } ``` *Reference*: `TestEventListeners::Release` removes the default printer from the internal repeater chain (see `googletest/src/gtest.cc` lines 5231-5235). ## Creating Custom Listeners for Bespoke Reporting Implement a custom listener by inheriting from `EmptyTestEventListener` and overriding specific callbacks. For example, capture `OnTestPartResult` to write failures to a separate log file while tests run silently. ```cpp #include #include class FailureLogger : public ::testing::EmptyTestEventListener { public: explicit FailureLogger(const std::string& path) : out_(path) {} void OnTestPartResult(const ::testing::TestPartResult& result) override { if (result.type() == ::testing::TestPartResult::kFatalFailure || result.type() == ::testing::TestPartResult::kNonFatalFailure) { out_ << "FAILURE in " << result.file_name() << ':' << result.line_number() << " – " << result.summary() << '\n'; } } private: std::ofstream out_; }; int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); ::testing::TestEventListeners& listeners = ::testing::UnitTest::GetInstance()->listeners(); listeners.Append(new FailureLogger("my_failures.txt")); return RUN_ALL_TESTS(); } ``` *Reference*: Subclassing `EmptyTestEventListener` is the recommended pattern for selective callback implementation (see [`docs/reference/testing.md`](https://github.com/google/googletest/blob/main/docs/reference/testing.md)). ## Configuring Built-in XML and JSON Reports GoogleTest provides built-in listeners for structured output. The `XmlUnitTestResultPrinter` and `JsonUnitTestResultPrinter` classes (defined in `googletest/src/gtest.cc` at lines 3983 and 4539) are automatically instantiated when you set the `GTEST_OUTPUT` environment variable or the `--gtest_output` flag using the syntax `xml:path` or `json:path`. ```cpp #include int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); // Request JSON output to a specific file via the flag. ::testing::GTEST_FLAG(output) = "json:custom_report.json"; // Alternatively, set the env var: export GTEST_OUTPUT=json:custom_report.json return RUN_ALL_TESTS(); } ``` *Reference*: The `--gtest_output` flag triggers the `JsonUnitTestResultPrinter` or `XmlUnitTestResultPrinter` according to the prefix provided (see [`docs/advanced.md`](https://github.com/google/googletest/blob/main/docs/advanced.md)). ## Combining Techniques for Production Workflows For production environments, you often need to silence the default printer, add a concise failure logger, and generate XML reports for CI systems. This pattern chains multiple modifications to the listeners container. ```cpp #include #include int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); // Silence the default printer. delete ::testing::UnitTest::GetInstance()->listeners().Release( ::testing::UnitTest::GetInstance()->listeners().default_result_printer()); // Add a concise printer that only prints failures. class TersePrinter : public ::testing::EmptyTestEventListener { public: void OnTestPartResult(const ::testing::TestPartResult& result) override { if (result.failed()) { std::cerr << result.summary() << std::endl; } } }; ::testing::UnitTest::GetInstance()->listeners().Append(new TersePrinter()); // Ask for XML output in a custom directory. ::testing::GTEST_FLAG(output) = "xml:reports/"; return RUN_ALL_TESTS(); } ``` *Reference*: This combines the removal technique from `gtest.cc` (line 5231) with the custom listener pattern documented in [`docs/reference/testing.md`](https://github.com/google/googletest/blob/main/docs/reference/testing.md). ## Summary - The `TestEventListeners` container in `googletest/src/gtest.cc` manages all output components through a repeater architecture that broadcasts events to registered listeners. - Remove the default console printer with `listeners.Release(listeners.default_result_printer())` to suppress standard output without affecting test execution. - Subclass `EmptyTestEventListener` when implementing custom reporting logic to avoid boilerplate for unused callbacks. - Use `--gtest_output` or the `GTEST_OUTPUT` environment variable with prefixes `xml:` or `json:` to trigger the built-in `XmlUnitTestResultPrinter` or `JsonUnitTestResultPrinter`. - Combine listener manipulation with environment flags to create sophisticated reporting pipelines that balance human readability and machine parseability. ## Frequently Asked Questions ### How do I completely silence GoogleTest console output? Call `listeners.Release(listeners.default_result_printer())` on the `TestEventListeners` instance returned by `UnitTest::GetInstance()->listeners()`, then delete the returned pointer. This removes the built-in printer from the repeater chain, preventing any console output while still allowing other registered listeners to function. ### What is the difference between TestEventListener and EmptyTestEventListener? `TestEventListener` is the abstract base class defining pure virtual callbacks for all test events, while `EmptyTestEventListener` is a concrete convenience class that provides empty implementations of these methods. When you customize GoogleTest output and reporting, subclass `EmptyTestEventListener` to avoid boilerplate for events you do not need to handle. ### How do I generate both XML and JSON reports simultaneously? GoogleTest only supports one built-in report format per run via the `--gtest_output` flag. To generate both formats, run the test binary twice with different output specifications, or implement a custom listener that writes both formats by subclassing `EmptyTestEventListener` and overriding `OnTestProgramEnd` to output the collected results in your desired formats. ### Can I modify the default printer behavior without replacing it? Yes. Use flags such as `--gtest_brief=1` to suppress successful test output, `--gtest_print_time=0` to hide elapsed times, or `--gtest_print_utf8=0` to disable UTF-8 characters. These modify the behavior of the existing `default_result_printer` without requiring you to remove it or implement a custom listener.