Omkar Yadav

This commit introduces **proactive timeout stack trace capture** for **Android Instrumentation tests**, mirroring existing functionality for Robolectric. It integrates `TpxTimeoutBufferManager` into `InstrumentationTestRunner` to capture thread dumps just before a test times out, significantly improving diagnostics for hanging tests. To achieve this, `TpxTimeoutBufferManager` and `ThreadDumpUtils` were **refactored** into a new shared `:timeout` BUCK target, allowing `instrumentation` to depend on it without pulling in `junit`. This **new capability** is controlled by the `ANDROID_PROACTIVE_TIMEOUT_ENABLED` environment variable, providing crucial debugging information for **flaky Android test failures**.

This commit **introduces a new feature** to **Android instrumentation tests** within the TPX framework, enabling the reporting of sub-results even when the main test encounters a fatal error or timeout. By activating `tpx:enable-error-sub-result-reporting` via the `test.use_error_sub_result_reporting` buckconfig, this change prevents the loss of valuable test signal from sub-tests that completed before an error. This **enhancement to test reporting** significantly **reduces data loss** (previously ~70k results weekly), providing more comprehensive and reliable insights into test execution for Android applications. The functionality is implemented in `prelude/android/android_instrumentation_test.bzl` and aligns with similar rollouts for other test types.

This commit **fixes a bug** in the **Robolectric test runner** where thread dumps were lost during per-test timeouts. Previously, `System.exit(1)` was called by `RobolectricTimeoutEnforcingRunListener` before the `JUnitTpxStandardOutputListener` could write stdout/stderr artifacts, making the thread dump invisible. The change modifies the `handleTimeout` and `writeTimeoutEvent` methods in `RobolectricTimeoutEnforcingRunListener.kt` to **capture and include thread dumps** in the timeout event before exiting. This **restores visibility of crucial debugging information** for test failures caused by timeouts, significantly improving diagnostic capabilities.

This commit **enables standard output** for all **Instrumentation test targets**, a crucial step for enhancing test result reporting within TPX. By modifying the `android_instrumentation_test_impl` logic in `prelude/android/android_instrumentation_test.bzl`, it ensures the `tpx:supports-test-result-output-spec` label is applied, activating the previously implemented standard output mechanism. This **new capability** is a prerequisite for significant **test result reporting improvements**, such as providing sub-results on timeouts and enabling real-time result streaming for better developer feedback.

This commit **fixes a bug** in the `TpxStandardOutputTestListener` that caused invalid test reporting for **Xplat GTest** executions. Previously, duplicate `testStarted`/`testEnded` events for ignored tests, particularly from `ddmlib`, would produce malformed JSON output, leading to **Fatal results** for tests that should have passed. Additionally, ignored tests were incorrectly reported as `SKIP` instead of `OMITTED`, which TPX treats as retryable. The changes introduce explicit guards within `TpxStandardOutputTestListener.java` to deduplicate events and correctly classify ignored tests as `OMITTED`. This **maintenance** ensures accurate and valid test output, preventing erroneous test failures and improving the reliability of test reporting for **Android instrumentation tests**.

This commit **fixes a bug** in the **Android test runner** where thread dumps generated by `TpxTimeoutBufferManager` during proactive timeouts were not reliably captured. The issue occurred because `JUnitTpxStandardOutputListener`'s `StandardOutputRecorder` intercepted `System.err`, buffering the dump instead of printing it directly, leading to its loss if the test process was killed prematurely. To resolve this, the `TpxTimeoutBufferManager` in `TpxTimeoutBufferManager.kt` now writes the thread dump directly to `FileDescriptor.err` (fd 2), bypassing the recorder. This ensures that **TPX reliably captures and includes these crucial thread dumps in timeout messages**, significantly improving the debuggability of timed-out **Android tests**.

