Uso de Assert.Concluyente

Cuando uso VS para generar las pruebas unitarias, obtuve Assert.Inclusivo para los métodos de prueba generados y por lo general cambio la afirmación por lo que algo más cuando los trabajo. Uso los signos de interrogación de Assert.No concluyente en el resultado de la prueba como marcadores para decirme rápidamente qué pruebas aún no he completado.

Bueno, es solo la forma en que lo uso. De su nombre "Inconcluso", supongo que se puede utilizar para indicar su estado indeterminista, siempre y cuando documente lo que medio.

Sin embargo, a partir de la descripción de su método Average(), creo que tal vez su prueba unitaria no es lo suficientemente atómica como para cubrir solo una "unidad", un escenario específico. A veces, escribo 2 o 3 métodos de prueba unitarios para un solo método. O puede dividir su método Average() en métodos más pequeños que cubren responsabilidades individuales. De esa manera, puede probar unitariamente esos métodos más pequeños antes de probarle unitariamente Average() uno.

Así es como implementaría la Sum() y Average() métodos.

public static class MyMath
{
    private static void ValidateInput(ICollection<int> numbers)
    {
        if (numbers == null)
            throw new ArgumentNullException("numbers", "Null input.  Nothing to compute!");
        if (numbers.Count == 0)
            throw new ArgumentException("Input is empty.  Nothing to compute!");
    }

    public static int Sum(int[] numbers)
    {
        ValidateInput(numbers);

        var total = 0;
        foreach (var number in numbers)
            total += number;

        return total;
    }

    public static double Average(int[] numbers)
    {
        ValidateInput(numbers);
        return Sum(numbers) / numbers.Length;
    }
}

Para simplificar, solo arrojo ArgumentException excepciones del método ValidateInput(ICollection<int>). También puede comprobar la posibilidad de desbordar y lanzar OverflowException en el método ValidateInput(ICollection<int>).

Dicho esto, así es como probaría la función Average(int[]).

[TestMethod]
public void AverageTest_GoodInput()
{
    int[] numbers = {1, 2, 3};
    const double expected = 2.0;
    var actual = MyMath.Average(numbers);
    Assert.AreEqual(expected, actual);
}

[TestMethod]
[ExpectedException(typeof(ArgumentNullException))]
public void AverageTest_NullInput()
{
    int[] numbers = null;
    MyMath.Average(numbers);
}

[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void AverageTest_EmptyInput()
{
    var numbers = new int[0];
    MyMath.Average(numbers);
}

Con esta configuración de pruebas, puedo estar seguro de que cuando todas las pruebas pasan, mi función es correcta. Bueno, excepto por el caso de desbordamiento. Ahora puedo volver al método ValidateInput(ICollection<int>) para agregar lógica para verificar desbordamiento, luego agregue una prueba más para esperar que se lance OverflowException para el tipo de entradas que causan desbordamiento. O hacerlo en el orden opuesto si te gusta acercarte usando TDD.

Espero que esto ayude a aclarar la idea.