Assert.AreEqual Method

Definition

Namespace:

Microsoft.VisualStudio.TestTools.UnitTesting

Assembly:

Microsoft.VisualStudio.TestPlatform.TestFramework.dll

Package:

MSTest.TestFramework v3.7.0

Overloads

AreEqual(String, String, Boolean, CultureInfo, String, Object[])	Tests whether the specified strings are equal and throws an exception if they are not equal.
AreEqual(String, String, Boolean, String, Object[])	Tests whether the specified strings are equal and throws an exception if they are not equal. The invariant culture is used for the comparison.
AreEqual(String, String, Boolean, CultureInfo, String)	Tests whether the specified strings are equal and throws an exception if they are not equal.
AreEqual(Single, Single, Single, String, Object[])	Tests whether the specified floats are equal and throws an exception if they are not equal.
AreEqual(Int64, Int64, Int64, String, Object[])	Tests whether the specified longs are equal and throws an exception if they are not equal.
AreEqual(Double, Double, Double, String, Object[])	Tests whether the specified doubles are equal and throws an exception if they are not equal.
AreEqual(Decimal, Decimal, Decimal, String, Object[])	Tests whether the specified decimals are equal and throws an exception if they are not equal.
AreEqual(String, String, Boolean, String)	Tests whether the specified strings are equal and throws an exception if they are not equal. The invariant culture is used for the comparison.
AreEqual(String, String, Boolean, CultureInfo)	Tests whether the specified strings are equal and throws an exception if they are not equal.
AreEqual(Single, Single, Single, String)	Tests whether the specified floats are equal and throws an exception if they are not equal.
AreEqual(Double, Double, Double, String)	Tests whether the specified doubles are equal and throws an exception if they are not equal.
AreEqual(Decimal, Decimal, Decimal, String)	Tests whether the specified decimals are equal and throws an exception if they are not equal.
AreEqual(String, String, Boolean)	Tests whether the specified strings are equal and throws an exception if they are not equal. The invariant culture is used for the comparison.
AreEqual(Single, Single, Single)	Tests whether the specified floats are equal and throws an exception if they are not equal.
AreEqual(Int64, Int64, Int64)	Tests whether the specified longs are equal and throws an exception if they are not equal.
AreEqual(Double, Double, Double)	Tests whether the specified doubles are equal and throws an exception if they are not equal.
AreEqual(Decimal, Decimal, Decimal)	Tests whether the specified decimals are equal and throws an exception if they are not equal.
AreEqual(Int64, Int64, Int64, String)	Tests whether the specified longs are equal and throws an exception if they are not equal.
AreEqual<T>(IEquatable<T>, IEquatable<T>, String, Object[])	Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.
AreEqual<T>(T, T, IEqualityComparer<T>, String, Object[])	Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the provided comparer parameter.
AreEqual<T>(T, T, IEqualityComparer<T>, String)	Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the provided comparer parameter.
AreEqual<T>(T, T, String)	Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.
AreEqual<T>(T, T, String, Object[])	Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.
AreEqual<T>(IEquatable<T>, IEquatable<T>, String)	Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.
AreEqual<T>(T, T)	Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.
AreEqual<T>(IEquatable<T>, IEquatable<T>)	Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.
AreEqual<T>(T, T, IEqualityComparer<T>)	Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.

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

Source:

Assert.AreEqual.cs

Tests whether the specified strings are equal and throws an exception if they are not equal.

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())

Parameters

expected

String

The first string to compare. This is the string the tests expects.

actual

String

The second string to compare. This is the string produced by the code under test.

ignoreCase

Boolean

A Boolean indicating a case-sensitive or insensitive comparison. (true indicates a case-insensitive comparison.)

culture

CultureInfo

A CultureInfo object that supplies culture-specific comparison information. If culture is null, the current culture is used.

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

parameters

Object[]

An array of parameters to use when formatting message.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified strings are equal and throws an exception if they are not equal. The invariant culture is used for the comparison.

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())

Parameters

expected

String

The first string to compare. This is the string the tests expects.

actual

String

The second string to compare. This is the string produced by the code under test.

ignoreCase

Boolean

A Boolean indicating a case-sensitive or insensitive comparison. (true indicates a case-insensitive comparison.)

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

parameters

Object[]

An array of parameters to use when formatting message.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified strings are equal and throws an exception if they are not equal.

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)

Parameters

expected

String

The first string to compare. This is the string the tests expects.

actual

String

The second string to compare. This is the string produced by the code under test.

ignoreCase

Boolean

A Boolean indicating a case-sensitive or insensitive comparison. (true indicates a case-insensitive comparison.)