This commit **refactors** the **timeout enforcement mechanism** within the `InstrumentationTestRunner` to ensure accurate reporting of test timeouts. It introduces a dynamic `resultListener` variable that points to either the **TPX listener** or the **Buck XML listener**, depending on the active output configuration. This change ensures that timeout failures are now properly reported with the correct message through the primary output channel, particularly when **TPX is enabled**. This is a critical **enhancement** and **preparatory step** towards migrating **Android Instrumentation Tests (AIT)** to the **TPX Standard output format**, improving the reliability of test result reporting.

This commit introduces a **new diagnostic capability** to the **Android test runner** by implementing a `TpxTimeoutBufferManager` and `ThreadDumpUtils`. The `TpxTimeoutBufferManager` is designed to proactively capture **JVM thread dumps** and report run failures a few seconds before a full test target timeout, providing crucial stack trace information that was previously unavailable. This **enhancement** significantly improves the **debuggability of test target timeouts** within the **Buck build system**, moving beyond just identifying the running test. This **preparatory change** lays the foundation for better **timeout diagnostics** for **Robolectric tests**, with future plans to extend this functionality to Instrumentation tests.

This commit introduces a **new capability** to the **`JUnitRunner`** by wiring up proactive timeout buffer management and a shared watchdog executor. This **enhancement** aims to significantly **improve debugging of test timeouts** for Android tests by capturing stack traces when an entire test target exceeds its time limit, rather than just identifying the running test. The logic is currently enabled via the `android.proactive.timeout.enabled` flag and will initially be used for **shadow runs** on Robolectric tests to ensure stability before broader integration. This change directly impacts the **developer experience** by providing more actionable insights into test failures.

This commit provides a **bug fix** to prevent `NoTestsRemainException` errors from being reported to TPX when only ignored tests are selected for execution. It **enhances the `JUnitTpxStandardOutputListener`** within the **Android test runner** by introducing logic to identify and filter out these specific exceptions during the test lifecycle. This **maintenance** work complements a previous fix (D90329599) by ensuring that `OMIT` status tests do not generate misleading "phantom tests" in TPX, thereby improving the accuracy of test reporting for **Android test execution**.

This commit **fixes a critical bug** in **Android instrumentation tests** where crashes were incorrectly reported as successful, instead of `FATAL` failures. It introduces a **new capability** to the **TPX test result output specification** by defining `RunFailureStatus` (including `FATAL`) and the `RunFailureEvent` class for serializing these failures. The `InstrumentationTpxStandardOutputTestListener` now correctly implements `testRunFailed()` to send these `FATAL` events, including crash details and device logcat traces, via the `sendRunFailure()` method in `TestResultsOutputSender`. This ensures accurate reporting of test run failures, significantly improving the reliability and diagnostic capabilities for **Android instrumentation test** results.

This commit **resolves an issue** where **Robolectric test stdout/stderr** was duplicated across all test results in the TPX Standard Output page. It introduces **per-test capture and storage** of stdout/stderr into dedicated artifact files, annotated with `test_case` information, mirroring the approach used for XCTest. The **`JUnitTpxStandardOutputListener`** in the **Android test runner** is updated to manage this, utilizing a `StandardOutputRecorder` and a thread-safe `ConcurrentHashMap` for logging. This **bug fix** and **enhancement** eliminates output duplication, providing a cleaner and more accurate test reporting experience by ensuring each test's output is uniquely associated with its result.

This commit performs a **refactoring** to centralize and reuse test name formatting logic within the **Buck Android test runner**. It extracts the shared `getFullTestName` helper method into `JUnitTpxStandardOutputListener.java`, which is now responsible for consistently formatting test names from method and class strings. The `JUnitRunner.java` module was updated to utilize this new helper, eliminating duplicate `String.format` calls. This change improves code maintainability and reduces redundancy in the **test reporting infrastructure** without altering the functional behavior of test execution or output.

