Estoy usando dotCover para analizar la cobertura de código de mis pruebas de unidad, y estoy obteniendo algunos resultados extraños ... Tengo un método de iterador para el cual la cobertura no está completa, pero las declaraciones que no están cubiertas son solo las llaves de cierre. Al final del método.

Aquí está el método que estoy probando:

    public static IEnumerable<T> CommonPrefix<T>(
        this IEnumerable<T> source,
        IEnumerable<T> other,
        IEqualityComparer<T> comparer)
    {
        source.CheckArgumentNull("source");
        other.CheckArgumentNull("other");

        return source.CommonPrefixImpl(other, comparer);
    }

    private static IEnumerable<T> CommonPrefixImpl<T>(
        this IEnumerable<T> source,
        IEnumerable<T> other,
        IEqualityComparer<T> comparer)
    {
        comparer = comparer ?? EqualityComparer<T>.Default;

        using (IEnumerator<T> en1 = source.GetEnumerator(),
                              en2 = other.GetEnumerator())
        {
            while (en1.MoveNext() && en2.MoveNext())
            {
                if (comparer.Equals(en1.Current, en2.Current))
                    yield return en1.Current;
                else
                    yield break;
            }
        } // not covered
    } // not covered

La prueba unitaria:

    [Test]
    public void Test_CommonPrefix_SpecificComparer()
    {
        var first = new[] { "Foo", "Bar", "Baz", "Titi", "Tata", "Toto" };
        var second = new[] { "FOO", "bAR", "baz", "tata", "Toto" };

        var expected = new[] { "Foo", "Bar", "Baz" };
        var actual = first.CommonPrefix(second, StringComparer.CurrentCultureIgnoreCase);
        Assert.That(actual, Is.EquivalentTo(expected));
    }

Y los resultados de la cobertura:

Asumo el corsé de cierre de lausing bloque es en realidad las llamadas aDispose en los enumeradores; Pero entonces, ¿por qué no se ejecuta? Primero sospeché que NUnit no estaba eliminando a los enumeradores, pero obtengo el mismo resultado si hago una investigación enactual.

En cuanto a la segunda llave de cierre descubierta, no tengo idea de lo que significa ... Supongo que está relacionado con la forma en que el compilador transforma el bloque de iteradores.

¿Alguien puede arrojar algo de luz sobre cuáles son estas dos "declaraciones" y por qué no se ejecutan?

EDIT: Peter planteó una muy buena pregunta: los resultados mostrados anteriormente se obtuvieron al ejecutar las pruebas en uncompilación de depuración. Si ejecuto las pruebas en unaversión de lanzamiento, cobertura de laCommonPrefixImpl El método es 100%, por lo que probablemente esté relacionado con las optimizaciones del compilador.