using System.Diagnostics;

namespace XGame.Framework
{
    public partial class Assert
    {

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(sbyte expected, sbyte actual)
        {
            if (expected != actual)
                AreEqual<sbyte>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(sbyte expected, sbyte actual, string format, params object[] args)
        {
            if (expected != actual)
                AreEqual<sbyte>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual<T>(sbyte expected, sbyte actual, T e) where T : System.Exception
        {
            if (expected != actual)
                AreEqual<sbyte, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(sbyte expected, sbyte actual)
        {
            if (expected == actual)
                AreNotEqual<sbyte>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(sbyte expected, sbyte actual, string format, params object[] args)
        {
            if (expected == actual)
                AreNotEqual<sbyte>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual<T>(sbyte expected, sbyte actual, T e) where T : System.Exception
        {
            if (expected == actual)
                AreNotEqual<sbyte, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(byte expected, byte actual)
        {
            if (expected != actual)
                AreEqual<byte>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(byte expected, byte actual, string format, params object[] args)
        {
            if (expected != actual)
                AreEqual<byte>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual<T>(byte expected, byte actual, T e) where T : System.Exception
        {
            if (expected != actual)
                AreEqual<byte, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(byte expected, byte actual)
        {
            if (expected == actual)
                AreNotEqual<byte>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(byte expected, byte actual, string format, params object[] args)
        {
            if (expected == actual)
                AreNotEqual<byte>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual<T>(byte expected, byte actual, T e) where T : System.Exception
        {
            if (expected == actual)
                AreNotEqual<byte, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(char expected, char actual)
        {
            if (expected != actual)
                AreEqual<char>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(char expected, char actual, string format, params object[] args)
        {
            if (expected != actual)
                AreEqual<char>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual<T>(char expected, char actual, T e) where T : System.Exception
        {
            if (expected != actual)
                AreEqual<char, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(char expected, char actual)
        {
            if (expected == actual)
                AreNotEqual<char>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(char expected, char actual, string format, params object[] args)
        {
            if (expected == actual)
                AreNotEqual<char>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual<T>(char expected, char actual, T e) where T : System.Exception
        {
            if (expected == actual)
                AreNotEqual<char, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(short expected, short actual)
        {
            if (expected != actual)
                AreEqual<short>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(short expected, short actual, string format, params object[] args)
        {
            if (expected != actual)
                AreEqual<short>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual<T>(short expected, short actual, T e) where T : System.Exception
        {
            if (expected != actual)
                AreEqual<short, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(short expected, short actual)
        {
            if (expected == actual)
                AreNotEqual<short>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(short expected, short actual, string format, params object[] args)
        {
            if (expected == actual)
                AreNotEqual<short>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual<T>(short expected, short actual, T e) where T : System.Exception
        {
            if (expected == actual)
                AreNotEqual<short, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(ushort expected, ushort actual)
        {
            if (expected != actual)
                AreEqual<ushort>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(ushort expected, ushort actual, string format, params object[] args)
        {
            if (expected != actual)
                AreEqual<ushort>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual<T>(ushort expected, ushort actual, T e) where T : System.Exception
        {
            if (expected != actual)
                AreEqual<ushort, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(ushort expected, ushort actual)
        {
            if (expected == actual)
                AreNotEqual<ushort>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(ushort expected, ushort actual, string format, params object[] args)
        {
            if (expected == actual)
                AreNotEqual<ushort>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual<T>(ushort expected, ushort actual, T e) where T : System.Exception
        {
            if (expected == actual)
                AreNotEqual<ushort, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(int expected, int actual)
        {
            if (expected != actual)
                AreEqual<int>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(int expected, int actual, string format, params object[] args)
        {
            if (expected != actual)
                AreEqual<int>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual<T>(int expected, int actual, T e) where T : System.Exception
        {
            if (expected != actual)
                AreEqual<int, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(int expected, int actual)
        {
            if (expected == actual)
                AreNotEqual<int>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(int expected, int actual, string format, params object[] args)
        {
            if (expected == actual)
                AreNotEqual<int>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual<T>(int expected, int actual, T e) where T : System.Exception
        {
            if (expected == actual)
                AreNotEqual<int, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(uint expected, uint actual)
        {
            if (expected != actual)
                AreEqual<uint>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(uint expected, uint actual, string format, params object[] args)
        {
            if (expected != actual)
                AreEqual<uint>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual<T>(uint expected, uint actual, T e) where T : System.Exception
        {
            if (expected != actual)
                AreEqual<uint, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(uint expected, uint actual)
        {
            if (expected == actual)
                AreNotEqual<uint>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(uint expected, uint actual, string format, params object[] args)
        {
            if (expected == actual)
                AreNotEqual<uint>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual<T>(uint expected, uint actual, T e) where T : System.Exception
        {
            if (expected == actual)
                AreNotEqual<uint, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(long expected, long actual)
        {
            if (expected != actual)
                AreEqual<long>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(long expected, long actual, string format, params object[] args)
        {
            if (expected != actual)
                AreEqual<long>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual<T>(long expected, long actual, T e) where T : System.Exception
        {
            if (expected != actual)
                AreEqual<long, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(long expected, long actual)
        {
            if (expected == actual)
                AreNotEqual<long>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(long expected, long actual, string format, params object[] args)
        {
            if (expected == actual)
                AreNotEqual<long>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual<T>(long expected, long actual, T e) where T : System.Exception
        {
            if (expected == actual)
                AreNotEqual<long, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(ulong expected, ulong actual)
        {
            if (expected != actual)
                AreEqual<ulong>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual(ulong expected, ulong actual, string format, params object[] args)
        {
            if (expected != actual)
                AreEqual<ulong>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreEqual<T>(ulong expected, ulong actual, T e) where T : System.Exception
        {
            if (expected != actual)
                AreEqual<ulong, T>(expected, actual, e);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(ulong expected, ulong actual)
        {
            if (expected == actual)
                AreNotEqual<ulong>(expected, actual, null);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual(ulong expected, ulong actual, string format, params object[] args)
        {
            if (expected == actual)
                AreNotEqual<ulong>(expected, actual, format, args);
        }

        [Conditional(MacroDefine.XGAME_ASSERT), Conditional(MacroDefine.UNITY_EDITOR)]
        public static void AreNotEqual<T>(ulong expected, ulong actual, T e) where T : System.Exception
        {
            if (expected == actual)
                AreNotEqual<ulong, T>(expected, actual, e);
        }
    }
}
