Assert.AreSequenceEqual Méthode

Définition

Espace de noms:: Microsoft.VisualStudio.TestTools.UnitTesting

Assembly:: MSTest.TestFramework.dll

Paquet:: MSTest.TestFramework v4.4.0

Paquet:: MSTest.TestFramework v4.3.0

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Surcharges

Nom	Description
AreSequenceEqual(IEnumerable, IEnumerable, String, String, String)	Teste si deux séquences contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.
AreSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)	Teste si deux séquences contiennent des éléments égaux à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)	Teste si deux séquences contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)	Teste si deux séquences contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux étendues contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux étendues contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux régions de mémoire contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux régions de mémoire contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux séquences contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)	Teste si deux étendues contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)	Teste si deux étendues contiennent des éléments égaux à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)	Teste si deux étendues contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)	Teste si deux régions de mémoire contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)	Teste si deux étendues contiennent des éléments égaux à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)	Teste si deux régions de mémoire contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)	Teste si deux régions de mémoire contiennent des éléments égaux à l’aide de la sémantique d’ordre spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(Memory<T>, Memory<T>, String, String, String)	Teste si deux régions de mémoire contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)	Teste si deux régions de mémoire contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)	Teste si deux étendues contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)	Teste si deux séquences contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)	Teste si deux séquences contiennent des éléments égaux à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)	Teste si deux séquences contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)	Teste si deux régions de mémoire contiennent des éléments égaux à l’aide de la sémantique d’ordre spécifié et lève une exception si ce n’est pas le cas.
AreSequenceEqual<T>(Span<T>, Span<T>, String, String, String)	Teste si deux étendues contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.

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

Source:: Assert.AreSequenceEqual.cs

Teste si deux séquences contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres

expected: IEnumerable

La séquence devrait être égale à actual.

actual: IEnumerable

Séquence produite par le code sous test.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Source:: Assert.AreSequenceEqual.cs

Teste si deux séquences contiennent des éléments égaux à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres

expected: IEnumerable

La séquence devrait être égale à actual.

actual: IEnumerable

Séquence produite par le code sous test.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Source:: Assert.AreSequenceEqual.cs

Teste si deux séquences contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres

expected: IEnumerable

La séquence devrait être égale à actual.

actual: IEnumerable

Séquence produite par le code sous test.

comparer: IEqualityComparer

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Source:: Assert.AreSequenceEqual.cs

Teste si deux séquences contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres

expected: IEnumerable

La séquence devrait être égale à actual.

actual: IEnumerable

Séquence produite par le code sous test.

comparer: IEqualityComparer

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux étendues contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: Span<T>

L’étendue attendue doit être égale à actual.

actual: Span<T>

Étendue produite par le code testé.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux étendues contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: ReadOnlySpan<T>

L’étendue attendue doit être égale à actual.

actual: ReadOnlySpan<T>

Étendue produite par le code testé.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux régions de mémoire contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: ReadOnlyMemory<T>

La mémoire attendue est égale à actual.

actual: ReadOnlyMemory<T>

Mémoire produite par le code sous test.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux régions de mémoire contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: Memory<T>

La mémoire attendue est égale à actual.

actual: Memory<T>

Mémoire produite par le code sous test.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Source:: Assert.AreSequenceEqual.cs

Teste si deux séquences contiennent des éléments égaux à l’aide de la sémantique de comparateur et d’ordre spécifiés et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: IEnumerable<T>

La séquence devrait être égale à actual.

actual: IEnumerable<T>

Séquence produite par le code sous test.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux étendues contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: Span<T>

L’étendue attendue doit être égale à actual.

actual: Span<T>

Étendue produite par le code testé.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux étendues contiennent des éléments égaux à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: Span<T>

L’étendue attendue doit être égale à actual.

actual: Span<T>

Étendue produite par le code testé.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux étendues contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: ReadOnlySpan<T>

L’étendue attendue doit être égale à actual.

actual: ReadOnlySpan<T>

Étendue produite par le code testé.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux régions de mémoire contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: ReadOnlyMemory<T>

La mémoire attendue est égale à actual.

actual: ReadOnlyMemory<T>

Mémoire produite par le code sous test.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux étendues contiennent des éléments égaux à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: ReadOnlySpan<T>

L’étendue attendue doit être égale à actual.

actual: ReadOnlySpan<T>

Étendue produite par le code testé.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux régions de mémoire contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: Memory<T>

La mémoire attendue est égale à actual.

actual: Memory<T>

Mémoire produite par le code sous test.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux régions de mémoire contiennent des éléments égaux à l’aide de la sémantique d’ordre spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: ReadOnlyMemory<T>

La mémoire attendue est égale à actual.

actual: ReadOnlyMemory<T>

Mémoire produite par le code sous test.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux régions de mémoire contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: Memory<T>

La mémoire attendue est égale à actual.

actual: Memory<T>

Mémoire produite par le code sous test.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux régions de mémoire contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: ReadOnlyMemory<T>

La mémoire attendue est égale à actual.

actual: ReadOnlyMemory<T>

Mémoire produite par le code sous test.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux étendues contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: ReadOnlySpan<T>

L’étendue attendue doit être égale à actual.

actual: ReadOnlySpan<T>

Étendue produite par le code testé.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Source:: Assert.AreSequenceEqual.cs

Teste si deux séquences contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: IEnumerable<T>

La séquence devrait être égale à actual.

actual: IEnumerable<T>

Séquence produite par le code sous test.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Source:: Assert.AreSequenceEqual.cs

Teste si deux séquences contiennent des éléments égaux à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: IEnumerable<T>

La séquence devrait être égale à actual.

actual: IEnumerable<T>

Séquence produite par le code sous test.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Source:: Assert.AreSequenceEqual.cs

Teste si deux séquences contiennent des éléments égaux dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: IEnumerable<T>

La séquence devrait être égale à actual.

actual: IEnumerable<T>

Séquence produite par le code sous test.

comparer: IEqualityComparer<T>

Comparateur d’égalité à utiliser lors de la comparaison d’éléments ou null pour utiliser le comparateur par défaut.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux régions de mémoire contiennent des éléments égaux à l’aide de la sémantique d’ordre spécifié et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: Memory<T>

La mémoire attendue est égale à actual.

actual: Memory<T>

Mémoire produite par le code sous test.

order: SequenceOrder

Spécifie si les éléments doivent apparaître dans le même ordre ou dans n’importe quel ordre.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

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

Teste si deux étendues contiennent des éléments égaux dans le même ordre et lève une exception si ce n’est pas le cas.

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 = "")

Paramètres de type

T

Type d’éléments de séquence.

Paramètres

expected: Span<T>

L’étendue attendue doit être égale à actual.

actual: Span<T>

Étendue produite par le code testé.

message: String

Message à inclure dans l’exception lorsque les séquences ne sont pas égales.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

actualExpression: String

Expression syntactique d’une expression réelle telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant.

S’applique à

Commentaires

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