MSTest-kenmerken

MSTest maakt gebruik van aangepaste kenmerken om tests te identificeren en aan te passen.

Deze sectie organiseert de leden van de Microsoft.VisualStudio.TestTools.UnitTesting naamruimte in groepen gerelateerde functionaliteit om een duidelijker overzicht te geven van het testframework.

Kenmerken die worden gebruikt om testklassen en -methoden te identificeren

Elke testklasse moet het TestClass kenmerk hebben en elke testmethode moet het TestMethod kenmerk hebben.

TestClassAttribute

Het kenmerk TestClass markeert een klasse die tests bevat en, optioneel, methoden initialiseren of opschonen.

Dit kenmerk kan worden uitgebreid om het standaardgedrag te wijzigen of uit te breiden.

Voorbeeld:

[TestClass]
public class MyTestClass
{
}

TestMethodAttribute

Het kenmerk TestMethod wordt in een TestClass gebruikt om de werkelijke testmethode te definiëren die moet worden uitgevoerd.

De methode moet een instantiemethode public zijn die is gedefinieerd als void, Taskof ValueTask (te beginnen met MSTest v3.3). Het kan optioneel zijn async , maar mag niet zijn async void.

De methode moet nul parameters hebben, tenzij deze is gemarkeerd met het kenmerk DataRow, het kenmerk DynamicData of een vergelijkbaar kenmerk dat testcasegegevens aan de testmethode levert.

Bekijk de volgende voorbeeldtestklasse:

[TestClass]
public class MyTestClass
{
    [TestMethod]
    public void TestMethod()
    {
    }
}

DiscoverInternalsAttribute

Het kenmerk DiscoverInternals wordt toegepast op assemblyniveau om MSTest in staat te stellen testklassen en testmethoden te detecteren die worden gedeclareerd als internal in plaats publicvan . MSTest detecteert standaard alleen openbare testklassen en -methoden. Wanneer dit kenmerk aanwezig is, worden zowel openbare als interne tests gedetecteerd.

Dit kenmerk wordt toegepast in het AssemblyInfo.cs bestand, het MSTestSettings.cs bestand of boven aan een bestand in de testassembly:

using Microsoft.VisualStudio.TestTools.UnitTesting;

[assembly: DiscoverInternals]

namespace MyTests
{
    [TestClass]
    internal class InternalTestClass // This class will be discovered
    {
        [TestMethod]
        internal void InternalTestMethod() // This method will be discovered
        {
            Assert.IsTrue(true);
        }
    }
}

Kenmerken die worden gebruikt voor gegevensgestuurde tests

Gebruik de volgende elementen om gegevensgestuurde tests in te stellen. Zie Een gegevensgestuurde eenheidstest maken en een configuratiebestand gebruiken om een gegevensbron te definiëren voor meer informatie.

• DataRowAttribute
• DataSourceAttribute
• TestMethodAttribute
• DynamicDataAttribute

DataRowAttribute

Met het kenmerk DataRow kunt u dezelfde testmethode uitvoeren met meerdere verschillende invoerwaarden. Het kan één of meerdere keren worden weergegeven op een testmethode. Deze moet worden gecombineerd met het kenmerk TestMethod.

Het aantal en de typen argumenten moeten exact overeenkomen met de handtekening van de testmethode. Bekijk het volgende voorbeeld van een geldige testklasse die het DataRowAttribute gebruik laat zien met inlineargumenten die zijn afgestemd op testmethodeparameters:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, "message", true, 2.0)]
    public void TestMethod1(int i, string s, bool b, float f)
    {
        // Omitted for brevity.
    }

    [TestMethod]
    [DataRow(new string[] { "line1", "line2" })]
    public void TestMethod2(string[] lines)
    {
        // Omitted for brevity.
    }

    [TestMethod]
    [DataRow(null)]
    public void TestMethod3(object o)
    {
        // Omitted for brevity.
    }

    [TestMethod]
    [DataRow(new string[] { "line1", "line2" }, new string[] { "line1.", "line2." })]
    public void TestMethod4(string[] input, string[] expectedOutput)
    {
        // Omitted for brevity.
    }
}

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2, 3, 4)]
    public void TestMethod(params int[] values) {}
}

