Assert.AreNotSequenceEqual Methode

Definition

Namespace:: Microsoft.VisualStudio.TestTools.UnitTesting

Assembly:: MSTest.TestFramework.dll

Paket:: MSTest.TestFramework v4.4.0

Paket:: MSTest.TestFramework v4.3.0

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Überlädt

Name	Beschreibung
AreNotSequenceEqual(IEnumerable, IEnumerable, String, String, String)	Testet, ob zwei Sequenzen in der gleichen Reihenfolge unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.
AreNotSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)	Testet, ob zwei Sequenzen mit der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)	Testet, ob zwei Sequenzen in der gleichen Reihenfolge mit dem angegebenen Comparer unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)	Testet, ob zwei Sequenzen mit der angegebenen Vergleichs- und Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)	Testet, ob zwei Bereiche mit der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testet, ob sich zwei Bereiche mit der angegebenen Vergleichs- und Reihenfolgesemantik unterscheiden, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testet, ob zwei Speicherbereiche mit der angegebenen Vergleichs- und Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testet, ob zwei Speicherbereiche mit der angegebenen Vergleichs- und Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testet, ob zwei Sequenzen mit der angegebenen Vergleichs- und Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)	Testet, ob sich zwei Spannweiten in der gleichen Reihenfolge unter Verwendung des angegebenen Vergleichs unterscheiden, und löst eine Ausnahme aus, wenn sie nicht.
AreNotSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)	Testet, ob zwei Bereiche mit der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.
AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testet, ob sich zwei Bereiche mit der angegebenen Vergleichs- und Reihenfolgesemantik unterscheiden, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)	Testet, ob sich zwei Spannweiten in der gleichen Reihenfolge unter Verwendung des angegebenen Vergleichs unterscheiden, und löst eine Ausnahme aus, wenn sie nicht.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)	Testet, ob zwei Speicherbereiche in der gleichen Reihenfolge mit dem angegebenen Comparer abweichen und eine Ausnahme auslösen, wenn dies nicht der Fehler ist.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)	Testet, ob zwei Sequenzen in der gleichen Reihenfolge mit dem angegebenen Comparer unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)	Testet, ob zwei Speicherbereiche in der gleichen Reihenfolge mit dem angegebenen Comparer abweichen und eine Ausnahme auslösen, wenn dies nicht der Fehler ist.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)	Testet, ob zwei Speicherbereiche mithilfe der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)	Testet, ob zwei Sequenzen mit der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.
AreNotSequenceEqual<T>(Span<T>, Span<T>, String, String, String)	Testet, ob sich zwei Spannen in derselben Reihenfolge unterscheiden und eine Ausnahme auslösen, wenn sie nicht.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)	Testet, ob sich zwei Spannen in derselben Reihenfolge unterscheiden und eine Ausnahme auslösen, wenn sie nicht.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)	Testet, ob zwei Speicherbereiche in der gleichen Reihenfolge unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, String, String, String)	Testet, ob zwei Speicherbereiche in der gleichen Reihenfolge unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)	Testet, ob zwei Sequenzen in der gleichen Reihenfolge unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)	Testet, ob zwei Speicherbereiche mithilfe der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

AreNotSequenceEqual(IEnumerable, IEnumerable, String, String, String)

Quelle:: Assert.AreNotSequenceEqual.cs

Testet, ob zwei Sequenzen in der gleichen Reihenfolge unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.

public static void AreNotSequenceEqual(System.Collections.IEnumerable? notExpected, System.Collections.IEnumerable? actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual (notExpected As IEnumerable, actual As IEnumerable, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Parameter

notExpected: IEnumerable

Die Sequenz wird nicht gleich actualerwartet.

actual: IEnumerable

Die Sequenz, die vom code unter Test erzeugt wird.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)

Quelle:: Assert.AreNotSequenceEqual.cs

Testet, ob zwei Sequenzen mit der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual(System.Collections.IEnumerable? notExpected, System.Collections.IEnumerable? actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual (notExpected As IEnumerable, actual As IEnumerable, order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Parameter

notExpected: IEnumerable

Die Sequenz wird nicht gleich actualerwartet.

actual: IEnumerable

Die Sequenz, die vom code unter Test erzeugt wird.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)

Quelle:: Assert.AreNotSequenceEqual.cs

Testet, ob zwei Sequenzen in der gleichen Reihenfolge mit dem angegebenen Comparer unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual(System.Collections.IEnumerable? notExpected, System.Collections.IEnumerable? actual, System.Collections.IEqualityComparer? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * System.Collections.IEqualityComparer * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual (notExpected As IEnumerable, actual As IEnumerable, comparer As IEqualityComparer, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Parameter

notExpected: IEnumerable

Die Sequenz wird nicht gleich actualerwartet.

actual: IEnumerable

Die Sequenz, die vom code unter Test erzeugt wird.

comparer: IEqualityComparer

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)

Quelle:: Assert.AreNotSequenceEqual.cs

Testet, ob zwei Sequenzen mit der angegebenen Vergleichs- und Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual(System.Collections.IEnumerable? notExpected, System.Collections.IEnumerable? actual, System.Collections.IEqualityComparer? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * System.Collections.IEqualityComparer * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual (notExpected As IEnumerable, actual As IEnumerable, comparer As IEqualityComparer, order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Parameter

notExpected: IEnumerable

Die Sequenz wird nicht gleich actualerwartet.

actual: IEnumerable

Die Sequenz, die vom code unter Test erzeugt wird.

comparer: IEqualityComparer

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)

Testet, ob zwei Bereiche mit der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.

public static void AreNotSequenceEqual<T>(ReadOnlySpan<T> notExpected, ReadOnlySpan<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: ReadOnlySpan<T>

Die Spanne wird nicht gleich actualsein.

actual: ReadOnlySpan<T>

Die spanne, die vom code under test erstellt wurde.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Testet, ob sich zwei Bereiche mit der angegebenen Vergleichs- und Reihenfolgesemantik unterscheiden, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual<T>(ReadOnlySpan<T> notExpected, ReadOnlySpan<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: ReadOnlySpan<T>

Die Spanne wird nicht gleich actualsein.

actual: ReadOnlySpan<T>

Die spanne, die vom code under test erstellt wurde.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Testet, ob zwei Speicherbereiche mit der angegebenen Vergleichs- und Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual<T>(ReadOnlyMemory<T> notExpected, ReadOnlyMemory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: ReadOnlyMemory<T>

Der Arbeitsspeicher sollte nicht gleich sein actual.

actual: ReadOnlyMemory<T>

Der vom Testcode erzeugte Arbeitsspeicher.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Testet, ob zwei Speicherbereiche mit der angegebenen Vergleichs- und Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual<T>(Memory<T> notExpected, Memory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Memory<'T> * Memory<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Memory(Of T), actual As Memory(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: Memory<T>

Der Arbeitsspeicher sollte nicht gleich sein actual.

actual: Memory<T>

Der vom Testcode erzeugte Arbeitsspeicher.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Quelle:: Assert.AreNotSequenceEqual.cs

Testet, ob zwei Sequenzen mit der angegebenen Vergleichs- und Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? notExpected, System.Collections.Generic.IEnumerable<T>? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : seq<'T> * seq<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As IEnumerable(Of T), actual As IEnumerable(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: IEnumerable<T>

Die Sequenz wird nicht gleich actualerwartet.

actual: IEnumerable<T>

Die Sequenz, die vom code unter Test erzeugt wird.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)

Testet, ob sich zwei Spannweiten in der gleichen Reihenfolge unter Verwendung des angegebenen Vergleichs unterscheiden, und löst eine Ausnahme aus, wenn sie nicht.

public static void AreNotSequenceEqual<T>(Span<T> notExpected, Span<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Span<'T> * Span<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Span(Of T), actual As Span(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: Span<T>

Die Spanne wird nicht gleich actualsein.

actual: Span<T>

Die spanne, die vom code under test erstellt wurde.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)

Testet, ob zwei Bereiche mit der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.

public static void AreNotSequenceEqual<T>(Span<T> notExpected, Span<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Span<'T> * Span<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Span(Of T), actual As Span(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: Span<T>

Die Spanne wird nicht gleich actualsein.

actual: Span<T>

Die spanne, die vom code under test erstellt wurde.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Testet, ob sich zwei Bereiche mit der angegebenen Vergleichs- und Reihenfolgesemantik unterscheiden, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual<T>(Span<T> notExpected, Span<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Span<'T> * Span<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Span(Of T), actual As Span(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: Span<T>

Die Spanne wird nicht gleich actualsein.

actual: Span<T>

Die spanne, die vom code under test erstellt wurde.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)

Testet, ob sich zwei Spannweiten in der gleichen Reihenfolge unter Verwendung des angegebenen Vergleichs unterscheiden, und löst eine Ausnahme aus, wenn sie nicht.

public static void AreNotSequenceEqual<T>(ReadOnlySpan<T> notExpected, ReadOnlySpan<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: ReadOnlySpan<T>

Die Spanne wird nicht gleich actualsein.

actual: ReadOnlySpan<T>

Die spanne, die vom code under test erstellt wurde.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)

Testet, ob zwei Speicherbereiche in der gleichen Reihenfolge mit dem angegebenen Comparer abweichen und eine Ausnahme auslösen, wenn dies nicht der Fehler ist.

public static void AreNotSequenceEqual<T>(ReadOnlyMemory<T> notExpected, ReadOnlyMemory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: ReadOnlyMemory<T>

Der Arbeitsspeicher sollte nicht gleich sein actual.

actual: ReadOnlyMemory<T>

Der vom Testcode erzeugte Arbeitsspeicher.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)

Quelle:: Assert.AreNotSequenceEqual.cs

Testet, ob zwei Sequenzen in der gleichen Reihenfolge mit dem angegebenen Comparer unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? notExpected, System.Collections.Generic.IEnumerable<T>? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : seq<'T> * seq<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As IEnumerable(Of T), actual As IEnumerable(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: IEnumerable<T>

Die Sequenz wird nicht gleich actualerwartet.

actual: IEnumerable<T>

Die Sequenz, die vom code unter Test erzeugt wird.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)

Testet, ob zwei Speicherbereiche in der gleichen Reihenfolge mit dem angegebenen Comparer abweichen und eine Ausnahme auslösen, wenn dies nicht der Fehler ist.

public static void AreNotSequenceEqual<T>(Memory<T> notExpected, Memory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Memory<'T> * Memory<'T> * System.Collections.Generic.IEqualityComparer<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Memory(Of T), actual As Memory(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: Memory<T>

Der Arbeitsspeicher sollte nicht gleich sein actual.

actual: Memory<T>

Der vom Testcode erzeugte Arbeitsspeicher.

comparer: IEqualityComparer<T>

Der Gleichheitsvergleich, der beim Vergleichen von Elementen verwendet werden soll, oder null zum Verwenden des Standardvergleichs.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)

Testet, ob zwei Speicherbereiche mithilfe der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual<T>(Memory<T> notExpected, Memory<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Memory<'T> * Memory<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Memory(Of T), actual As Memory(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: Memory<T>

Der Arbeitsspeicher sollte nicht gleich sein actual.

actual: Memory<T>

Der vom Testcode erzeugte Arbeitsspeicher.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)

Quelle:: Assert.AreNotSequenceEqual.cs

Testet, ob zwei Sequenzen mit der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? notExpected, System.Collections.Generic.IEnumerable<T>? actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : seq<'T> * seq<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As IEnumerable(Of T), actual As IEnumerable(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: IEnumerable<T>

Die Sequenz wird nicht gleich actualerwartet.

actual: IEnumerable<T>

Die Sequenz, die vom code unter Test erzeugt wird.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(Span<T>, Span<T>, String, String, String)

Testet, ob sich zwei Spannen in derselben Reihenfolge unterscheiden und eine Ausnahme auslösen, wenn sie nicht.

public static void AreNotSequenceEqual<T>(Span<T> notExpected, Span<T> actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Span<'T> * Span<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Span(Of T), actual As Span(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: Span<T>

Die Spanne wird nicht gleich actualsein.

actual: Span<T>

Die spanne, die vom code under test erstellt wurde.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)

Testet, ob sich zwei Spannen in derselben Reihenfolge unterscheiden und eine Ausnahme auslösen, wenn sie nicht.

public static void AreNotSequenceEqual<T>(ReadOnlySpan<T> notExpected, ReadOnlySpan<T> actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: ReadOnlySpan<T>

Die Spanne wird nicht gleich actualsein.

actual: ReadOnlySpan<T>

Die spanne, die vom code under test erstellt wurde.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)

Testet, ob zwei Speicherbereiche in der gleichen Reihenfolge unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.

public static void AreNotSequenceEqual<T>(ReadOnlyMemory<T> notExpected, ReadOnlyMemory<T> actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: ReadOnlyMemory<T>

Der Arbeitsspeicher sollte nicht gleich sein actual.

actual: ReadOnlyMemory<T>

Der vom Testcode erzeugte Arbeitsspeicher.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(Memory<T>, Memory<T>, String, String, String)

Testet, ob zwei Speicherbereiche in der gleichen Reihenfolge unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.

public static void AreNotSequenceEqual<T>(Memory<T> notExpected, Memory<T> actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Memory<'T> * Memory<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Memory(Of T), actual As Memory(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: Memory<T>

Der Arbeitsspeicher sollte nicht gleich sein actual.

actual: Memory<T>

Der vom Testcode erzeugte Arbeitsspeicher.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)

Quelle:: Assert.AreNotSequenceEqual.cs

Testet, ob zwei Sequenzen in der gleichen Reihenfolge unterschiedlich sind, und löst eine Ausnahme aus, wenn sie nicht.

public static void AreNotSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? notExpected, System.Collections.Generic.IEnumerable<T>? actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : seq<'T> * seq<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As IEnumerable(Of T), actual As IEnumerable(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: IEnumerable<T>

Die Sequenz wird nicht gleich actualerwartet.

actual: IEnumerable<T>

Die Sequenz, die vom code unter Test erzeugt wird.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)

Testet, ob zwei Speicherbereiche mithilfe der angegebenen Reihenfolgesemantik unterschiedlich sind, und löst eine Ausnahme aus, wenn sie dies nicht tun.

public static void AreNotSequenceEqual<T>(ReadOnlyMemory<T> notExpected, ReadOnlyMemory<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Typparameter

T

Der Typ der Sequenzelemente.

Parameter

notExpected: ReadOnlyMemory<T>

Der Arbeitsspeicher sollte nicht gleich sein actual.

actual: ReadOnlyMemory<T>

Der vom Testcode erzeugte Arbeitsspeicher.

order: SequenceOrder

Gibt an, ob Elemente in derselben Reihenfolge oder in beliebiger Reihenfolge angezeigt werden müssen.

message: String

Die Meldung, die in die Ausnahme eingeschlossen werden soll, wenn die Sequenzen gleich sind.

notExpectedExpression: String

Der syntaktische Ausdruck von "notExpected" wie vom Compiler über den Aufruferargumentausdruck angegeben.

actualExpression: String

Der syntaktische Ausdruck des tatsächlichen Ausdrucks, der vom Compiler über den Aufruferargumentausdruck angegeben wird.

Gilt für:

Feedback

War diese Seite hilfreich?