Fließend Assertions: Etwa zwei 2D rechteckigen Arrays vergleichen

Question

Ich bin in der Lage zu etwa zwei in Fluent Assertions wie diese 2D rechteckigen Arrays vergleichen:

float precision = 1e-5f; 
float[,] expectedArray = new float[,] { { 3.1f, 4.5f}, { 2, 4} }; 
float[,] calculatedArray = new float[,] { { 3.09f, 4.49f}, { 2, 4} }; 

for (int y = 0; y < 2; ++y) 
{ 
    for (int x = 0; x < 2; ++x) 
    { 
     calculatedArray[y,x].Should().BeApproximately(expectedArray[y,x], precision); 
    } 
} 

aber gibt es eine sauberere Möglichkeit, dies zu erreichen (ohne die für Schleifen) Zum Beispiel etwas in der gleichen Richtung wie diese (die für 1D-Arrays ist):

double[] source = { 10.01, 8.01, 6.01 }; 
double[] target = { 10.0, 8.0, 6.0 }; 

source.Should().Equal(target, (left, right) => Math.Abs(left-right) <= 0.01); 

Die obige Lösung für einen 1D-Array von der Frage kommt: Fluent Assertions: Compare two numeric collections approximately

Answer 1

Es scheint nicht, etwas zu sein, derzeit in dem Rahmen, der dies unterstützt. Wenn Sie die Schleife nicht in Ihren Tests verwenden möchten, können Sie eigene Erweiterungen hinzufügen, um dieses Szenario abzudecken.

Es gibt zwei Elemente dazu. Die erste ist eine Erweiterungsmethode hinzuzufügen, die die Should Fähigkeit, 2D-Arrays ergänzt:

public static class FluentExtensionMethods 
{ 
    public static Generic2DArrayAssertions<T> Should<T>(this T[,] actualValue) 
    { 
     return new Generic2DArrayAssertions<T>(actualValue); 
    } 
} 

Sie dann die eigentliche Behauptung Klasse implementieren müssen, die die Vergleichs-Schleife enthält:

public class Generic2DArrayAssertions<T> 
{ 
    T[,] _actual; 

    public Generic2DArrayAssertions(T[,] actual) 
    { 
     _actual = actual; 
    } 

    public bool Equal(T[,] expected, Func<T,T, bool> func) 
    { 
     for (int i = 0; i < expected.Rank; i++) 
      _actual.GetUpperBound(i).Should().Be(expected.GetUpperBound(i), 
               "dimensions should match"); 

     for (int x = expected.GetLowerBound(0); x <= expected.GetUpperBound(0); x++) 
     { 
      for (int y = expected.GetLowerBound(1); y <= expected.GetUpperBound(1); y++) 
      { 
       func(_actual[x, y], expected[x, y]) 
        .Should() 
        .BeTrue("'{2}' should equal '{3}' at element [{0},{1}]", 
         x, y, _actual[x,y], expected[x,y]); 
      } 
     } 

     return true; 
    } 
} 

Sie können verwenden Sie es dann in Ihren Tests wie andere Behauptungen:

calculatedArray.Should().Equal(expectedArray, 
           (left,right)=> Math.Abs(left - right) <= 0.01); 

ich denke, Ihr Kommentar ist zu fragen, wie Sie testen Sie die Erweiterung gehen ich schlage. Die Antwort ist, genauso wie Sie etwas anderes testen, Werte übergeben und die Ausgabe validieren. Ich habe unten einige Tests hinzugefügt (mit Nunit), um einige Schlüsselszenarien abzudecken. Einige Dinge zu beachten, die Daten für die Szenarien sind unvollständig (es scheint außerhalb des Geltungsbereichs und ist nicht so schwer zu generieren). Die Tests verwenden eine Funktion von left == right, da der Punkt darin besteht, die Erweiterung zu testen, nicht die Auswertung der Approximation.

[TestCaseSource("differentSizedScenarios")] 
public void ShouldThrowIfDifferentSizes(float[,] actual, float[,] expected) 
{ 
    Assert.Throws<AssertionException>(()=>actual.Should().Equal(expected, (l, r) => l == r)).Message.Should().Be(string.Format("Expected value to be {0} because dimensions should match, but found {1}.", expected.GetUpperBound(0), actual.GetUpperBound(0))); 
} 

[TestCaseSource("missMatchedScenarios")] 
public void ShouldThrowIfMismatched(int[,] actual, int[,] expected, int actualVal, int expectedVal, string index) 
{ 
    Assert.Throws<AssertionException>(()=>actual.Should().Equal(expected, (l, r) => l.Equals(r))).Message.Should().Be(string.Format("Expected True because '{0}' should equal '{1}' at element [{2}], but found False.", actualVal, expectedVal, index)); 
} 

[Test] 
public void ShouldPassOnMatched() 
{ 
    var expected = new float[,] { { 3.1f, 4.5f }, { 2, 4 } }; 
    var actual = new float[,] { { 3.1f, 4.5f }, { 2, 4 } }; 
    actual.Should().Equal(expected, (l, r) => l.Equals(r)); 
} 

static object[] differentSizedScenarios = 
{ 
    new object[] { 
     new float[,] { { 3.1f, 4.5f }, { 2, 4 } }, 
     new float[,] { { 3.1f, 4.5f }, { 2, 4 }, {1,2} } 
    }, 
    new object[] { 
     new float[,] { { 3.1f, 4.5f }, { 2, 4 } }, 
     new float[,] { { 3.1f, 4.5f }} 
    } 
    // etc... 
}; 
static object[] missMatchedScenarios = 
{ 
    new object[] { 
     new int[,] { { 1, 2}, { 3, 4 } }, 
     new int[,] { { 11, 2}, { 3, 4 } } 
     ,1, 11, "0,0" 
    }, 
    new object[] { 
     new int[,] { { 1, 2}, { 3, 14 } }, 
     new int[,] { { 1, 2}, { 3, 4 } } 
     ,14, 4, "1,1" 
    }, 
    // etc... 
};