ClassicAssert
The Assert class contains a collection of static methods that
implement the most common assertions used in NUnit.
using NUnit.Framework.Constraints;
using System;
using System.Collections;
using System.ComponentModel;
using System.Runtime.CompilerServices;
namespace NUnit.Framework.Legacy
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
public abstract class ClassicAssert : Assert
{
public static void Greater(int arg1, int arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(int arg1, int arg2)
{
Assert.That(arg1, Is.GreaterThan(arg2), default(NUnitString), "arg1", "Is.GreaterThan(arg2)");
}
[CLSCompliant(false)]
public static void Greater(uint arg1, uint arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThan(arg2)");
}
[CLSCompliant(false)]
public static void Greater(uint arg1, uint arg2)
{
Assert.That(arg1, Is.GreaterThan(arg2), default(NUnitString), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(long arg1, long arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(long arg1, long arg2)
{
Assert.That(arg1, Is.GreaterThan(arg2), default(NUnitString), "arg1", "Is.GreaterThan(arg2)");
}
[CLSCompliant(false)]
public static void Greater(ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThan(arg2)");
}
[CLSCompliant(false)]
public static void Greater(ulong arg1, ulong arg2)
{
Assert.That(arg1, Is.GreaterThan(arg2), default(NUnitString), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(decimal arg1, decimal arg2)
{
Assert.That(arg1, Is.GreaterThan(arg2), default(NUnitString), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(double arg1, double arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(double arg1, double arg2)
{
Assert.That(arg1, Is.GreaterThan(arg2), default(NUnitString), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(float arg1, float arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(float arg1, float arg2)
{
Assert.That(arg1, Is.GreaterThan(arg2), default(NUnitString), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThan(arg2)");
}
public static void Greater(IComparable arg1, IComparable arg2)
{
Assert.That(arg1, Is.GreaterThan(arg2), default(NUnitString), "arg1", "Is.GreaterThan(arg2)");
}
public static void Less(int arg1, int arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThan(arg2)");
}
public static void Less(int arg1, int arg2)
{
Assert.That(arg1, Is.LessThan(arg2), default(NUnitString), "arg1", "Is.LessThan(arg2)");
}
[CLSCompliant(false)]
public static void Less(uint arg1, uint arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThan(arg2)");
}
[CLSCompliant(false)]
public static void Less(uint arg1, uint arg2)
{
Assert.That(arg1, Is.LessThan(arg2), default(NUnitString), "arg1", "Is.LessThan(arg2)");
}
public static void Less(long arg1, long arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThan(arg2)");
}
public static void Less(long arg1, long arg2)
{
Assert.That(arg1, Is.LessThan(arg2), default(NUnitString), "arg1", "Is.LessThan(arg2)");
}
[CLSCompliant(false)]
public static void Less(ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThan(arg2)");
}
[CLSCompliant(false)]
public static void Less(ulong arg1, ulong arg2)
{
Assert.That(arg1, Is.LessThan(arg2), default(NUnitString), "arg1", "Is.LessThan(arg2)");
}
public static void Less(decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThan(arg2)");
}
public static void Less(decimal arg1, decimal arg2)
{
Assert.That(arg1, Is.LessThan(arg2), default(NUnitString), "arg1", "Is.LessThan(arg2)");
}
public static void Less(double arg1, double arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThan(arg2)");
}
public static void Less(double arg1, double arg2)
{
Assert.That(arg1, Is.LessThan(arg2), default(NUnitString), "arg1", "Is.LessThan(arg2)");
}
public static void Less(float arg1, float arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThan(arg2)");
}
public static void Less(float arg1, float arg2)
{
Assert.That(arg1, Is.LessThan(arg2), default(NUnitString), "arg1", "Is.LessThan(arg2)");
}
public static void Less(IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThan(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThan(arg2)");
}
public static void Less(IComparable arg1, IComparable arg2)
{
Assert.That(arg1, Is.LessThan(arg2), default(NUnitString), "arg1", "Is.LessThan(arg2)");
}
public static void GreaterOrEqual(int arg1, int arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(int arg1, int arg2)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
[CLSCompliant(false)]
public static void GreaterOrEqual(uint arg1, uint arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
[CLSCompliant(false)]
public static void GreaterOrEqual(uint arg1, uint arg2)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(long arg1, long arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(long arg1, long arg2)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
[CLSCompliant(false)]
public static void GreaterOrEqual(ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
[CLSCompliant(false)]
public static void GreaterOrEqual(ulong arg1, ulong arg2)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(decimal arg1, decimal arg2)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(double arg1, double arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(double arg1, double arg2)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(float arg1, float arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(float arg1, float arg2)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void GreaterOrEqual(IComparable arg1, IComparable arg2)
{
Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.GreaterThanOrEqualTo(arg2)");
}
public static void LessOrEqual(int arg1, int arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(int arg1, int arg2)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
[CLSCompliant(false)]
public static void LessOrEqual(uint arg1, uint arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
[CLSCompliant(false)]
public static void LessOrEqual(uint arg1, uint arg2)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(long arg1, long arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(long arg1, long arg2)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
[CLSCompliant(false)]
public static void LessOrEqual(ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
[CLSCompliant(false)]
public static void LessOrEqual(ulong arg1, ulong arg2)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(decimal arg1, decimal arg2)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(double arg1, double arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(double arg1, double arg2)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(float arg1, float arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(float arg1, float arg2)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), () => AssertBase.ConvertMessageWithArgs(message, args), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void LessOrEqual(IComparable arg1, IComparable arg2)
{
Assert.That(arg1, Is.LessThanOrEqualTo(arg2), default(NUnitString), "arg1", "Is.LessThanOrEqualTo(arg2)");
}
public static void True(bool? condition, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(condition, Is.True, () => AssertBase.ConvertMessageWithArgs(message, args), "condition", "Is.True");
}
public static void True(bool condition, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(condition, Is.True, () => AssertBase.ConvertMessageWithArgs(message, args), "condition", "Is.True");
}
public static void True(bool? condition)
{
Assert.That(condition, Is.True, default(NUnitString), "condition", "Is.True");
}
public static void True(bool condition)
{
Assert.That(condition, Is.True, default(NUnitString), "condition", "Is.True");
}
public static void IsTrue(bool? condition, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(condition, Is.True, () => AssertBase.ConvertMessageWithArgs(message, args), "condition", "Is.True");
}
public static void IsTrue(bool condition, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(condition, Is.True, () => AssertBase.ConvertMessageWithArgs(message, args), "condition", "Is.True");
}
public static void IsTrue(bool? condition)
{
Assert.That(condition, Is.True, default(NUnitString), "condition", "Is.True");
}
public static void IsTrue(bool condition)
{
Assert.That(condition, Is.True, default(NUnitString), "condition", "Is.True");
}
public static void False(bool? condition, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(condition, Is.False, () => AssertBase.ConvertMessageWithArgs(message, args), "condition", "Is.False");
}
public static void False(bool condition, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(condition, Is.False, () => AssertBase.ConvertMessageWithArgs(message, args), "condition", "Is.False");
}
public static void False(bool? condition)
{
Assert.That(condition, Is.False, default(NUnitString), "condition", "Is.False");
}
public static void False(bool condition)
{
Assert.That(condition, Is.False, default(NUnitString), "condition", "Is.False");
}
public static void IsFalse(bool? condition, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(condition, Is.False, () => AssertBase.ConvertMessageWithArgs(message, args), "condition", "Is.False");
}
public static void IsFalse(bool condition, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(condition, Is.False, () => AssertBase.ConvertMessageWithArgs(message, args), "condition", "Is.False");
}
public static void IsFalse(bool? condition)
{
Assert.That(condition, Is.False, default(NUnitString), "condition", "Is.False");
}
public static void IsFalse(bool condition)
{
Assert.That(condition, Is.False, default(NUnitString), "condition", "Is.False");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void NotNull(object anObject, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(anObject, Is.Not.Null, () => AssertBase.ConvertMessageWithArgs(message, args), "anObject", "Is.Not.Null");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void NotNull(object anObject)
{
Assert.That(anObject, Is.Not.Null, default(NUnitString), "anObject", "Is.Not.Null");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNotNull(object anObject, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(anObject, Is.Not.Null, () => AssertBase.ConvertMessageWithArgs(message, args), "anObject", "Is.Not.Null");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNotNull(object anObject)
{
Assert.That(anObject, Is.Not.Null, default(NUnitString), "anObject", "Is.Not.Null");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void Null(object anObject, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(anObject, Is.Null, () => AssertBase.ConvertMessageWithArgs(message, args), "anObject", "Is.Null");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void Null(object anObject)
{
Assert.That(anObject, Is.Null, default(NUnitString), "anObject", "Is.Null");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNull(object anObject, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(anObject, Is.Null, () => AssertBase.ConvertMessageWithArgs(message, args), "anObject", "Is.Null");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNull(object anObject)
{
Assert.That(anObject, Is.Null, default(NUnitString), "anObject", "Is.Null");
}
public static void IsNaN(double aDouble, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(aDouble, Is.NaN, () => AssertBase.ConvertMessageWithArgs(message, args), "aDouble", "Is.NaN");
}
public static void IsNaN(double aDouble)
{
Assert.That(aDouble, Is.NaN, default(NUnitString), "aDouble", "Is.NaN");
}
public static void IsNaN(double? aDouble, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(aDouble, Is.NaN, () => AssertBase.ConvertMessageWithArgs(message, args), "aDouble", "Is.NaN");
}
public static void IsNaN(double? aDouble)
{
Assert.That(aDouble, Is.NaN, default(NUnitString), "aDouble", "Is.NaN");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsEmpty(string aString, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(aString, new EmptyStringConstraint(), () => AssertBase.ConvertMessageWithArgs(message, args), "aString", "new EmptyStringConstraint()");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsEmpty(string aString)
{
Assert.That(aString, new EmptyStringConstraint(), default(NUnitString), "aString", "new EmptyStringConstraint()");
}
public static void IsEmpty(IEnumerable collection, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(collection, new EmptyCollectionConstraint(), () => AssertBase.ConvertMessageWithArgs(message, args), "collection", "new EmptyCollectionConstraint()");
}
public static void IsEmpty(IEnumerable collection)
{
Assert.That(collection, new EmptyCollectionConstraint(), default(NUnitString), "collection", "new EmptyCollectionConstraint()");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNotEmpty(string aString, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(aString, Is.Not.Empty, () => AssertBase.ConvertMessageWithArgs(message, args), "aString", "Is.Not.Empty");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNotEmpty(string aString)
{
Assert.That(aString, Is.Not.Empty, default(NUnitString), "aString", "Is.Not.Empty");
}
public static void IsNotEmpty(IEnumerable collection, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(collection, Is.Not.Empty, () => AssertBase.ConvertMessageWithArgs(message, args), "collection", "Is.Not.Empty");
}
public static void IsNotEmpty(IEnumerable collection)
{
Assert.That(collection, Is.Not.Empty, default(NUnitString), "collection", "Is.Not.Empty");
}
public static void Zero(int actual)
{
Assert.That(actual, Is.Zero, default(NUnitString), "actual", "Is.Zero");
}
public static void Zero(int actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Zero");
}
[CLSCompliant(false)]
public static void Zero(uint actual)
{
Assert.That(actual, Is.Zero, default(NUnitString), "actual", "Is.Zero");
}
[CLSCompliant(false)]
public static void Zero(uint actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Zero");
}
public static void Zero(long actual)
{
Assert.That(actual, Is.Zero, default(NUnitString), "actual", "Is.Zero");
}
public static void Zero(long actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Zero");
}
[CLSCompliant(false)]
public static void Zero(ulong actual)
{
Assert.That(actual, Is.Zero, default(NUnitString), "actual", "Is.Zero");
}
[CLSCompliant(false)]
public static void Zero(ulong actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Zero");
}
public static void Zero(decimal actual)
{
Assert.That(actual, Is.Zero, default(NUnitString), "actual", "Is.Zero");
}
public static void Zero(decimal actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Zero");
}
public static void Zero(double actual)
{
Assert.That(actual, Is.Zero, default(NUnitString), "actual", "Is.Zero");
}
public static void Zero(double actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Zero");
}
public static void Zero(float actual)
{
Assert.That(actual, Is.Zero, default(NUnitString), "actual", "Is.Zero");
}
public static void Zero(float actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Zero");
}
public static void NotZero(int actual)
{
Assert.That(actual, Is.Not.Zero, default(NUnitString), "actual", "Is.Not.Zero");
}
public static void NotZero(int actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Not.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.Zero");
}
[CLSCompliant(false)]
public static void NotZero(uint actual)
{
Assert.That(actual, Is.Not.Zero, default(NUnitString), "actual", "Is.Not.Zero");
}
[CLSCompliant(false)]
public static void NotZero(uint actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Not.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.Zero");
}
public static void NotZero(long actual)
{
Assert.That(actual, Is.Not.Zero, default(NUnitString), "actual", "Is.Not.Zero");
}
public static void NotZero(long actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Not.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.Zero");
}
[CLSCompliant(false)]
public static void NotZero(ulong actual)
{
Assert.That(actual, Is.Not.Zero, default(NUnitString), "actual", "Is.Not.Zero");
}
[CLSCompliant(false)]
public static void NotZero(ulong actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Not.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.Zero");
}
public static void NotZero(decimal actual)
{
Assert.That(actual, Is.Not.Zero, default(NUnitString), "actual", "Is.Not.Zero");
}
public static void NotZero(decimal actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Not.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.Zero");
}
public static void NotZero(double actual)
{
Assert.That(actual, Is.Not.Zero, default(NUnitString), "actual", "Is.Not.Zero");
}
public static void NotZero(double actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Not.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.Zero");
}
public static void NotZero(float actual)
{
Assert.That(actual, Is.Not.Zero, default(NUnitString), "actual", "Is.Not.Zero");
}
public static void NotZero(float actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Not.Zero, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.Zero");
}
public static void Positive(int actual)
{
Assert.That(actual, Is.Positive, default(NUnitString), "actual", "Is.Positive");
}
public static void Positive(int actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Positive, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Positive");
}
[CLSCompliant(false)]
public static void Positive(uint actual)
{
Assert.That(actual, Is.Positive, default(NUnitString), "actual", "Is.Positive");
}
[CLSCompliant(false)]
public static void Positive(uint actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Positive, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Positive");
}
public static void Positive(long actual)
{
Assert.That(actual, Is.Positive, default(NUnitString), "actual", "Is.Positive");
}
public static void Positive(long actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Positive, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Positive");
}
[CLSCompliant(false)]
public static void Positive(ulong actual)
{
Assert.That(actual, Is.Positive, default(NUnitString), "actual", "Is.Positive");
}
[CLSCompliant(false)]
public static void Positive(ulong actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Positive, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Positive");
}
public static void Positive(decimal actual)
{
Assert.That(actual, Is.Positive, default(NUnitString), "actual", "Is.Positive");
}
public static void Positive(decimal actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Positive, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Positive");
}
public static void Positive(double actual)
{
Assert.That(actual, Is.Positive, default(NUnitString), "actual", "Is.Positive");
}
public static void Positive(double actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Positive, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Positive");
}
public static void Positive(float actual)
{
Assert.That(actual, Is.Positive, default(NUnitString), "actual", "Is.Positive");
}
public static void Positive(float actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Positive, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Positive");
}
public static void Negative(int actual)
{
Assert.That(actual, Is.Negative, default(NUnitString), "actual", "Is.Negative");
}
public static void Negative(int actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Negative, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Negative");
}
[CLSCompliant(false)]
public static void Negative(uint actual)
{
Assert.That(actual, Is.Negative, default(NUnitString), "actual", "Is.Negative");
}
[CLSCompliant(false)]
public static void Negative(uint actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Negative, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Negative");
}
public static void Negative(long actual)
{
Assert.That(actual, Is.Negative, default(NUnitString), "actual", "Is.Negative");
}
public static void Negative(long actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Negative, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Negative");
}
[CLSCompliant(false)]
public static void Negative(ulong actual)
{
Assert.That(actual, Is.Negative, default(NUnitString), "actual", "Is.Negative");
}
[CLSCompliant(false)]
public static void Negative(ulong actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Negative, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Negative");
}
public static void Negative(decimal actual)
{
Assert.That(actual, Is.Negative, default(NUnitString), "actual", "Is.Negative");
}
public static void Negative(decimal actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Negative, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Negative");
}
public static void Negative(double actual)
{
Assert.That(actual, Is.Negative, default(NUnitString), "actual", "Is.Negative");
}
public static void Negative(double actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Negative, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Negative");
}
public static void Negative(float actual)
{
Assert.That(actual, Is.Negative, default(NUnitString), "actual", "Is.Negative");
}
public static void Negative(float actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Negative, () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Negative");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void Contains(object expected, ICollection actual, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(actual, new SomeItemsConstraint(new EqualConstraint(expected)), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "new SomeItemsConstraint(new EqualConstraint(expected))");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void Contains(object expected, ICollection actual)
{
Assert.That(actual, new SomeItemsConstraint(new EqualConstraint(expected)), default(NUnitString), "actual", "new SomeItemsConstraint(new EqualConstraint(expected))");
}
[EditorBrowsable(EditorBrowsableState.Never)]
public new static bool Equals(object a, object b)
{
throw new InvalidOperationException("Assert.Equals should not be used. Use Assert.AreEqual instead.");
}
[EditorBrowsable(EditorBrowsableState.Never)]
public new static void ReferenceEquals(object a, object b)
{
throw new InvalidOperationException("Assert.ReferenceEquals should not be used. Use Assert.AreSame instead.");
}
public static void AreEqual(double expected, double actual, double delta, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
AssertDoublesAreEqual(expected, actual, delta, message, args);
}
public static void AreEqual(double expected, double actual, double delta)
{
AssertDoublesAreEqual(expected, actual, delta, string.Empty, null);
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void AreEqual(object expected, object actual, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(actual, Is.EqualTo(expected), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.EqualTo(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void AreEqual(object expected, object actual)
{
Assert.That(actual, Is.EqualTo(expected), default(NUnitString), "actual", "Is.EqualTo(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void AreNotEqual(object expected, object actual, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(actual, Is.Not.EqualTo(expected), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.EqualTo(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void AreNotEqual(object expected, object actual)
{
Assert.That(actual, Is.Not.EqualTo(expected), default(NUnitString), "actual", "Is.Not.EqualTo(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void AreSame(object expected, object actual, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(actual, Is.SameAs(expected), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.SameAs(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void AreSame(object expected, object actual)
{
Assert.That(actual, Is.SameAs(expected), default(NUnitString), "actual", "Is.SameAs(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void AreNotSame(object expected, object actual, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(actual, Is.Not.SameAs(expected), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.SameAs(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void AreNotSame(object expected, object actual)
{
Assert.That(actual, Is.Not.SameAs(expected), default(NUnitString), "actual", "Is.Not.SameAs(expected)");
}
protected static void AssertDoublesAreEqual(double expected, double actual, double delta, string message, [System.Runtime.CompilerServices.Nullable(2)] object[] args)
{
if (double.IsNaN(expected) || double.IsInfinity(expected))
Assert.That(actual, Is.EqualTo(expected), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.EqualTo(expected)");
else
Assert.That(actual, Is.EqualTo(expected).Within(delta), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.EqualTo(expected).Within(delta)");
}
public static void IsAssignableFrom(Type expected, [System.Runtime.CompilerServices.Nullable(2)] object actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.AssignableFrom(expected), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.AssignableFrom(expected)");
}
public static void IsAssignableFrom(Type expected, [System.Runtime.CompilerServices.Nullable(2)] object actual)
{
Assert.That(actual, Is.AssignableFrom(expected), default(NUnitString), "actual", "Is.AssignableFrom(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsAssignableFrom<TExpected>(object actual, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(actual, Is.AssignableFrom(typeof(TExpected)), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.AssignableFrom(typeof(TExpected))");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsAssignableFrom<TExpected>(object actual)
{
Assert.That(actual, Is.AssignableFrom(typeof(TExpected)), default(NUnitString), "actual", "Is.AssignableFrom(typeof(TExpected))");
}
public static void IsNotAssignableFrom(Type expected, [System.Runtime.CompilerServices.Nullable(2)] object actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Not.AssignableFrom(expected), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.AssignableFrom(expected)");
}
public static void IsNotAssignableFrom(Type expected, [System.Runtime.CompilerServices.Nullable(2)] object actual)
{
Assert.That(actual, Is.Not.AssignableFrom(expected), default(NUnitString), "actual", "Is.Not.AssignableFrom(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNotAssignableFrom<TExpected>(object actual, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(actual, Is.Not.AssignableFrom(typeof(TExpected)), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.AssignableFrom(typeof(TExpected))");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNotAssignableFrom<TExpected>(object actual)
{
Assert.That(actual, Is.Not.AssignableFrom(typeof(TExpected)), default(NUnitString), "actual", "Is.Not.AssignableFrom(typeof(TExpected))");
}
public static void IsInstanceOf(Type expected, [System.Runtime.CompilerServices.Nullable(2)] object actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.InstanceOf(expected), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.InstanceOf(expected)");
}
public static void IsInstanceOf(Type expected, [System.Runtime.CompilerServices.Nullable(2)] object actual)
{
Assert.That(actual, Is.InstanceOf(expected), default(NUnitString), "actual", "Is.InstanceOf(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsInstanceOf<TExpected>(object actual, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(actual, Is.InstanceOf(typeof(TExpected)), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.InstanceOf(typeof(TExpected))");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsInstanceOf<TExpected>(object actual)
{
Assert.That(actual, Is.InstanceOf(typeof(TExpected)), default(NUnitString), "actual", "Is.InstanceOf(typeof(TExpected))");
}
public static void IsNotInstanceOf(Type expected, [System.Runtime.CompilerServices.Nullable(2)] object actual, string message, [System.Runtime.CompilerServices.Nullable(2)] params object[] args)
{
Assert.That(actual, Is.Not.InstanceOf(expected), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.InstanceOf(expected)");
}
public static void IsNotInstanceOf(Type expected, [System.Runtime.CompilerServices.Nullable(2)] object actual)
{
Assert.That(actual, Is.Not.InstanceOf(expected), default(NUnitString), "actual", "Is.Not.InstanceOf(expected)");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNotInstanceOf<TExpected>(object actual, [System.Runtime.CompilerServices.Nullable(1)] string message, params object[] args)
{
Assert.That(actual, Is.Not.InstanceOf(typeof(TExpected)), () => AssertBase.ConvertMessageWithArgs(message, args), "actual", "Is.Not.InstanceOf(typeof(TExpected))");
}
[System.Runtime.CompilerServices.NullableContext(2)]
public static void IsNotInstanceOf<TExpected>(object actual)
{
Assert.That(actual, Is.Not.InstanceOf(typeof(TExpected)), default(NUnitString), "actual", "Is.Not.InstanceOf(typeof(TExpected))");
}
}
}