Voorbeelden van ongeldige combinaties:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2)] // Not valid, we are passing 2 inline data but signature expects 1
    public void TestMethod1(int i) {}

    [TestMethod]
    [DataRow(1)] // Not valid, we are passing 1 inline data but signature expects 2
    public void TestMethod2(int i, int j) {}

    [TestMethod]
    [DataRow(1)] // Not valid, count matches but types do not match
    public void TestMethod3(string s) {}
}

U kunt de weergavenaam wijzigen die wordt gebruikt in Visual Studio en loggers voor elk exemplaar van DataRowAttribute door de eigenschap in te DisplayName stellen.

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2, DisplayName = "Functional Case FC100.1")]
    public void TestMethod(int i, int j) {}
}

U kunt ook uw eigen gespecialiseerde DataRow kenmerk maken door de DataRowAttributeover te nemen.

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public class MyCustomDataRowAttribute : DataRowAttribute
{
}

[TestClass]
public class TestClass
{
    [TestMethod]
    [MyCustomDataRow(1)]
    public void TestMethod(int i) {}
}

Vanaf MSTest v3.8 kunt u de IgnoreMessage eigenschap gebruiken om specifieke testcases voorwaardelijk te negeren:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DataRow(1, 2)]
    [DataRow(3, 4, IgnoreMessage = "Temporarily disabled")]
    [DataRow(5, 6)]
    public void TestMethod(int i, int j)
    {
        // Only the first and third data rows will run
        // The second data row is skipped with the provided message
    }
}

DynamicDataAttribute

Met het kenmerk DynamicData kunt u dezelfde testmethode uitvoeren met gegevens die worden geleverd door een veld, een eigenschap of een methode. Dit is handig wanneer u testgegevens dynamisch moet genereren of wanneer de testgegevens te complex zijn om inline met DataRowAttributete definiëren.

Het kenmerk vereist de naam van een veld, een eigenschap of methode die de testgegevens levert. De gegevensbron kan een van de volgende typen retourneren:

• IEnumerable<object[]> - elk object[] vertegenwoordigt de argumenten voor één testcase
• IEnumerable<ValueTuple> - elke tuple vertegenwoordigt de argumenten voor één testcase (bijvoorbeeld IEnumerable<(int, string)>)
• IEnumerable<Tuple<...>> - elk Tuple vertegenwoordigt de argumenten voor één testcase
• IEnumerable<TestDataRow> - biedt extra controle over metagegevens van testcases (zie Subsectie TestDataRow )

[TestClass]
public class TestClass
{
    [TestMethod]
    [DynamicData(nameof(GetTestData))]
    public void TestMethod(int value1, string value2)
    {
        // Test implementation
    }

    public static IEnumerable<object[]> GetTestData()
    {
        yield return new object[] { 1, "first" };
        yield return new object[] { 2, "second" };
        yield return new object[] { 3, "third" };
    }
}

Standaard zoekt de DynamicDataAttribute gegevensbron in dezelfde klasse als de testmethode. U kunt een andere klasse opgeven met behulp van de DynamicDataSourceType parameter:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DynamicData(nameof(TestDataProvider.GetTestData), typeof(TestDataProvider))]
    public void TestMethod(int value1, string value2)
    {
        // Test implementation
    }
}

public class TestDataProvider
{
    public static IEnumerable<object[]> GetTestData()
    {
        yield return new object[] { 1, "first" };
        yield return new object[] { 2, "second" };
    }
}

U kunt ook eigenschappen of velden gebruiken in plaats van methoden:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DynamicData(nameof(TestData))]
    public void TestMethod(int value1, string value2)
    {
        // Test implementation
    }

    public static IEnumerable<object[]> TestData => new[]
    {
        new object[] { 1, "first" },
        new object[] { 2, "second" },
        new object[] { 3, "third" }
    };

    // Fields are also supported
    public static IEnumerable<object[]> TestDataField = new[]
    {
        new object[] { 10, "ten" },
        new object[] { 20, "twenty" }
    };
}

De DynamicDataAttribute eigenschap ondersteunt ook de DynamicDataDisplayName eigenschap om aan te passen hoe testcases worden weergegeven in Test Explorer. U kunt de indeling van de weergavenaam opgeven met behulp van de DynamicDataDisplayNameDeclaringType methode om te verwijzen naar een methode waarmee de weergavenaam wordt gegenereerd:

using System.Reflection;

[TestClass]
public class TestClass
{
    [TestMethod]
    [DynamicData(nameof(GetTestData), DynamicDataDisplayName = nameof(GetDisplayName))]
    public void TestMethod(int value1, string value2)
    {
        // Test implementation
    }

    public static IEnumerable<object[]> GetTestData()
    {
        yield return new object[] { 1, "first" };
        yield return new object[] { 2, "second" };
    }

    public static string GetDisplayName(MethodInfo methodInfo, object[] data)
    {
        return $"{methodInfo.Name} - {data[0]} and {data[1]}";
    }
}

Vanaf MSTest v3.8 kunt u de IgnoreMessage eigenschap gebruiken om alle testcases die zijn gegenereerd door de dynamische gegevensbron voorwaardelijk te negeren:

[TestClass]
public class TestClass
{
    [TestMethod]
    [DynamicData(nameof(GetTestData), IgnoreMessage = "Feature not ready")]
    public void TestMethod(int value1, string value2)
    {
        // All test cases from GetTestData will be skipped
    }

    public static IEnumerable<object[]> GetTestData()
    {
        yield return new object[] { 1, "first" };
        yield return new object[] { 2, "second" };
    }
}

TestDataRow

De TestDataRow<T> klasse biedt verbeterde controle over testgegevens in gegevensgestuurde tests. IEnumerable<TestDataRow<T>> Wanneer u het retourtype voor uw dynamische gegevensbron gebruikt, kunt u extra metagegevens opgeven voor elke testcase, zoals aangepaste weergavenamen en testeigenschappen.

TestDataRow<T> biedt de volgende voordelen:

• Aangepaste weergavenamen: Stel een unieke weergavenaam in voor elke testcase met behulp van de DisplayName eigenschap.
• Testcategorieën: voeg metagegevens toe aan afzonderlijke testcases met behulp van de TestCategories eigenschap.
• Typeveilige gegevens: gebruik de algemene TestDataRow<T> gegevens om sterk getypte testgegevens te bieden.

[TestClass]
public class TestClass
{
    [TestMethod]
    [DynamicData(nameof(GetTestDataRows))]
    public void TestMethod(int value1, string value2)
    {
        // Test implementation
    }

    public static IEnumerable<TestDataRow> GetTestDataRows()
    {
        yield return new TestDataRow((1, "first"))
        {
            DisplayName = "Test Case 1: Basic scenario"
        };
        
        yield return new TestDataRow((2, "second"))
        {
            DisplayName = "Test Case 2: Edge case",
            TestProperties = { ["Priority"] = "High", ["Category"] = "Critical" }
        };
    }
}

eigenschap UnfoldingStrategy

Gegevensgestuurde testkenmerken zoals DataRowAttribute en DynamicDataAttribute ondersteunen de TestDataSourceUnfoldingStrategy eigenschap, waarmee wordt bepaald hoe testcases worden weergegeven in Test Explorer en TRX-resultaten. Deze eigenschap bepaalt ook of afzonderlijke testcases onafhankelijk kunnen worden uitgevoerd.

De UnfoldingStrategy eigenschap accepteert de volgende waarden:

• TestDataSourceUnfoldingStrategy.Auto (standaard): MSTest bepaalt automatisch of testcases moeten worden uitgevouwen op basis van het aantal gegevensrijen. Testcases worden samengevouwen wanneer er veel gegevensrijen zijn om vervuiling van Test Explorer te voorkomen, en uitgevouwen wanneer er weinig gegevensrijen zijn voor betere zichtbaarheid.
• TestDataSourceUnfoldingStrategy.Unfold: Alle testcases worden uitgebreid en afzonderlijk weergegeven in testverkenner en TRX-resultaten. Elke testcase kan onafhankelijk worden uitgevoerd.
• TestDataSourceUnfoldingStrategy.Fold: Alle testcases worden samengevouwen tot één testknooppunt. Afzonderlijke testcases kunnen niet onafhankelijk worden uitgevoerd; de volledige gegevensgestuurde test wordt uitgevoerd als één eenheid.

Voor de meeste scenario's biedt het standaardgedrag Auto de beste balans tussen bruikbaarheid en prestaties. Het wijzigen van deze instelling wordt beschouwd als een geavanceerd scenario en moet alleen worden uitgevoerd wanneer u specifieke vereisten hebt, zoals niet-deterministische gegevensbron of bekende beperkingen of bugs van MSTest.

[TestClass]
public class TestClass
{
    [TestMethod(UnfoldingStrategy = TestDataSourceUnfoldingStrategy.Unfold)] // Force unfolding/expanding
    [DataRow(1)] 
    [DataRow(2)]
    [DataRow(3)]
    public void TestMethodWithUnfolding(int value)
    {
        // Each test case appears individually in Test Explorer
    }

    [TestMethod(UnfoldingStrategy = TestDataSourceUnfoldingStrategy.Fold)] // Force folding/collapsing
    [DynamicData(nameof(GetData))]
    public void TestMethodWithFolding(int value)
    {
        // All test cases appear as a single collapsed node
    }

    public static IEnumerable<object[]> GetData()
    {
        yield return new object[] { 1 };
        yield return new object[] { 2 };
        yield return new object[] { 3 };
    }
}

Kenmerken die worden gebruikt om initialisatie en opschoning te bieden

Het instellen en opschonen dat gebruikelijk is voor meerdere tests, kan worden geëxtraheerd naar een afzonderlijke methode en gemarkeerd met een van de kenmerken die in de volgende sectie worden vermeld, om deze op het juiste moment uit te voeren, bijvoorbeeld voor elke test. Zie Anatomie van een eenheidstest voor meer informatie.

Assemblyniveau

Het kenmerk AssemblyInitialize wordt direct aangeroepen nadat de assembly is geladen en het kenmerk AssemblyCleanup wordt aangeroepen voordat de assembly wordt verwijderd.

De methoden die zijn gemarkeerd met deze kenmerken, moeten worden gedefinieerd als static void, static Task of static ValueTask (te beginnen met MSTest v3.3), in een klasse die is gemarkeerd met TestClassAttributeen slechts één keer worden weergegeven. Voor het initialiseren is één parameter van het type TestContext vereist en het opschonen vereist geen parameters, of vanaf MSTest 3.8 kan het één parameter van het type TestContexthebben.

[TestClass]
public class MyTestClass
{
    [AssemblyInitialize]
    public static void AssemblyInitialize(TestContext testContext)
    {
    }

    [AssemblyCleanup]
    public static void AssemblyCleanup() // Starting with MSTest 3.8, it can be AssemblyCleanup(TestContext testContext)
    {
    }
}

Klasniveau

Het kenmerk ClassInitialize wordt direct aangeroepen voordat uw klasse wordt geladen (maar na de statische constructor) en de ClassCleanup- direct nadat uw klasse is geladen, wordt aangeroepen.

Het is ook mogelijk om het overnamegedrag te beheren: alleen voor de huidige klasse die InheritanceBehavior.Nonegebruikt, of voor alle afgeleide klassen die gebruikmaken van InheritanceBehavior.BeforeEachDerivedClass.

De methoden die zijn gemarkeerd met deze kenmerken, moeten worden gedefinieerd als static void, static Task of static ValueTask (beginnend met MSTest v3.3), in een TestClass, en worden slechts één keer weergegeven. Voor het initialiseren is één parameter van het type TestContext vereist en het opschonen vereist geen parameters, of vanaf MSTest 3.8 kan het één parameter van het type TestContexthebben.

