Assert.AreEqual Método

Definição

Namespace:: Microsoft.VisualStudio.TestTools.UnitTesting

Assembly:: Microsoft.VisualStudio.TestPlatform.TestFramework.dll

Assembly:: Microsoft.VisualStudio.QualityTools.UnitTestFramework.dll

Assembly:: MSTest.TestFramework.dll

Pacote:: MSTest.TestFramework v2.2.10

Pacote:: MSTest.TestFramework v3.0.4

Pacote:: MSTest.TestFramework v3.1.1

Pacote:: MSTest.TestFramework v3.10.5

Pacote:: MSTest.TestFramework v3.11.0

Pacote:: MSTest.TestFramework v3.2.2

Pacote:: MSTest.TestFramework v3.3.1

Pacote:: MSTest.TestFramework v3.4.3

Pacote:: MSTest.TestFramework v3.5.2

Pacote:: MSTest.TestFramework v3.6.4

Pacote:: MSTest.TestFramework v3.7.3

Pacote:: MSTest.TestFramework v3.8.3

Pacote:: MSTest.TestFramework v3.9.3

Pacote:: MSTest.TestFramework v1.1.18

Pacote:: MSTest.TestFramework v1.2.1

Pacote:: MSTest.TestFramework v1.3.2

Pacote:: MSTest.TestFramework v1.4.0

Pacote:: MSTest.TestFramework v2.0.0

Pacote:: MSTest.TestFramework v2.1.2

Pacote:: MSTest.TestFramework v4.0.2

Pacote:: MSTest.TestFramework v4.1.0

Pacote:: MSTest.TestFramework v4.2.3

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
AreEqual(Int64, Int64, Int64, String, Object[])	Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Single, Single, Single, String, Object[])	Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(String, String, Boolean, CultureInfo, String)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(String, String, Boolean, String, Object[])	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.
AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)	Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(Decimal, Decimal, Decimal, String, String, String)	Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)	Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(String, String, Boolean, CultureInfo, String, Object[])	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)	Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Int64, Int64, Int64, String, String, String)	Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Single, Single, Single, String, String, String)	Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.
AreEqual(Double, Double, Double, String, Object[])	Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(String, String, Boolean, String, String, String)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.
AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(String, String, Boolean, CultureInfo, String, String, String)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(Double, Double, Double, String, String, String)	Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Decimal, Decimal, Decimal, String, Object[])	Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)	Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(String, String, Boolean, CultureInfo)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(Object, Object)	Testa se os objetos especificados são iguais e gera uma exceção se os dois objetos não são iguais. Tipos numéricos diferentes são tratados como desiguais mesmo se os valores lógicos forem iguais. 42L não é igual a 42.
AreEqual(Decimal, Decimal, Decimal)	Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(Double, Double, Double)	Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Int64, Int64, Int64)	Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Object, Object, String)	Testa se os objetos especificados são iguais e gera uma exceção se os dois objetos não são iguais. Tipos numéricos diferentes são tratados como desiguais mesmo se os valores lógicos forem iguais. 42L não é igual a 42.
AreEqual(Single, Single, Single)	Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(String, String, Boolean)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.
AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)	Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual(String, String, Boolean, String)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.
AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)	Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Double, Double, Double, String)	Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)	Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Int64, Int64, Int64, String)	Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Object, Object, String, Object[])	Testa se os objetos especificados são iguais e gera uma exceção se os dois objetos não são iguais. Tipos numéricos diferentes são tratados como desiguais mesmo se os valores lógicos forem iguais. 42L não é igual a 42.
AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)	Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(Single, Single, Single, String)	Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.
AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)	Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.
AreEqual(Decimal, Decimal, Decimal, String)	Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.
AreEqual<T>(T, T, IEqualityComparer<T>, String)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido `comparer` .
AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido `comparer` .
AreEqual<T>(T, T, String, String, String)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(T, T, IEqualityComparer<T>, String, Object[])	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido `comparer` .
AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(T, T, String, Object[])	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(T, T, IEqualityComparer<T>, String, String, String)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido `comparer` .
AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido `comparer` .
AreEqual<T>(T, T, String)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(T, T, IEqualityComparer<T>)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(IEquatable<T>, IEquatable<T>, String)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(IEquatable<T>, IEquatable<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(T, T)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(IEquatable<T>, IEquatable<T>)	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.
AreEqual<T>(IEquatable<T>, IEquatable<T>, String, Object[])	Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

AreEqual(Int64, Int64, Int64, String, Object[])

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(long expected, long actual, long delta, string message, params object[] parameters);

public static void AreEqual(long expected, long actual, long delta, string? message, params object?[]? parameters);

static member AreEqual : int64 * int64 * int64 * string * obj[] -> unit

Public Shared Sub AreEqual (expected As Long, actual As Long, delta As Long, message As String, ParamArray parameters As Object())

Parâmetros

expected: Int64

O primeiro longo a ser comparado. Esse é o tempo que os testes esperam.

actual: Int64

O segundo longo a ser comparado. Este é o longo produzido pelo código em teste.

delta: Int64

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Single, Single, Single, String, Object[])

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(float expected, float actual, float delta, string message, params object[] parameters);

