Assert.AreNotSequenceEqual Method

Definition

Namespace:: Microsoft.VisualStudio.TestTools.UnitTesting

Assembly:: MSTest.TestFramework.dll

Package:: MSTest.TestFramework v4.4.0

Package:: MSTest.TestFramework v4.3.0

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Overloads

Name	Description
AreNotSequenceEqual(IEnumerable, IEnumerable, String, String, String)	Tests whether two sequences differ in the same order and throws an exception if they do not.
AreNotSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)	Tests whether two sequences differ using the specified order semantics and throws an exception if they do not.
AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)	Tests whether two sequences differ in the same order using the specified comparer and throws an exception if they do not.
AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)	Tests whether two sequences differ using the specified comparer and order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)	Tests whether two spans differ using the specified order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Tests whether two spans differ using the specified comparer and order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Tests whether two memory regions differ using the specified comparer and order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Tests whether two memory regions differ using the specified comparer and order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Tests whether two sequences differ using the specified comparer and order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)	Tests whether two spans differ in the same order using the specified comparer and throws an exception if they do not.
AreNotSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)	Tests whether two spans differ using the specified order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)	Tests whether two spans differ using the specified comparer and order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)	Tests whether two spans differ in the same order using the specified comparer and throws an exception if they do not.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)	Tests whether two memory regions differ in the same order using the specified comparer and throws an exception if they do not.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)	Tests whether two sequences differ in the same order using the specified comparer and throws an exception if they do not.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)	Tests whether two memory regions differ in the same order using the specified comparer and throws an exception if they do not.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)	Tests whether two memory regions differ using the specified order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)	Tests whether two sequences differ using the specified order semantics and throws an exception if they do not.
AreNotSequenceEqual<T>(Span<T>, Span<T>, String, String, String)	Tests whether two spans differ in the same order and throws an exception if they do not.
AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, String, String, String)	Tests whether two spans differ in the same order and throws an exception if they do not.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, String, String, String)	Tests whether two memory regions differ in the same order and throws an exception if they do not.
AreNotSequenceEqual<T>(Memory<T>, Memory<T>, String, String, String)	Tests whether two memory regions differ in the same order and throws an exception if they do not.
AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)	Tests whether two sequences differ in the same order and throws an exception if they do not.
AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)	Tests whether two memory regions differ using the specified order semantics and throws an exception if they do not.

AreNotSequenceEqual(IEnumerable, IEnumerable, String, String, String)

Source:: Assert.AreNotSequenceEqual.cs

Tests whether two sequences differ in the same order and throws an exception if they do not.

