Daniel Gorin

This commit performs a **maintenance** update to ensure consistent formatting across several **Erlang source files**. It primarily focuses on improving **code style and readability** within the **`prelude/erlang`** components, specifically impacting modules related to **`common_test`** utilities and the **`toolchain`** builders. Changes include reformatting function specifications, argument alignment, line breaks, and indentation in functions such as `test_metrics_artifact_annotation`, `handle_io_request`, and `build_dep_info`. This effort enhances the overall consistency and maintainability of the Erlang codebase without introducing any functional changes.

This commit **removes support for the old XML output format** within the **Erlang `common_test` framework's `test_binary` module**. It **refactors** the `prelude/erlang/common_test/test_binary/src/test_binary.erl` file by eliminating the conditional logic for XML output, thereby making **JSON output the default** for test results. This **maintenance** task simplifies the codebase and means that the `-json` flag is now a no-op, impacting any downstream systems or users that previously relied on XML test result formats.

This commit **refactors** the **Erlang common test framework** to improve the efficiency of testcase name generation. It eliminates a redundant and potentially quadratic string concatenation within the `test_case_info` function in `list_test.erl`. Instead of explicitly building a string, the system now directly passes an `io_list()` to `io_lib:format()`. This **performance optimization** streamlines the process of listing Erlang tests, ensuring the correct name format is maintained while avoiding unnecessary processing overhead.

This commit **enhances the Erlang Common Test framework's test listing** by integrating **breakpoint information** directly into test specifications. It **adds a `breakpoint` field** to the `test_spec_test_info` record in `tpx_records.hrl`, enabling the storage of breakpoint locations. The core **test listing logic** in `list_test.erl` is refactored to process this new data, and the `listing_interfacer.erl` module is updated to include these breakpoint details in the **JSON output**. This **new feature** provides richer metadata for individual test cases, allowing external tools to display or utilize specific breakpoint locations.

This commit **improves error handling** within the **Erlang common_test framework**, specifically for the `test_binary` module. It introduces a **bug fix** by wrapping the test listing logic in the `handle_list` function with a try-catch block. This ensures that if the process of listing Erlang tests fails, an explicit error is reported, and the test process is halted. The change prevents silent failures during test discovery, making the test execution more robust and providing clearer feedback to developers.

This commit **refactors** the **Erlang common_test framework** by removing the unnecessary export of the internal `list_test_spec` function from the `list_test.erl` module. Previously, this function was exported solely for internal testing purposes, violating good encapsulation principles. By making `list_test_spec` truly internal, this change improves the **code hygiene and modularity** of the test suite, ensuring that internal helper functions are not exposed externally. The overall functionality of the tests remains unchanged, but the internal structure is cleaner.

This commit introduces a **new feature** to the **Erlang Common Test runner**, enabling users to list available tests in a machine-readable, one-JSON-per-line format. It modifies the `test_binary` **CLI** to include a new `--json` option, which, when invoked, utilizes new functions like `produce_json_file` and `test_info_to_json_line` within `listing_interfacer.erl` to generate the structured output. This enhancement provides a standardized way to programmatically consume test listings, improving integration with external tooling and automation workflows.

This commit **refactors the stdout processing pipeline** within the **Erlang Common Test framework** to remove progress markers on the fly. Previously, raw stdout was written to a file and then post-processed; now, the system **processes and filters stdout as it is streamed**, eliminating the intermediate raw file. This **enhancement** primarily affects the `ct_stdout` module, which gains new functions like `process_stdout_line` for real-time filtering, and the `test_runner` and `ct_runner` modules, which are adapted to consume this pre-filtered output. The change **improves efficiency** by reducing I/O and ensuring that only clean, filtered stdout is ever persisted.

This commit introduces a **new fingerprint-based mechanism** to robustly identify and filter internal test progress markers within the **Erlang Common Test framework's** stdout processing. It modifies `prelude/erlang/common_test/common/src/ct_stdout.erl` to generate and utilize a unique fingerprint for each test suite execution, ensuring that these implementation details are removed before output is presented to the user. This **enhancement** prevents output pollution and lays crucial groundwork for enabling direct stdout streaming during debugging without exposing internal markers. The `prelude/erlang/common_test/common/include/buck_ct_records.hrl`, `prelude/erlang/common_test/cth_hooks/src/cth_tpx.erl`, and `prelude/erlang/common_test/test_binary/src/test_runner.erl` modules are updated to support this new identification method.

This commit introduces a **new capability** to enable **real-time streaming of stdout** during the execution of **Erlang Common Test (CT) suites**, specifically when **debugging with `edb`**. It modifies the **CT stdout processing** within `ct_stdout.erl` to conditionally output log lines directly to the test-binary's stdout, controlled by a new `ct_stdout_streaming` flag added to the `test_env` record in `buck_ct_records.hrl`. This feature is activated when `edb` setup code is injected, significantly improving the **developer experience** by allowing users to see test output as it happens, rather than waiting for post-processing. The changes span across `test_binary.erl`, `test_runner.erl`, and `ct_runner.erl` to propagate and utilize this streaming preference throughout the test execution flow.

