Uruchamianie wybranych testów jednostkowych

dotnet test Za pomocą polecenia w programie .NET Core można użyć wyrażenia filtru do uruchamiania wybranych testów. W tym artykule pokazano, jak filtrować testy. W przykładach użyto metody dotnet test. Jeśli używasz polecenia vstest.console.exe, zastąp ciąg --filter ciąg .--testcasefilter:

Note

Składnia opisana --filter w poniższych sekcjach dotyczy bibliotek MSTest, NUnit i xUnit. Funkcja TUnit używa innej składni; wybierz pozycję TUnit w górnej części tego artykułu, aby uzyskać szczegółowe informacje.

Składnia

dotnet test --filter <Expression>

Wyrażenie ma format <Property><Operator><Value>[|&<Expression>].

Wyrażenia można łączyć z operatorami logicznymi: | dla wartości logicznych lub wartości & logicznych i.

Wyrażenia można ujęć w nawiasy. Na przykład: (Name~MyClass) | (Name~MyClass2).

Wyrażenie bez żadnego operatora jest interpretowane jako element zawiera we FullyQualifiedName właściwości . Na przykład kod dotnet test --filter xyz jest taki sam jak kod dotnet test --filter FullyQualifiedName~xyz.

Właściwość jest atrybutem Test Case. Na przykład następujące właściwości są obsługiwane przez popularne struktury testów jednostkowych.

Struktura testowa	Obsługiwane właściwości
MSTest	`FullyQualifiedName` `Name` `ClassName` `Priority` `TestCategory` `Id`
NUnit	`FullyQualifiedName` `Name` `Priority` `TestCategory` `Category` `Property`
xUnit	`FullyQualifiedName` `DisplayName` `Traits`

Operatory
- = dokładne dopasowanie
- !=niezrównane dokładne dopasowanie
- ~ Contains
- !~ nie zawiera
Wartość jest ciągiem. Wszystkie wyszukiwania są bez uwzględniania wielkości liter.

Znak ucieczki

Użyj sekwencji ucieczki, aby reprezentować znaki operatora filtru w wartości filtru. Te sekwencje ucieczki są oddzielone od każdego, co wymaga ucieczki powłoki.

