Assert.AreEqual Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Overload
| Nome | Descrizione |
|---|---|
| AreEqual(Int64, Int64, Int64, String, Object[]) |
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Single, Single, Single, String, Object[]) |
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, CultureInfo, String) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, String, Object[]) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto. |
| AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String) |
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Decimal, Decimal, Decimal, String, String, String) |
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String) |
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, CultureInfo, String, Object[]) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String) |
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Int64, Int64, Int64, String, String, String) |
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Single, Single, Single, String, String, String) |
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto. |
| AreEqual(Double, Double, Double, String, Object[]) |
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, String, String, String) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto. |
| AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, CultureInfo, String, String, String) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Double, Double, Double, String, String, String) |
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Decimal, Decimal, Decimal, String, Object[]) |
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String) |
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, CultureInfo) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Object, Object) |
Verifica se gli oggetti specificati sono uguali e genera un'eccezione se i due oggetti non sono uguali. I tipi numerici diversi vengono considerati diversi anche se i valori logici sono uguali. 42L non è uguale a 42. |
| AreEqual(Decimal, Decimal, Decimal) |
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Double, Double, Double) |
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Int64, Int64, Int64) |
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Object, Object, String) |
Verifica se gli oggetti specificati sono uguali e genera un'eccezione se i due oggetti non sono uguali. I tipi numerici diversi vengono considerati diversi anche se i valori logici sono uguali. 42L non è uguale a 42. |
| AreEqual(Single, Single, Single) |
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto. |
| AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler) |
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, String) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto. |
| AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler) |
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Double, Double, Double, String) |
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler) |
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Int64, Int64, Int64, String) |
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Object, Object, String, Object[]) |
Verifica se gli oggetti specificati sono uguali e genera un'eccezione se i due oggetti non sono uguali. I tipi numerici diversi vengono considerati diversi anche se i valori logici sono uguali. 42L non è uguale a 42. |
| AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler) |
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(Single, Single, Single, String) |
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler) |
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto. |
| AreEqual(Decimal, Decimal, Decimal, String) |
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali. |
| AreEqual<T>(T, T, IEqualityComparer<T>, String) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato |
| AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato |
| AreEqual<T>(T, T, String, String, String) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(T, T, IEqualityComparer<T>, String, Object[]) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato |
| AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(T, T, String, Object[]) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(T, T, IEqualityComparer<T>, String, String, String) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato |
| AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato |
| AreEqual<T>(T, T, String) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(T, T, IEqualityComparer<T>) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(IEquatable<T>, IEquatable<T>, String) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(IEquatable<T>, IEquatable<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(T, T) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(IEquatable<T>, IEquatable<T>) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
| AreEqual<T>(IEquatable<T>, IEquatable<T>, String, Object[]) |
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito EqualityComparer<T>. |
AreEqual(Int64, Int64, Int64, String, Object[])
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali.
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())
Parametri
- expected
- Int64
Primo lungo da confrontare. Questo è il tempo previsto dai test.
- actual
- Int64
Secondo long da confrontare. Questo è il lungo prodotto dal codice sottoposto a test.
- delta
- Int64
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Single, Single, Single, String, Object[])
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali.
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())
Parametri
- expected
- Single
Primo oggetto float da confrontare. Si tratta del float previsto dai test.
- actual
- Single
Secondo oggetto float da confrontare. Questo è il float prodotto dal codice sottoposto a test.
- delta
- Single
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
- culture
- CultureInfo
Oggetto CultureInfo che fornisce informazioni di confronto specifiche delle impostazioni cultura. Se le impostazioni cultura sono Null, vengono utilizzate le impostazioni cultura correnti.
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Si applica a
AreEqual(String, String, Boolean, CultureInfo, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
- culture
- CultureInfo
Oggetto CultureInfo che fornisce informazioni di confronto specifiche delle impostazioni cultura. Se le impostazioni cultura sono Null, vengono utilizzate le impostazioni cultura correnti.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(String, String, Boolean, String, Object[])
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto.
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())
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.Numerics.cs
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- Decimal
Primo decimale da confrontare. Questo è il decimale previsto dai test.
- actual
- Decimal
Secondo decimale da confrontare. Questo è il decimale prodotto dal codice sottoposto a test.
- delta
- Decimal
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Si applica a
AreEqual(Decimal, Decimal, Decimal, String, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.Numerics.cs
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- Decimal
Primo decimale da confrontare. Questo è il decimale previsto dai test.
- actual
- Decimal
Secondo decimale da confrontare. Questo è il decimale prodotto dal codice sottoposto a test.
- delta
- Decimal
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.Numerics.cs
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- Double
Primo doppio da confrontare. Questo è il doppio dei test previsti.
- actual
- Double
Secondo double da confrontare. Questo è il doppio prodotto dal codice sottoposto a test.
- delta
- Double
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Si applica a
AreEqual(String, String, Boolean, CultureInfo, String, Object[])
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali.
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())
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
- culture
- CultureInfo
Oggetto CultureInfo che fornisce informazioni di confronto specifiche delle impostazioni cultura. Se le impostazioni cultura sono Null, vengono utilizzate le impostazioni cultura correnti.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.Numerics.cs
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- Int64
Primo lungo da confrontare. Questo è il tempo previsto dai test.
- actual
- Int64
Secondo long da confrontare. Questo è il lungo prodotto dal codice sottoposto a test.
- delta
- Int64
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Si applica a
AreEqual(Int64, Int64, Int64, String, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.Numerics.cs
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- Int64
Primo lungo da confrontare. Questo è il tempo previsto dai test.
- actual
- Int64
Secondo long da confrontare. Questo è il lungo prodotto dal codice sottoposto a test.
- delta
- Int64
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Single, Single, Single, String, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.Numerics.cs
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- Single
Primo oggetto float da confrontare. Si tratta del float previsto dai test.
- actual
- Single
Secondo oggetto float da confrontare. Questo è il float prodotto dal codice sottoposto a test.
- delta
- Single
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.String.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto.
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 = "")
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Si applica a
AreEqual(Double, Double, Double, String, Object[])
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali.
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())
Parametri
- expected
- Double
Primo doppio da confrontare. Questo è il doppio dei test previsti.
- actual
- Double
Secondo double da confrontare. Questo è il doppio prodotto dal codice sottoposto a test.
- delta
- Double
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(String, String, Boolean, String, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.String.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto.
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 = "")
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(String, String, Boolean, CultureInfo, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.String.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
- culture
- CultureInfo
Oggetto CultureInfo che fornisce informazioni di confronto specifiche delle impostazioni cultura. Se le impostazioni cultura sono Null, vengono utilizzate le impostazioni cultura correnti.
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Si applica a
AreEqual(String, String, Boolean, CultureInfo, String, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.String.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
- culture
- CultureInfo
Oggetto CultureInfo che fornisce informazioni di confronto specifiche delle impostazioni cultura. Se le impostazioni cultura sono Null, vengono utilizzate le impostazioni cultura correnti.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Double, Double, Double, String, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.Numerics.cs
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- Double
Primo doppio da confrontare. Questo è il doppio dei test previsti.
- actual
- Double
Secondo double da confrontare. Questo è il doppio prodotto dal codice sottoposto a test.
- delta
- Double
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Decimal, Decimal, Decimal, String, Object[])
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali.
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())
Parametri
- expected
- Decimal
Primo decimale da confrontare. Questo è il decimale previsto dai test.
- actual
- Decimal
Secondo decimale da confrontare. Questo è il decimale prodotto dal codice sottoposto a test.
- delta
- Decimal
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.Numerics.cs
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali.
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 = "")
Parametri
- expected
- Single
Primo oggetto float da confrontare. Si tratta del float previsto dai test.
- actual
- Single
Secondo oggetto float da confrontare. Questo è il float prodotto dal codice sottoposto a test.
- delta
- Single
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Si applica a
AreEqual(String, String, Boolean, CultureInfo)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
- culture
- CultureInfo
Oggetto CultureInfo che fornisce informazioni di confronto specifiche delle impostazioni cultura. Se le impostazioni cultura sono Null, vengono utilizzate le impostazioni cultura correnti.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Object, Object)
Verifica se gli oggetti specificati sono uguali e genera un'eccezione se i due oggetti non sono uguali. I tipi numerici diversi vengono considerati diversi anche se i valori logici sono uguali. 42L non è uguale 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)
Parametri
- expected
- Object
Primo oggetto da confrontare. Si tratta dell'oggetto previsto dai test.
- actual
- Object
Secondo oggetto da confrontare. Si tratta dell'oggetto prodotto dal codice sottoposto a test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Decimal, Decimal, Decimal)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Decimal
Primo decimale da confrontare. Questo è il decimale previsto dai test.
- actual
- Decimal
Secondo decimale da confrontare. Questo è il decimale prodotto dal codice sottoposto a test.
- delta
- Decimal
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Double, Double, Double)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Double
Primo doppio da confrontare. Questo è il doppio dei test previsti.
- actual
- Double
Secondo double da confrontare. Questo è il doppio prodotto dal codice sottoposto a test.
- delta
- Double
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Int64, Int64, Int64)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Int64
Primo lungo da confrontare. Questo è il tempo previsto dai test.
- actual
- Int64
Secondo long da confrontare. Questo è il lungo prodotto dal codice sottoposto a test.
- delta
- Int64
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Object, Object, String)
Verifica se gli oggetti specificati sono uguali e genera un'eccezione se i due oggetti non sono uguali. I tipi numerici diversi vengono considerati diversi anche se i valori logici sono uguali. 42L non è uguale a 42.
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)
Parametri
- expected
- Object
Primo oggetto da confrontare. Si tratta dell'oggetto previsto dai test.
- actual
- Object
Secondo oggetto da confrontare. Si tratta dell'oggetto prodotto dal codice sottoposto a test.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Single, Single, Single)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Single
Primo oggetto float da confrontare. Si tratta del float previsto dai test.
- actual
- Single
Secondo oggetto float da confrontare. Questo è il float prodotto dal codice sottoposto a test.
- delta
- Single
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(String, String, Boolean)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto.
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)
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Decimal, Decimal, Decimal, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Decimal
Primo decimale da confrontare. Questo è il decimale previsto dai test.
- actual
- Decimal
Secondo decimale da confrontare. Questo è il decimale prodotto dal codice sottoposto a test.
- delta
- Decimal
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
Si applica a
AreEqual(String, String, Boolean, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto.
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)
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Double, Double, Double, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Double
Primo doppio da confrontare. Questo è il doppio dei test previsti.
- actual
- Double
Secondo double da confrontare. Questo è il doppio prodotto dal codice sottoposto a test.
- delta
- Double
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
Si applica a
AreEqual(Double, Double, Double, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori double specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Double
Primo doppio da confrontare. Questo è il doppio dei test previsti.
- actual
- Double
Secondo double da confrontare. Questo è il doppio prodotto dal codice sottoposto a test.
- delta
- Double
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Int64, Int64, Int64, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Int64
Primo lungo da confrontare. Questo è il tempo previsto dai test.
- actual
- Int64
Secondo long da confrontare. Questo è il lungo prodotto dal codice sottoposto a test.
- delta
- Int64
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
Si applica a
AreEqual(Int64, Int64, Int64, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i long specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Int64
Primo lungo da confrontare. Questo è il tempo previsto dai test.
- actual
- Int64
Secondo long da confrontare. Questo è il lungo prodotto dal codice sottoposto a test.
- delta
- Int64
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Object, Object, String, Object[])
Verifica se gli oggetti specificati sono uguali e genera un'eccezione se i due oggetti non sono uguali. I tipi numerici diversi vengono considerati diversi anche se i valori logici sono uguali. 42L non è uguale a 42.
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())
Parametri
- expected
- Object
Primo oggetto da confrontare. Si tratta dell'oggetto previsto dai test.
- actual
- Object
Secondo oggetto da confrontare. Si tratta dell'oggetto prodotto dal codice sottoposto a test.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(Single, Single, Single, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Single
Primo oggetto float da confrontare. Si tratta del float previsto dai test.
- actual
- Single
Secondo oggetto float da confrontare. Questo è il float prodotto dal codice sottoposto a test.
- delta
- Single
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
Si applica a
AreEqual(Single, Single, Single, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori float specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Single
Primo oggetto float da confrontare. Si tratta del float previsto dai test.
- actual
- Single
Secondo oggetto float da confrontare. Questo è il float prodotto dal codice sottoposto a test.
- delta
- Single
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual(String, String, Boolean, Assert+AssertNonGenericAreEqualInterpolatedStringHandler)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se le stringhe specificate sono uguali e genera un'eccezione se non sono uguali. Le impostazioni cultura invarianti vengono utilizzate per il confronto.
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)
Parametri
- expected
- String
Prima stringa da confrontare. Si tratta della stringa prevista dai test.
- actual
- String
Seconda stringa da confrontare. Questa è la stringa prodotta dal codice sottoposto a test.
- ignoreCase
- Boolean
Valore booleano che indica un confronto con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole. True indica un confronto senza distinzione tra maiuscole e minuscole.
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Si applica a
AreEqual(Decimal, Decimal, Decimal, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i decimali specificati sono uguali e genera un'eccezione se non sono uguali.
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)
Parametri
- expected
- Decimal
Primo decimale da confrontare. Questo è il decimale previsto dai test.
- actual
- Decimal
Secondo decimale da confrontare. Questo è il decimale prodotto dal codice sottoposto a test.
- delta
- Decimal
Accuratezza richiesta. Verrà generata un'eccezione solo se actual è diversa da più expected di delta.
- message
- String
Messaggio da includere nell'eccezione quando actual è diverso da più expected di delta. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(T, T, IEqualityComparer<T>, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato 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)
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- comparer
- IEqualityComparer<T>
Implementazione IEqualityComparer<T> da usare durante il confronto delle chiavi o null per l'uso dell'oggetto predefinito EqualityComparer<T>.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato 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 = "")
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- comparer
- IEqualityComparer<T>
Implementazione IEqualityComparer<T> da usare durante il confronto delle chiavi o null per l'uso dell'oggetto predefinito EqualityComparer<T>.
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Si applica a
AreEqual<T>(T, T, String, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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 = "")
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(T, T, IEqualityComparer<T>, String, Object[])
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato 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())
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- comparer
- IEqualityComparer<T>
Implementazione IEqualityComparer<T> da usare durante il confronto delle chiavi o null per l'uso dell'oggetto predefinito EqualityComparer<T>.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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 = "")
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(T, T, String, Object[])
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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())
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(T, T, IEqualityComparer<T>, String, String, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato 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 = "")
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- comparer
- IEqualityComparer<T>
Implementazione IEqualityComparer<T> da usare durante il confronto delle chiavi o null per l'uso dell'oggetto predefinito EqualityComparer<T>.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- expectedExpression
- String
Espressione sintattica di prevista come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
- actualExpression
- String
Espressione sintattica dell'effettivo come specificato dal compilatore tramite l'espressione di argomento del chiamante. Gli utenti non devono passare un valore per questo parametro.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(T, T, IEqualityComparer<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali.
L'uguaglianza viene calcolata usando il parametro specificato 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))
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- comparer
- IEqualityComparer<T>
Implementazione IEqualityComparer<T> da usare durante il confronto delle chiavi o null per l'uso dell'oggetto predefinito EqualityComparer<T>.
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Si applica a
AreEqual<T>(T, T, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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)
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(T, T, IEqualityComparer<T>)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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))
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- comparer
- IEqualityComparer<T>
Implementazione IEqualityComparer<T> da usare durante il confronto delle chiavi o null per l'uso dell'oggetto predefinito EqualityComparer<T>.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(T, T, Assert.AssertAreEqualInterpolatedStringHandler<T>)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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))
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Si applica a
AreEqual<T>(IEquatable<T>, IEquatable<T>, String)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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)
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- IEquatable<T>
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- IEquatable<T>
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(IEquatable<T>, IEquatable<T>, Assert.AssertAreEqualInterpolatedStringHandler<T>)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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))
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- IEquatable<T>
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- IEquatable<T>
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
Si applica a
AreEqual<T>(T, T)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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)
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- T
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- T
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(IEquatable<T>, IEquatable<T>)
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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))
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- IEquatable<T>
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- IEquatable<T>
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
Eccezioni
Generata se expected non è uguale a actual.
Si applica a
AreEqual<T>(IEquatable<T>, IEquatable<T>, String, Object[])
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
- Origine:
- Assert.AreEqual.cs
Verifica se i valori specificati sono uguali e genera un'eccezione se i due valori non sono uguali. L'uguaglianza viene calcolata usando l'oggetto predefinito 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())
Parametri di tipo
- T
Tipo di valori da confrontare.
Parametri
- expected
- IEquatable<T>
Primo valore da confrontare. Questo è il valore previsto dai test.
- actual
- IEquatable<T>
Secondo valore da confrontare. Questo è il valore prodotto dal codice sottoposto a test.
- message
- String
Messaggio da includere nell'eccezione quando actual non è uguale a expected. Il messaggio viene visualizzato nei risultati del test.
- parameters
- Object[]
Matrice di parametri da utilizzare per la formattazione di message.
Eccezioni
Generata se expected non è uguale a actual.