This commit provides a **bug fix** to the **Erlang test execution system** by preventing truncation of long `stdout` lines. Previously, the `ct_runner` in `prelude/erlang/common_test/test_exec/src/ct_runner.erl` only processed `{eol, L}` messages, causing parts of very long lines sent as `{noeol, Ln}` to be missed. The `handle_info` function is now updated to correctly process these `noeol` messages, ensuring that all `stdout` output from Erlang tests is captured completely and accurately. This change improves the reliability of test logging by preserving full output, especially for lines exceeding 1KB.

This commit **refactors** the `getCtHook` function within the **`prelude/erlang/common_test/test_binary/src/test_runner.erl` module** to improve how `ct_hooks` configurations are collected and merged into the `CT test-spec`. Previously, the logic for handling user-provided `{ct_hooks, ...}` entries was convoluted and suffered from quadratic performance issues. By leveraging `lists:splitwith()`, this change **simplifies the code** and **optimizes the efficiency** of test-spec generation, leading to faster and more robust test setup, especially in scenarios with numerous custom hooks.

This commit performs a **refactoring** to **improve type safety** within the **Common Test infrastructure**. It updates type specifications in the `cth_tpx` and `test_runner` modules, changing the type for file paths from the generic `string()` to the more precise `file:filename_all()`. This change specifically affects how the system handles the names of files used to store test results, enhancing clarity and reducing potential errors in functions like `init_role_top`, `write_output`, and `getCtHook`. The update ensures better type enforcement for output paths involved in the test result collection process.

This commit **reinstates user notification** for **truncated `stdout` output** within the **Erlang Common Test framework**, specifically when test results are displayed. It introduces a new mechanism in `ct_stdout.erl` to explicitly mark when `stdout` has been truncated during collection, and integrates this notice into the collected method results via `cth_tpx_test_tree.erl`'s `to_collected_method_result` function. This **feature addition** also includes a **refactoring** in `cth_tpx.erl` to remove the previous, non-functional truncation message handling. The change significantly **improves developer experience** by providing clear feedback during test failures, preventing confusion from incomplete test logs.

This commit performs a **refactoring** to remove obsolete `stdout` collection logic from the **Erlang common test execution framework**. It eliminates the `io_buffer` field and associated stdout capture mechanisms from `cth_tpx.erl` and removes the `std_out` field from the `method_result` type in `cth_tpx_test_tree.erl`. Additionally, definitions for stdout buffer limits and the `io_buffer` process initialization are removed from `ct_executor.erl`. This **maintenance** task cleans up the **test execution pipeline** by removing unused code, as stdout collection is now handled directly by the test binary, improving code clarity and reducing complexity.

This commit performs a significant **refactoring** within the **Erlang Common Test (CT)** framework's result processing, introducing distinct types for test results at different stages. It defines `collected_method_result()` and `collected_result()` to differentiate results generated by the **test-executor** from those collected by the **test-binary** for reporting. This **plumbing** effort updates core modules like `cth_tpx_test_tree.erl` and `test_runner.erl`, including renaming `get_result` to `collect_results`, to consistently use these new types. The change is a crucial preparatory step, enabling future optimizations where the test-executor will transmit only stdout progress markers, with full stdout blobs computed later in the pipeline.

This commit introduces a **new capability** to process raw stdout log files after test execution, specifically within the **test infrastructure**'s `ct_stdout.erl` module. It leverages progress markers emitted during tests to **extract test-case specific output** and remove these markers, creating a cleaned-up log, with integration handled by `test_runner.erl`. This **refactoring** of the stdout capture mechanism addresses previous issues with memory usage and accuracy by moving away from real-time interception, paving the way for more efficient and reliable test output handling.

This commit introduces a **new capability** to the **Erlang Common Test (CT) framework** by implementing a mechanism to **insert unique progress markers into stdout** during test execution. A new module, `ct_stdout`, provides functions like `emit_progress` to generate these markers, which are then integrated into the test lifecycle via modifications to `cth_tpx` hooks. This foundational change aims to **refactor the existing convoluted stdout capture logic**, enabling more accurate, memory-efficient, and streamable test output by allowing later postprocessing of stdout to associate specific output with test cases and their timing. The `method_result` type in `cth_tpx_test_tree.erl` is also updated to accommodate these new markers and timing information. This is a crucial first step towards a more robust and performant test output processing system.

This commit **removes bogus stdout accumulation logic** from the **Erlang test execution framework**, specifically within the `test-binary`'s port loop. It targets the `ct_runner.erl` module, eliminating the `std_out` field from its state record and associated accumulation logic in the `handle_continue` and `handle_info` functions. This **maintenance refactoring** cleans up redundant and unused code, as the `test-executor` node already captures its stdout to a file. The change improves the **robustness and clarity** of the test runner by removing unnecessary state management, ensuring the `test-binary` no longer attempts to store output that is already handled.

This commit **enhances the Erlang Common Test framework** by implementing **real-time stdout streaming** from the `test-executor` to the `test-binary` node. It **refactors the I/O mechanism** across `ct_daemon_node.erl` and `ct_executor.erl` to prevent the executor from capturing its own stdout, instead configuring `test_logger.erl` for direct streaming. The `ct_runner.erl` on the `test-binary` node now processes incoming data from the port, writing it to a raw stdout file. This **feature enhancement** enables immediate visibility of test progress, significantly aiding debugging and allowing tests to run effectively without specific tools like TPX.