MSTest-försäkran

Använd klasserna Assert i Microsoft.VisualStudio.TestTools.UnitTesting namnområdet för att verifiera specifika funktioner. En testmetod använder koden i ditt program men rapporterar endast korrekthet när du inkluderar Assert instruktioner.

Översikt

MSTest tillhandahåller tre assertklasser:

Class Avsikt
Assert Allmänna försäkran för värden, typer och undantag.
StringAssert Strängspecifika uttryck för mönster, delsträngar och jämförelser.
CollectionAssert Säkerställanden för att jämföra och verifiera samlingar.

Important

För ny kod, använd alltid klassen Assert. Klasserna StringAssert och CollectionAssert kommer sannolikt att bli inaktuella i en framtida version. De behålls främst för bakåtkompatibilitet, men de rekommenderas inte eftersom uppdelningen av asserter på tre typer försämrar upptäckbarheten.

Alla kontrollmetoder accepterar en valfri meddelandeparameter som visas när försäkran misslyckas, vilket hjälper dig att identifiera orsaken:

Assert.AreEqual(expected, actual, "Values should match after processing");

Klassen Assert

Använd klassen Assert för att kontrollera att koden som testas fungerar som förväntat.

Vanliga assertionsmetoder

[TestMethod]
public async Task AssertExamples()
{
    // Equality
    Assert.AreEqual(5, calculator.Add(2, 3));
    Assert.AreNotEqual(0, result);

    // Reference equality
    Assert.AreSame(expected, actual);
    Assert.AreNotSame(obj1, obj2);

    // Boolean conditions
    Assert.IsTrue(result > 0);
    Assert.IsFalse(string.IsNullOrEmpty(name));

    // Null checks
    Assert.IsNull(optionalValue);
    Assert.IsNotNull(requiredValue);

    // Type checks
    Assert.IsInstanceOfType<IDisposable>(obj);
    Assert.IsNotInstanceOfType<string>(obj);

    // Exception testing (MSTest v3.8+)
    Assert.ThrowsExactly<ArgumentNullException>(() => service.Process(null!));
    await Assert.ThrowsExactlyAsync<InvalidOperationException>(
        async () => await service.ProcessAsync());
}

Tillgängliga API:er

Klassen StringAssert

StringAssert Använd klassen för att jämföra och undersöka strängar.

Varning

Klassen StringAssert kommer sannolikt att bli inaktuell i en framtida version. Den underhålls endast för bakåtkompatibilitet och rekommenderas inte för ny kod. Alla StringAssert metoder har motsvarigheter i Assert klassen, vilket ger bättre identifiering. Information om hur du migrerar befintliga användningar finns i analyserarens MSTEST0046.

Tillgängliga API:er är:

Klassen CollectionAssert

CollectionAssert Använd klassen för att jämföra samlingar av objekt eller för att verifiera tillståndet för en samling.

Varning

Klassen CollectionAssert kommer sannolikt att bli inaktuell i en framtida version. Den underhålls främst för bakåtkompatibilitet och rekommenderas inte för ny kod. När det finns en motsvarande metod på Assert (till exempel Assert.Contains, Assert.DoesNotContaineller Assert.HasCount), kan du använda Assert för bättre identifiering.

Tillgängliga API:er är:

Skapa anpassade intyg med Assert.That

De inbyggda asserteringsmetoderna täcker inte alla scenarier. För att utöka asserteringsinfrastrukturen med egna kontroller exponerar MSTest singletonegenskapen Assert.That som en utökbarhetspunkt. Du lägger till anpassade intyg som C#-tilläggsmetoder för Assert instanstypen och anropare anropar dem med den välbekanta Assert.That.MyAssertion(...) syntaxen.

Organisera projektomfattande asserter i en dedikerad statisk klass för bättre hittbarhet. Anpassade assertions som man kommer åt via Assert.That visas tillsammans med de inbyggda metoderna i IntelliSense, så att man inte behöver hålla reda på en separat hjälptyp.

Skapa en anpassad försäkran