public static void AreEqual(float expected, float actual, float delta, string? message, params object?[]? parameters);

static member AreEqual : single * single * single * string * obj[] -> unit

Public Shared Sub AreEqual (expected As Single, actual As Single, delta As Single, message As String, ParamArray parameters As Object())

Parâmetros

expected: Single

O primeiro float a ser comparado. Este é o float que os testes esperam.

actual: Single

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

delta: Single

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(string? expected, string? actual, bool ignoreCase, System.Globalization.CultureInfo culture, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message);

static member AreEqual : string * string * bool * System.Globalization.CultureInfo * AssertNonGenericAreEqualInterpolatedStringHandler -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, culture As CultureInfo, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler)

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

Um booliano que indica uma comparação que diferencia maiúsculas de minúsculas ou não diferencia maiúsculas de minúsculas. (true indica uma comparação que não diferencia maiúsculas de minúsculas.)

culture: CultureInfo

Um objeto CultureInfo que fornece informações de comparação específicas da cultura. Se a cultura for nula, a cultura atual será usada.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

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

Aplica-se a

AreEqual(String, String, Boolean, CultureInfo, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(string expected, string actual, bool ignoreCase, System.Globalization.CultureInfo culture, string message);

public static void AreEqual(string? expected, string? actual, bool ignoreCase, System.Globalization.CultureInfo? culture, string? message);

public static void AreEqual(string? expected, string? actual, bool ignoreCase, System.Globalization.CultureInfo culture, string? message);

static member AreEqual : string * string * bool * System.Globalization.CultureInfo * string -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, culture As CultureInfo, message As String)

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres que os testes esperam.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

culture: CultureInfo

Um objeto CultureInfo que fornece informações de comparação específicas da cultura. Se a cultura for nula, a cultura atual será usada.

message: String

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

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(String, String, Boolean, String, Object[])

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.

public static void AreEqual(string expected, string actual, bool ignoreCase, string message, params object[] parameters);

public static void AreEqual(string? expected, string? actual, bool ignoreCase, string? message, params object?[]? parameters);

static member AreEqual : string * string * bool * string * obj[] -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, message As String, ParamArray parameters As Object())

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

message: String

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

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.Numerics.cs

Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(decimal expected, decimal actual, decimal delta, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message, string expectedExpression = "", string actualExpression = "");

static member AreEqual : decimal * decimal * decimal * AssertNonGenericAreEqualInterpolatedStringHandler * string * string -> unit

