[Feature]: Multi dimension arrays assertions about fluentassertions

[jnyrup]

I agree about not going down the TwoDimensionalArrayAssertions path.

Since Array.GetValue() has overloads for up to three indices before deferring to params int[] indices or params long[] indices, Let's as well go with three Shoulds for T[,], T[,,] and T[,,,].
If users needs more, they can always add those overloads themselves as they just resolve ambiguity and forward to MultiDimensionArrayAssertions.

Since we haven't had requests for multi-dimensional arrays, I don't think we should duplicate all functionality from GenericCollectionAssertions

I suggest starting out soft with these:

• BeEmpty()
• NotBeEmpty()
• HaveCount(int expected)
• NotHaveCount(int unexpected)

[dennisdoomen]

You can already use BeEquivalenTo for that. It has support for multi-dimensional arrays.

[dennisdoomen]

But what kind of assertion would you suggest?

[Meir017]

for asserting the Length and GetLength functionality

maybe something like this

var array = new string[2,3] { { "a", "b", "c" }, { "d", "e", "f" } };
array.Should().BeEmpty();
array.Should().NotBeEmpty();

array.Should().HaveElementAt(0, 0, "a");
array.Should().HaveElementAt(1, 2, "f");

array.Should().HaveTotalLength(6);
array.Should().HaveDimensionLength(0, 2);
array.Should().HaveDimensionLength(1, 3);

[dennisdoomen]

I like that. What do you think @jnyrup ?

[Meir017]

I'm wondering if for each different array dimension there should be a dedicated assertions class, this will allow to have strongly-typed assertions and not just use the System.Array type.

this would mean that instead of HaveDimensionLength there could be a dedicated method for each dimension length

something like this:

public static class Extensions
{
    public static TwoDimensionalArrayAssertions<T> Should<T>(this T[,] actual) => new(actual);
    public static ThreeDimensionalArrayAssertions<T> Should<T>(this T[,,] actual) => new(actual);
    public static FourDimensionalArrayAssertions<T> Should<T>(this T[,,,] actual) => new(actual);
}

public class TwoDimensionalArrayAssertions<T>
{
    public TwoDimensionalArrayAssertions(T[,] array) { }
}
public class ThreeDimensionalArrayAssertions<T>
{
    public ThreeDimensionalArrayAssertions(T[,,] array) { }
}
public class FourDimensionalArrayAssertions<T>
{
    public FourDimensionalArrayAssertions(T[,,,] array) { }
}

[dennisdoomen]

That's possible, but this is the first time in 13 years that somebody suggests this feature, so your original proposal should be good enough.

[Meir017]

I think that a generic assertion extension will not work here

public static ArrayAssertions Should(this Array array) => new ArrayAssertions(array);

I think that the assertion extensions need to be for each dimension separately, otherwise when using a single-dimension array the extension method used will be the new one instead of the Collections.GenericCollectionAssertions<T>

so we would need something like this -

public static class Ex
{
    public static MultiDimensionArrayAssertions Should<T>(this T[,] array) => new MultiDimensionArrayAssertions(array);
    public static MultiDimensionArrayAssertions Should<T>(this T[,,] array) => new MultiDimensionArrayAssertions(array);
    public static MultiDimensionArrayAssertions Should<T>(this T[,,,] array) => new MultiDimensionArrayAssertions(array);
    // more dimensions ...
}

public class MultiDimensionArrayAssertions // what should this extend from?
{
    public MultiDimensionArrayAssertions(Array array) { }
}

[dennisdoomen]

Yeah, you're right. You can define an extension method on Array, but for single-dimension arrays, it'll result in ambiguous calls.

[dennisdoomen]

Let's as well go with three Shoulds for T[,], T[,,] and T[,,,].

That settles it then