Lägg till en tilläggsmetod som riktar sig mot Assert typen och utlöser AssertFailedException när villkoret misslyckas:

using System;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;

public static class CustomAssertExtensions
{
    public static void IsPrime(this Assert assert, int value)
    {
        if (value < 2 || Enumerable.Range(2, (int)Math.Sqrt(value) - 1).Any(i => value % i == 0))
        {
            throw new AssertFailedException($"Assert.That.IsPrime failed. Value <{value}> is not a prime number.");
        }
    }
}

Använd ett anpassat intyg

När du har importerat namnområdet som innehåller dina tilläggsmetoder anropar du din anpassade försäkran via Assert.That:

[TestMethod]
public void Compute_ReturnsPrime()
{
    int result = _calculator.NextPrime(10);
    Assert.That.IsPrime(result);
}

Förlängningskrokar på StringAssert och CollectionAssert

Egenskaperna StringAssert.That och CollectionAssert.That exponerar samma singleton-mönster för bakåtkompatibilitet. För nya anpassade påståenden ska du alltid rikta dig mot Assert.That. Annars ärver hjälparna samma identifieringsproblem som de äldre klasserna, och de behöver migrering om StringAssert och CollectionAssert är inaktuella.

Assert.That egenskap kontra Assert.That(...) metod

Anmärkning

Blanda inte ihop Assert.Thatsingleton-egenskapen – som används som en utökningspunkt – med Assert.That(() => condition)metoden som lades till i MSTest 3.8. Det senare accepterar ett booleskt uttryck och skapar detaljerade felmeddelanden genom att analysera uttrycksträdet (till exempel Assert.That(() => order.Total > 0)). De två API:erna delar ett namn men har olika syften.

Metodtips

  • Använd specifika försäkran: Föredra AreEqual framför IsTrue(a == b) för bättre felmeddelanden.

  • Inkludera beskrivande meddelanden: Hjälp till att snabbt identifiera fel med tydliga försäkran.

  • Testa en sak i taget: Varje testmetod bör verifiera ett enda beteende.

  • Använda Throws/ThrowsExactly för undantag: I MSTest v3.8+ föredrar du Assert.Throws, Assert.ThrowsExactlyoch deras asynkrona motsvarigheter (ThrowsAsync, ThrowsExactlyAsync) framför ExpectedException attributet.

  • Föredra Assert framför StringAssert/CollectionAssert: För bättre upptäckbarhet och enhetlighet, använd klassen Assert. Klasserna StringAssert och CollectionAssert kommer sannolikt att bli inaktuella i en framtida version.

  • Utöka Assert.That för anpassade kontroller: För konsekvent identifiering lägger du till anpassade kontroller som tilläggsmetoder på Assert och anropar dem via Assert.That. Rikta inte in ny kod på StringAssert.That eller CollectionAssert.That.

Följande analysverktyg hjälper till att säkerställa korrekt användning av försäkran:

  • MSTEST0006 – Undvik ExpectedException attribut, använd Assert.Throws metoder i stället.
  • MSTEST0017 – Argument för påståenden ska skickas i rätt ordning.
  • MSTEST0023 – Negera inte booleska påståenden.
  • MSTEST0025 – Föredrar Assert.Fail framför alltid falska villkor.
  • MSTEST0026 – Argument för försäkran bör undvika villkorlig åtkomst.
  • MSTEST0032 – Granska alltid sanna assert-villkor.
  • MSTEST0037 – Använd rätt kontrollmetoder.
  • MSTEST0038 – Undvik Assert.AreSame med värdetyper.
  • MSTEST0039 – Använd nyare Assert.Throws metoder.
  • MSTEST0040 – Undvik att använda assertioner i asynkron kontext av void.
  • MSTEST0046 – Använd Assert i stället för StringAssert.
  • - Assert.Throws MSTEST0051 ska innehålla en enda instruktion.
  • MSTEST0053 – Undvik Assert formatparametrar.
  • MSTEST0058 – Undvik asserter i fångstblock.

Se även

  • Last updated on