Public Shared Sub AreEqual (expected As Decimal, actual As Decimal, delta As Decimal, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler, Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: Decimal

O primeiro decimal a ser comparado. Essa é a decimal esperada pelos testes.

actual: Decimal

O segundo decimal a ser comparado. Essa é a decimal produzida pelo código em teste.

delta: Decimal

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . 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.

Aplica-se a

AreEqual(Decimal, Decimal, Decimal, String, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.Numerics.cs

Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(decimal expected, decimal actual, decimal delta, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreEqual : decimal * decimal * decimal * string * string * string -> unit

Public Shared Sub AreEqual (expected As Decimal, actual As Decimal, delta As Decimal, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: Decimal

O primeiro decimal a ser comparado. Essa é a decimal esperada pelos testes.

actual: Decimal

O segundo decimal a ser comparado. Essa é a decimal produzida pelo código em teste.

delta: Decimal

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . 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

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.Numerics.cs

Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(double expected, double actual, double delta, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message, string expectedExpression = "", string actualExpression = "");

static member AreEqual : double * double * double * AssertNonGenericAreEqualInterpolatedStringHandler * string * string -> unit

Public Shared Sub AreEqual (expected As Double, actual As Double, delta As Double, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler, Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: Double

O primeiro duplo a ser comparado. Esse é o dobro dos testes esperados.

actual: Double

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

delta: Double

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . 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.

Aplica-se a

AreEqual(String, String, Boolean, CultureInfo, String, Object[])

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(string expected, string actual, bool ignoreCase, System.Globalization.CultureInfo culture, string message, params object[] parameters);

public static void AreEqual(string? expected, string? actual, bool ignoreCase, System.Globalization.CultureInfo? culture, string? message, params object?[]? parameters);

public static void AreEqual(string? expected, string? actual, bool ignoreCase, System.Globalization.CultureInfo culture, string? message, params object?[]? parameters);

static member AreEqual : string * string * bool * System.Globalization.CultureInfo * string * obj[] -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, culture As CultureInfo, message As String, ParamArray parameters As Object())

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

culture: CultureInfo

Um objeto CultureInfo que fornece informações de comparação específicas da cultura. Se a cultura for nula, a cultura atual será usada.

message: String

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

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.Numerics.cs

Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(long expected, long actual, long delta, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message, string expectedExpression = "", string actualExpression = "");

static member AreEqual : int64 * int64 * int64 * AssertNonGenericAreEqualInterpolatedStringHandler * string * string -> unit

Public Shared Sub AreEqual (expected As Long, actual As Long, delta As Long, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler, Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: Int64

O primeiro longo a ser comparado. Esse é o tempo que os testes esperam.

actual: Int64

O segundo longo a ser comparado. Este é o longo produzido pelo código em teste.

delta: Int64

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . 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.

Aplica-se a

AreEqual(Int64, Int64, Int64, String, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.Numerics.cs

Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(long expected, long actual, long delta, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreEqual : int64 * int64 * int64 * string * string * string -> unit

Public Shared Sub AreEqual (expected As Long, actual As Long, delta As Long, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: Int64

O primeiro longo a ser comparado. Esse é o tempo que os testes esperam.

actual: Int64

O segundo longo a ser comparado. Este é o longo produzido pelo código em teste.

delta: Int64

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . 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

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Single, Single, Single, String, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.Numerics.cs

Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(float expected, float actual, float delta, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreEqual : single * single * single * string * string * string -> unit

Public Shared Sub AreEqual (expected As Single, actual As Single, delta As Single, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: Single

O primeiro float a ser comparado. Este é o float que os testes esperam.

actual: Single

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

delta: Single

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . 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

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.String.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.

public static void AreEqual(string? expected, string? actual, bool ignoreCase, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message, string expectedExpression = "", string actualExpression = "");

static member AreEqual : string * string * bool * AssertNonGenericAreEqualInterpolatedStringHandler * string * string -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler, Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres que os testes esperam.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual não for igual 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.

Aplica-se a

AreEqual(Double, Double, Double, String, Object[])

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(double expected, double actual, double delta, string message, params object[] parameters);

public static void AreEqual(double expected, double actual, double delta, string? message, params object?[]? parameters);

static member AreEqual : double * double * double * string * obj[] -> unit

Public Shared Sub AreEqual (expected As Double, actual As Double, delta As Double, message As String, ParamArray parameters As Object())

Parâmetros

expected: Double

O primeiro duplo a ser comparado. Esse é o dobro dos testes esperados.

actual: Double

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

delta: Double

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(String, String, Boolean, String, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.String.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.

public static void AreEqual(string? expected, string? actual, bool ignoreCase, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreEqual : string * string * bool * string * string * string -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

message: String

A mensagem a ser incluída na exceção quando actual não for igual 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

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.String.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(string? expected, string? actual, bool ignoreCase, System.Globalization.CultureInfo culture, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message, string expectedExpression = "", string actualExpression = "");

static member AreEqual : string * string * bool * System.Globalization.CultureInfo * AssertNonGenericAreEqualInterpolatedStringHandler * string * string -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, culture As CultureInfo, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler, Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

culture: CultureInfo

Um objeto CultureInfo que fornece informações de comparação específicas da cultura. Se a cultura for nula, a cultura atual será usada.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual não for igual 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.

Aplica-se a

AreEqual(String, String, Boolean, CultureInfo, String, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.String.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(string? expected, string? actual, bool ignoreCase, System.Globalization.CultureInfo culture, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreEqual : string * string * bool * System.Globalization.CultureInfo * string * string * string -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, culture As CultureInfo, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

culture: CultureInfo

Um objeto CultureInfo que fornece informações de comparação específicas da cultura. Se a cultura for nula, a cultura atual será usada.

message: String

A mensagem a ser incluída na exceção quando actual não for igual 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

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Double, Double, Double, String, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.Numerics.cs

Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(double expected, double actual, double delta, string? message = "", string expectedExpression = "", string actualExpression = "");

static member AreEqual : double * double * double * string * string * string -> unit

Public Shared Sub AreEqual (expected As Double, actual As Double, delta As Double, Optional message As String = "", Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: Double

O primeiro duplo a ser comparado. Esse é o dobro dos testes esperados.

actual: Double

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

delta: Double

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . 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

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Decimal, Decimal, Decimal, String, Object[])

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(decimal expected, decimal actual, decimal delta, string message, params object[] parameters);

public static void AreEqual(decimal expected, decimal actual, decimal delta, string? message, params object?[]? parameters);

static member AreEqual : decimal * decimal * decimal * string * obj[] -> unit

Public Shared Sub AreEqual (expected As Decimal, actual As Decimal, delta As Decimal, message As String, ParamArray parameters As Object())

Parâmetros

expected: Decimal

O primeiro decimal a ser comparado. Essa é a decimal esperada pelos testes.

actual: Decimal

O segundo decimal a ser comparado. Essa é a decimal produzida pelo código em teste.

delta: Decimal

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.Numerics.cs

Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(float expected, float actual, float delta, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message, string expectedExpression = "", string actualExpression = "");

static member AreEqual : single * single * single * AssertNonGenericAreEqualInterpolatedStringHandler * string * string -> unit

Public Shared Sub AreEqual (expected As Single, actual As Single, delta As Single, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler, Optional expectedExpression As String = "", Optional actualExpression As String = "")

Parâmetros

expected: Single

O primeiro float a ser comparado. Este é o float que os testes esperam.

actual: Single

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

delta: Single

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . 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.

Aplica-se a

AreEqual(String, String, Boolean, CultureInfo)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(string expected, string actual, bool ignoreCase, System.Globalization.CultureInfo culture);

public static void AreEqual(string? expected, string? actual, bool ignoreCase, System.Globalization.CultureInfo? culture);

public static void AreEqual(string? expected, string? actual, bool ignoreCase, System.Globalization.CultureInfo culture);

static member AreEqual : string * string * bool * System.Globalization.CultureInfo -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, culture As CultureInfo)

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

culture: CultureInfo

Um objeto CultureInfo que fornece informações de comparação específicas da cultura. Se a cultura for nula, a cultura atual será usada.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Object, Object)

Testa se os objetos especificados são iguais e gera uma exceção se os dois objetos não são iguais. Tipos numéricos diferentes são tratados como desiguais mesmo se os valores lógicos forem iguais. 42L não é igual a 42.

public static void AreEqual(object expected, object actual);

static member AreEqual : obj * obj -> unit

Public Shared Sub AreEqual (expected As Object, actual As Object)

Parâmetros

expected: Object

O primeiro objeto a ser comparado. Esse é o objeto que os testes esperam.

actual: Object

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

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Decimal, Decimal, Decimal)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(decimal expected, decimal actual, decimal delta);

static member AreEqual : decimal * decimal * decimal -> unit

Public Shared Sub AreEqual (expected As Decimal, actual As Decimal, delta As Decimal)

Parâmetros

expected: Decimal

O primeiro decimal a ser comparado. Essa é a decimal esperada pelos testes.

actual: Decimal

O segundo decimal a ser comparado. Essa é a decimal produzida pelo código em teste.

delta: Decimal

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Double, Double, Double)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(double expected, double actual, double delta);

static member AreEqual : double * double * double -> unit

Public Shared Sub AreEqual (expected As Double, actual As Double, delta As Double)

Parâmetros

expected: Double

O primeiro duplo a ser comparado. Esse é o dobro dos testes esperados.

actual: Double

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

delta: Double

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Int64, Int64, Int64)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(long expected, long actual, long delta);

static member AreEqual : int64 * int64 * int64 -> unit

Public Shared Sub AreEqual (expected As Long, actual As Long, delta As Long)

Parâmetros

expected: Int64

O primeiro longo a ser comparado. Esse é o tempo que os testes esperam.

actual: Int64

O segundo longo a ser comparado. Este é o longo produzido pelo código em teste.

delta: Int64

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Object, Object, String)

public static void AreEqual(object expected, object actual, string message);

static member AreEqual : obj * obj * string -> unit

Public Shared Sub AreEqual (expected As Object, actual As Object, message As String)

Parâmetros

expected: Object

O primeiro objeto a ser comparado. Esse é o objeto que os testes esperam.

actual: Object

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

message: String

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

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Single, Single, Single)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(float expected, float actual, float delta);

static member AreEqual : single * single * single -> unit

Public Shared Sub AreEqual (expected As Single, actual As Single, delta As Single)

Parâmetros

expected: Single

O primeiro float a ser comparado. Este é o float que os testes esperam.

actual: Single

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

delta: Single

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(String, String, Boolean)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.

public static void AreEqual(string expected, string actual, bool ignoreCase);

public static void AreEqual(string? expected, string? actual, bool ignoreCase);

static member AreEqual : string * string * bool -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean)

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(decimal expected, decimal actual, decimal delta, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message);

static member AreEqual : decimal * decimal * decimal * AssertNonGenericAreEqualInterpolatedStringHandler -> unit

Public Shared Sub AreEqual (expected As Decimal, actual As Decimal, delta As Decimal, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler)

Parâmetros

expected: Decimal

O primeiro decimal a ser comparado. Essa é a decimal esperada pelos testes.

actual: Decimal

O segundo decimal a ser comparado. Essa é a decimal produzida pelo código em teste.

delta: Decimal

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

Aplica-se a

AreEqual(String, String, Boolean, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.

public static void AreEqual(string expected, string actual, bool ignoreCase, string message);

public static void AreEqual(string? expected, string? actual, bool ignoreCase, string? message);

static member AreEqual : string * string * bool * string -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, message As String)

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

message: String

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

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(double expected, double actual, double delta, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message);

static member AreEqual : double * double * double * AssertNonGenericAreEqualInterpolatedStringHandler -> unit

Public Shared Sub AreEqual (expected As Double, actual As Double, delta As Double, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler)

Parâmetros

expected: Double

O primeiro duplo a ser comparado. Esse é o dobro dos testes esperados.

actual: Double

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

delta: Double

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

Aplica-se a

AreEqual(Double, Double, Double, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os duplos especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(double expected, double actual, double delta, string message);

public static void AreEqual(double expected, double actual, double delta, string? message);

static member AreEqual : double * double * double * string -> unit

Public Shared Sub AreEqual (expected As Double, actual As Double, delta As Double, message As String)

Parâmetros

expected: Double

O primeiro duplo a ser comparado. Esse é o dobro dos testes esperados.

actual: Double

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

delta: Double

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(long expected, long actual, long delta, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message);

static member AreEqual : int64 * int64 * int64 * AssertNonGenericAreEqualInterpolatedStringHandler -> unit

Public Shared Sub AreEqual (expected As Long, actual As Long, delta As Long, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler)

Parâmetros

expected: Int64

O primeiro longo a ser comparado. Esse é o tempo que os testes esperam.

actual: Int64

O segundo longo a ser comparado. Este é o longo produzido pelo código em teste.

delta: Int64

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

Aplica-se a

AreEqual(Int64, Int64, Int64, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os longs especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(long expected, long actual, long delta, string message);

public static void AreEqual(long expected, long actual, long delta, string? message);

static member AreEqual : int64 * int64 * int64 * string -> unit

Public Shared Sub AreEqual (expected As Long, actual As Long, delta As Long, message As String)

Parâmetros

expected: Int64

O primeiro longo a ser comparado. Esse é o tempo que os testes esperam.

actual: Int64

O segundo longo a ser comparado. Este é o longo produzido pelo código em teste.

delta: Int64

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Object, Object, String, Object[])

public static void AreEqual(object expected, object actual, string message, params object[] parameters);

static member AreEqual : obj * obj * string * obj[] -> unit

Public Shared Sub AreEqual (expected As Object, actual As Object, message As String, ParamArray parameters As Object())

Parâmetros

expected: Object

O primeiro objeto a ser comparado. Esse é o objeto que os testes esperam.

actual: Object

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

message: String

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

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(float expected, float actual, float delta, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message);

static member AreEqual : single * single * single * AssertNonGenericAreEqualInterpolatedStringHandler -> unit

Public Shared Sub AreEqual (expected As Single, actual As Single, delta As Single, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler)

Parâmetros

expected: Single

O primeiro float a ser comparado. Este é o float que os testes esperam.

actual: Single

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

delta: Single

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

Aplica-se a

AreEqual(Single, Single, Single, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os floats especificados são iguais e gera uma exceção se eles não são iguais.

public static void AreEqual(float expected, float actual, float delta, string message);

public static void AreEqual(float expected, float actual, float delta, string? message);

static member AreEqual : single * single * single * string -> unit

Public Shared Sub AreEqual (expected As Single, actual As Single, delta As Single, message As String)

Parâmetros

expected: Single

O primeiro float a ser comparado. Este é o float que os testes esperam.

actual: Single

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

delta: Single

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as cadeias de caracteres especificadas são iguais e gera uma exceção se elas não são iguais. A cultura invariável é usada para a comparação.

public static void AreEqual(string? expected, string? actual, bool ignoreCase, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertNonGenericAreEqualInterpolatedStringHandler message);

static member AreEqual : string * string * bool * AssertNonGenericAreEqualInterpolatedStringHandler -> unit

Public Shared Sub AreEqual (expected As String, actual As String, ignoreCase As Boolean, ByRef message As Assert.AssertNonGenericAreEqualInterpolatedStringHandler)

Parâmetros

expected: String

A primeira cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres esperada pelos testes.

actual: String

A segunda cadeia de caracteres a ser comparada. Essa é a cadeia de caracteres produzida pelo código em teste.

ignoreCase: Boolean

message: Assert.AssertNonGenericAreEqualInterpolatedStringHandler

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

Aplica-se a

AreEqual(Decimal, Decimal, Decimal, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se as decimais especificadas são iguais e gera uma exceção se elas não são iguais.

public static void AreEqual(decimal expected, decimal actual, decimal delta, string message);

public static void AreEqual(decimal expected, decimal actual, decimal delta, string? message);

static member AreEqual : decimal * decimal * decimal * string -> unit

Public Shared Sub AreEqual (expected As Decimal, actual As Decimal, delta As Decimal, message As String)

Parâmetros

expected: Decimal

O primeiro decimal a ser comparado. Essa é a decimal esperada pelos testes.

actual: Decimal

O segundo decimal a ser comparado. Essa é a decimal produzida pelo código em teste.

delta: Decimal

A precisão necessária. Uma exceção será gerada somente se actual for diferente de mais de expecteddelta.

message: String

A mensagem a ser incluída na exceção quando actual for diferente de mais de deltaexpected . A mensagem é mostrada nos resultados do teste.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(T, T, IEqualityComparer<T>, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido comparer .

public static void AreEqual<T>(T? expected, T? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message);

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

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, comparer As IEqualityComparer(Of T), message 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 pelos testes.

actual: T

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

comparer: IEqualityComparer<T>

A IEqualityComparer<T> implementação a ser usada ao comparar chaves ou nulo para usar o padrão EqualityComparer<T>.

message: String

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

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido comparer .

public static void AreEqual<T>(T? expected, T? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertAreEqualInterpolatedStringHandler<T> message, string expectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, comparer As IEqualityComparer(Of T), ByRef message As Assert.AssertAreEqualInterpolatedStringHandler(Of T), 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 pelos testes.

actual: T

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

comparer: IEqualityComparer<T>

A IEqualityComparer<T> implementação a ser usada ao comparar chaves ou nulo para usar o padrão EqualityComparer<T>.

message: Assert.AssertAreEqualInterpolatedStringHandler<T>

A mensagem a ser incluída na exceção quando actual não for igual 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.

Aplica-se a

AreEqual<T>(T, T, String, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

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

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

Public Shared Sub AreEqual(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 pelos testes.

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 igual 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

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(T, T, IEqualityComparer<T>, String, Object[])

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido comparer .

public static void AreEqual<T>(T? expected, T? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message, params object?[]? parameters);

static member AreEqual : 'T * 'T * System.Collections.Generic.IEqualityComparer<'T> * string * obj[] -> unit

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, comparer As IEqualityComparer(Of T), message As String, ParamArray parameters As Object())

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 pelos testes.

actual: T

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

comparer: IEqualityComparer<T>

A IEqualityComparer<T> implementação a ser usada ao comparar chaves ou nulo para usar o padrão EqualityComparer<T>.

message: String

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

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(T? expected, T? actual, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertAreEqualInterpolatedStringHandler<T> message, string expectedExpression = "", string actualExpression = "");

static member AreEqual : 'T * 'T * AssertAreEqualInterpolatedStringHandler * string * string -> unit

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, ByRef message As Assert.AssertAreEqualInterpolatedStringHandler(Of T), 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 pelos testes.

actual: T

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

message: Assert.AssertAreEqualInterpolatedStringHandler<T>

A mensagem a ser incluída na exceção quando actual não for igual 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

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(T, T, String, Object[])

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(T expected, T actual, string message, params object[] parameters);

public static void AreEqual<T>(T? expected, T? actual, string? message, params object?[]? parameters);

static member AreEqual : 'T * 'T * string * obj[] -> unit

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, message As String, ParamArray parameters As Object())

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 pelos testes.

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 igual a expected. A mensagem é mostrada nos resultados do teste.

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(T, T, IEqualityComparer<T>, String, String, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido comparer .

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

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

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, comparer As IEqualityComparer(Of 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 pelos testes.

actual: T

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

comparer: IEqualityComparer<T>

A IEqualityComparer<T> implementação a ser usada ao comparar chaves ou nulo para usar o padrão EqualityComparer<T>.

message: String

A mensagem a ser incluída na exceção quando actual não for igual 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

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o parâmetro fornecido comparer .

public static void AreEqual<T>(T? expected, T? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertAreEqualInterpolatedStringHandler<T> message);

static member AreEqual : 'T * 'T * System.Collections.Generic.IEqualityComparer<'T> * AssertAreEqualInterpolatedStringHandler -> unit

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, comparer As IEqualityComparer(Of T), ByRef message As Assert.AssertAreEqualInterpolatedStringHandler(Of T))

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 pelos testes.

actual: T

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

comparer: IEqualityComparer<T>

A IEqualityComparer<T> implementação a ser usada ao comparar chaves ou nulo para usar o padrão EqualityComparer<T>.

message: Assert.AssertAreEqualInterpolatedStringHandler<T>

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

Aplica-se a

AreEqual<T>(T, T, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(T expected, T actual, string message);

public static void AreEqual<T>(T? expected, T? actual, string? message);

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

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, message 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 pelos testes.

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 igual a expected. A mensagem é mostrada nos resultados do teste.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(T, T, IEqualityComparer<T>)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(T? expected, T? actual, System.Collections.Generic.IEqualityComparer<T>? comparer);

static member AreEqual : 'T * 'T * System.Collections.Generic.IEqualityComparer<'T> -> unit

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, comparer As IEqualityComparer(Of T))

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 pelos testes.

actual: T

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

comparer: IEqualityComparer<T>

A IEqualityComparer<T> implementação a ser usada ao comparar chaves ou nulo para usar o padrão EqualityComparer<T>.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(T? expected, T? actual, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertAreEqualInterpolatedStringHandler<T> message);

static member AreEqual : 'T * 'T * AssertAreEqualInterpolatedStringHandler -> unit

Public Shared Sub AreEqual(Of T) (expected As T, actual As T, ByRef message As Assert.AssertAreEqualInterpolatedStringHandler(Of T))

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 pelos testes.

actual: T

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

message: Assert.AssertAreEqualInterpolatedStringHandler<T>

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

Aplica-se a

AreEqual<T>(IEquatable<T>, IEquatable<T>, String)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(IEquatable<T>? expected, IEquatable<T>? actual, string? message);

static member AreEqual : IEquatable<'T> * IEquatable<'T> * string -> unit

Public Shared Sub AreEqual(Of T) (expected As IEquatable(Of T), actual As IEquatable(Of T), message As String)

Parâmetros de tipo

T

O tipo de valores a serem comparados.

Parâmetros

expected: IEquatable<T>

O primeiro valor a ser comparado. Esse é o valor esperado pelos testes.

actual: IEquatable<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 igual a expected. A mensagem é mostrada nos resultados do teste.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(IEquatable<T>, IEquatable<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(IEquatable<T>? expected, IEquatable<T>? actual, ref Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AssertAreEqualInterpolatedStringHandler<T> message);

static member AreEqual : IEquatable<'T> * IEquatable<'T> * AssertAreEqualInterpolatedStringHandler -> unit

Public Shared Sub AreEqual(Of T) (expected As IEquatable(Of T), actual As IEquatable(Of T), ByRef message As Assert.AssertAreEqualInterpolatedStringHandler(Of T))

Parâmetros de tipo

T

O tipo de valores a serem comparados.

Parâmetros

expected: IEquatable<T>

O primeiro valor a ser comparado. Esse é o valor esperado pelos testes.

actual: IEquatable<T>

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

message: Assert.AssertAreEqualInterpolatedStringHandler<T>

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

Aplica-se a

AreEqual<T>(T, T)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(T expected, T actual);

public static void AreEqual<T>(T? expected, T? actual);

static member AreEqual : 'T * 'T -> unit

Public Shared Sub AreEqual(Of T) (expected As T, actual As T)

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 pelos testes.

actual: T

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

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(IEquatable<T>, IEquatable<T>)

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(IEquatable<T>? expected, IEquatable<T>? actual);

static member AreEqual : IEquatable<'T> * IEquatable<'T> -> unit

Public Shared Sub AreEqual(Of T) (expected As IEquatable(Of T), actual As IEquatable(Of T))

Parâmetros de tipo

T

O tipo de valores a serem comparados.

Parâmetros

expected: IEquatable<T>

O primeiro valor a ser comparado. Esse é o valor esperado pelos testes.

actual: IEquatable<T>

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

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

AreEqual<T>(IEquatable<T>, IEquatable<T>, String, Object[])

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Origem:: Assert.AreEqual.cs

Testa se os valores especificados são iguais e gera uma exceção se os dois valores não são iguais. A igualdade é calculada usando o padrão EqualityComparer<T>.

public static void AreEqual<T>(IEquatable<T>? expected, IEquatable<T>? actual, string? message, params object?[]? parameters);

static member AreEqual : IEquatable<'T> * IEquatable<'T> * string * obj[] -> unit

Public Shared Sub AreEqual(Of T) (expected As IEquatable(Of T), actual As IEquatable(Of T), message As String, ParamArray parameters As Object())

Parâmetros de tipo

T

O tipo de valores a serem comparados.

Parâmetros

expected: IEquatable<T>

O primeiro valor a ser comparado. Esse é o valor esperado pelos testes.

actual: IEquatable<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 igual a expected. A mensagem é mostrada nos resultados do teste.

parameters: Object[]

Uma matriz de parâmetros a ser usada ao formatar message.

Exceções

AssertFailedException

Lançado se expected não for igual a actual.

Aplica-se a

Comentários

Esta página foi útil?