niko
286 lines
9.3 KiB
C#
286 lines
9.3 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using UnityEngine.Assertions.Comparers;
|
|
|
|
namespace UnityEngine.Assertions
|
|
{
|
|
// Token: 0x02000491 RID: 1169
|
|
[DebuggerStepThrough]
|
|
public static class Assert
|
|
{
|
|
// Token: 0x06003A7C RID: 14972 RVA: 0x00066DE4 File Offset: 0x00064FE4
|
|
private static void Fail(string message, string userMessage)
|
|
{
|
|
if (Debugger.IsAttached)
|
|
{
|
|
throw new AssertionException(message, userMessage);
|
|
}
|
|
if (Assert.raiseExceptions)
|
|
{
|
|
throw new AssertionException(message, userMessage);
|
|
}
|
|
if (message == null)
|
|
{
|
|
message = "Assertion has failed\n";
|
|
}
|
|
if (userMessage != null)
|
|
{
|
|
message = userMessage + '\n' + message;
|
|
}
|
|
Debug.LogAssertion(message);
|
|
}
|
|
|
|
// Token: 0x06003A7D RID: 14973 RVA: 0x00066E40 File Offset: 0x00065040
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("Assert.Equals should not be used for Assertions", true)]
|
|
public new static bool Equals(object obj1, object obj2)
|
|
{
|
|
throw new InvalidOperationException("Assert.Equals should not be used for Assertions");
|
|
}
|
|
|
|
// Token: 0x06003A7E RID: 14974 RVA: 0x00066E50 File Offset: 0x00065050
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
[Obsolete("Assert.ReferenceEquals should not be used for Assertions", true)]
|
|
public new static bool ReferenceEquals(object obj1, object obj2)
|
|
{
|
|
throw new InvalidOperationException("Assert.ReferenceEquals should not be used for Assertions");
|
|
}
|
|
|
|
// Token: 0x06003A7F RID: 14975 RVA: 0x00066E60 File Offset: 0x00065060
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsTrue(bool condition)
|
|
{
|
|
Assert.IsTrue(condition, null);
|
|
}
|
|
|
|
// Token: 0x06003A80 RID: 14976 RVA: 0x00066E6C File Offset: 0x0006506C
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsTrue(bool condition, string message)
|
|
{
|
|
if (!condition)
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.BooleanFailureMessage(true), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A81 RID: 14977 RVA: 0x00066E84 File Offset: 0x00065084
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsFalse(bool condition)
|
|
{
|
|
Assert.IsFalse(condition, null);
|
|
}
|
|
|
|
// Token: 0x06003A82 RID: 14978 RVA: 0x00066E90 File Offset: 0x00065090
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsFalse(bool condition, string message)
|
|
{
|
|
if (condition)
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.BooleanFailureMessage(false), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A83 RID: 14979 RVA: 0x00066EA8 File Offset: 0x000650A8
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreApproximatelyEqual(float expected, float actual)
|
|
{
|
|
Assert.AreEqual<float>(expected, actual, null, FloatComparer.s_ComparerWithDefaultTolerance);
|
|
}
|
|
|
|
// Token: 0x06003A84 RID: 14980 RVA: 0x00066EB8 File Offset: 0x000650B8
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreApproximatelyEqual(float expected, float actual, string message)
|
|
{
|
|
Assert.AreEqual<float>(expected, actual, message, FloatComparer.s_ComparerWithDefaultTolerance);
|
|
}
|
|
|
|
// Token: 0x06003A85 RID: 14981 RVA: 0x00066EC8 File Offset: 0x000650C8
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreApproximatelyEqual(float expected, float actual, float tolerance)
|
|
{
|
|
Assert.AreApproximatelyEqual(expected, actual, tolerance, null);
|
|
}
|
|
|
|
// Token: 0x06003A86 RID: 14982 RVA: 0x00066ED4 File Offset: 0x000650D4
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreApproximatelyEqual(float expected, float actual, float tolerance, string message)
|
|
{
|
|
Assert.AreEqual<float>(expected, actual, message, new FloatComparer(tolerance));
|
|
}
|
|
|
|
// Token: 0x06003A87 RID: 14983 RVA: 0x00066EE8 File Offset: 0x000650E8
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreNotApproximatelyEqual(float expected, float actual)
|
|
{
|
|
Assert.AreNotEqual<float>(expected, actual, null, FloatComparer.s_ComparerWithDefaultTolerance);
|
|
}
|
|
|
|
// Token: 0x06003A88 RID: 14984 RVA: 0x00066EF8 File Offset: 0x000650F8
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreNotApproximatelyEqual(float expected, float actual, string message)
|
|
{
|
|
Assert.AreNotEqual<float>(expected, actual, message, FloatComparer.s_ComparerWithDefaultTolerance);
|
|
}
|
|
|
|
// Token: 0x06003A89 RID: 14985 RVA: 0x00066F08 File Offset: 0x00065108
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreNotApproximatelyEqual(float expected, float actual, float tolerance)
|
|
{
|
|
Assert.AreNotApproximatelyEqual(expected, actual, tolerance, null);
|
|
}
|
|
|
|
// Token: 0x06003A8A RID: 14986 RVA: 0x00066F14 File Offset: 0x00065114
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreNotApproximatelyEqual(float expected, float actual, float tolerance, string message)
|
|
{
|
|
Assert.AreNotEqual<float>(expected, actual, message, new FloatComparer(tolerance));
|
|
}
|
|
|
|
// Token: 0x06003A8B RID: 14987 RVA: 0x00066F28 File Offset: 0x00065128
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreEqual<T>(T expected, T actual)
|
|
{
|
|
Assert.AreEqual<T>(expected, actual, null);
|
|
}
|
|
|
|
// Token: 0x06003A8C RID: 14988 RVA: 0x00066F34 File Offset: 0x00065134
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreEqual<T>(T expected, T actual, string message)
|
|
{
|
|
Assert.AreEqual<T>(expected, actual, message, EqualityComparer<T>.Default);
|
|
}
|
|
|
|
// Token: 0x06003A8D RID: 14989 RVA: 0x00066F44 File Offset: 0x00065144
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreEqual<T>(T expected, T actual, string message, IEqualityComparer<T> comparer)
|
|
{
|
|
if (typeof(Object).IsAssignableFrom(typeof(T)))
|
|
{
|
|
Assert.AreEqual(expected as Object, actual as Object, message);
|
|
}
|
|
else if (!comparer.Equals(actual, expected))
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.GetEqualityMessage(actual, expected, true), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A8E RID: 14990 RVA: 0x00066FB8 File Offset: 0x000651B8
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreEqual(Object expected, Object actual, string message)
|
|
{
|
|
if (actual != expected)
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.GetEqualityMessage(actual, expected, true), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A8F RID: 14991 RVA: 0x00066FD8 File Offset: 0x000651D8
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreNotEqual<T>(T expected, T actual)
|
|
{
|
|
Assert.AreNotEqual<T>(expected, actual, null);
|
|
}
|
|
|
|
// Token: 0x06003A90 RID: 14992 RVA: 0x00066FE4 File Offset: 0x000651E4
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreNotEqual<T>(T expected, T actual, string message)
|
|
{
|
|
Assert.AreNotEqual<T>(expected, actual, message, EqualityComparer<T>.Default);
|
|
}
|
|
|
|
// Token: 0x06003A91 RID: 14993 RVA: 0x00066FF4 File Offset: 0x000651F4
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreNotEqual<T>(T expected, T actual, string message, IEqualityComparer<T> comparer)
|
|
{
|
|
if (typeof(Object).IsAssignableFrom(typeof(T)))
|
|
{
|
|
Assert.AreNotEqual(expected as Object, actual as Object, message);
|
|
}
|
|
else if (comparer.Equals(actual, expected))
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.GetEqualityMessage(actual, expected, false), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A92 RID: 14994 RVA: 0x00067068 File Offset: 0x00065268
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void AreNotEqual(Object expected, Object actual, string message)
|
|
{
|
|
if (actual == expected)
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.GetEqualityMessage(actual, expected, false), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A93 RID: 14995 RVA: 0x00067088 File Offset: 0x00065288
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsNull<T>(T value) where T : class
|
|
{
|
|
Assert.IsNull<T>(value, null);
|
|
}
|
|
|
|
// Token: 0x06003A94 RID: 14996 RVA: 0x00067094 File Offset: 0x00065294
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsNull<T>(T value, string message) where T : class
|
|
{
|
|
if (typeof(Object).IsAssignableFrom(typeof(T)))
|
|
{
|
|
Assert.IsNull(value as Object, message);
|
|
}
|
|
else if (value != null)
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.NullFailureMessage(value, true), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A95 RID: 14997 RVA: 0x000670F8 File Offset: 0x000652F8
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsNull(Object value, string message)
|
|
{
|
|
if (value != null)
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.NullFailureMessage(value, true), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A96 RID: 14998 RVA: 0x00067114 File Offset: 0x00065314
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsNotNull<T>(T value) where T : class
|
|
{
|
|
Assert.IsNotNull<T>(value, null);
|
|
}
|
|
|
|
// Token: 0x06003A97 RID: 14999 RVA: 0x00067120 File Offset: 0x00065320
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsNotNull<T>(T value, string message) where T : class
|
|
{
|
|
if (typeof(Object).IsAssignableFrom(typeof(T)))
|
|
{
|
|
Assert.IsNotNull(value as Object, message);
|
|
}
|
|
else if (value == null)
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.NullFailureMessage(value, false), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06003A98 RID: 15000 RVA: 0x00067184 File Offset: 0x00065384
|
|
[Conditional("UNITY_ASSERTIONS")]
|
|
public static void IsNotNull(Object value, string message)
|
|
{
|
|
if (value == null)
|
|
{
|
|
Assert.Fail(AssertionMessageUtil.NullFailureMessage(value, false), message);
|
|
}
|
|
}
|
|
|
|
// Token: 0x040011B0 RID: 4528
|
|
internal const string UNITY_ASSERTIONS = "UNITY_ASSERTIONS";
|
|
|
|
// Token: 0x040011B1 RID: 4529
|
|
public static bool raiseExceptions;
|
|
}
|
|
}
|