Exécuter certains tests unitaires

La commande dotnet test dans .NET Core vous permet d’utiliser une expression de filtre pour exécuter certains tests. Cet article explique comment filtrer les tests. Les exemples utilisent dotnet test. Si vous utilisez vstest.console.exe, remplacez --filter par --testcasefilter:.

Note

La --filter syntaxe décrite dans les sections suivantes s’applique à MSTest, NUnit et xUnit. TUnit utilise une syntaxe différente ; Sélectionnez TUnit en haut de cet article pour plus d’informations.

Syntax

dotnet test --filter <Expression>

L’expression est au format <Property><Operator><Value>[|&<Expression>].

Les expressions peuvent être jointes à l’aide d’opérateurs booléens : | pour l’opérateur or booléen ou & pour l’opérateur and booléen.

Les expressions peuvent être placées entre parenthèses. Par exemple : (Name~MyClass) | (Name~MyClass2).

Une expression sans opérateur est interprétée comme un contains sur la propriété FullyQualifiedName. Par exemple, dotnet test --filter xyz est identique à dotnet test --filter FullyQualifiedName~xyz.

La propriété est un attribut du Test Case. Par exemple, les propriétés suivantes sont prises en charge par les principaux frameworks de test unitaire.

Framework de test	Propriétés prises en charge
MSTest	`FullyQualifiedName` `Name` `ClassName` `Priority` `TestCategory` `Id`
NUnit	`FullyQualifiedName` `Name` `Priority` `TestCategory` `Category` `Property`
xUnit	`FullyQualifiedName` `DisplayName` `Traits`

Opérateurs
- = correspondance exacte
- != pas de correspondance exacte
- ~ contient
- !~ ne contient pas
La valeur est une chaîne. Toutes les recherches respectent la casse.

Échappement de caractères

Utilisez des séquences d’échappement pour représenter les caractères d’opérateur de filtre dans une valeur de filtre. Ces séquences d’échappement sont distinctes de toute échappement requise par votre interpréteur de commandes.