culture

CultureInfo

A CultureInfo object that supplies culture-specific comparison information. If culture is null, the current culture is used.

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified floats are equal and throws an exception if they are not equal.

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())

Parameters

expected

Single

The first float to compare. This is the float the tests expects.

actual

Single

The second float to compare. This is the float produced by the code under test.

delta

Single

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

message

String

The message to include in the exception when actual is different than expected by more than delta. The message is shown in test results.

parameters

Object[]

An array of parameters to use when formatting message.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified longs are equal and throws an exception if they are not equal.

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())

Parameters

expected

Int64

The first long to compare. This is the long the tests expects.

actual

Int64

The second long to compare. This is the long produced by the code under test.

delta

Int64

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

message

String

The message to include in the exception when actual is different than expected by more than delta. The message is shown in test results.

parameters

Object[]

An array of parameters to use when formatting message.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified doubles are equal and throws an exception if they are not equal.

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())

Parameters

expected

Double

The first double to compare. This is the double the tests expects.

actual

Double

The second double to compare. This is the double produced by the code under test.

delta

Double

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

message

String

The message to include in the exception when actual is different than expected by more than delta. The message is shown in test results.

parameters

Object[]

An array of parameters to use when formatting message.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified decimals are equal and throws an exception if they are not equal.

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())

Parameters

expected

Decimal

The first decimal to compare. This is the decimal the tests expects.

actual

Decimal

The second decimal to compare. This is the decimal produced by the code under test.

delta

Decimal

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

message

String

The message to include in the exception when actual is different than expected by more than delta. The message is shown in test results.

parameters

Object[]

An array of parameters to use when formatting message.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(String, String, Boolean, String)

Source:

Assert.AreEqual.cs

Tests whether the specified strings are equal and throws an exception if they are not equal. The invariant culture is used for the comparison.

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)

Parameters

expected

String

The first string to compare. This is the string the tests expects.

actual

String

The second string to compare. This is the string produced by the code under test.

ignoreCase

Boolean

A Boolean indicating a case-sensitive or insensitive comparison. (true indicates a case-insensitive comparison.)

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(String, String, Boolean, CultureInfo)

Source:

Assert.AreEqual.cs

Tests whether the specified strings are equal and throws an exception if they are not equal.

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)

Parameters

expected

String

The first string to compare. This is the string the tests expects.

actual

String

The second string to compare. This is the string produced by the code under test.

ignoreCase

Boolean

A Boolean indicating a case-sensitive or insensitive comparison. (true indicates a case-insensitive comparison.)

culture

CultureInfo

A CultureInfo object that supplies culture-specific comparison information. If culture is null, the current culture is used.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(Single, Single, Single, String)

Source:

Assert.AreEqual.cs

Tests whether the specified floats are equal and throws an exception if they are not equal.

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)

Parameters

expected

Single

The first float to compare. This is the float the tests expects.

actual

Single

The second float to compare. This is the float produced by the code under test.

delta

Single

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

message

String

The message to include in the exception when actual is different than expected by more than delta. The message is shown in test results.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(Double, Double, Double, String)

Source:

Assert.AreEqual.cs

Tests whether the specified doubles are equal and throws an exception if they are not equal.

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)

Parameters

expected

Double

The first double to compare. This is the double the tests expects.

actual

Double

The second double to compare. This is the double produced by the code under test.

delta

Double

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

message

String

The message to include in the exception when actual is different than expected by more than delta. The message is shown in test results.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(Decimal, Decimal, Decimal, String)

Source:

Assert.AreEqual.cs

Tests whether the specified decimals are equal and throws an exception if they are not equal.

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)

Parameters

expected

Decimal

The first decimal to compare. This is the decimal the tests expects.

actual

Decimal

The second decimal to compare. This is the decimal produced by the code under test.

delta

Decimal

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

message

String

The message to include in the exception when actual is different than expected by more than delta. The message is shown in test results.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(String, String, Boolean)

Source:

Assert.AreEqual.cs

Tests whether the specified strings are equal and throws an exception if they are not equal. The invariant culture is used for the comparison.

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)

Parameters

expected

String

The first string to compare. This is the string the tests expects.

actual

String

The second string to compare. This is the string produced by the code under test.

ignoreCase

Boolean

A Boolean indicating a case-sensitive or insensitive comparison. (true indicates a case-insensitive comparison.)

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(Single, Single, Single)

Source:

Assert.AreEqual.cs

Tests whether the specified floats are equal and throws an exception if they are not equal.

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)

Parameters

expected

Single