[TestClass]
public class MyTestClass
{
    [ClassInitialize]
    public static void ClassInitialize(TestContext testContext)
    {
    }

    [ClassCleanup]
    public static void ClassCleanup() // Starting with MSTest 3.8, it can be ClassCleanup(TestContext testContext)
    {
    }
}

Testniveau

De TestInitialize kenmerk wordt direct aangeroepen voordat de test wordt gestart en de TestCleanup- direct nadat de test is voltooid.

De TestInitializeAttribute is vergelijkbaar met de klasseconstructor, maar is meestal geschikter voor lange of asynchrone initialisaties. De TestInitializeAttribute wordt altijd na de constructor aangeroepen en voor elke test aangeroepen (inclusief elke vermelding van gegevensgestuurde tests).

De TestCleanupAttribute is vergelijkbaar met de klasse Dispose (of DisposeAsync) maar is meestal geschikter voor lange of asynchrone opschoning. De TestCleanupAttribute wordt altijd net vóór de DisposeAsync/Dispose aangeroepen en voor elke test aangeroepen (inclusief elke vermelding van gegevensgestuurde tests).

De methoden die zijn gemarkeerd met deze kenmerken, moeten worden gedefinieerd als void, Task of ValueTask (beginnend met MSTest v3.3), in een TestClass, parameterloos zijn en één of meerdere keren worden weergegeven.

[TestClass]
public class MyTestClass
{
    [TestInitialize]
    public void TestInitialize()
    {
    }

    [TestCleanup]
    public void TestCleanup()
    {
    }
}

Globaal testniveau

Het kenmerk GlobalTestInitialize wordt vlak voor elke testmethode in de assembly aangeroepen en de GlobalTestCleanup wordt direct na elke testmethode in de assembly aangeroepen. Deze kenmerken zijn geïntroduceerd in MSTest 3.10.0.

Deze kenmerken bieden een manier om initialisatie- en opschoonlogica te definiëren die van toepassing is op alle testmethoden in de hele assembly, zonder dat dezelfde initialisatie-/opschooncode in elke testklasse hoeft te worden toegevoegd.

De methoden die zijn gemarkeerd met deze kenmerken, moeten worden gedefinieerd als public static void, static Task of static ValueTask, in een klasse die is gemarkeerd met TestClassAttribute, moet niet-algemeen zijn, moet precies één parameter van het type TestContexthebben en kan meerdere keren worden weergegeven in verschillende testklassen in de assembly.

[TestClass]
public class MyTestClass
{
    [GlobalTestInitialize]
    public static void GlobalTestInitialize(TestContext testContext)
    {
        // This runs before every test method in the assembly
    }

    [GlobalTestCleanup]
    public static void GlobalTestCleanup(TestContext testContext)
    {
        // This runs after every test method in the assembly
    }
}

Kenmerken die worden gebruikt om de testuitvoering te beheren

De volgende kenmerken kunnen worden gebruikt om de manier te wijzigen waarop tests worden uitgevoerd.

Threading-kenmerken

Deze kenmerken bepalen het threadingmodel voor testuitvoering.

STATestClassAttribute

Wanneer het attribuut STATestClass wordt toegepast op een testklasse, geeft het aan dat alle testmethoden (en de [ClassInitialize]- en [ClassCleanup]-methoden) in de klasse moeten worden uitgevoerd in een single-threaded apartment (STA). Dit kenmerk is handig wanneer de testmethoden communiceren met COM-objecten waarvoor STA is vereist.

STATestMethodAttribute

Wanneer deze wordt toegepast op een testmethode, geeft de STATestMethod-kenmerk aan dat de testmethode moet worden uitgevoerd in een STA (Single Threaded Apartment). Dit kenmerk is handig wanneer de testmethode communiceert met COM-objecten waarvoor STA is vereist.

UITestMethodAttribute

Wanneer het kenmerk wordt toegepast op een testmethode, geeft het UITestMethod kenmerk aan dat de testmethode moet worden gepland op de UI-thread van het platform. Dit kenmerk is speciaal ontworpen voor het testen van UWP -toepassingen (Universal Windows Platform) en WinUI-toepassingen waarvoor toegang tot ui-threads is vereist.

Dit kenmerk is handig bij het testen van ui-onderdelen, besturingselementen of code die moet worden uitgevoerd op de UI-thread om te communiceren met de visuele elementen van de toepassing.

[TestClass]
public class MyUITestClass
{
    [UITestMethod]
    public void TestUIComponent()
    {
        // This test runs on the UI thread, allowing interaction with UI elements
        var button = new Button();
        Assert.IsNotNull(button);
    }
}

Parallellisatiekenmerken

Deze kenmerken bepalen of en hoe tests parallel worden uitgevoerd.

ParallelizeAttribute

MSTest voert standaard tests uit in een opeenvolgende volgorde. Het kenmerk op assemblyniveau Parallelliseren kenmerk kan worden gebruikt om tests parallel uit te voeren. U kunt opgeven of de parallelle uitvoering moet plaatsvinden op klasseniveau (meerdere klassen kunnen parallel worden uitgevoerd, maar tests in een bepaalde klasse worden opeenvolgend uitgevoerd) of op methodeniveau.

Het is ook mogelijk om het maximum aantal threads op te geven dat moet worden gebruikt voor parallelle uitvoering. Een waarde van 0 (standaardwaarde) betekent dat het aantal threads gelijk is aan het aantal logische processors op de computer.

Het is ook mogelijk om de parallelle uitvoering op te geven via de parallelle eigenschappen van het runettings-bestand.

DoNotParallelizeAttribute

Het kenmerk DoNotParallelize kan worden gebruikt om parallelle uitvoering van tests in een bepaalde assembly te voorkomen. Dit kenmerk kan worden toegepast op assemblyniveau, klasseniveau of methodeniveau.

Time-out en kenmerken voor opnieuw proberen

Deze kenmerken bepalen de uitvoeringstijdlimieten en het gedrag van opnieuw proberen.

TimeoutAttribute

Het time-outkenmerk kan worden gebruikt om de maximale tijd in milliseconden op te geven die door een testmethode mag worden uitgevoerd. Als de testmethode langer wordt uitgevoerd dan de opgegeven tijd, wordt de test afgebroken en gemarkeerd als mislukt.

Dit kenmerk kan worden toegepast op elke testmethode of een willekeurige armaturenmethode (initialisatie- en opschoonmethoden). Het is ook mogelijk om de time-out globaal op te geven voor alle testmethoden of alle testarmaturenmethoden met behulp van de time-outeigenschappen van het runettings-bestand.

Wanneer u de time-outfunctie gebruikt, wordt er een afzonderlijke thread/taak gemaakt om de testmethode uit te voeren. De hoofdthread/taak is verantwoordelijk voor het controleren van de time-out en het ongedaan maken van de methodethread/-taak als de time-out is bereikt.

Vanaf MSTest 3.6 is het mogelijk om eigenschap op te geven CooperativeCancellation op het kenmerk (of globaal via runsettings) om coöperatief annuleren mogelijk te maken. In deze modus is de methode verantwoordelijk voor het controleren van het annuleringstoken en het afbreken van de test als deze wordt gesignaleerd zoals u zou doen in een typische async methode. Deze modus is beter presterend en maakt een nauwkeurigere controle over het annuleringsproces mogelijk. Deze modus kan worden toegepast op zowel asynchrone als synchronisatiemethoden.

RetryAttribute

Het kenmerk Opnieuw proberen is geïntroduceerd in MSTest 3.8. Dit kenmerk zorgt ervoor dat de testmethode opnieuw wordt uitgevoerd wanneer deze mislukt of een timeout geeft. Hiermee kunt u het maximum aantal nieuwe pogingen, de tijdsvertraging tussen nieuwe pogingen en een vertragingsachterstand opgeven, wat een constante of exponentiële waarde is.

Er mag slechts één RetryAttribute aanwezig zijn op een testmethode, en RetryAttribute mag niet gebruikt worden bij methoden zonder de aanduiding TestMethod-.