This commit **fixes a critical bug** affecting **Robolectric tests** run with `--retry N` and **TPX Standard Output**, where `@Ignore` tests caused `NoTestsRemainException` during retry attempts, blocking diff lands. The issue stemmed from `@Ignore` tests being filtered by `RecordingFilter` and not reported to TPX JSON, leading TPX to incorrectly attempt retries. To resolve this, a new `OMIT` status was added to the `TestStatus` enum, and the **Buck JUnitRunner** was updated to report filtered `DISABLED` tests to TPX with this `OMIT` status via new `testOmitted()` methods. This **bug fix** ensures TPX correctly identifies intentionally omitted tests, preventing erroneous retries and resolving the `NoTestsRemainException` within the **test runner infrastructure**.

This commit **improves the developer experience** by enhancing the error messages for **Android test timeouts** within the **Buck build system**. Specifically, the **Instrumentation test runner** and **Robolectric test runner** now provide **actionable guidance** when tests exceed their time limits. The updated message instructs users to add `long_running` or `glacial` tags to their BUCK target's labels and includes a link to relevant documentation, rather than just stating a timeout occurred. This **maintenance** and **developer experience improvement** helps developers quickly understand and resolve test timeout issues, reducing debugging time.

This commit introduces a **new capability** to enforce **per-test timeouts for Android Instrumentation Tests**, aligning with the existing Robolectric test flow. It integrates an `InstrumentationTimeoutEnforcingRunListener` into the `InstrumentationTestRunner` by adding a `vm_args` attribute for passing JVM arguments, which enables the listener when the `android.per.test.timeout.enabled` system property is active. This enhancement to the **Android test runner infrastructure** prevents individual instrumentation tests from running indefinitely, thereby improving overall test stability and reliability. As part of this change, the `InstrumentationTimeoutEnforcingRunListener` was updated to retrieve timeout multipliers from environment variables instead of system properties, supporting the new configuration mechanism.

This commit **enables per-test timeouts** for **Android Robolectric tests**, setting a 60-second limit (respecting TPX multipliers) to prevent indefinite test execution. This **new capability** ensures that any test exceeding this duration will fail, and all subsequent tests in the same run will be marked as skipped. The primary impact is to improve test signal by automatically moving problematic, long-running tests to a disabled collection, preventing them from blocking other test results. This change activates an already implemented mechanism found in `RobolectricTimeoutEnforcingRunListener`.

This commit introduces a **new capability** to enforce timeouts for **Android instrumentation tests** within the `buck` test runner. It adds the `InstrumentationTimeoutEnforcingRunListener.kt` class, which monitors test execution and terminates tests that exceed a configured timeout by logging a failure and exiting the system. This **feature implementation** mirrors existing timeout enforcement in Robolectric tests, aiming for consistent test behavior across different Android test environments. While the listener is fully implemented, it is **not yet integrated or activated** in this commit, serving as foundational work for future timeout enforcement.

This commit **enhances the `Buck` Android test runner** by improving the detection of Robolectric tests within `JUnitRunner.java`. It **modifies the `isRobolectricTest` method** and introduces `isRobolectricSuiteRunner` to correctly identify parameterized Robolectric tests that are wrapped in `Suite`-based runners, like `WhatsAppParameterizedRobolectricTestRunner`. This **new capability** ensures that **per-test timeouts** can be properly applied to these complex test configurations, which was previously not possible. The change primarily benefits **WhatsApp tests** by enabling more robust test execution and resource management, with timeouts activated based on the `use_per_test_timeout` configuration.

This commit introduces **infrastructure support** for **standard output shadow runs** within the **Android instrumentation test framework**. It enhances the `android_instrumentation_test_impl` function in `prelude/android/android_instrumentation_test.bzl` to conditionally append the `tpx:supports-test-result-output-spec` label to tests based on a root configuration. This **new capability** lays the groundwork for enabling shadow runs across all Android tests, providing a mechanism for parallel test execution without impacting primary results. While this change sets up the necessary plumbing in the `prelude` configuration, it does not yet activate standard output shadow runs.