Eseguire unit test selezionati

Con il comando dotnet test in .NET Core è possibile usare un'espressione filtro per eseguire test selezionati. Questo articolo illustra come filtrare i test. Negli esempi viene usato dotnet test. Se si utilizza vstest.console.exe, sostituire --filter con --testcasefilter:.

Sintassi

dotnet test --filter <Expression>

L'espressione è nel formato <Property><Operator><Value>[|&<Expression>].

Le espressioni possono essere unite con operatori booleani: | per booleano o, & per booleano e.

Le espressioni possono essere racchiuse tra parentesi. Ad esempio: (Name~MyClass) | (Name~MyClass2).

Un'espressione senza alcun operatore viene interpretata come contiene nella proprietà FullyQualifiedName. Ad esempio, dotnet test --filter xyz è identico a dotnet test --filter FullyQualifiedName~xyz.

Proprietà è un attributo di Test Case. Ad esempio, le seguenti proprietà sono supportate da framework diffusi per unit test.

Framework di test	Proprietà supportate
MSTest	`FullyQualifiedName` `Name` `ClassName` `Priority` `TestCategory`
xUnit	`FullyQualifiedName` `DisplayName` `Traits`
Nunit	`FullyQualifiedName` `Name` `Priority` `TestCategory`

Operatori
- = corrispondenza esatta
- != corrispondenza non esatta
- ~ contiene
- !~ non contiene
Il valore è una stringa. Per tutte le ricerche non viene fatta distinzione tra maiuscole e minuscole.

Escape di caratteri

Per usare un punto esclamativo (!) in un'espressione filtro, è necessario eseguirne l'escape in alcune shell Linux o macOS inserendo una barra rovesciata davanti (\!). Ad esempio, il filtro seguente ignora tutti i test in uno spazio dei nomi che contiene IntegrationTests:

dotnet test --filter FullyQualifiedName\!~IntegrationTests

Per i valori FullyQualifiedName che includono una virgola per i parametri di tipo generico, esegui l'escape della virgola con %2C. Ad esempio:

dotnet test --filter "FullyQualifiedName=MyNamespace.MyTestsClass<ParameterType1%2CParameterType2>.MyTestMethod"

Per Name o DisplayName, usare la codifica URL per i caratteri speciali. Ad esempio, per eseguire un test con il nome MyTestMethod e un valore stringa "text", usare il filtro seguente:

dotnet test --filter "Name=MyTestMethod \(%22text%22\)"

Esempi di MSTest

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace MSTestNamespace
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod, Priority(1), TestCategory("CategoryA")]
        public void TestMethod1()
        {
        }

        [TestMethod, Priority(2)]
        public void TestMethod2()
        {
        }
    }
}

Espressione	Risultato
`dotnet test --filter Method`	Esegue i test il cui FullyQualifiedName contiene `Method`.
`dotnet test --filter Name~TestMethod1`	Esegue i test il cui nome contiene `TestMethod1`.
`dotnet test --filter ClassName=MSTestNamespace.UnitTest1`	Esegue i test presenti nella classe `MSTestNamespace.UnitTest1`. Nota: il valore `ClassName` deve avere uno spazio dei nomi, pertanto `ClassName=UnitTest1` non funziona.
`dotnet test --filter FullyQualifiedName!=MSTestNamespace.UnitTest1.TestMethod1`	Esegue tutti i test tranne `MSTestNamespace.UnitTest1.TestMethod1`.
`dotnet test --filter TestCategory=CategoryA`	Esegue i test annotati con `[TestCategory("CategoryA")]`.
`dotnet test --filter Priority=2`	Esegue i test annotati con `[Priority(2)]`.

Esempi che usano gli operatori condizionali | e &:

Per eseguire test con UnitTest1 oTestCategoryAttributeè ."CategoryA"

dotnet test --filter "FullyQualifiedName~UnitTest1|TestCategory=CategoryA"

Per eseguire i test che includono UnitTest1FullyQualifiedName e hanno un TestCategoryAttribute di "CategoryA".
```
dotnet test --filter "FullyQualifiedName~UnitTest1&TestCategory=CategoryA"
```
Per eseguire i test che contengono FullyQualifiedNameUnitTest1 e hanno oPriorityAttributepriorità .1
```
dotnet test --filter "(FullyQualifiedName~UnitTest1&TestCategory=CategoryA)|Priority=1"
```