Séquence d’échappement	Représente
`\\`	`\`
`\(`	`(`
`\)`	`)`
`\&`	`&`
`\\|`	`\|`
`\=`	`=`
`\!`	`!`
`\~`	`~`

Pour échapper des valeurs de filtre par programmation, utilisez l’API Microsoft.VisualStudio.TestPlatform.ObjectModel.Utilities.FilterHelper.Escape à partir du Microsoft.VisualStudio.TestPlatform.ObjectModel package NuGet.

Pour utiliser un point d’exclamation (!) dans une expression de filtre, vous devez l’échapper dans certains shells Linux ou macOS en plaçant une barre oblique inverse devant (\!). Par exemple, le filtre suivant ignore tous les tests dans un espace de noms qui contient IntegrationTests :

dotnet test --filter FullyQualifiedName\!~IntegrationTests

Pour les valeurs FullyQualifiedName qui incluent une virgule pour les paramètres de type générique, échappez la virgule avec %2C. Par exemple :

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

Étant donné que votre interpréteur de commandes analyse également l’expression de filtre, citez la valeur entière --filter chaque fois qu’elle contient des caractères traités spécialement, tels que <, >ou ,. Les guillemets sont requis dans PowerShell, où la virgule est l’opérateur de tableau.

Pour Name ou DisplayName, utilisez l’encodage d’URL pour les caractères spéciaux. Par exemple, pour exécuter un test avec le nom MyTestMethod et une valeur de chaîne "text", utilisez le filtre suivant :

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

Exemples 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()
        {
        }
    }
}

Expression	Résultats
`dotnet test --filter Method`	Exécute les tests dont FullyQualifiedName contient `Method`.
`dotnet test --filter Name~TestMethod1`	Exécute les tests dont le nom contient `TestMethod1`.
`dotnet test --filter ClassName=MSTestNamespace.UnitTest1`	Exécute des tests qui se trouvent dans la classe `MSTestNamespace.UnitTest1`. Remarque : La valeur `ClassName` doit avoir un espace de noms, donc `ClassName=UnitTest1` ne fonctionnera pas.
`dotnet test --filter FullyQualifiedName!=MSTestNamespace.UnitTest1.TestMethod1`	Exécute tous les tests sauf `MSTestNamespace.UnitTest1.TestMethod1`.
`dotnet test --filter TestCategory=CategoryA`	Exécute des tests annotés avec `[TestCategory("CategoryA")]`.
`dotnet test --filter Priority=2`	Exécute des tests annotés avec `[Priority(2)]`.
`dotnet test --filter "Id=<guid>"`	Exécute le cas de test dont la valeur découverte `TestCase.Id` correspond exactement au GUID.

Id le filtrage nécessite MSTest.TestAdapter 3.6 ou version ultérieure. Obtenez le GUID à partir du cas de test dans lequel la découverte VSTest est retournée TestCase.Id. Ce filtre peut sélectionner une itération pilotée par les données sans correspondance ni échappement de son nom complet. Chaque ligne doit être découverte en tant que cas de test individuel ; un test plié piloté par les données n’expose qu’une seule identité parente.

Exemples utilisant les opérateurs conditionnels | et & :

Pour exécuter des tests qui ont UnitTest1 dans leur FullyQualifiedNameouTestCategoryAttribute est "CategoryA".
```
dotnet test --filter "FullyQualifiedName~UnitTest1|TestCategory=CategoryA"
```
Pour exécuter des tests qui ont UnitTest1 dans leur FullyQualifiedNameet ont un TestCategoryAttribute de "CategoryA".
```
dotnet test --filter "FullyQualifiedName~UnitTest1&TestCategory=CategoryA"
```
Pour exécuter des tests qui contiennent FullyQualifiedNameUnitTest1 et ont un TestCategoryAttribute ou"CategoryA" ont une PriorityAttribute priorité de .1
```
dotnet test --filter "(FullyQualifiedName~UnitTest1&TestCategory=CategoryA)|Priority=1"
```

Exemples 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()
        {
        }
    }
}

Expression	Résultats
`dotnet test --filter DisplayName=XUnitNamespace.TestClass1.Test1`	Exécute uniquement un test, `XUnitNamespace.TestClass1.Test1`.
`dotnet test --filter FullyQualifiedName!=XUnitNamespace.TestClass1.Test1`	Exécute tous les tests sauf `XUnitNamespace.TestClass1.Test1`.
`dotnet test --filter DisplayName~TestClass1`	Exécute les tests dont le nom d’affichage contient `TestClass1`.

Dans l’exemple de code, les caractéristiques définies avec les clés "Category" et "Priority" peuvent être utilisées pour filtrer.

Expression	Résultats
`dotnet test --filter XUnit`	Exécute les tests dont FullyQualifiedName contient `XUnit`.
`dotnet test --filter Category=CategoryA`	Exécute des tests qui ont `[Trait("Category", "CategoryA")]`.

Exemples utilisant les opérateurs conditionnels | et & :

Pour exécuter des tests qui ont TestClass1 dans leur FullyQualifiedNameou ont une Trait clé et "Category" une valeur de "CategoryA".
```
dotnet test --filter "FullyQualifiedName~TestClass1|Category=CategoryA"
```
Pour exécuter des tests qui ont TestClass1 dans leur FullyQualifiedNameet ont une Trait clé et "Category" une valeur de "CategoryA".
```
dotnet test --filter "FullyQualifiedName~TestClass1&Category=CategoryA"
```
Pour exécuter des tests qui contiennent FullyQualifiedNameTestClass1 et ont une Trait clé et "Category" une valeur de clé ou "CategoryA" ont une Trait clé de et "Priority" une valeur de .1
```
dotnet test --filter "(FullyQualifiedName~TestClass1&Category=CategoryA)|Priority=1"
```

Exemples NUnit

Pour NUnit, TestCategory et Category sont des noms de propriétés de filtre interchangeables. Les deux filtrent les catégories que vous affectez avec l’attribut Category , de sorte que les commandes NUnit existantes qui utilisent --filter Category=MyCategory n’ont pas besoin de changer.

using NUnit.Framework;

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

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

Expression	Résultats
`dotnet test --filter Method`	Exécute les tests dont FullyQualifiedName contient `Method`.
`dotnet test --filter Name~TestMethod1`	Exécute les tests dont le nom contient `TestMethod1`.
`dotnet test --filter FullyQualifiedName~NUnitNamespace.UnitTest1`	Exécute des tests qui se trouvent dans la classe `NUnitNamespace.UnitTest1`.
`dotnet test --filter FullyQualifiedName!=NUnitNamespace.UnitTest1.TestMethod1`	Exécute tous les tests sauf `NUnitNamespace.UnitTest1.TestMethod1`.
`dotnet test --filter TestCategory=CategoryA`	Exécute des tests annotés avec `[Category("CategoryA")]`.
`dotnet test --filter Category=CategoryA`	Exécute les mêmes tests que `TestCategory=CategoryA`.
`dotnet test --filter Priority=2`	Exécute des tests annotés avec `[Priority(2)]`.

Exemples utilisant les opérateurs conditionnels | et & :

Pour exécuter des tests qui ont UnitTest1 dans leur FullyQualifiedName ou ont un de Category"CategoryA".

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

Pour exécuter des tests qui ont UnitTest1 dans leur FullyQualifiedNameet ont un Category de "CategoryA".

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

Pour exécuter des tests qui ont un FullyQualifiedName conteneur UnitTest1 et ont un Category ou "CategoryA" ont un Property avec un ."Priority"1

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

Pour plus d’informations, consultez Filtre TestCase.

Exemples TUnit

TUnit ne prend pas en charge l’option --filter décrite précédemment dans cet article. Au lieu de cela, il utilise l’option MTP --treenode-filter . Un filtre de nœud d’arborescence est un chemin d’accès au formulaire /<Assembly>/<Namespace>/<Class>/<Method>, où :

* correspond à n’importe quelle valeur au sein d’un segment de chemin d’accès unique et peut être combinée à d’autres textes, tels que *Method*.
** correspond à n’importe quel nombre de segments de chemin d’accès.
[<Property>=<Value>] une fois qu’un segment de chemin correspond aux tests qui ont cette propriété. [Category("CategoryA")] est exposé en tant que propriété Category, et [Property("Priority", "2")] en tant que propriété Priority.
| (ou) et (et & ) combinent des alternatives dans un seul segment de chemin d’accès ou filtre de propriété. Placez chaque alternative entre parenthèses, par exemple /*/*/(UnitTest1)|(UnitTest2)/* ou [(Category=CategoryA)|(Priority=2)].

L’option est une option MTP. Elle --treenode-filter doit donc dotnet test s’exécuter en mode MTP. Avec le sdk .NET 10 ou version ultérieure, ajoutez la configuration suivante au fichier global.json à la racine de votre solution :

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

Sans cela, dotnet test s’exécute en mode VSTest et échoue MSB1001: Unknown switch avant toute exécution de test. Pour plus d’informations, notamment sur l’exécution de projets MTP avec des sdk antérieurs, consultez le mode MTP du test dotnet.

Les exemples utilisent la classe de test suivante :

namespace TUnitNamespace;

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

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

Expression	Résultats
`dotnet test --treenode-filter "////Method*"`	Exécute des tests dont le nom de méthode contient `Method`.
`dotnet test --treenode-filter "///*/TestMethod1"`	Exécute des tests dont le nom est `TestMethod1`.
`dotnet test --treenode-filter "//TUnitNamespace/UnitTest1/"`	Exécute tous les tests dans la classe `TUnitNamespace.UnitTest1`.
`dotnet test --treenode-filter "/**[Category=CategoryA]"`	Exécute des tests annotés avec `[Category("CategoryA")]`.
`dotnet test --treenode-filter "/**[Priority=2]"`	Exécute des tests annotés avec `[Property("Priority", "2")]`.

Exemples utilisant les opérateurs conditionnels | et & :

Pour exécuter des tests qui se trouvent dans la classe UnitTest1et qui ont un Category de "CategoryA":

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

Pour exécuter des tests dont l’un Categoryou l’autre Priority"CategoryA" doit "2"être :

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

Pour exécuter des tests qui se trouvent dans la classe UnitTest1et qui ont un Categoryou plusieursPriority des "CategoryA""2"éléments suivants :

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

Pour exécuter des tests dont l’un Categoryet l’autre Priority"CategoryA""1"sont les suivants :

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

Voir aussi

Étapes suivantes

Trier les tests unitaires

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-11-06

Exécuter certains tests unitaires

Syntax

Échappement de caractères

Exemples MSTest

Exemples xUnit

Exemples NUnit

Exemples TUnit

Voir aussi

Étapes suivantes

Commentaires

Ressources supplémentaires