dotnet-testing-test-output-logging

name	dotnet-testing-test-output-logging
category	testing
subcategory	fundamentals
description	Complete guide for xUnit test output and logging. Use when you need to implement test output, diagnostic logging, or ILogger alternatives in xUnit tests. Covers ITestOutputHelper injection, AbstractLogger pattern, structured output design. Includes XUnitLogger, CompositeLogger, performance test diagnostic tool implementations. Keywords: ITestOutputHelper, ILogger testing, test output xunit, test output, test logging, AbstractLogger, XUnitLogger, CompositeLogger, testOutputHelper.WriteLine, test diagnostics, logger mock, test log, structured output, Received().Log
targets	["*"]
license	MIT
metadata	{"author":"Kevin Tseng","version":"1.0.0","tags":"xunit, ITestOutputHelper, ILogger, testing, diagnostics, logging","related_skills":"unit-test-fundamentals, nsubstitute-mocking, xunit-project-setup"}
claudecode	{}
opencode	{}
codexcli	{"short-description":".NET skill guidance for dotnet-testing-test-output-logging"}
copilot	{}
geminicli	{}
antigravity	{}

Source: kevintsengtw/dotnet-testing-agent-skills (MIT). Ported into dotnet-agent-harness.

Test Output and Logging Expert Guide

This skill helps you implement high-quality test output and logging mechanisms in .NET xUnit test projects.

Applicable Scenarios

Use this skill when asked to perform the following tasks:

• Use ITestOutputHelper in xUnit tests to output diagnostic information
• Implement ILogger test alternatives (XUnitLogger)
• Create AbstractLogger or CompositeLogger patterns
• Design structured test output for debugging
• Implement performance test diagnostic tools

Core Principles

1. ITestOutputHelper Usage Principles

Correct Injection Method

• Inject ITestOutputHelper via constructor
• Each test class instance bound to test method
• Cannot be shared between static methods or across test methods

public class MyTests
{
    private readonly ITestOutputHelper _output;

    public MyTests(ITestOutputHelper testOutputHelper)
    {
        _output = testOutputHelper;
    }
}
```text

### Common Mistakes

- ❌ Static access: `private static ITestOutputHelper _output`
- ❌ Using without awaiting in async tests
- ❌ Attempting to use in Dispose method

### 2. Structured Output Format Design

### Recommended Output Structure

```csharp
private void LogSection(string title)
{
    _output.WriteLine($"\n=== {title} ===");
}

private void LogKeyValue(string key,  )
{
    _output.WriteLine();
}


{
    _output.WriteLine();
}
```text



- At test start: Log test setup  input data
- During execution: Log important state changes
- Before assertion: Log expected  actual values
- At test end: Log execution time  result summary





`ILogger.LogError()`  an extension method, NSubstitute cannot directly intercept. Need to intercept underlying `Log<TState>` method:

```csharp

logger.Received().LogError(Arg.Any<>());


logger.Received().Log(
    LogLevel.Error,
    Arg.Any<EventId>(),
    Arg.Is<>(o => o.ToString().Contains()),
    Arg.Any<Exception>(),
    Arg.Any<Func<, Exception, >>()
);
```text



Create `AbstractLogger<T>` to simplify testing:

```
{
    
        => ;

    
        => ;

    
    {
        Log(logLevel, exception, state?.ToString() ?? .Empty);
    }

    ;
}
```text



```csharp
 logger = Substitute.For<AbstractLogger<MyService>>();

logger.Received().Log(LogLevel.Error, Arg.Any<Exception>(), Arg.Is<>(s => s.Contains()));
```text





```csharp
  <> : <>
{
      ITestOutputHelper _testOutputHelper;

    
    {
        _testOutputHelper = testOutputHelper;
    }

    
    {
         message = formatter(state, exception);
        _testOutputHelper.WriteLine();
         (exception != )
        {
            _testOutputHelper.WriteLine();
        }
    }

    
}
```text



```csharp
  <> : <>
{
      ILogger<T>[] _loggers;

    
    {
        _loggers = loggers;
    }

    
    {
         ( logger  _loggers)
        {
            logger.Log(logLevel, eventId, state, exception, formatter);
        }
    }

    
}
```text



```csharp

 mockLogger = Substitute.For<AbstractLogger<MyService>>();
 xunitLogger =  XUnitLogger<MyService>(_output);
 compositeLogger =  CompositeLogger<MyService>(mockLogger, xunitLogger);

 service =  MyService(compositeLogger);
```text





```csharp
[]

{
    
     stopwatch = Stopwatch.StartNew();
     checkpoints =  List<( Stage, TimeSpan Elapsed)>();

    _output.WriteLine();

    
     processor.LoadData(dataSet);
    checkpoints.Add((, stopwatch.Elapsed));
    _output.WriteLine();

     processor.ProcessData();
    checkpoints.Add((, stopwatch.Elapsed));
    _output.WriteLine();

    stopwatch.Stop();

    
    _output.WriteLine();
     ( (stage, elapsed)  checkpoints)
    {
        _output.WriteLine();
    }
}
```text



```csharp
   
{
      ITestOutputHelper Output;

    
    {
        Output = output;
    }

    
    {
        Output.WriteLine();
        Output.WriteLine();
    }

    
    {
        Output.WriteLine();
    }

    
    {
        Output.WriteLine();
        Output.WriteLine();
        Output.WriteLine();
        Output.WriteLine();
    }
}
```text



 **Appropriate Use of ITestOutputHelper**
   - ✅ Log important steps  complex tests
   - ✅ Adopt consistent structured output format
   - ✅ Provide diagnostic information  tests fail
   - ✅ Record timing points  performance tests

 **Logger Testing Strategy**
   - ✅