Sekwencja ucieczki	Reprezentuje
`\\`	`\`
`\(`	`(`
`\)`	`)`
`\&`	`&`
`\\|`	`\|`
`\=`	`=`
`\!`	`!`
`\~`	`~`

Aby programowo uniknąć wartości filtru, użyj interfejsu Microsoft.VisualStudio.TestPlatform.ObjectModel.Utilities.FilterHelper.EscapeMicrosoft.VisualStudio.TestPlatform.ObjectModel API z pakietu NuGet.

Aby użyć wykrzyknika (!) w wyrażeniu filtru, musisz go użyć w niektórych powłokach systemu Linux lub macOS, umieszczając ukośnik odwrotny przed nim (\!). Na przykład następujący filtr pomija wszystkie testy w przestrzeni nazw zawierającej IntegrationTests:

dotnet test --filter FullyQualifiedName\!~IntegrationTests

W przypadku FullyQualifiedName wartości, które zawierają przecinek dla parametrów typu ogólnego, należy zawrzeć przecinek za pomocą polecenia %2C. Na przykład:

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

Ponieważ powłoka analizuje również wyrażenie filtru, cudzysłowuj całą --filter wartość za każdym razem, gdy zawiera znaki, które powłoka traktuje specjalnie, na przykład <, >lub ,. Cudzysłów jest wymagany w programie PowerShell, gdzie przecinek jest operatorem tablicy.

W przypadku Name lub DisplayNameużyj kodowania adresu URL dla znaków specjalnych. Aby na przykład uruchomić test o nazwie MyTestMethod i wartości ciągu "text", użyj następującego filtru:

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

Przykłady 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	Result
`dotnet test --filter Method`	Uruchamia testy, których FullyQualifiedName zawiera `Method`.
`dotnet test --filter Name~TestMethod1`	Uruchamia testy, których nazwa zawiera `TestMethod1`.
`dotnet test --filter ClassName=MSTestNamespace.UnitTest1`	Uruchamia testy w klasie `MSTestNamespace.UnitTest1`. Uwaga:`ClassName` wartość powinna mieć przestrzeń nazw, więc `ClassName=UnitTest1` nie będzie działać.
`dotnet test --filter FullyQualifiedName!=MSTestNamespace.UnitTest1.TestMethod1`	Uruchamia wszystkie testy z wyjątkiem `MSTestNamespace.UnitTest1.TestMethod1`.
`dotnet test --filter TestCategory=CategoryA`	Uruchamia testy, które są oznaczone adnotacjami za pomocą `[TestCategory("CategoryA")]`polecenia .
`dotnet test --filter Priority=2`	Uruchamia testy, które są oznaczone adnotacjami za pomocą `[Priority(2)]`polecenia .
`dotnet test --filter "Id=<guid>"`	Uruchamia przypadek testowy, którego odnaleziona `TestCase.Id` wartość dokładnie odpowiada identyfikatorowi GUID.

Id filtrowanie wymaga biblioteki MSTest.TestAdapter 3.6 lub nowszej. Uzyskaj identyfikator GUID z przypadku testowego zwracanego przez odnajdywanie VSTest w elem.TestCase.Id Ten filtr może wybrać jedną rozwijaną iterację opartą na danych bez dopasowywania lub ucieczki od nazwy wyświetlanej. Każdy wiersz musi zostać odnaleziony jako pojedynczy przypadek testowy; złożony test oparty na danych uwidacznia tylko jedną tożsamość nadrzędną.

Przykłady przy użyciu operatorów | warunkowych i &:

Aby uruchomić testy, które mają UnitTest1 element FullyQualifiedNamelubTestCategoryAttribute ma wartość "CategoryA".
```
dotnet test --filter "FullyQualifiedName~UnitTest1|TestCategory=CategoryA"
```
Aby uruchomić testy, które mają UnitTest1 element FullyQualifiedNamei mają TestCategoryAttribute element "CategoryA".
```
dotnet test --filter "FullyQualifiedName~UnitTest1&TestCategory=CategoryA"
```
Aby uruchomić testy, które zawierają FullyQualifiedNameUnitTest1element lub mają TestCategoryAttribute"CategoryA" wartość mają priorytet .PriorityAttribute
```
dotnet test --filter "(FullyQualifiedName~UnitTest1&TestCategory=CategoryA)|Priority=1"
```

Przykłady narzędzia 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	Result
`dotnet test --filter DisplayName=XUnitNamespace.TestClass1.Test1`	Uruchamia tylko jeden test, `XUnitNamespace.TestClass1.Test1`.
`dotnet test --filter FullyQualifiedName!=XUnitNamespace.TestClass1.Test1`	Uruchamia wszystkie testy z wyjątkiem `XUnitNamespace.TestClass1.Test1`.
`dotnet test --filter DisplayName~TestClass1`	Uruchamia testy, których nazwa wyświetlana zawiera `TestClass1`.

W przykładzie kodu zdefiniowane cechy z kluczami "Category" i "Priority" mogą służyć do filtrowania.

Expression	Result
`dotnet test --filter XUnit`	Uruchamia testy, których FullyQualifiedName zawiera `XUnit`.
`dotnet test --filter Category=CategoryA`	Uruchamia testy z systemem `[Trait("Category", "CategoryA")]`.

Przykłady przy użyciu operatorów | warunkowych i &:

Aby uruchomić testy, które mają TestClass1 w sobie FullyQualifiedName lub mają Trait klucz o wartości "Category" i "CategoryA".
```
dotnet test --filter "FullyQualifiedName~TestClass1|Category=CategoryA"
```
Aby uruchomić testy, które mają TestClass1 w sobie FullyQualifiedNamei mają Trait klucz i "Category" wartość "CategoryA".
```
dotnet test --filter "FullyQualifiedName~TestClass1&Category=CategoryA"
```
Aby uruchomić testy, które zawierają FullyQualifiedNameTestClass1klucz iTrait mają klucz "Category" i wartość "CategoryA" lub mają Trait klucz o wartości i z kluczem "Priority" i wartości .1
```
dotnet test --filter "(FullyQualifiedName~TestClass1&Category=CategoryA)|Priority=1"
```

Przykłady NUnit

W przypadku NUnit TestCategory i Category są wymiennymi nazwami właściwości filtru. Oba filtry kategorii, które przypisujesz za pomocą atrybutu Category , więc istniejące polecenia NUnit, które używają --filter Category=MyCategory , nie muszą się zmieniać.

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	Result
`dotnet test --filter Method`	Uruchamia testy, których FullyQualifiedName zawiera `Method`.
`dotnet test --filter Name~TestMethod1`	Uruchamia testy, których nazwa zawiera `TestMethod1`.
`dotnet test --filter FullyQualifiedName~NUnitNamespace.UnitTest1`	Uruchamia testy w klasie `NUnitNamespace.UnitTest1`.
`dotnet test --filter FullyQualifiedName!=NUnitNamespace.UnitTest1.TestMethod1`	Uruchamia wszystkie testy z wyjątkiem `NUnitNamespace.UnitTest1.TestMethod1`.
`dotnet test --filter TestCategory=CategoryA`	Uruchamia testy, które są oznaczone adnotacjami za pomocą `[Category("CategoryA")]`polecenia .
`dotnet test --filter Category=CategoryA`	Uruchamia te same testy co `TestCategory=CategoryA`.
`dotnet test --filter Priority=2`	Uruchamia testy, które są oznaczone adnotacjami za pomocą `[Priority(2)]`polecenia .

Przykłady przy użyciu operatorów | warunkowych i &:

Aby uruchomić testy, które mają UnitTest1 element FullyQualifiedNamelub mają Category element "CategoryA".

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

Aby uruchomić testy, które mają UnitTest1 element FullyQualifiedNamei mają Category element "CategoryA".

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

Aby uruchomić testy, które zawierają FullyQualifiedNameUnitTest1element i mają Category element lub "CategoryA" mają Property element z wartością ."Priority"1

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

Aby uzyskać więcej informacji, zobacz Filtr TestCase.

Przykłady TUnit

Funkcja TUnit nie obsługuje opcji opisanej --filter wcześniej w tym artykule. Zamiast tego używa opcji MTP --treenode-filter . Filtr węzła drzewa jest ścieżką w postaci /<Assembly>/<Namespace>/<Class>/<Method>, gdzie:

* dopasuje dowolną wartość w ramach pojedynczego segmentu ścieżki i można je połączyć z innym tekstem, takim jak *Method*.
** pasuje do dowolnej liczby segmentów ścieżki.
[<Property>=<Value>] po segment ścieżki pasuje do testów, które mają te właściwości. [Category("CategoryA")] element jest uwidaczniony jako właściwość Category, i [Property("Priority", "2")] jako właściwość Priority.
| (lub) i & (i) łączą alternatywy w ramach pojedynczego segmentu ścieżki lub filtru właściwości. Ująć każdą alternatywę w nawiasach, na przykład /*/*/(UnitTest1)|(UnitTest2)/* lub [(Category=CategoryA)|(Priority=2)].

Opcja --treenode-filter jest opcją MTP, więc dotnet test musi działać w trybie MTP. W przypadku zestawu .NET 10 SDK lub nowszego dodaj następującą konfigurację do pliku global.json w katalogu głównym rozwiązania:

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

Bez niego dotnet test działa w trybie VSTest i kończy się niepowodzeniem przed każdym przebiegiem MSB1001: Unknown switch testu. Aby uzyskać więcej informacji, w tym sposób uruchamiania projektów MTP z wcześniejszymi zestawami SDK, zobacz MTP mode of dotnet test (Tryb MTP testu dotnet).

W przykładach użyto następującej klasy testowej:

namespace TUnitNamespace;

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

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

Expression	Result
`dotnet test --treenode-filter "////Method*"`	Uruchamia testy, których nazwa metody zawiera `Method`.
`dotnet test --treenode-filter "///*/TestMethod1"`	Uruchamia testy, których nazwa to `TestMethod1`.
`dotnet test --treenode-filter "//TUnitNamespace/UnitTest1/"`	Uruchamia wszystkie testy w klasie `TUnitNamespace.UnitTest1`.
`dotnet test --treenode-filter "/**[Category=CategoryA]"`	Uruchamia testy, które są oznaczone adnotacjami za pomocą `[Category("CategoryA")]`polecenia .
`dotnet test --treenode-filter "/**[Priority=2]"`	Uruchamia testy, które są oznaczone adnotacjami za pomocą `[Property("Priority", "2")]`polecenia .

Przykłady przy użyciu operatorów | warunkowych i &:

Aby uruchomić testy, które znajdują się w klasie UnitTest1i mają element Category"CategoryA":

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

Aby uruchomić testy z wartością Category"CategoryA"lub wartością Priority"2":

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

Aby uruchomić testy, które znajdują się w klasie UnitTest1i mają Category wartość "CategoryA"lub z Priority"2":

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

Aby uruchomić testy z wartością Category"CategoryA"i wartością Priority"1":

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

Zobacz też

Następne kroki

Zamawianie testów jednostkowych

Opinia

Czy ta strona była pomocna?

Ostatnia aktualizacja o 2026-11-06

Uruchamianie wybranych testów jednostkowych

Składnia

Znak ucieczki

Przykłady msTest

Przykłady narzędzia xUnit

Przykłady NUnit

Przykłady TUnit

Zobacz też

Następne kroki

Opinia

Dodatkowe zasoby