[TestClass]
public class MyTestClass
{
    [TestMethod]
    [Retry(3)] // Retry up to 3 times if the test fails
    public void FlakeyTest()
    {
        // Test implementation that might occasionally fail
    }
}

Kenmerken voor voorwaardelijke uitvoering

Deze kenmerken bepalen of tests worden uitgevoerd op basis van specifieke voorwaarden.

ConditionBaseAttribute

Het kenmerk ConditionBase is een abstracte basisklasse die wordt gebruikt om voorwaardelijk te bepalen of een testklasse of testmethode wordt uitgevoerd of genegeerd. Dit kenmerk biedt de basis voor het maken van aangepaste logica voor voorwaardelijke uitvoering.

Afgeleide klassen, zoals CIConditionAttribute, IgnoreAttribute en OSConditionAttribute, implementeren specifieke voorwaarden om te bepalen of tests moeten worden uitgevoerd.

CIConditionAttribute

Het KENMERK CICondition wordt gebruikt om een testklasse of testmethode voorwaardelijk uit te voeren of te negeren op basis van of de test wordt uitgevoerd in een CI-omgeving (continue integratie). Dit kenmerk is afgeleid van ConditionBaseAttribute.

U kunt de ConditionMode opgeven om op te nemen (alleen uitvoeren in CI) of uitsluiten (overslaan in CI):

[TestClass]
public class MyTestClass
{
    [TestMethod]
    [CICondition] // Run only in CI (default behavior, equivalent to `[CICondition(ConditionMode.Include)]`)
    public void CIOnlyTest()
    {
        // This test runs only when executed in a CI environment
    }

    [TestMethod]
    [CICondition(ConditionMode.Exclude)] // Skip in CI
    public void LocalOnlyTest()
    {
        // This test is skipped when running in a CI environment
    }
}

OSConditionAttribute

Het kenmerk OSCondition wordt gebruikt om een testklasse of testmethode voorwaardelijk uit te voeren of te negeren op basis van het besturingssysteem waarop de test wordt uitgevoerd. Dit kenmerk is afgeleid van ConditionBaseAttribute.

U kunt opgeven welke besturingssystemen door de test worden ondersteund of niet worden ondersteund met behulp van het enum van operatingSystems-vlaggen, waaronder Windows, ( LinuxOSX macOS) en FreeBSD. U kunt meerdere besturingssystemen combineren met behulp van de bitsgewijze OR-operator.

[TestClass]
public class MyTestClass
{
    [TestMethod]
    [OSCondition(OperatingSystems.Windows)] // Run only on Windows
    public void WindowsOnlyTest()
    {
        // This test runs only on Windows
    }

    [TestMethod]
    [OSCondition(OperatingSystems.Linux | OperatingSystems.OSX)] // Run on Linux or macOS
    public void UnixLikeTest()
    {
        // This test runs on Linux or macOS
    }

    [TestMethod]
    [OSCondition(ConditionMode.Exclude, OperatingSystems.Windows)] // Skip on Windows
    public void SkipOnWindowsTest()
    {
        // This test is skipped on Windows
    }
}

IgnoreAttribute

Het kenmerk Negeren markeert een testklasse of testmethode die moet worden overgeslagen tijdens de testuitvoering. Dit kenmerk is handig voor het tijdelijk uitschakelen van tests zonder ze uit de codebasis te verwijderen.

U kunt desgewenst een reden opgeven voor het negeren van de test:

[TestClass]
public class MyTestClass
{
    [TestMethod]
    [Ignore]
    public void TemporarilyDisabledTest()
    {
        // This test is skipped
    }

    [TestMethod]
    [Ignore("Waiting for bug fix")]
    public void TestWithReason()
    {
        // This test is skipped with a reason
    }
}

Wanneer u een test negeert vanwege een specifiek werkitem of probleem, kunt u overwegen om de kenmerken WorkItem of GitHubWorkItem te gebruiken om een gestructureerde koppeling naar het ticket te bieden in plaats van een eenvoudige tekenreeks. Deze kenmerken bieden een betere traceerbaarheid en kunnen worden gebruikt om rapporten te genereren die tests koppelen aan specifieke werkitems:

[TestClass]
public class MyTestClass
{
    [TestMethod]
    [Ignore("Waiting for fix")]
    [WorkItem(12345)] // Links to work item 12345 in your tracking system
    public void TestWithWorkItem()
    {
        // This test is skipped and linked to a work item
    }

    [TestMethod]
    [Ignore("Known issue")]
    [GitHubWorkItem("https://github.com/owner/repo/issues/42")] // Links to GitHub issue
    public void TestWithGitHubIssue()
    {
        // This test is skipped and linked to a GitHub issue
    }
}

Kenmerken van hulpprogramma's

DeploymentItemAttribute

Het kenmerk DeploymentItem wordt gebruikt voor het kopiëren van bestanden of mappen die zijn opgegeven als implementatie-items naar de implementatiemap (zonder een aangepast uitvoerpad toe te voegen, bevinden de gekopieerde bestanden zich in TestResults map in de projectmap). De implementatiemap is waar alle implementatie-items aanwezig zijn, samen met het dll-bestand van het testproject.

Deze kan worden gebruikt voor testklassen (klassen die zijn gemarkeerd met het kenmerk TestClass) of op testmethoden (methoden die zijn gemarkeerd met Kenmerk TestMethod).

Gebruikers kunnen meerdere exemplaren van het kenmerk hebben om meer dan één item op te geven.

En hier kunt u de constructors zien.

Voorbeeld

[TestClass]
[DeploymentItem(@"C:\classLevelDepItem.xml")]   // Copy file using some absolute path
public class UnitTest1
{
    [TestMethod]
    [DeploymentItem(@"..\..\methodLevelDepItem1.xml")]   // Copy file using a relative path from the dll output location
    [DeploymentItem(@"C:\DataFiles\methodLevelDepItem2.xml", "SampleDataFiles")]   // File will be added under a SampleDataFiles in the deployment directory
    public void TestMethod1()
    {
        string textFromFile = File.ReadAllText("classLevelDepItem.xml");
    }
}

ExpectedExceptionAttribute

Het kenmerk ExpectedException definieert de uitzondering die de testmethode naar verwachting zal genereren. De test wordt doorgegeven als de verwachte uitzondering wordt gegenereerd en het uitzonderingsbericht overeenkomt met het verwachte bericht.

Metagegevenskenmerken

De volgende kenmerken en de waarden die eraan zijn toegewezen, worden weergegeven in het Visual Studiovenster Eigenschappen voor een bepaalde testmethode. Deze kenmerken zijn niet bedoeld om te worden geopend via de code van de test. In plaats daarvan hebben ze invloed op de manieren waarop de test wordt gebruikt of uitgevoerd door u via de IDE van Visual Studio of door de Visual Studio-testengine. Sommige van deze kenmerken worden bijvoorbeeld weergegeven als kolommen in het venster Testbeheer en het venster Testresultaten . Dit betekent dat u ze kunt gebruiken om tests en testresultaten te groeperen en te sorteren. Een dergelijk kenmerk is TestPropertyAttribute, dat u gebruikt om willekeurige metagegevens toe te voegen aan tests.

U kunt deze bijvoorbeeld gebruiken om de naam van een 'testpas' op te slaan die door deze test wordt behandeld, door de test te markeren met [TestProperty("Feature", "Accessibility")]. Of u kunt het gebruiken om een indicator op te slaan van het soort test waarmee [TestProperty("ProductMilestone", "42")]het is. De eigenschap die u maakt met dit kenmerk en de eigenschapswaarde die u toewijst, worden beide weergegeven in het venster Eigenschappen van Visual Studio onder de kop Testspecifiek.

• DescriptionAttribute
• GitHubWorkItemAttribute
• OwnerAttribute
• PriorityAttribute
• TestCategoryAttribute
• TestPropertyAttribute
• WorkItemAttribute

De onderstaande kenmerken relateren de testmethode die ze versieren aan entiteiten in de projecthiërarchie van een Team Foundation Server teamproject:

• CssIterationAttribute
• CssProjectStructureAttribute