# AreNotEqual

> Assert that the values are not equal.

## Definition

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

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

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual<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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

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

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual<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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

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

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual<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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(Object, Object, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(sbyte, sbyte)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(sbyte, sbyte, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(byte, byte)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(byte, byte, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(char, char)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(char, char, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(short, short)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(short, short, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(ushort, ushort)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(ushort, ushort, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(int, int)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(int, int, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(uint, uint)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(uint, uint, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(long, long)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(long, long, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(ulong, ulong)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```

## AreNotEqual(ulong, ulong, string)

Assert that the values are not equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreNotEqual(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 equal.

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

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the Game Object's layer is never set to 0
        Assert.AreNotEqual(0, gameObject.layer);
    }
}
```

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);
    }
}
```