Assert.AreEquivalent 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
AreEquivalent<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, Boolean, String, String, String)	Teste si deux régions de mémoire sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre).
AreEquivalent<T>(Span<T>, Span<T>, Boolean, String, String, String)	Teste si deux étendues sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre profond).
AreEquivalent<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, Boolean, String, String, String)	Teste si deux étendues sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre profond).
AreEquivalent<T>(Memory<T>, Memory<T>, Boolean, String, String, String)	Teste si deux régions de mémoire sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre).
AreEquivalent<T>(T, T, Boolean, String, String, String)	Teste si deux graphiques d’objets sont structurellement équivalents (égalité profonde) et lève une exception si ce n’est pas le cas.
AreEquivalent<T>(Span<T>, Span<T>, String, String, String)	Teste si deux étendues sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre profond).
AreEquivalent<T>(Memory<T>, Memory<T>, String, String, String)	Teste si deux régions de mémoire sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre).
AreEquivalent<T>(T, T, String, String, String)	Teste si deux graphiques d’objets sont structurellement équivalents (égalité profonde) et lève une exception si ce n’est pas le cas.
AreEquivalent<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)	Teste si deux étendues sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre profond).
AreEquivalent<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)	Teste si deux régions de mémoire sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre).

AreEquivalent<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, Boolean, String, String, String)

Teste si deux régions de mémoire sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre).

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

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

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

Paramètres de type

T

Type d’élément des régions de mémoire.

Paramètres

expected: ReadOnlyMemory<T>

Mémoire attendue par le test.

actual: ReadOnlyMemory<T>

Mémoire produite par le code sous test.

strict: Boolean

Quand true, la comparaison est effectuée en mode strict.

message: String

Message à inclure dans l’exception en cas d’échec de l’assertion.

expectedExpression: String

Expression syntactique attendue telle qu’elle est donnée par le compilateur via l’expression d’argument de l’appelant. Les utilisateurs ne doivent pas transmettre de valeur pour ce paramètre.

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. Les utilisateurs ne doivent pas transmettre de valeur pour ce paramètre.

S’applique à

AreEquivalent<T>(Span<T>, Span<T>, Boolean, String, String, String)

Teste si deux étendues sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre profond).

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

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

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

Paramètres de type

T

Type d’élément des étendues.

Paramètres

expected: Span<T>

Étendue attendue par le test.

actual: Span<T>

Étendue produite par le code testé.

strict: Boolean

Quand true, la comparaison est effectuée en mode strict.

message: String

Message à inclure dans l’exception en cas d’échec de l’assertion.

expectedExpression: String

actualExpression: String

S’applique à

AreEquivalent<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, Boolean, String, String, String)

Teste si deux étendues sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre profond).

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

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

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

Paramètres de type

T

Type d’élément des étendues.

Paramètres

expected: ReadOnlySpan<T>

Étendue attendue par le test.

actual: ReadOnlySpan<T>

Étendue produite par le code testé.

strict: Boolean

Quand true, la comparaison est effectuée en mode strict.

message: String

Message à inclure dans l’exception en cas d’échec de l’assertion.

expectedExpression: String

actualExpression: String

S’applique à

AreEquivalent<T>(Memory<T>, Memory<T>, Boolean, String, String, String)

Teste si deux régions de mémoire sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre).

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

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

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

Paramètres de type

T

Type d’élément des régions de mémoire.

Paramètres

expected: Memory<T>

Mémoire attendue par le test.

actual: Memory<T>

Mémoire produite par le code sous test.

strict: Boolean

Quand true, la comparaison est effectuée en mode strict.

message: String

Message à inclure dans l’exception en cas d’échec de l’assertion.

expectedExpression: String

actualExpression: String

S’applique à

AreEquivalent<T>(T, T, Boolean, String, String, String)

Source:: Assert.AreEquivalent.cs

Teste si deux graphiques d’objets sont structurellement équivalents (égalité profonde) et lève une exception si ce n’est pas le cas.

public static void AreEquivalent<T>(T? expected, T? actual, bool strict, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreEquivalent : 'T * 'T * bool * string * string * string -> unit

Public Shared Sub AreEquivalent(Of T) (expected As T, actual As T, strict As Boolean, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Paramètres de type

T

Type de valeurs à comparer.

Paramètres

expected: T

Première valeur à comparer. Il s’agit de la valeur attendue par le test.

actual: T

Deuxième valeur à comparer. Il s’agit de la valeur produite par le code testé.

strict: Boolean

Lorsque true, la comparaison échoue si actual elle déclare des propriétés publiques ou des champs qui ne sont pas présents sur expectedle type d’exécution du runtime, ou si des clés de dictionnaire supplémentaires sont présentes sur actual. Lorsque false (valeur par défaut), des membres supplémentaires et des clés de dictionnaire sont actual ignorés. Lorsque les types d’exécution expected et actual sont identiques, cet indicateur n’a aucun effet sur la comparaison des membres publics, mais il rejette toujours des clés actual de dictionnaire supplémentaires lors de la comparaison des dictionnaires.

message: String

Message à inclure dans l’exception lorsqu’il actual n’est pas équivalent à expected. Le message s’affiche dans les résultats des tests.

expectedExpression: String

actualExpression: String

Exceptions

AssertFailedException

Levée si expected et actual ne sont pas structurellement équivalentes.

S’applique à

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

Teste si deux étendues sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre profond).

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

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

Public Shared Sub AreEquivalent(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ément des étendues.

Paramètres

expected: Span<T>

Étendue attendue par le test.

actual: Span<T>

Étendue produite par le code testé.

message: String

Message à inclure dans l’exception en cas d’échec de l’assertion.

expectedExpression: String

actualExpression: String

S’applique à

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

Teste si deux régions de mémoire sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre).

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

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

Public Shared Sub AreEquivalent(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ément des régions de mémoire.

Paramètres

expected: Memory<T>

Mémoire attendue par le test.

actual: Memory<T>

Mémoire produite par le code sous test.

message: String

Message à inclure dans l’exception en cas d’échec de l’assertion.

expectedExpression: String

actualExpression: String

S’applique à

AreEquivalent<T>(T, T, String, String, String)

Source:: Assert.AreEquivalent.cs

Teste si deux graphiques d’objets sont structurellement équivalents (égalité profonde) et lève une exception si ce n’est pas le cas.

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

static member AreEquivalent : 'T * 'T * string * string * string -> unit

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

Paramètres de type

T

Type de valeurs à comparer.

Paramètres

expected: T

Première valeur à comparer. Il s’agit de la valeur attendue par le test.

actual: T

Deuxième valeur à comparer. Il s’agit de la valeur produite par le code testé.

message: String

Message à inclure dans l’exception lorsqu’il actual n’est pas équivalent à expected. Le message s’affiche dans les résultats des tests.

expectedExpression: String

actualExpression: String

Exceptions

AssertFailedException

Levée si expected et actual ne sont pas structurellement équivalentes.

Remarques

Cette assertion effectue une comparaison structurelle profonde et sensible aux ordres de deux graphiques d’objets. Il diffère de AreEquivalent(ICollection, ICollection), qui vérifie uniquement l’équivalence de collection de niveau supérieur sans tenir compte de l’ordre des éléments.

Les règles de comparaison sont les suivantes :

Les valeurs égales aux références (y compris les deux null) sont considérées comme équivalentes.
Les types de type primitif (numériques, Boolean, , Char String, enums, DateTime, DateTimeOffset, TimeSpan, , Guid Uri, Type Version) sont comparés à Equals(Object). Sur les frameworks cibles qui les expédient, DateOnly, , TimeOnlyHalf, Int128et UInt128 sont également traités comme primitifs.
Si le type statique (compile-time) d’une valeur est implémenté pour lui-même, IEquatable<T> est utilisé et la récursivité Equals(T) s’arrête à ce stade. Les remplacements bruts Equals(Object) sont ignorés : le comparateur récurse toujours en membres pour ceux-ci.
Les dictionnaires (IDictionary, IDictionary<TKey, TValue>ou IReadOnlyDictionary<TKey,TValue>) sont comparés par jeu de clés, avec des valeurs comparées de manière récursive. Les recherches sont routées via le dictionnaire source afin que ses IEqualityComparer<T> clés soient conservées.
D’autres énumérables (à l’exclusion String) sont comparées par élément dans l’ordre d’itération. La comparaison respecte l’ordre ; si l’ordre n’est pas pertinent, utilisez AreEquivalent(ICollection, ICollection) la collection elle-même.
D’autres types de référence sont comparés en récursant toutes les propriétés d’instance publique (avec un getter public et aucun paramètre d’index) et les champs d’instance publique. Les membres statiques, non publics et indexés sont ignorés.
Les cycles de référence sont suivis et parcourus au plus une fois par paire (attendue, réelle). Le même mécanisme applique la topologie de graphe : si la même référence d’un côté est associée à différentes références de l’autre côté, l’assertion échoue.
Si un accès utilisateur Equals(T)défini par l’utilisateur, getter ou dictionnaire (TryGetValue, ContainsKeyou énumération) lève lors de l’évaluation, l’assertion échoue avec un message décrivant le type d’exception et le message.
La comparaison s’arrête après une profondeur de récursivité limitée pour éviter StackOverflowException les graphiques d’objets inhabituellement profonds et signale cette condition en tant qu’échec d’assertion.

S’applique à

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

Teste si deux étendues sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre profond).

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

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

Public Shared Sub AreEquivalent(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ément des étendues.

Paramètres

expected: ReadOnlySpan<T>

Étendue attendue par le test.

actual: ReadOnlySpan<T>

Étendue produite par le code testé.

message: String

Message à inclure dans l’exception en cas d’échec de l’assertion.

expectedExpression: String

actualExpression: String

S’applique à

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

Teste si deux régions de mémoire sont structurellement équivalentes (comparaison d’éléments sensibles à l’ordre).

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

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

Public Shared Sub AreEquivalent(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ément des régions de mémoire.

Paramètres

expected: ReadOnlyMemory<T>

Mémoire attendue par le test.

actual: ReadOnlyMemory<T>

Mémoire produite par le code sous test.

message: String

Message à inclure dans l’exception en cas d’échec de l’assertion.

expectedExpression: String

actualExpression: String

S’applique à

Commentaires

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