# AreEqual

> Assert that the values are equal.

## Definition

* **Type:** Method
* **Namespace:** [UnityEngine.Assertions](/engine/6000.7/script-reference/unityengine/assertions.md)
* **Assembly:** UnityEngine.CoreModule

## AreEqual\<T>(T, T)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual<T>(T expected, T actual)
```

### Parameters

**** (T): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (T): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual\<T>(T, T, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual<T>(T expected, T actual, string message)
```

### Parameters

**** (T): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (T): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual\<T>(T, T, string, IEqualityComparer\<T>)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual<T>(T expected, T actual, string message, IEqualityComparer<T> comparer)
```

### Parameters

**** (T): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (T): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).**** (\[IEqualityComparer\<T>]\(https\://learn.microsoft.com/dotnet/api/system.collections.generic.iequalitycomparer)): Method to compare `expected` and `actual` arguments have the same value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(Object, Object, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(Object expected, Object actual, string message)
```

### Parameters

**** (\[Object]\(/engine/6000.7/script-reference/unityengine/object)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[Object]\(/engine/6000.7/script-reference/unityengine/object)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(sbyte, sbyte)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(sbyte expected, sbyte actual)
```

### Parameters

**** (\[sbyte]\(https\://learn.microsoft.com/dotnet/api/system.sbyte)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[sbyte]\(https\://learn.microsoft.com/dotnet/api/system.sbyte)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(sbyte, sbyte, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(sbyte expected, sbyte actual, string message)
```

### Parameters

**** (\[sbyte]\(https\://learn.microsoft.com/dotnet/api/system.sbyte)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[sbyte]\(https\://learn.microsoft.com/dotnet/api/system.sbyte)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(byte, byte)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(byte expected, byte actual)
```

### Parameters

**** (\[byte]\(https\://learn.microsoft.com/dotnet/api/system.byte)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[byte]\(https\://learn.microsoft.com/dotnet/api/system.byte)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(byte, byte, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(byte expected, byte actual, string message)
```

### Parameters

**** (\[byte]\(https\://learn.microsoft.com/dotnet/api/system.byte)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[byte]\(https\://learn.microsoft.com/dotnet/api/system.byte)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(char, char)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(char expected, char actual)
```

### Parameters

**** (\[char]\(https\://learn.microsoft.com/dotnet/api/system.char)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[char]\(https\://learn.microsoft.com/dotnet/api/system.char)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(char, char, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(char expected, char actual, string message)
```

### Parameters

**** (\[char]\(https\://learn.microsoft.com/dotnet/api/system.char)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[char]\(https\://learn.microsoft.com/dotnet/api/system.char)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(short, short)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(short expected, short actual)
```

### Parameters

**** (\[short]\(https\://learn.microsoft.com/dotnet/api/system.int16)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[short]\(https\://learn.microsoft.com/dotnet/api/system.int16)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(short, short, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(short expected, short actual, string message)
```

### Parameters

**** (\[short]\(https\://learn.microsoft.com/dotnet/api/system.int16)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[short]\(https\://learn.microsoft.com/dotnet/api/system.int16)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(ushort, ushort)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(ushort expected, ushort actual)
```

### Parameters

**** (\[ushort]\(https\://learn.microsoft.com/dotnet/api/system.uint16)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[ushort]\(https\://learn.microsoft.com/dotnet/api/system.uint16)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(ushort, ushort, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(ushort expected, ushort actual, string message)
```

### Parameters

**** (\[ushort]\(https\://learn.microsoft.com/dotnet/api/system.uint16)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[ushort]\(https\://learn.microsoft.com/dotnet/api/system.uint16)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(int, int)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(int expected, int actual)
```

### Parameters

**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(int, int, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(int expected, int actual, string message)
```

### Parameters

**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(uint, uint)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(uint expected, uint actual)
```

### Parameters

**** (\[uint]\(https\://learn.microsoft.com/dotnet/api/system.uint32)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[uint]\(https\://learn.microsoft.com/dotnet/api/system.uint32)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(uint, uint, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(uint expected, uint actual, string message)
```

### Parameters

**** (\[uint]\(https\://learn.microsoft.com/dotnet/api/system.uint32)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[uint]\(https\://learn.microsoft.com/dotnet/api/system.uint32)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(long, long)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(long expected, long actual)
```

### Parameters

**** (\[long]\(https\://learn.microsoft.com/dotnet/api/system.int64)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[long]\(https\://learn.microsoft.com/dotnet/api/system.int64)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(long, long, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(long expected, long actual, string message)
```

### Parameters

**** (\[long]\(https\://learn.microsoft.com/dotnet/api/system.int64)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[long]\(https\://learn.microsoft.com/dotnet/api/system.int64)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(ulong, ulong)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(ulong expected, ulong actual)
```

### Parameters

**** (\[ulong]\(https\://learn.microsoft.com/dotnet/api/system.uint64)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[ulong]\(https\://learn.microsoft.com/dotnet/api/system.uint64)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```

## AreEqual(ulong, ulong, string)

Assert that the values are equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreEqual(ulong expected, ulong actual, string message)
```

### Parameters

**** (\[ulong]\(https\://learn.microsoft.com/dotnet/api/system.uint64)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[ulong]\(https\://learn.microsoft.com/dotnet/api/system.uint64)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

Show message when the `expected` and `actual` are not equal. If no comparer is specified, `EqualityComparer<T>.Default` is used.

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object is always tagged as "Player"
        Assert.AreEqual("Player", gameObject.tag);
    }
}
```

Another example:

```csharp
using UnityEngine;
using UnityEngine.Assertions;

// Assert.AreEqual and Assert.AreNotEqual example
//
// Compare 32 to 32. AreNotEqual prints message.
// Compare 32 to 33. AreEqual prints message.

public class Example : MonoBehaviour
{
    void Start()
    {
        int expectedInt = 32;
        int actualInt = 32;

        // Do not show message (32 is equal to 32).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Show message (32 is equal to 32).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);

        actualInt = 33;

        // Show message (32 is not equal to 33).
        Assert.AreEqual(expectedInt, actualInt, "AreEqual: " + expectedInt + " equals " + actualInt);

        // Do not show message (32 is not equal to 33).
        Assert.AreNotEqual(expectedInt, actualInt, "AreNotEqual: " + expectedInt + " not equal to " + actualInt);
    }
}
```

And another example:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Assertions;

// Assertion.Assert.AreEqual example
//
// Compare Vector2Int Assert using IEqualityComparer.

public class Example : MonoBehaviour
{
    // Implement the EqualityComparer class.
    class EqualityComparer : IEqualityComparer<Vector2Int>
    {
        // Compare two Vector2Int structures.
        // These represent the expected and actual values.
        public bool Equals(Vector2Int v1, Vector2Int v2)
        {
            if ((v1.x == v2.x) && (v1.y == v2.y))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHashCode(Vector2Int v)
        {
            int vCode = v.x ^ v.y;
            return vCode.GetHashCode();
        }
    }

    void Start()
    {
        // Creates three Vector2Int structures. v1 and v3 have equal values.
        Vector2Int v1 = new Vector2Int(1, 2);
        Vector2Int v2 = new Vector2Int(2, 1);
        Vector2Int v3 = new Vector2Int(1, 2);

        // Display missing matches between the three Vector2Int structures.
        EqualityComparer comparer = new EqualityComparer();

        Debug.Log("Comparison of v1 against v2");
        Assert.AreEqual(v1, v2, "v1 does not matches v2", comparer);
        Assert.AreNotEqual(v1, v2, "v1 matches v2", comparer);

        Debug.Log("Comparison of v1 against v3");
        Assert.AreEqual(v1, v3, "v1 does not matches v3", comparer);
        Assert.AreNotEqual(v1, v3, "v1 matches v3", comparer);

        Debug.Log("Comparison of v2 against v3");
        Assert.AreEqual(v2, v3, "v2 does not matches v3", comparer);
        Assert.AreNotEqual(v2, v3, "v2 matches v3", comparer);
    }
}
```