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:.

Note

La --filter sintassi descritta nelle sezioni seguenti si applica a MSTest, NUnit e xUnit. TUnit usa una sintassi diversa; Selezionare TUnit nella parte superiore di questo articolo per informazioni dettagliate.

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` `Id`
NUnit	`FullyQualifiedName` `Name` `Priority` `TestCategory` `Category` `Property`
xUnit	`FullyQualifiedName` `DisplayName` `Traits`

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

Usare sequenze di escape per rappresentare i caratteri dell'operatore di filtro in un valore di filtro. Queste sequenze di escape sono separate da qualsiasi escape richiesto dalla shell.

Sequenza di escape	Rappresenta
`\\`	`\`
`\(`	`(`
`\)`	`)`
`\&`	`&`
`\\|`	`\|`
`\=`	`=`
`\!`	`!`
`\~`	`~`

Per applicare un escape ai valori di filtro a livello di codice, usare l'API Microsoft.VisualStudio.TestPlatform.ObjectModel.Utilities.FilterHelper.Escape del Microsoft.VisualStudio.TestPlatform.ObjectModel pacchetto NuGet.

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"

Poiché la shell analizza anche l'espressione di filtro, racchiudere tra virgolette l'intero --filter valore ogni volta che contiene caratteri trattati dalla shell, ad esempio <, >o ,. Le virgolette sono necessarie in PowerShell, dove la virgola è l'operatore di matrice.

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)]`.
`dotnet test --filter "Id=<guid>"`	Esegue il test case il cui valore individuato `TestCase.Id` corrisponde esattamente al GUID.

Id il filtro richiede MSTest.TestAdapter 3.6 o versione successiva. Ottenere il GUID dal test case restituito dall'individuazione VSTest in TestCase.Id. Questo filtro può selezionare un'iterazione guidata dai dati aperta senza corrispondenza o escape del nome visualizzato. Ogni riga deve essere individuata come singolo test case; Un test basato sui dati piegato espone una sola identità padre.

Esempi che usano gli operatori condizionali | e &:

Per eseguire test con UnitTest1 oFullyQualifiedNameè .

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 oTestCategoryAttributepriorità ."CategoryA"
```
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

Per NUnit TestCategory e Category sono nomi di proprietà di filtro intercambiabili. Entrambe filtrano le categorie assegnate con l'attributo Category , quindi i comandi NUnit esistenti che usano --filter Category=MyCategory non devono essere modificati.

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 Category=CategoryA`	Esegue gli stessi test di `TestCategory=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.

Esempi di TUnit

TUnit non supporta l'opzione --filter descritta in precedenza in questo articolo. Usa invece l'opzione MTP --treenode-filter . Un filtro nodo albero è un percorso nel formato /<Assembly>/<Namespace>/<Class>/<Method>, dove:

* corrisponde a qualsiasi valore all'interno di un singolo segmento di percorso e può essere combinato con altro testo, ad esempio *Method*.
** corrisponde a un numero qualsiasi di segmenti di percorso.
[<Property>=<Value>] dopo che un segmento di percorso corrisponde ai test con tale proprietà. [Category("CategoryA")] viene esposto come proprietà Categorye [Property("Priority", "2")] come proprietà Priority.
| (o) e & (e) combinano alternative all'interno di un singolo segmento di percorso o filtro di proprietà. Racchiudere ogni alternativa tra parentesi, ad esempio /*/*/(UnitTest1)|(UnitTest2)/* o [(Category=CategoryA)|(Priority=2)].

L'opzione --treenode-filter è un'opzione MTP, quindi dotnet test deve essere eseguita in modalità MTP. Con il .NET 10 SDK o versione successiva, aggiungere la configurazione seguente al file global.json nella radice della soluzione:

{
    "test": {
        "runner": "Microsoft.Testing.Platform"
    }
}

Senza di esso, dotnet test viene eseguito in modalità VSTest e ha esito negativo con MSB1001: Unknown switch prima di qualsiasi esecuzione di test. Per altre informazioni, tra cui come eseguire progetti MTP con SDK precedenti, vedere La modalità MTP del test dotnet.

Negli esempi viene usata la classe di test seguente:

namespace TUnitNamespace;

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

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

Espressione	Risultato
`dotnet test --treenode-filter "////Method*"`	Esegue i test il cui nome del metodo contiene `Method`.
`dotnet test --treenode-filter "///*/TestMethod1"`	Esegue i test il cui nome è `TestMethod1`.
`dotnet test --treenode-filter "//TUnitNamespace/UnitTest1/"`	Esegue tutti i test nella classe `TUnitNamespace.UnitTest1`.
`dotnet test --treenode-filter "/**[Category=CategoryA]"`	Esegue i test annotati con `[Category("CategoryA")]`.
`dotnet test --treenode-filter "/**[Priority=2]"`	Esegue i test annotati con `[Property("Priority", "2")]`.

Esempi che usano gli operatori condizionali | e &:

Per eseguire i test presenti nella classe UnitTest1e avere un Category valore di "CategoryA":

dotnet test --treenode-filter "/*/*/UnitTest1/*[Category=CategoryA]"

Per eseguire test con Category"CategoryA"o un Priority di "2":

dotnet test --treenode-filter "/**[(Category=CategoryA)|(Priority=2)]"

Per eseguire i test presenti nella classe UnitTest1edisporre di"CategoryA" o Category di Priority"2":

dotnet test --treenode-filter "/*/*/UnitTest1/*[(Category=CategoryA)|(Priority=2)]"

Per eseguire test con un Category di "CategoryA"e un Priority di "1":

dotnet test --treenode-filter "/**[(Category=CategoryA)&(Priority=1)]"

Vedi anche

di test dotnet
dotnet test --filter

Passaggi successivi

Ordine Unit test

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-11-06

Eseguire unit test selezionati

Sintassi

Escape di caratteri

Esempi di MSTest

Esempi di xUnit

Esempi NUnit

Esempi di TUnit

Vedi anche

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive