Assert.AreSequenceEqual Metoda

Definice

Obor názvů:: Microsoft.VisualStudio.TestTools.UnitTesting

Sestavení:: MSTest.TestFramework.dll

Balíček:: MSTest.TestFramework v4.4.0

Balíček:: MSTest.TestFramework v4.3.0

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Přetížení

Name	Description
AreSequenceEqual(IEnumerable, IEnumerable, String, String, String)	Testuje, zda dvě sekvence obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)	Testuje, zda dvě sekvence obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)	Testuje, zda dvě sekvence obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.
AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)	Testuje, zda dvě sekvence obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testuje, zda dva rozsahy obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testuje, zda dva rozsahy obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testuje, zda dvě oblasti paměti obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testuje, zda dvě oblasti paměti obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Testuje, zda dvě sekvence obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)	Testuje, zda dva rozsahy obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)	Testuje, zda dva rozsahy obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)	Testuje, zda dva rozsahy obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)	Testuje, zda dvě oblasti paměti obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)	Testuje, zda dva rozsahy obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)	Testuje, zda dvě oblasti paměti obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)	Testuje, zda dvě oblasti paměti obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(Memory<T>, Memory<T>, String, String, String)	Testuje, zda dvě oblasti paměti obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)	Testuje, zda dvě oblasti paměti obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)	Testuje, zda dva rozsahy obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)	Testuje, zda dvě sekvence obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)	Testuje, zda dvě sekvence obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)	Testuje, zda dvě sekvence obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)	Testuje, zda dvě oblasti paměti obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.
AreSequenceEqual<T>(Span<T>, Span<T>, String, String, String)	Testuje, zda dva rozsahy obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.

AreSequenceEqual(IEnumerable, IEnumerable, String, String, String)

Zdroj:: Assert.AreSequenceEqual.cs

Testuje, zda dvě sekvence obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.

public static void AreSequenceEqual(System.Collections.IEnumerable? expected, System.Collections.IEnumerable? actual, string? message = "", string expectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreSequenceEqual (expected As IEnumerable, actual As IEnumerable, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry

expected: IEnumerable

Očekává se, že sekvence bude rovna actual.

actual: IEnumerable

Posloupnost vytvořená kódem v rámci testu.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

AreSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)

Zdroj:: Assert.AreSequenceEqual.cs

Testuje, zda dvě sekvence obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual (expected As IEnumerable, actual As IEnumerable, order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry

expected: IEnumerable

Očekává se, že sekvence bude rovna actual.

actual: IEnumerable

Posloupnost vytvořená kódem v rámci testu.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)

Zdroj:: Assert.AreSequenceEqual.cs

Testuje, zda dvě sekvence obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.

public static void AreSequenceEqual(System.Collections.IEnumerable? expected, System.Collections.IEnumerable? actual, System.Collections.IEqualityComparer? comparer, string? message = "", string expectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreSequenceEqual (expected As IEnumerable, actual As IEnumerable, comparer As IEqualityComparer, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry

expected: IEnumerable

Očekává se, že sekvence bude rovna actual.

actual: IEnumerable

Posloupnost vytvořená kódem v rámci testu.

comparer: IEqualityComparer

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)

Zdroj:: Assert.AreSequenceEqual.cs

Testuje, zda dvě sekvence obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual (expected As IEnumerable, actual As IEnumerable, comparer As IEqualityComparer, order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry

expected: IEnumerable

Očekává se, že sekvence bude rovna actual.

actual: IEnumerable

Posloupnost vytvořená kódem v rámci testu.

comparer: IEqualityComparer

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dva rozsahy obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As Span(Of T), actual As Span(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: Span<T>

Očekává se, že rozsah bude roven actual.

actual: Span<T>

Rozsah vytvořený kódem, který testuje.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dva rozsahy obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: ReadOnlySpan<T>

Očekává se, že rozsah bude roven actual.

actual: ReadOnlySpan<T>

Rozsah vytvořený kódem, který testuje.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dvě oblasti paměti obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: ReadOnlyMemory<T>

Očekává se, že paměť bude rovna actual.

actual: ReadOnlyMemory<T>

Paměť vytvořená kódem, který testuje.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dvě oblasti paměti obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As Memory(Of T), actual As Memory(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: Memory<T>

Očekává se, že paměť bude rovna actual.

actual: Memory<T>

Paměť vytvořená kódem, který testuje.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Zdroj:: Assert.AreSequenceEqual.cs

Testuje, zda dvě sekvence obsahují stejné prvky pomocí zadaného porovnávače a sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As IEnumerable(Of T), actual As IEnumerable(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: IEnumerable<T>

Očekává se, že sekvence bude rovna actual.

actual: IEnumerable<T>

Posloupnost vytvořená kódem v rámci testu.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dva rozsahy obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As Span(Of T), actual As Span(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: Span<T>

Očekává se, že rozsah bude roven actual.

actual: Span<T>

Rozsah vytvořený kódem, který testuje.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dva rozsahy obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As Span(Of T), actual As Span(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: Span<T>

Očekává se, že rozsah bude roven actual.

actual: Span<T>

Rozsah vytvořený kódem, který testuje.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dva rozsahy obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: ReadOnlySpan<T>

Očekává se, že rozsah bude roven actual.

actual: ReadOnlySpan<T>

Rozsah vytvořený kódem, který testuje.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dvě oblasti paměti obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: ReadOnlyMemory<T>

Očekává se, že paměť bude rovna actual.

actual: ReadOnlyMemory<T>

Paměť vytvořená kódem, který testuje.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dva rozsahy obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: ReadOnlySpan<T>

Očekává se, že rozsah bude roven actual.

actual: ReadOnlySpan<T>

Rozsah vytvořený kódem, který testuje.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dvě oblasti paměti obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As Memory(Of T), actual As Memory(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: Memory<T>

Očekává se, že paměť bude rovna actual.

actual: Memory<T>

Paměť vytvořená kódem, který testuje.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dvě oblasti paměti obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: ReadOnlyMemory<T>

Očekává se, že paměť bude rovna actual.

actual: ReadOnlyMemory<T>

Paměť vytvořená kódem, který testuje.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dvě oblasti paměti obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.

public static void AreSequenceEqual<T>(Memory<T> expected, Memory<T> actual, string? message = "", string expectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreSequenceEqual(Of T) (expected As Memory(Of T), actual As Memory(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: Memory<T>

Očekává se, že paměť bude rovna actual.

actual: Memory<T>

Paměť vytvořená kódem, který testuje.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dvě oblasti paměti obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.

public static void AreSequenceEqual<T>(ReadOnlyMemory<T> expected, ReadOnlyMemory<T> actual, string? message = "", string expectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: ReadOnlyMemory<T>

Očekává se, že paměť bude rovna actual.

actual: ReadOnlyMemory<T>

Paměť vytvořená kódem, který testuje.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dva rozsahy obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.

public static void AreSequenceEqual<T>(ReadOnlySpan<T> expected, ReadOnlySpan<T> actual, string? message = "", string expectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreSequenceEqual(Of T) (expected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: ReadOnlySpan<T>

Očekává se, že rozsah bude roven actual.

actual: ReadOnlySpan<T>

Rozsah vytvořený kódem, který testuje.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Zdroj:: Assert.AreSequenceEqual.cs

Testuje, zda dvě sekvence obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.

public static void AreSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? expected, System.Collections.Generic.IEnumerable<T>? actual, string? message = "", string expectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreSequenceEqual(Of T) (expected As IEnumerable(Of T), actual As IEnumerable(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: IEnumerable<T>

Očekává se, že sekvence bude rovna actual.

actual: IEnumerable<T>

Posloupnost vytvořená kódem v rámci testu.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Zdroj:: Assert.AreSequenceEqual.cs

Testuje, zda dvě sekvence obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As IEnumerable(Of T), actual As IEnumerable(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: IEnumerable<T>

Očekává se, že sekvence bude rovna actual.

actual: IEnumerable<T>

Posloupnost vytvořená kódem v rámci testu.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Zdroj:: Assert.AreSequenceEqual.cs

Testuje, zda dvě sekvence obsahují stejné prvky ve stejném pořadí pomocí zadaného porovnávače a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As IEnumerable(Of T), actual As IEnumerable(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: IEnumerable<T>

Očekává se, že sekvence bude rovna actual.

actual: IEnumerable<T>

Posloupnost vytvořená kódem v rámci testu.

comparer: IEqualityComparer<T>

Porovnávač rovnosti, který se má použít při porovnávání prvků nebo null použití výchozího porovnávače.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dvě oblasti paměti obsahují stejné prvky pomocí zadané sémantiky pořadí a vyvolá výjimku, pokud ne.

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

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

Public Shared Sub AreSequenceEqual(Of T) (expected As Memory(Of T), actual As Memory(Of T), order As SequenceOrder, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: Memory<T>

Očekává se, že paměť bude rovna actual.

actual: Memory<T>

Paměť vytvořená kódem, který testuje.

order: SequenceOrder

Určuje, zda se prvky musí zobrazovat ve stejném pořadí nebo v libovolném pořadí.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

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

Testuje, zda dva rozsahy obsahují stejné prvky ve stejném pořadí a vyvolá výjimku, pokud ne.

public static void AreSequenceEqual<T>(Span<T> expected, Span<T> actual, string? message = "", string expectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreSequenceEqual(Of T) (expected As Span(Of T), actual As Span(Of T), Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parametry typu

T

Typ sekvencí prvků.

Parametry

expected: Span<T>

Očekává se, že rozsah bude roven actual.

actual: Span<T>

Rozsah vytvořený kódem, který testuje.

message: String

Zpráva, která se má zahrnout do výjimky, pokud se sekvence nerovnají.

expectedExpression: String

Syntaktický výraz očekávaného výrazu kompilátoru prostřednictvím výrazu argumentu volajícího.

actualExpression: String

Syntaktický výraz skutečné hodnoty, který kompilátor předá prostřednictvím výrazu argumentu volajícího.

Platí pro

Váš názor

Byla tato stránka užitečná?