public static void AreNotSequenceEqual(System.Collections.IEnumerable? notExpected, System.Collections.IEnumerable? actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual (notExpected As IEnumerable, actual As IEnumerable, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Parameters

notExpected: IEnumerable

The sequence not expected to equal actual.

actual: IEnumerable

The sequence produced by the code under test.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual(IEnumerable, IEnumerable, SequenceOrder, String, String, String)

Source:: Assert.AreNotSequenceEqual.cs

Tests whether two sequences differ using the specified order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual(System.Collections.IEnumerable? notExpected, System.Collections.IEnumerable? actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual (notExpected As IEnumerable, actual As IEnumerable, order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Parameters

notExpected: IEnumerable

The sequence not expected to equal actual.

actual: IEnumerable

The sequence produced by the code under test.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, String, String, String)

Source:: Assert.AreNotSequenceEqual.cs

Tests whether two sequences differ in the same order using the specified comparer and throws an exception if they do not.

public static void AreNotSequenceEqual(System.Collections.IEnumerable? notExpected, System.Collections.IEnumerable? actual, System.Collections.IEqualityComparer? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * System.Collections.IEqualityComparer * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual (notExpected As IEnumerable, actual As IEnumerable, comparer As IEqualityComparer, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Parameters

notExpected: IEnumerable

The sequence not expected to equal actual.

actual: IEnumerable

The sequence produced by the code under test.

comparer: IEqualityComparer

The equality comparer to use when comparing elements, or null to use the default comparer.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual(IEnumerable, IEnumerable, IEqualityComparer, SequenceOrder, String, String, String)

Source:: Assert.AreNotSequenceEqual.cs

Tests whether two sequences differ using the specified comparer and order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual(System.Collections.IEnumerable? notExpected, System.Collections.IEnumerable? actual, System.Collections.IEqualityComparer? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : System.Collections.IEnumerable * System.Collections.IEnumerable * System.Collections.IEqualityComparer * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual (notExpected As IEnumerable, actual As IEnumerable, comparer As IEqualityComparer, order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Parameters

notExpected: IEnumerable

The sequence not expected to equal actual.

actual: IEnumerable

The sequence produced by the code under test.

comparer: IEqualityComparer

The equality comparer to use when comparing elements, or null to use the default comparer.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, SequenceOrder, String, String, String)

Tests whether two spans differ using the specified order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(ReadOnlySpan<T> notExpected, ReadOnlySpan<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: ReadOnlySpan<T>

The span not expected to equal actual.

actual: ReadOnlySpan<T>

The span produced by the code under test.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Tests whether two spans differ using the specified comparer and order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(ReadOnlySpan<T> notExpected, ReadOnlySpan<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlySpan<'T> * ReadOnlySpan<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: ReadOnlySpan<T>

The span not expected to equal actual.

actual: ReadOnlySpan<T>

The span produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Tests whether two memory regions differ using the specified comparer and order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(ReadOnlyMemory<T> notExpected, ReadOnlyMemory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: ReadOnlyMemory<T>

The memory not expected to equal actual.

actual: ReadOnlyMemory<T>

The memory produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Tests whether two memory regions differ using the specified comparer and order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(Memory<T> notExpected, Memory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Memory<'T> * Memory<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Memory(Of T), actual As Memory(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: Memory<T>

The memory not expected to equal actual.

actual: Memory<T>

The memory produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Source:: Assert.AreNotSequenceEqual.cs

Tests whether two sequences differ using the specified comparer and order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? notExpected, System.Collections.Generic.IEnumerable<T>? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : seq<'T> * seq<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As IEnumerable(Of T), actual As IEnumerable(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: IEnumerable<T>

The sequence not expected to equal actual.

actual: IEnumerable<T>

The sequence produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, String, String, String)

Tests whether two spans differ in the same order using the specified comparer and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(Span<T> notExpected, Span<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Span(Of T), actual As Span(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: Span<T>

The span not expected to equal actual.

actual: Span<T>

The span produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(Span<T>, Span<T>, SequenceOrder, String, String, String)

Tests whether two spans differ using the specified order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(Span<T> notExpected, Span<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Span<'T> * Span<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Span(Of T), actual As Span(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: Span<T>

The span not expected to equal actual.

actual: Span<T>

The span produced by the code under test.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(Span<T>, Span<T>, IEqualityComparer<T>, SequenceOrder, String, String, String)

Tests whether two spans differ using the specified comparer and order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(Span<T> notExpected, Span<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Span<'T> * Span<'T> * System.Collections.Generic.IEqualityComparer<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Span(Of T), actual As Span(Of T), comparer As IEqualityComparer(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: Span<T>

The span not expected to equal actual.

actual: Span<T>

The span produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, IEqualityComparer<T>, String, String, String)

Tests whether two spans differ in the same order using the specified comparer and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(ReadOnlySpan<T> notExpected, ReadOnlySpan<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: ReadOnlySpan<T>

The span not expected to equal actual.

actual: ReadOnlySpan<T>

The span produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, IEqualityComparer<T>, String, String, String)

Tests whether two memory regions differ in the same order using the specified comparer and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(ReadOnlyMemory<T> notExpected, ReadOnlyMemory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: ReadOnlyMemory<T>

The memory not expected to equal actual.

actual: ReadOnlyMemory<T>

The memory produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>, String, String, String)

Source:: Assert.AreNotSequenceEqual.cs

Tests whether two sequences differ in the same order using the specified comparer and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? notExpected, System.Collections.Generic.IEnumerable<T>? actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As IEnumerable(Of T), actual As IEnumerable(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: IEnumerable<T>

The sequence not expected to equal actual.

actual: IEnumerable<T>

The sequence produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(Memory<T>, Memory<T>, IEqualityComparer<T>, String, String, String)

Tests whether two memory regions differ in the same order using the specified comparer and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(Memory<T> notExpected, Memory<T> actual, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string notExpectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Memory(Of T), actual As Memory(Of T), comparer As IEqualityComparer(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: Memory<T>

The memory not expected to equal actual.

actual: Memory<T>

The memory produced by the code under test.

comparer: IEqualityComparer<T>

The equality comparer to use when comparing elements, or null to use the default comparer.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(Memory<T>, Memory<T>, SequenceOrder, String, String, String)

Tests whether two memory regions differ using the specified order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(Memory<T> notExpected, Memory<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : Memory<'T> * Memory<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Memory(Of T), actual As Memory(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: Memory<T>

The memory not expected to equal actual.

actual: Memory<T>

The memory produced by the code under test.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, SequenceOrder, String, String, String)

Source:: Assert.AreNotSequenceEqual.cs

Tests whether two sequences differ using the specified order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? notExpected, System.Collections.Generic.IEnumerable<T>? actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : seq<'T> * seq<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As IEnumerable(Of T), actual As IEnumerable(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: IEnumerable<T>

The sequence not expected to equal actual.

actual: IEnumerable<T>

The sequence produced by the code under test.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

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

Tests whether two spans differ in the same order and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(Span<T> notExpected, Span<T> actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Span(Of T), actual As Span(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: Span<T>

The span not expected to equal actual.

actual: Span<T>

The span produced by the code under test.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

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

Tests whether two spans differ in the same order and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(ReadOnlySpan<T> notExpected, ReadOnlySpan<T> actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlySpan(Of T), actual As ReadOnlySpan(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: ReadOnlySpan<T>

The span not expected to equal actual.

actual: ReadOnlySpan<T>

The span produced by the code under test.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

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

Tests whether two memory regions differ in the same order and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(ReadOnlyMemory<T> notExpected, ReadOnlyMemory<T> actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: ReadOnlyMemory<T>

The memory not expected to equal actual.

actual: ReadOnlyMemory<T>

The memory produced by the code under test.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

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

Tests whether two memory regions differ in the same order and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(Memory<T> notExpected, Memory<T> actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

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

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As Memory(Of T), actual As Memory(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: Memory<T>

The memory not expected to equal actual.

actual: Memory<T>

The memory produced by the code under test.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(IEnumerable<T>, IEnumerable<T>, String, String, String)

Source:: Assert.AreNotSequenceEqual.cs

Tests whether two sequences differ in the same order and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(System.Collections.Generic.IEnumerable<T>? notExpected, System.Collections.Generic.IEnumerable<T>? actual, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : seq<'T> * seq<'T> * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As IEnumerable(Of T), actual As IEnumerable(Of T), Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: IEnumerable<T>

The sequence not expected to equal actual.

actual: IEnumerable<T>

The sequence produced by the code under test.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

AreNotSequenceEqual<T>(ReadOnlyMemory<T>, ReadOnlyMemory<T>, SequenceOrder, String, String, String)

Tests whether two memory regions differ using the specified order semantics and throws an exception if they do not.

public static void AreNotSequenceEqual<T>(ReadOnlyMemory<T> notExpected, ReadOnlyMemory<T> actual, Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder order, string? message = "", string notExpectedExpression = "", string actualExpression = "");

static member AreNotSequenceEqual : ReadOnlyMemory<'T> * ReadOnlyMemory<'T> * Microsoft.VisualStudio.TestTools.UnitTesting.SequenceOrder * string * string * string -> unit

Public Shared Sub AreNotSequenceEqual(Of T) (notExpected As ReadOnlyMemory(Of T), actual As ReadOnlyMemory(Of T), order As SequenceOrder, Optional message As String = "", Optional notExpectedExpression As String = "", Optional actualExpression As String = "")

Type Parameters

T

The type of sequence elements.

Parameters

notExpected: ReadOnlyMemory<T>

The memory not expected to equal actual.

actual: ReadOnlyMemory<T>

The memory produced by the code under test.

order: SequenceOrder

Specifies whether elements must appear in the same order or in any order.

message: String

The message to include in the exception when the sequences are equal.

notExpectedExpression: String

The syntactic expression of notExpected as given by the compiler via caller argument expression.

actualExpression: String

The syntactic expression of actual as given by the compiler via caller argument expression.

Applies to

Feedback

Was this page helpful?