语言

Assert.AreNotSequenceEqual 方法

定义

重载

名称 说明
AreNotSequenceEqual(IEnumerable, IEnumerable, String, String, String)

测试两个序列是否以相同顺序不同,如果两个序列不同,则引发异常。

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

测试两个序列是否使用指定的顺序语义不同,如果未指定序列,则会引发异常。

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

使用指定的比较器测试两个序列是否以相同顺序不同,如果两个序列不同,则引发异常。

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

测试两个序列是否使用指定的比较器和顺序语义不同,如果两个序列不同,则引发异常。

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

测试两个跨度是否使用指定的顺序语义不同,如果未指定顺序语义,则会引发异常。

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

测试两个范围是否使用指定的比较器和顺序语义不同,如果两个范围不相同,则引发异常。

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

测试两个内存区域是否使用指定的比较器和顺序语义而有所不同,如果两个内存区域不相同,则引发异常。

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

测试两个内存区域是否使用指定的比较器和顺序语义而有所不同,如果两个内存区域不相同,则引发异常。

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

测试两个序列是否使用指定的比较器和顺序语义不同,如果两个序列不同,则引发异常。

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

使用指定的比较器测试两个跨度是否以相同顺序不同,如果两个范围不同,则引发异常。

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

测试两个跨度是否使用指定的顺序语义不同,如果未指定顺序语义,则会引发异常。

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

测试两个范围是否使用指定的比较器和顺序语义不同,如果两个范围不相同,则引发异常。

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

使用指定的比较器测试两个跨度是否以相同顺序不同,如果两个范围不同,则引发异常。

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

使用指定的比较器测试两个内存区域是否以相同的顺序不同,如果两个内存区域不同,则引发异常。

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

使用指定的比较器测试两个序列是否以相同顺序不同,如果两个序列不同,则引发异常。

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

使用指定的比较器测试两个内存区域是否以相同的顺序不同,如果两个内存区域不同,则引发异常。

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

测试两个内存区域是否使用指定的顺序语义不同,如果未指定,则引发异常。

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

测试两个序列是否使用指定的顺序语义不同,如果未指定序列,则会引发异常。

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

测试两个跨度是否按相同顺序不同,如果两个范围不同,则引发异常。

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

测试两个跨度是否按相同顺序不同,如果两个范围不同,则引发异常。

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

测试两个内存区域的顺序是否相同,如果没有,则会引发异常。

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

测试两个内存区域的顺序是否相同,如果没有,则会引发异常。

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

测试两个序列是否以相同顺序不同,如果两个序列不同,则引发异常。

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

测试两个内存区域是否使用指定的顺序语义不同,如果未指定,则引发异常。

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

Source:
Assert.AreNotSequenceEqual.cs

测试两个序列是否以相同顺序不同,如果两个序列不同,则引发异常。

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

参数

notExpected
IEnumerable

序列不应等于 actual。

actual
IEnumerable

由所测试的代码生成的序列。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

Source:
Assert.AreNotSequenceEqual.cs

测试两个序列是否使用指定的顺序语义不同,如果未指定序列,则会引发异常。

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

参数

notExpected
IEnumerable

序列不应等于 actual。

actual
IEnumerable

由所测试的代码生成的序列。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

Source:
Assert.AreNotSequenceEqual.cs

使用指定的比较器测试两个序列是否以相同顺序不同,如果两个序列不同,则引发异常。

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

参数

notExpected
IEnumerable

序列不应等于 actual。

actual
IEnumerable

由所测试的代码生成的序列。

comparer
IEqualityComparer

比较元素时要使用的相等比较器,或使用 null 默认比较器。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

Source:
Assert.AreNotSequenceEqual.cs

测试两个序列是否使用指定的比较器和顺序语义不同,如果两个序列不同,则引发异常。

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

参数

notExpected
IEnumerable

序列不应等于 actual。

actual
IEnumerable

由所测试的代码生成的序列。

comparer
IEqualityComparer

比较元素时要使用的相等比较器,或使用 null 默认比较器。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个跨度是否使用指定的顺序语义不同,如果未指定顺序语义,则会引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
ReadOnlySpan<T>

范围不应相等 actual。

actual
ReadOnlySpan<T>

由所测试的代码生成的范围。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个范围是否使用指定的比较器和顺序语义不同,如果两个范围不相同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
ReadOnlySpan<T>

范围不应相等 actual。

actual
ReadOnlySpan<T>

