Add support for Span and ReadOnlySpan

Description

Add support for Span<T> and ReadOnlySpan<T>. Though they do not directly implement IEnumerable<T> interface it would be nice to be able to assert using NotContain etc.

Complete minimal example reproducing the issue

// Arrange
ReadOnlySpan<string> span = new ReadOnlySpan<string>(new[] {"a", "b", "c"});

// Act
span = span.Slice(1);

// Assert
span.Should().NotContain("a");

Expected behavior:

Test should pass.

Actual behavior:

Compilation error saying extension method Should does not exist for ReadOnlySpan<T>.

Versions

• Which version of Fluent Assertions are you using? 5.4.1
• Which .NET runtime and version are you targeting? .NET Core 2.1.

[jnyrup]

Everyone who has shown interest in assertions on Span.

[jnyrup]

Here’s an example of what we can do without converting [ReadOnly]Span<T> into T[] or string. It utilizes that Span<T> is implicitly convertible to ReadOnlySpan<T> to avoid duplicating ReadOnlySpanAssertions<T>.

Span<byte> bytes = stackalloc byte[] { 42 };
bytes.Should().NotBeEmpty()
    .And.ContainSingle()
    .Which.Should().Be(42);

ReadOnlySpan<byte> ros = stackalloc byte[] { 42 };
ros.Should().NotBeEmpty()
    .And.ContainSingle()
    .Which.Should().Be(42);

public readonly ref struct ReadOnlySpanAssertions<T>
{
    private readonly ReadOnlySpan<T> span;
        
    public ReadOnlySpanAssertions(ReadOnlySpan<T> span)
    {
        this.span = span;
    }
        
    public SpanAndConstraint<T> NotBeEmpty()
    {
        if (span.IsEmpty)
        {
            throw new Exception("Did not expect span to be empty");
        }
        
        return new(this);
    }
    
    public SpanAndWhichConstraint<T> ContainSingle()
    {
        if (span.Length != 1)
        {
            throw new Exception("Expected span to contain a single element");
        }
        
        return new(this, span[0]);
    } 
}

public readonly ref struct SpanAndConstraint<T>
{
    public ReadOnlySpanAssertions<T> And { get; }

    public SpanAndConstraint(ReadOnlySpanAssertions<T> parentConstraint)
    {
        And = parentConstraint;
    }
}

public readonly ref struct SpanAndWhichConstraint<T>
{
    public ReadOnlySpanAssertions<T> And { get; }
    
    public T Which { get; }

    public SpanAndWhichConstraint(ReadOnlySpanAssertions<T> parentConstraint, T whichValue)
    {
        And = parentConstraint;
        Which = whichValue;
    }
}

public class ByteAssertions
{
    private readonly byte subject;
    
    public ByteAssertions(byte subject)
    {
        this.subject = subject;
    }
    
    public void Be(byte expected)
    {
        if (subject != expected)
        {
            throw new Exception("Expected subject to be expected");
        }
    }
}

public static class Extensions
{
    public static ReadOnlySpanAssertions<T> Should<T>(this ReadOnlySpan<T> span) => new(span);
    
    public static ReadOnlySpanAssertions<T> Should<T>(this Span<T> span) => new(span);
    
    public static ByteAssertions Should(this byte b) => new(b);
}

SharpLab

The major downside to that approach is that we would probably have to duplicate a lot of code for a limited benefit.

The easy way out

public static class Extensions
{
    public static StringAssertions Should(this ReadOnlySpan<char> span) => span.ToString().Should();
    public static StringAssertions Should(this Span<char> span) => span.ToString().Should();
    
    public static GenericCollectionAssertions<T> Should<T>(this ReadOnlySpan<T> span) => span.ToArray().Should();
    public static GenericCollectionAssertions<T> Should<T>(this Span<T> span) => span.ToArray().Should();
}