The first float to compare. This is the float the tests expects.

actual

Single

The second float to compare. This is the float produced by the code under test.

delta

Single

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(Int64, Int64, Int64)

Source:

Assert.AreEqual.cs

Tests whether the specified longs are equal and throws an exception if they are not equal.

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)

Parameters

expected

Int64

The first long to compare. This is the long the tests expects.

actual

Int64

The second long to compare. This is the long produced by the code under test.

delta

Int64

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(Double, Double, Double)

Source:

Assert.AreEqual.cs

Tests whether the specified doubles are equal and throws an exception if they are not equal.

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)

Parameters

expected

Double

The first double to compare. This is the double the tests expects.

actual

Double

The second double to compare. This is the double produced by the code under test.

delta

Double

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(Decimal, Decimal, Decimal)

Source:

Assert.AreEqual.cs

Tests whether the specified decimals are equal and throws an exception if they are not equal.

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)

Parameters

expected

Decimal

The first decimal to compare. This is the decimal the tests expects.

actual

Decimal

The second decimal to compare. This is the decimal produced by the code under test.

delta

Decimal

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual(Int64, Int64, Int64, String)

Source:

Assert.AreEqual.cs

Tests whether the specified longs are equal and throws an exception if they are not equal.

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)

Parameters

expected

Int64

The first long to compare. This is the long the tests expects.

actual

Int64

The second long to compare. This is the long produced by the code under test.

delta

Int64

The required accuracy. An exception will be thrown only if actual is different than expected by more than delta.

message

String

The message to include in the exception when actual is different than expected by more than delta. The message is shown in test results.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default 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())

Type Parameters

T

The type of values to compare.

Parameters

expected

IEquatable<T>

The first value to compare. This is the value the tests expects.

actual

IEquatable<T>

The second value to compare. This is the value produced by the code under test.

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

parameters

Object[]

An array of parameters to use when formatting message.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the provided comparer parameter.

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())

Type Parameters

T

The type of values to compare.

Parameters

expected

T

The first value to compare. This is the value the tests expects.

actual

T

The second value to compare. This is the value produced by the code under test.

comparer

IEqualityComparer<T>

The IEqualityComparer<T> implementation to use when comparing keys, or null to use the default EqualityComparer<T>.

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

parameters

Object[]

An array of parameters to use when formatting message.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the provided comparer parameter.

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)

Type Parameters

T

The type of values to compare.

Parameters

expected

T

The first value to compare. This is the value the tests expects.

actual

T

The second value to compare. This is the value produced by the code under test.

comparer

IEqualityComparer<T>

The IEqualityComparer<T> implementation to use when comparing keys, or null to use the default EqualityComparer<T>.

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual<T>(T, T, String)

Source:

Assert.AreEqual.cs

Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.

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)

Type Parameters

T

The type of values to compare.

Parameters

expected

T

The first value to compare. This is the value the tests expects.

actual

T

The second value to compare. This is the value produced by the code under test.

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.

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())

Type Parameters

T

The type of values to compare.

Parameters

expected

T

The first value to compare. This is the value the tests expects.

actual

T

The second value to compare. This is the value produced by the code under test.

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

parameters

Object[]

An array of parameters to use when formatting message.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default 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)

Type Parameters

T

The type of values to compare.

Parameters

expected

IEquatable<T>

The first value to compare. This is the value the tests expects.

actual

IEquatable<T>

The second value to compare. This is the value produced by the code under test.

message

String

The message to include in the exception when actual is not equal to expected. The message is shown in test results.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

AreEqual<T>(T, T)

Source:

Assert.AreEqual.cs

Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default EqualityComparer<T>.

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)

Type Parameters

T

The type of values to compare.

Parameters

expected

T

The first value to compare. This is the value the tests expects.

actual

T

The second value to compare. This is the value produced by the code under test.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default 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))

Type Parameters

T

The type of values to compare.

Parameters

expected

IEquatable<T>

The first value to compare. This is the value the tests expects.

actual

IEquatable<T>

The second value to compare. This is the value produced by the code under test.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.

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

Source:

Assert.AreEqual.cs

Tests whether the specified values are equal and throws an exception if the two values are not equal. The equality is computed using the default 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))

Type Parameters

T

The type of values to compare.

Parameters

expected

T

The first value to compare. This is the value the tests expects.

actual

T

The second value to compare. This is the value produced by the code under test.

comparer

IEqualityComparer<T>

The IEqualityComparer<T> implementation to use when comparing keys, or null to use the default EqualityComparer<T>.

Exceptions

AssertFailedException

Thrown if expected is not equal to actual.