fix: preserve whitespace in captured console output

[thomhurst]

Summary

• Remove .Trim() calls from GetStandardOutput() and GetErrorOutput() in Context.cs
• Preserves user's intentional whitespace including empty lines created by Console.WriteLine()

Problem

Console.WriteLine output with empty lines was appearing scrambled because .Trim() was stripping leading and trailing whitespace from the captured output.

For example, this code:

Console.WriteLine("Serialized form:");
Console.WriteLine(value);
Console.WriteLine(Environment.NewLine);
Console.WriteLine("_");
Console.WriteLine(Environment.NewLine);

Would have its empty lines stripped/moved around in the captured output.

Solution

Simply remove the .Trim() calls to preserve the exact output as written by the user.

Fixes #4196

🤖 Generated with Claude Code

[thomhurst]

Summary

Removes .Trim() calls from GetStandardOutput() and GetErrorOutput() to preserve intentional whitespace in captured console output.

Critical Issues

Breaking Test Failures Expected ⚠️

This change will break at least two existing tests that rely on trimmed output:

1. TUnit.TestProject/OrderedSetupTests/Tests.cs:19-45 - Expects exact match without trailing newline
2. TUnit.TestProject/OrderedByAttributeOrderParameterSetupTests/Tests.cs - Similar exact match expectation

The issue: All Console.WriteLine() calls append a newline character. When the last line is written (e.g., Console.WriteLine("Tests.B_After3")), the StringBuilder will contain "Tests.B_After3\n". The current .Trim() removes this trailing newline, allowing the test assertion to pass. Without .Trim(), the captured output will have a trailing newline that won't match the expected raw string literal.

Required Actions:

1. Update test expectations in OrderedSetupTests/Tests.cs to include trailing newline
2. Update test expectations in OrderedByAttributeOrderParameterSetupTests/Tests.cs similarly
3. Run the test suite to identify any other tests affected by this behavioral change
4. Verify all affected tests pass before merging

Alternative Consideration:
The fix is correct for the reported issue (#4196) where users intentionally add empty lines via Console.WriteLine(). However, you may want to consider whether the trailing newline from the final Console.WriteLine() is "intentional whitespace" or an artifact. Most users would not expect Console.WriteLine("foo") to produce "foo\n" when captured - they'd expect "foo" with the newline being part of the output mechanism, not the content.

If this is too nuanced, the current approach is acceptable, but the tests must be updated.

Suggestions

None - the implementation itself is clean and correct for the stated goal.

Verdict

⚠️ REQUEST CHANGES - Must update affected tests before merging

[Copilot]

Pull request overview

This PR fixes a bug where console output with empty lines was being scrambled due to .Trim() calls in the output capture methods. The fix removes these .Trim() calls to preserve user-intended whitespace including empty lines created by Console.WriteLine().

Key Changes

• Removed .Trim() from GetStandardOutput() to preserve leading/trailing whitespace in standard output
• Removed .Trim() from GetErrorOutput() to preserve leading/trailing whitespace in error output

[thomhurst]

@claude Fix the test expectation

[claude]

Claude finished @thomhurst's task in 1m 24s —— View job

---

Test Expectations Updated ✓

Updated test expectations to account for preserved whitespace in console output.

Tasks Completed

• Read failing test files to understand current expectations
• Update OrderedSetupTests/Tests.cs to include trailing newlines
• Update OrderedByAttributeOrderParameterSetupTests/Tests.cs to include trailing newlines
• Commit and push changes

Changes Made

• TUnit.TestProject/OrderedSetupTests/Tests.cs: Added trailing newline to expected output (line 45)
• TUnit.TestProject/OrderedByAttributeOrderParameterSetupTests/Tests.cs: Added trailing newline to expected output (line 45)

Explanation

Both test files were expecting console output without trailing newlines because the previous implementation used .Trim() which removed them. Now that .Trim() has been removed to preserve intentional whitespace (fixing issue #4196), the expected output needs to include the trailing newline that Console.WriteLine() naturally adds.

The fix adds a blank line before the closing """ delimiter in the raw string literals, which represents the trailing newline from the last Console.WriteLine() call.

---

Branch: fix/console-output-handling-4196 |

[thomhurst]

Summary

Removes .Trim() calls from GetStandardOutput() and GetErrorOutput() to preserve user's intentional whitespace in captured console output.

Critical Issues

None found ✅

Suggestions

1. Consider the breaking change implications

While this fix correctly addresses issue #4196, removing .Trim() is a behavioral change that could affect existing code expecting trimmed output. Consider:

• Adding a note in the PR description or release notes that this is a minor breaking change
• Users who rely on trimmed output will need to call .Trim() themselves

However, this change is the correct behavior - test frameworks should preserve exact output, and the original .Trim() was lossy and caused the reported bugs.

2. Test coverage looks good

The PR correctly updates the two affected test files (OrderedSetupTests and OrderedByAttributeOrderParameterSetupTests) to expect trailing newlines. Other tests using .Contains() assertions will continue working correctly.

3. Performance note

Minor performance improvement: removes one string allocation per call (no new trimmed string created). Aligns with TUnit's "Performance First" principle.

Verdict

✅ APPROVE - No critical issues

This is a clean fix that correctly addresses the bug. The behavioral change is justified and necessary to fix the whitespace handling issue.

[thomhurst]

Summary

Removes .Trim() calls from console output capture methods to preserve user-intended whitespace including empty lines.

Critical Issues

None found ✅

Suggestions

Test Assertion Strictness: The changes from .IsEqualTo() to .Contains() in CaptureOutputTests.cs and other test files make the assertions less strict. While this is pragmatic given the whitespace preservation, consider whether these tests should verify the complete output format more precisely.

For example, in CaptureOutputTests.cs:16-17, the test now just checks that "Blah1" is contained in the output rather than verifying the exact output. If the intent is to verify output isolation between tests (ensuring no cross-contamination), .Contains() is sufficient. However, if you want to ensure proper formatting, consider using a more specific pattern match or trimming at the assertion level:

await Assert.That(TestContext.Current.GetStandardOutput().Trim()).IsEqualTo("Blah1");

This would preserve whitespace in the API (as intended) while still verifying expected output format in tests.

Minor: In OrderedByAttributeOrderParameterSetupTests/Tests.cs:45 and OrderedSetupTests/Tests.cs:45, the trailing empty line in the expected string looks intentional and matches the new behavior - good catch on updating these.

Verdict

✅ APPROVE - No critical issues

The fix correctly addresses #4196 by preserving user-intended whitespace in console output capture. The behavior change is breaking but justified - the previous .Trim() behavior was lossy and caused the reported scrambling issues. Test updates appropriately reflect the new behavior.