Как я могу проверить, что оператор LINQ Range отложен?

Я реализовал какой-то оператор диапазона LINQ и хочу провести тест, который проверит, что оператор диапазона действительно отложен.

Методы оператора My Range:

/// <summary>
/// The Range static method, validation part.
/// </summary>
/// <param name = "start">The start.</param>
/// <param name = "count">The count.</param>
/// <returns></returns>
public static IEnumerable<int> Range(int start, int count)
{
    long max = ((long) start) + count - 1;
    if (count < 0 || max > Int32.MaxValue) throw new ArgumentOutOfRangeException(nameof(count));
    return RangeIterator(start, count);
}

/// <summary>
/// The Range operator iterator.
/// </summary>
/// <param name = "start">The start.</param>
/// <param name = "count">The count.</param>
/// <returns></returns>
static IEnumerable<int> RangeIterator(int start, int count)
{
    for (int i = 0; i < count; ++i)
    {
        yield return start + i;
    }
}

Для других отложенных операторов я создал служебный класс ThrowingExceptionEnumerable, который помогает при тестировании:

/// <summary>
/// The class responsible for verifying that linq operator is deferred.
/// </summary>
/// <typeparam name = "T"></typeparam>
public sealed class ThrowingExceptionEnumerable<T> : IEnumerable<T>
{
    /// <summary>
    /// The methods throws <see cref = "InvalidOperationException"/>.
    /// </summary>
    /// <returns></returns>
    public IEnumerator<T> GetEnumerator()
    {
        throw new InvalidOperationException();
    }

    /// <inheritdoc />
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    /// <summary>
    /// The method which checks that the given <see cref = "deferredFunction"/> actually uses deferred execution.
    /// When the function just call itself it should not throw an exception. But, when using the result
    /// by calling <see cref = "GetEnumerator"/> and than GetNext() methods should throws the <see cref = "InvalidOperationException"/>.
    /// </summary>
    /// <typeparam name = "TSource">The deferred function source type.</typeparam>
    /// <typeparam name = "TResult">The deferred function result type.</typeparam>
    /// <param name = "deferredFunction">The deferred function (unit of work under the test).</param>
    public static void AssertDeferred<TSource,TResult>(
        Func<IEnumerable<TSource>, IEnumerable<TResult>> deferredFunction)
    {
        var source = new ThrowingExceptionEnumerable<TSource>();
        
        // Does not throw any exception here, because GetEnumerator() method is not yet used.
        var result = deferredFunction(source);

        // Does not throw InvalidOperationException even here, despite the fact that we retrieve the enumerator.
        using var iterator = result.GetEnumerator();

        Assert.Throws<InvalidOperationException>(() => iterator.MoveNext());
    }

И, например, отложенный оператор Select имеет следующий тест:

/// <summary>
/// Should check that Select operator is deferred.
/// </summary>
[Fact]
public void VerifySelectExecutionIsDeferred()
{
    ThrowingExceptionEnumerable<int>.AssertDeferred<int, int>(source => source.Select(x => x));
}

Первая проблема, с которой я столкнулся при написании такого модульного теста для оператора Range, заключается в том, что Range на самом деле является статическим методом, а не методом расширения. Также дело в том, что у подписи Range нет исходного параметра, поэтому такой подход не может быть использован.

У вас есть умные идеи, как это можно проверить?