由所测试的代码生成的范围。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个内存区域是否使用指定的比较器和顺序语义而有所不同,如果两个内存区域不相同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
ReadOnlyMemory<T>

内存不应等于 actual。

actual
ReadOnlyMemory<T>

受测代码生成的内存。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个内存区域是否使用指定的比较器和顺序语义而有所不同,如果两个内存区域不相同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
Memory<T>

内存不应等于 actual。

actual
Memory<T>

受测代码生成的内存。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

Source:
Assert.AreNotSequenceEqual.cs

测试两个序列是否使用指定的比较器和顺序语义不同,如果两个序列不同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
IEnumerable<T>

序列不应等于 actual。

actual
IEnumerable<T>

由所测试的代码生成的序列。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

使用指定的比较器测试两个跨度是否以相同顺序不同,如果两个范围不同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
Span<T>

范围不应相等 actual。

actual
Span<T>

由所测试的代码生成的范围。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个跨度是否使用指定的顺序语义不同,如果未指定顺序语义,则会引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
Span<T>

范围不应相等 actual。

actual
Span<T>

由所测试的代码生成的范围。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个范围是否使用指定的比较器和顺序语义不同,如果两个范围不相同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
Span<T>

范围不应相等 actual。

actual
Span<T>

由所测试的代码生成的范围。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

使用指定的比较器测试两个跨度是否以相同顺序不同,如果两个范围不同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
ReadOnlySpan<T>

范围不应相等 actual。

actual
ReadOnlySpan<T>

由所测试的代码生成的范围。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

使用指定的比较器测试两个内存区域是否以相同的顺序不同,如果两个内存区域不同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
ReadOnlyMemory<T>

内存不应等于 actual。

actual
ReadOnlyMemory<T>

受测代码生成的内存。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

Source:
Assert.AreNotSequenceEqual.cs

使用指定的比较器测试两个序列是否以相同顺序不同,如果两个序列不同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
IEnumerable<T>

序列不应等于 actual。

actual
IEnumerable<T>

由所测试的代码生成的序列。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

使用指定的比较器测试两个内存区域是否以相同的顺序不同,如果两个内存区域不同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
Memory<T>

内存不应等于 actual。

actual
Memory<T>

受测代码生成的内存。

comparer
IEqualityComparer<T>

比较元素时要使用的相等比较器,或使用 null 默认比较器。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个内存区域是否使用指定的顺序语义不同,如果未指定,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
Memory<T>

内存不应等于 actual。

actual
Memory<T>

受测代码生成的内存。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

Source:
Assert.AreNotSequenceEqual.cs

测试两个序列是否使用指定的顺序语义不同,如果未指定序列,则会引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
IEnumerable<T>

序列不应等于 actual。

actual
IEnumerable<T>

由所测试的代码生成的序列。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个跨度是否按相同顺序不同,如果两个范围不同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
Span<T>

范围不应相等 actual。

actual
Span<T>

由所测试的代码生成的范围。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个跨度是否按相同顺序不同,如果两个范围不同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
ReadOnlySpan<T>

范围不应相等 actual。

actual
ReadOnlySpan<T>

由所测试的代码生成的范围。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个内存区域的顺序是否相同,如果没有,则会引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
ReadOnlyMemory<T>

内存不应等于 actual。

actual
ReadOnlyMemory<T>

受测代码生成的内存。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个内存区域的顺序是否相同,如果没有,则会引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
Memory<T>

内存不应等于 actual。

actual
Memory<T>

受测代码生成的内存。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

Source:
Assert.AreNotSequenceEqual.cs

测试两个序列是否以相同顺序不同,如果两个序列不同,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
IEnumerable<T>

序列不应等于 actual。

actual
IEnumerable<T>

由所测试的代码生成的序列。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于

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

测试两个内存区域是否使用指定的顺序语义不同,如果未指定,则引发异常。

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

类型参数

T

序列元素的类型。

参数

notExpected
ReadOnlyMemory<T>

内存不应等于 actual。

actual
ReadOnlyMemory<T>

受测代码生成的内存。

order
SequenceOrder

指定元素是必须按相同顺序显示还是按任意顺序显示。

message
String

序列相等时要包含在异常中的消息。

notExpectedExpression
String

由编译器通过调用方参数表达式给出的 notExpectic 表达式的语法表达式。

actualExpression
String

编译器通过调用方参数表达式给出的实际语法表达式。

适用于