Esempi di xUnit

using Xunit;

namespace XUnitNamespace
{
    public class TestClass1
    {
        [Fact, Trait("Priority", "1"), Trait("Category", "CategoryA")]
        public void Test1()
        {
        }

        [Fact, Trait("Priority", "2")]
        public void Test2()
        {
        }
    }
}

Espressione	Risultato
`dotnet test --filter DisplayName=XUnitNamespace.TestClass1.Test1`	Esegue solo un test, `XUnitNamespace.TestClass1.Test1`.
`dotnet test --filter FullyQualifiedName!=XUnitNamespace.TestClass1.Test1`	Esegue tutti i test tranne `XUnitNamespace.TestClass1.Test1`.
`dotnet test --filter DisplayName~TestClass1`	Esegue i test il cui nome visualizzato contiene `TestClass1`.

Nell'esempio di codice, i tratti definiti con le chiavi "Category" e "Priority" possono essere utilizzati per il filtraggio.

Espressione	Risultato
`dotnet test --filter XUnit`	Esegue i test il cui FullyQualifiedName contiene `XUnit`.
`dotnet test --filter Category=CategoryA`	Esegue test che includono `[Trait("Category", "CategoryA")]`.

Esempi che usano gli operatori condizionali | e &:

Per eseguire i test che includono TestClass1FullyQualifiedNameo hanno un Trait oggetto con una chiave di "Category" e il valore ."CategoryA"
```
dotnet test --filter "FullyQualifiedName~TestClass1|Category=CategoryA"
```
Per eseguire i test che includono TestClass1FullyQualifiedNamee hanno un Trait oggetto con una chiave di "Category" e il valore di ."CategoryA"
```
dotnet test --filter "FullyQualifiedName~TestClass1&Category=CategoryA"
```
Per eseguire i test che contengono FullyQualifiedNameTestClass1e hanno un Trait oggetto con una chiave e "Category" il valore di "CategoryA"o hanno un Trait oggetto con una chiave di "Priority" e il valore di 1.
```
dotnet test --filter "(FullyQualifiedName~TestClass1&Category=CategoryA)|Priority=1"
```

Esempi NUnit

using NUnit.Framework;

namespace NUnitNamespace
{
    public class UnitTest1
    {
        [Test, Property("Priority", 1), Category("CategoryA")]
        public void TestMethod1()
        {
        }

        [Test, Property("Priority", 2)]
        public void TestMethod2()
        {
        }
    }
}

Espressione	Risultato
`dotnet test --filter Method`	Esegue i test il cui FullyQualifiedName contiene `Method`.
`dotnet test --filter Name~TestMethod1`	Esegue i test il cui nome contiene `TestMethod1`.
`dotnet test --filter FullyQualifiedName~NUnitNamespace.UnitTest1`	Esegue i test presenti nella classe `NUnitNamespace.UnitTest1`.
`dotnet test --filter FullyQualifiedName!=NUnitNamespace.UnitTest1.TestMethod1`	Esegue tutti i test tranne `NUnitNamespace.UnitTest1.TestMethod1`.
`dotnet test --filter TestCategory=CategoryA`	Esegue i test annotati con `[Category("CategoryA")]`.
`dotnet test --filter Priority=2`	Esegue i test annotati con `[Priority(2)]`.

Esempi che usano gli operatori condizionali | e &:

Per eseguire i test che includono UnitTest1FullyQualifiedName o hanno un Category di "CategoryA".

dotnet test --filter "FullyQualifiedName~UnitTest1|TestCategory=CategoryA"

Per eseguire i test che includono UnitTest1FullyQualifiedName e hanno un Category di "CategoryA".

dotnet test --filter "FullyQualifiedName~UnitTest1&TestCategory=CategoryA"

Per eseguire i test che hanno un FullyQualifiedName oggetto contenente UnitTest1e hanno o Category"CategoryA" hanno un Property oggetto con un "Priority" di .1

dotnet test --filter "(FullyQualifiedName~UnitTest1&TestCategory=CategoryA)|Priority=1"

Per altre informazioni, fai riferimento a Filtro TestCase.

Vedi anche

Passaggi successivi

Ordine Unit test

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2024-07-04

Condividi tramite

Eseguire unit test selezionati

Sintassi

Escape di caratteri

Esempi di MSTest

Esempi di xUnit

Esempi NUnit

Vedi anche

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive