Assert.AreEquivalent Método

Definição

Namespace:: Microsoft.VisualStudio.TestTools.UnitTesting

Assembly:: MSTest.TestFramework.dll

Pacote:: MSTest.TestFramework v4.4.0

Pacote:: MSTest.TestFramework v4.3.0

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Sobrecargas

Nome	Description
AreEquivalent<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, Boolean, String, String, String)	Testa se duas regiões de memória são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).
AreEquivalent<T>(Span<T>, Span<T>, Boolean, String, String, String)	Testa se dois intervalos são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).
AreEquivalent<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, Boolean, String, String, String)	Testa se dois intervalos são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).
AreEquivalent<T>(Memory<T>, Memory<T>, Boolean, String, String, String)	Testa se duas regiões de memória são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).
AreEquivalent<T>(T, T, Boolean, String, String, String)	Testa se dois grafos de objeto são estruturalmente equivalentes (igualdade profunda) e gera uma exceção se não forem.
AreEquivalent<T>(Span<T>, Span<T>, String, String, String)	Testa se dois intervalos são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).
AreEquivalent<T>(Memory<T>, Memory<T>, String, String, String)	Testa se duas regiões de memória são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).
AreEquivalent<T>(T, T, String, String, String)	Testa se dois grafos de objeto são estruturalmente equivalentes (igualdade profunda) e gera uma exceção se não forem.
AreEquivalent<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)	Testa se dois intervalos são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).
AreEquivalent<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)	Testa se duas regiões de memória são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).

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

Testa se duas regiões de memória são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).

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

Parâmetros de tipo

T

O tipo de elemento das regiões de memória.

Parâmetros

expected: ReadOnlyMemory<T>

A memória esperada pelo teste.

actual: ReadOnlyMemory<T>

A memória produzida pelo código em teste.

strict: Boolean

Quando true, a comparação é executada no modo estrito.

message: String

A mensagem a ser incluída na exceção quando a asserção falhar.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Aplica-se a

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

Testa se dois intervalos são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).

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

Parâmetros de tipo

T

O tipo de elemento dos intervalos.

Parâmetros

expected: Span<T>

O intervalo esperado pelo teste.

actual: Span<T>

O intervalo produzido pelo código em teste.

strict: Boolean

Quando true, a comparação é executada no modo estrito.

message: String

A mensagem a ser incluída na exceção quando a asserção falhar.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Aplica-se a

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

Testa se dois intervalos são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).

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

Parâmetros de tipo

T

O tipo de elemento dos intervalos.

Parâmetros

expected: ReadOnlySpan<T>

O intervalo esperado pelo teste.

actual: ReadOnlySpan<T>

O intervalo produzido pelo código em teste.

strict: Boolean

Quando true, a comparação é executada no modo estrito.

message: String

A mensagem a ser incluída na exceção quando a asserção falhar.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Aplica-se a

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

Testa se duas regiões de memória são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).

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

Parâmetros de tipo

T

O tipo de elemento das regiões de memória.

Parâmetros

expected: Memory<T>

A memória esperada pelo teste.

actual: Memory<T>

A memória produzida pelo código em teste.

strict: Boolean

Quando true, a comparação é executada no modo estrito.

message: String

A mensagem a ser incluída na exceção quando a asserção falhar.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Aplica-se a

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

Origem:: Assert.AreEquivalent.cs

Testa se dois grafos de objeto são estruturalmente equivalentes (igualdade profunda) e gera uma exceção se não forem.

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

Parâmetros de tipo

T

O tipo de valores a serem comparados.

Parâmetros

expected: T

O primeiro valor a ser comparado. Esse é o valor esperado pelo teste.

actual: T

O segundo valor a ser comparado. Esse é o valor produzido pelo código em teste.

strict: Boolean

Quando true, a comparação falhará se actual declarar quaisquer propriedades ou campos públicos que não estejam presentes no expectedtipo de runtime ou se houver chaves de dicionário extras presentes actual. Quando false (o padrão), membros adicionais e chaves actual de dicionário são ignorados. Quando os tipos de expectedactual runtime são idênticos, esse sinalizador não tem efeito na comparação entre membros públicos, mas ainda rejeita chaves de dicionário extras ao actual comparar dicionários.

message: String

A mensagem a ser incluída na exceção quando actual não for equivalente a expected. A mensagem é mostrada nos resultados do teste.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Exceções

AssertFailedException

Gerado se expected e actual não são estruturalmente equivalentes.

Aplica-se a

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

Testa se dois intervalos são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).

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

Parâmetros de tipo

T

O tipo de elemento dos intervalos.

Parâmetros

expected: Span<T>

O intervalo esperado pelo teste.

actual: Span<T>

O intervalo produzido pelo código em teste.

message: String

A mensagem a ser incluída na exceção quando a asserção falhar.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Aplica-se a

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

Testa se duas regiões de memória são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).

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

Parâmetros de tipo

T

O tipo de elemento das regiões de memória.

Parâmetros

expected: Memory<T>

A memória esperada pelo teste.

actual: Memory<T>

A memória produzida pelo código em teste.

message: String

A mensagem a ser incluída na exceção quando a asserção falhar.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Aplica-se a

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

Origem:: Assert.AreEquivalent.cs

Testa se dois grafos de objeto são estruturalmente equivalentes (igualdade profunda) e gera uma exceção se não forem.

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

Parâmetros de tipo

T

O tipo de valores a serem comparados.

Parâmetros

expected: T

O primeiro valor a ser comparado. Esse é o valor esperado pelo teste.

actual: T

O segundo valor a ser comparado. Esse é o valor produzido pelo código em teste.

message: String

A mensagem a ser incluída na exceção quando actual não for equivalente a expected. A mensagem é mostrada nos resultados do teste.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Exceções

AssertFailedException

Gerado se expected e actual não são estruturalmente equivalentes.

Comentários

Essa asserção executa uma comparação estrutural profunda e sensível à ordem de dois grafos de objeto. Ela difere de , que verifica apenas a equivalência de coleção de nível superior sem levar em conta a ordem do AreEquivalent(ICollection, ICollection)elemento.

As regras de comparação são:

Valores iguais a referência (incluindo ambos null) são considerados equivalentes.
Tipos primitivos (numéricos, Boolean, Char, String, enums, DateTime, DateTimeOffset, , TimeSpan, Guid, Uri, , Type) Versionsão comparados com Equals(Object). Em estruturas de destino que os enviam, DateOnly, TimeOnly, Halfe Int128UInt128 também são tratados como primitivos.
Se o tipo estático (tempo de compilação) de um valor for implementado IEquatable<T> para si mesmo, Equals(T) será usado e a recursão será interrompida nesse ponto. Substituições Equals(Object) simples são ignoradas – o comparador sempre se recursa em membros para eles.
Dicionários (IDictionary, IDictionary<TKey, TValue>ou IReadOnlyDictionary<TKey,TValue>) são comparados por conjunto de chaves, com valores comparados recursivamente. As pesquisas são roteadas por meio do dicionário de origem para que as IEqualityComparer<T> chaves sejam preservadas.
Outros enumeráveis (excluindo String) são comparados elemento por elemento na ordem de iteração. A comparação diferencia a ordem; se a ordem for irrelevante, use AreEquivalent(ICollection, ICollection) na própria coleção.
Outros tipos de referência são comparados recursando em todas as propriedades de instância pública (com um getter público e sem parâmetros de índice) e campos de instância pública. Membros estáticos, não públicos e indexados são ignorados.
Os ciclos de referência são acompanhados e percorridos no máximo uma vez por par (esperado, real). O mesmo mecanismo impõe a topologia do grafo: se a mesma referência de um lado for emparelhada com referências diferentes do outro lado, a asserção falhará.
Se um acesso de dicionário (Equals(T)TryGetValueou enumeração) definido ContainsKeypelo usuário ou membro for gerado durante a avaliação, a declaração falhará com uma mensagem que descreve o tipo de exceção e a mensagem.
A comparação é interrompida após uma profundidade de recursão limitada para evitar StackOverflowException em grafos de objeto extraordinariamente profundos e relata essa condição como uma falha de declaração.

Aplica-se a

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

Testa se dois intervalos são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).

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

Parâmetros de tipo

T

O tipo de elemento dos intervalos.

Parâmetros

expected: ReadOnlySpan<T>

O intervalo esperado pelo teste.

actual: ReadOnlySpan<T>

O intervalo produzido pelo código em teste.

message: String

A mensagem a ser incluída na exceção quando a asserção falhar.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Aplica-se a

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

Testa se duas regiões de memória são estruturalmente equivalentes (comparação profunda de elementos sensíveis à ordem).

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

Parâmetros de tipo

T

O tipo de elemento das regiões de memória.

Parâmetros

expected: ReadOnlyMemory<T>

A memória esperada pelo teste.

actual: ReadOnlyMemory<T>

A memória produzida pelo código em teste.

message: String

A mensagem a ser incluída na exceção quando a asserção falhar.

expectedExpression: String

A expressão sintactica do esperado, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

actualExpression: String

A expressão sintactica de real, conforme fornecido pelo compilador por meio da expressão de argumento do chamador. Os usuários não devem passar um valor para esse parâmetro.

Aplica-se a

Comentários

Esta página foi útil?