Bug

The test GetLogsAsync_RegardlessOfClearDuringWait_SuppliesNextLogWhenRecorded(clearIsCalledDuringWait: True) is flaky due to a race condition.

Root Cause

The test creates two async enumerators over FakeLogCollector.GetLogsAsync():

• Enumerator Add MVC common utilities. #1 (abSequenceTask): waits for logs "A", "B"
• Enumerator Adding NullLogging project #2 (abcSequenceTask): waits for logs "A", "B", "C"

After emitting logs "A" and "B", the test awaits abSequenceTask (enumerator #1) completing, then immediately calls fakeLogCollector.Clear(). However, enumerator #1 completing does not guarantee enumerator #2 has also consumed "A" and "B" — they run on separate thread pool threads.

When Clear() is called before enumerator #2 finishes processing "A" and "B":

1. Clear() empties _records and increments _recordCollectionVersion
2. When enumerator Adding NullLogging project #2 resumes, MoveNextAsync detects the version change and resets _index to 0
3. The only record available is "C" (added after the clear), but enumerator Adding NullLogging project #2 still expects "A" or "B" next
4. "C" doesn't match → enumerator Adding NullLogging project #2 blocks forever waiting for a record that will never come
5. AssertAwaitingTaskCompleted(abcSequenceTask) times out after 5 seconds

Fix

In the test file test/Libraries/Microsoft.Extensions.Diagnostics.Testing.Tests/Logging/FakeLogCollectorTests.LogEnumeration.cs, in the GetLogsAsync_RegardlessOfClearDuringWait_SuppliesNextLogWhenRecorded method:

Add a TaskCompletionSource that signals when enumerator #2 has processed both "A" and "B" (i.e., when moveNextCounter reaches 2), and await it before calling Clear().

Change the code from:

var abcSequenceTask = AwaitSequence(
    new Queue<string>(["A", "B", "C"]),
    fromIndex: 0,
    fakeLogCollector,
    null,
    cancellationToken: CancellationToken.None,
    () => Interlocked.Increment(ref moveNextCounter));

EmitLogs(logger, ["A", "B"], null);
await AssertAwaitingTaskCompleted(abSequenceTask); // checkpoint to not clear, before A, B is processed

if (clearIsCalledDuringWait)
{
    fakeLogCollector.Clear();
}

To:

var abcProcessedAB = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);

var abcSequenceTask = AwaitSequence(
    new Queue<string>(["A", "B", "C"]),
    fromIndex: 0,
    fakeLogCollector,
    null,
    cancellationToken: CancellationToken.None,
    () =>
    {
        if (Interlocked.Increment(ref moveNextCounter) == 2)
        {
            abcProcessedAB.TrySetResult();
        }
    });

EmitLogs(logger, ["A", "B"], null);
await AssertAwaitingTaskCompleted(abSequenceTask); // checkpoint to not clear, before A, B is processed
await AssertAwaitingTaskCompleted(abcProcessedAB.Task); // ensure enumerator #2 has also consumed A and B

if (clearIsCalledDuringWait)
{
    fakeLogCollector.Clear();
}

This ensures enumerator #2 has definitively consumed "A" and "B" before Clear() wipes the records and triggers the version-change index reset. The fix reuses the existing AssertAwaitingTaskCompleted helper which provides a 5-second timeout.

Only the test file needs to be changed. The production FakeLogCollector code is correct.