Assert.AreNotSequenceEqual 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
AreNotSequenceEqual(IEnumerable, IEnumerable, String, String, String)	Teste si deux séquences diffèrent dans le même ordre et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)	Teste si deux séquences diffèrent à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)	Teste si deux séquences diffèrent dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)	Teste si deux séquences diffèrent à 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.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)	Teste si deux étendues diffèrent à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux étendues diffèrent à 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.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux régions de mémoire diffèrent à 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.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux régions de mémoire diffèrent à 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.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux séquences diffèrent à 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.
AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)	Teste si deux étendues diffèrent dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)	Teste si deux étendues diffèrent à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Teste si deux étendues diffèrent à 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.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)	Teste si deux étendues diffèrent dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)	Teste si deux régions de mémoire diffèrent dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)	Teste si deux séquences diffèrent dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)	Teste si deux régions de mémoire diffèrent dans le même ordre à l’aide du comparateur spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)	Teste si deux régions de mémoire diffèrent à l’aide de la sémantique d’ordre spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)	Teste si deux séquences diffèrent à l’aide de la sémantique de l’ordre spécifié et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(Span<T>, Span<T>, String, String, String)	Teste si deux étendues diffèrent dans le même ordre et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)	Teste si deux étendues diffèrent dans le même ordre et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)	Teste si deux régions de mémoire diffèrent dans le même ordre et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, String, String, String)	Teste si deux régions de mémoire diffèrent dans le même ordre et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)	Teste si deux séquences diffèrent dans le même ordre et lève une exception si ce n’est pas le cas.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)	Teste si deux régions de mémoire diffèrent à l’aide de la sémantique d’ordre spécifié et lève une exception si ce n’est pas le cas.

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

Source:: Assert.AreNotSequenceEqual.cs

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

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

Paramètres

notExpected: IEnumerable

La séquence n’est pas censée être égale actualà .

actual: IEnumerable

Séquence produite par le code sous test.

message: String

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

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Source:: Assert.AreNotSequenceEqual.cs

Teste si deux séquences diffèrent à 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 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 = "")

Paramètres

notExpected: IEnumerable

La séquence n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Source:: Assert.AreNotSequenceEqual.cs

Teste si deux séquences diffèrent 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 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 = "")

Paramètres

notExpected: IEnumerable

La séquence n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Source:: Assert.AreNotSequenceEqual.cs

Teste si deux séquences diffèrent à 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 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 = "")

Paramètres

notExpected: IEnumerable

La séquence n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux étendues diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: ReadOnlySpan<T>

L’étendue n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux étendues diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: ReadOnlySpan<T>

L’étendue n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux régions de mémoire diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: ReadOnlyMemory<T>

La mémoire n’est pas censée être é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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux régions de mémoire diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: Memory<T>

La mémoire n’est pas censée être é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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Source:: Assert.AreNotSequenceEqual.cs

Teste si deux séquences diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: IEnumerable<T>

La séquence n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux étendues diffèrent 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: Span<T>

L’étendue n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux étendues diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: Span<T>

L’étendue n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux étendues diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: Span<T>

L’étendue n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux étendues diffèrent 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: ReadOnlySpan<T>

L’étendue n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux régions de mémoire diffèrent 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: ReadOnlyMemory<T>

La mémoire n’est pas censée être é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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Source:: Assert.AreNotSequenceEqual.cs

Teste si deux séquences diffèrent 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: IEnumerable<T>

La séquence n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux régions de mémoire diffèrent 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: Memory<T>

La mémoire n’est pas censée être é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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux régions de mémoire diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: Memory<T>

La mémoire n’est pas censée être é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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Source:: Assert.AreNotSequenceEqual.cs

Teste si deux séquences diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: IEnumerable<T>

La séquence n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

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

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

Paramètres de type

T

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

Paramètres

notExpected: Span<T>

L’étendue n’est pas censée être égale actualà .

actual: Span<T>

Étendue produite par le code testé.

message: String

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

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

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

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

Paramètres de type

T

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

Paramètres

notExpected: ReadOnlySpan<T>

L’étendue n’est pas censée être égale actualà .

actual: ReadOnlySpan<T>

Étendue produite par le code testé.

message: String

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

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

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

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

Paramètres de type

T

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

Paramètres

notExpected: ReadOnlyMemory<T>

La mémoire n’est pas censée être égale actualà .

actual: ReadOnlyMemory<T>

Mémoire produite par le code sous test.

message: String

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

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

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

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

Paramètres de type

T

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

Paramètres

notExpected: Memory<T>

La mémoire n’est pas censée être égale actualà .

actual: Memory<T>

Mémoire produite par le code sous test.

message: String

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

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Source:: Assert.AreNotSequenceEqual.cs

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

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

Paramètres de type

T

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

Paramètres

notExpected: IEnumerable<T>

La séquence n’est pas censée ê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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 à

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

Teste si deux régions de mémoire diffèrent à 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 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 = "")

Paramètres de type

T

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

Paramètres

notExpected: ReadOnlyMemory<T>

La mémoire n’est pas censée être é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 sont égales.

notExpectedExpression: String

Expression syntactique de notExpected 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 ?