NUnit, est-il possible de poursuivre l'exécution de test après l'Assertion échoue?

Je préfère être pratique et de mettre plusieurs affirmations dans une méthode.

J'ai une classe helper qui permet à la syntaxe suivante (que j'utilise):

AssertAll.Succeed(
    () => Assert.AreEqual("bb", id.Context),
    () => Assert.AreEqual("abc", id.FullName),
    () => Assert.AreEqual("b", id.SessionID));

qui me donne des messages d'erreur comme ceci:

Assert.AreEqual failed. Expected:<bb>. Actual:<b\c>. 
Assert.AreEqual failed. Expected:<abc>. Actual:<[b\c]a{103}>. 
at FXP_COM.Tests.EnumToStringConverterterTests.<>c__DisplayClass3.<ShouldConvert>b__0() in UnitTest1.cs: line 31
at FXP_COM.Tests.AssertAll.Succeed(Action[] assertions) in UnitTest1.cs: line 46 at FXP_COM.Tests.AssertAll.Succeed(Action[] assertions) in UnitTest1.cs: line 62
at FXP_COM.Tests.EnumToStringConverterterTests.ShouldConvert() in UnitTest1.cs: line 30

et la classe helper est le suivant:

using System;
using NUnit.Framework;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

public static class AssertAll
{
    public static void Succeed(params Action[] assertions)
    {
        var errors = new List<Exception>();

        foreach (var assertion in assertions)
            try
            {
                assertion();
            }
            catch (Exception ex)
            {
                errors.Add(ex);
            }

        if (errors.Any())
        {
            var ex = new AssertionException(
                string.Join(Environment.NewLine, errors.Select(e => e.Message)),
                errors.First());

            //Use stack trace from the first exception to ensure first
            //failed Assert is one click away
            ReplaceStackTrace(ex, errors.First().StackTrace);

            throw ex;
        }
    }

    static void ReplaceStackTrace(Exception exception, string stackTrace)
    {
        var remoteStackTraceString = typeof(Exception)
            .GetField("_remoteStackTraceString",
                BindingFlags.Instance | BindingFlags.NonPublic);

        remoteStackTraceString.SetValue(exception, stackTrace);
    }
}

Non, vous ne pouvez pas le faire avec NUnit seul. Que vous avez à faire quelque chose comme @Konstantin Spirin dit. J'ai créé une petite extension que vous pouvez utiliser; il est appelé NUnit-GroupAssert. Il peut être trouvé ici: https://github.com/slvnperron/NUnit-GroupAssert

Comment l'utiliser:

[Test]
public void Verify_GroupsExceptions()
{
    var group = new AssertGroup();
    group.Add(() => Assert.AreEqual(10, 20));
    group.Add(() => Assert.AreEqual(1, 1));
    group.Add(() => Assert.AreEqual(3, 4));
    group.Add(() => Assert.IsTrue(1 > 3));
    group.Verify();
}

//OR

public void Verify_GroupsExceptions()
{
    //Verifies on disposal
    using (var group = new AssertGroup())
    {
        group.Add(() => Assert.AreEqual(10, 20));
        group.Add(() => Assert.AreEqual(1, 1));
        group.Add(() => Assert.AreEqual(3, 4));
        group.Add(() => Assert.IsTrue(1 > 3));
    }
}

il sera de sortie:

Test a échoué parce que l'un ou plusieurs des assertions a échoué:

1) Prévu: 10

Mais était: 20

De Verify_GroupsExceptions à la ligne 18

2) Prévu: 3

Mais était: 4

De Verify_GroupsExceptions à la ligne 20

3) Attendu: Vrai

Mais était: Faux

De Verify_GroupsExceptions à la ligne 21

Nope. Vous ne devriez pas vraiment plus qu'un faire valoir pour tester de toute façon, qui réduit la séparation et le rend plus difficile à trouver celui qui a échoué.

Si vous avez beaucoup de code qui doit exécuter avant de l'Affirmer, séparé dans une [SetUp] de la fonction, ou en faire une autre procédure.

Vous pourriez restructurer votre test pour envelopper les assertions contenues dans le bloc try/catch et de garder une trace d'eux pour validation ultérieure. Je ne le recommande pas, cependant. Vous devez vraiment être à l'aide de tests distincts pour chaque état, si vous voulez être testés de façon indépendante.

  bool[] assertionSuccesses = new bool[] { false, false, false };

  try
  {
       Assert.AreEqual( 1, 1 );
       assertionSuccesses[0] = true;
  }
  catch (AssertionException) {}
  ...

  if (assertionSuccesses.Any( s => !s ))
  {
       Assert.Fail("one of the assertions failed");
  }