Exemplo n.º 1
0
        public void ArrayTest()
        {
            // Class
            ST_Array st = new ST_Array();

            st.bools   = new bool[] { true, false, true, false, true, false, true, false };
            st.sbytes  = new sbyte[] { sbyte.MinValue, sbyte.MaxValue };
            st.shorts  = new short[] { short.MinValue, short.MaxValue };
            st.ints    = new int[] { int.MaxValue, int.MaxValue };
            st.longs   = new long[] { long.MinValue, long.MaxValue };
            st.bytes   = new byte[] { byte.MinValue, byte.MaxValue };
            st.ushorts = new ushort[] { ushort.MinValue, ushort.MaxValue };
            st.uints   = new uint[] { uint.MaxValue, uint.MaxValue };
            st.ulongs  = new ulong[] { ulong.MinValue, ulong.MaxValue };
            st.floats  = new float[] { 0.1234567f, float.MinValue, float.MaxValue };
            st.doubles = new double[] { 0.12345678987654321d, double.MinValue, double.MaxValue };
            st.strings = new string[] { "AAA", "BBB", "CCC" };

            // LBObject
            LBObject lb = new LBObject();

            lb.SetBoolArray("bools", st.bools);
            lb.SetSByteArray("sbytes", st.sbytes);
            lb.SetShortArray("shorts", st.shorts);
            lb.SetIntArray("ints", st.ints);
            lb.SetLongArray("longs", st.longs);
            lb.SetByteArray("bytes", st.bytes);
            lb.SetUShortArray("ushorts", st.ushorts);
            lb.SetUIntArray("uints", st.uints);
            lb.SetULongArray("ulongs", st.ulongs);
            lb.SetFloatArray("floats", st.floats);
            lb.SetDoubleArray("doubles", st.doubles);
            lb.SetStringArray("strings", st.strings);

            ClassTest("Array", st, lb);
        }
Exemplo n.º 2
0
        public void AllTypeTest()
        {
            // ========================== Class ===============================
            ST_AllType st = new ST_AllType();

            // Bit
            st.bit1 = true;
            st.bit2 = 2;
            st.bit3 = 3;
            st.bit4 = 4;
            st.bit5 = 5;
            st.bit6 = 6;
            st.bit7 = 7;

            // Int
            st.int8  = 8;
            st.int16 = 16;
            st.int24 = 24;
            st.int32 = 32;
            st.int40 = 40;
            st.int48 = 48;
            st.int56 = 56;
            st.int64 = 64;

            // UInt
            st.uint8  = 8;
            st.uint16 = 16;
            st.uint24 = 24;
            st.uint32 = 32;
            st.uint40 = 40;
            st.uint48 = 48;
            st.uint56 = 56;
            st.uint64 = 64;

            // Float
            st.float8  = 1 / 255f;
            st.float16 = 0.12345f;
            st.float24 = 0.1234567f;
            st.float32 = float.MaxValue;
            st.float64 = double.MaxValue;

            // VarInt
            st.vint16 = short.MinValue;
            st.vint32 = int.MinValue;
            st.vint64 = long.MinValue;

            // VarUInt
            st.vuint16 = ushort.MaxValue;
            st.vuint32 = uint.MaxValue;
            st.vuint64 = ulong.MaxValue;

            // String
            st.utf8    = "UTF8 String";
            st.unicode = "Unicode String";
            st.ascii   = "ASCII String";

            // CustomType
            st.position = new ST_Vector3(1.12345f, 2.12345f, 3.12345f);

            // BitArray
            bool[] bit1Array = new bool[] { true, false, true, false, true, false, true, false };
            byte[] bit2Array = new byte[4];
            byte[] bit3Array = new byte[8];
            byte[] bit4Array = new byte[16];
            byte[] bit5Array = new byte[32];
            byte[] bit6Array = new byte[64];
            byte[] bit7Array = new byte[128];
            for (int i = 0; i < bit2Array.Length; i++)
            {
                bit2Array[i] = (byte)i;
            }
            for (int i = 0; i < bit3Array.Length; i++)
            {
                bit3Array[i] = (byte)i;
            }
            for (int i = 0; i < bit4Array.Length; i++)
            {
                bit4Array[i] = (byte)i;
            }
            for (int i = 0; i < bit5Array.Length; i++)
            {
                bit5Array[i] = (byte)i;
            }
            for (int i = 0; i < bit6Array.Length; i++)
            {
                bit6Array[i] = (byte)i;
            }
            for (int i = 0; i < bit7Array.Length; i++)
            {
                bit7Array[i] = (byte)i;
            }
            st.bit1Array = bit1Array;
            st.bit2Array = bit2Array;
            st.bit3Array = bit3Array;
            st.bit4Array = bit4Array;
            st.bit5Array = bit5Array;
            st.bit6Array = bit6Array;
            st.bit7Array = bit7Array;

            // IntArray
            sbyte[] int8Array  = new sbyte[] { 0, 1, 2, sbyte.MinValue, sbyte.MaxValue };
            short[] int16Array = new short[] { 0, 1, 2, short.MinValue, short.MaxValue };
            int[]   int24Array = new int[] { 0, 1, 2, LBInt24.MinValue, LBInt24.MaxValue };
            int[]   int32Array = new int[] { 0, 1, 2, int.MinValue, int.MaxValue };
            long[]  int40Array = new long[] { 0, 1, 2, LBInt40.MinValue, LBInt40.MaxValue };
            long[]  int48Array = new long[] { 0, 1, 2, LBInt48.MinValue, LBInt48.MaxValue };
            long[]  int56Array = new long[] { 0, 1, 2, LBInt56.MinValue, LBInt56.MaxValue };
            long[]  int64Array = new long[] { 0, 1, 2, long.MinValue, long.MaxValue };
            st.int8Array  = int8Array;
            st.int16Array = int16Array;
            st.int24Array = int24Array;
            st.int32Array = int32Array;
            st.int40Array = int40Array;
            st.int48Array = int48Array;
            st.int56Array = int56Array;
            st.int64Array = int64Array;

            // UIntArray
            byte[]   uint8Array  = new byte[] { 0, 1, 2, byte.MinValue, byte.MaxValue };
            ushort[] uint16Array = new ushort[] { 0, 1, 2, ushort.MinValue, ushort.MaxValue };
            uint[]   uint24Array = new uint[] { 0, 1, 2, LBUInt24.MinValue, LBUInt24.MaxValue };
            uint[]   uint32Array = new uint[] { 0, 1, 2, uint.MinValue, uint.MaxValue };
            ulong[]  uint40Array = new ulong[] { 0, 1, 2, LBUInt40.MinValue, LBUInt40.MaxValue };
            ulong[]  uint48Array = new ulong[] { 0, 1, 2, LBUInt48.MinValue, LBUInt48.MaxValue };
            ulong[]  uint56Array = new ulong[] { 0, 1, 2, LBUInt56.MinValue, LBUInt56.MaxValue };
            ulong[]  uint64Array = new ulong[] { 0, 1, 2, ulong.MinValue, ulong.MaxValue };
            st.uint8Array  = uint8Array;
            st.uint16Array = uint16Array;
            st.uint24Array = uint24Array;
            st.uint32Array = uint32Array;
            st.uint40Array = uint40Array;
            st.uint48Array = uint48Array;
            st.uint56Array = uint56Array;
            st.uint64Array = uint64Array;

            // FloatArray
            float[]  float8Array  = new float[] { 1 / 255F, 2 / 255F, LBFloat8.MinValue, LBFloat8.MaxValue };
            float[]  float16Array = new float[] { 1 / 255F, -1 / 255F, LBFloat16.MinValue, LBFloat16.MaxValue };
            float[]  float24Array = new float[] { 1 / 255F, -1 / 255F, LBFloat24.MinValue, LBFloat24.MaxValue };
            float[]  float32Array = new float[] { 1 / 255F, -1 / 255F, LBFloat32.MinValue, LBFloat32.MaxValue };
            double[] float64Array = new double[] { 1 / 255d, -1 / 255F, LBFloat64.MinValue, LBFloat64.MaxValue };
            st.float8Array  = float8Array;
            st.float16Array = float16Array;
            st.float24Array = float24Array;
            st.float32Array = float32Array;
            st.float64Array = float64Array;

            // Variant-length Integer Array
            short[]  varInt16Array  = new short[] { 1, -1, short.MinValue, short.MaxValue };
            int[]    varInt32Array  = new int[] { 1, -1, int.MinValue, int.MaxValue };
            long[]   varInt64Array  = new long[] { 1, -1, long.MaxValue, long.MinValue };
            ushort[] varUInt16Array = new ushort[] { 1, 2, ushort.MinValue, ushort.MaxValue };
            uint[]   varUInt32Array = new uint[] { 1, 2, uint.MinValue, uint.MaxValue };
            ulong[]  varUInt64Array = new ulong[] { 1, 2, ulong.MinValue, ulong.MaxValue };
            st.vint16Array  = varInt16Array;
            st.vint32Array  = varInt32Array;
            st.vint64Array  = varInt64Array;
            st.vuint16Array = varUInt16Array;
            st.vuint32Array = varUInt32Array;
            st.vuint64Array = varUInt64Array;

            // StringArray
            st.utf8Array    = new string[] { "utf8_1", "utf8_2", "utf8_3" };
            st.unicodeArray = new string[] { "unicode_1", "unicode_2", "unicode_3" };
            st.asciiArray   = new string[] { "ascii_1", "ascii_2", "ascii_3" };

            // ========================== LBObject ===============================
            LBObject lb = new LBObject();

            // Bit
            lb.SetBool("bit1", st.bit1);
            lb.SetByte("bit2", st.bit2);
            lb.SetByte("bit3", st.bit3);
            lb.SetByte("bit4", st.bit4);
            lb.SetByte("bit5", st.bit5);
            lb.SetByte("bit6", st.bit6);
            lb.SetByte("bit7", st.bit7);

            // Int
            lb.SetSByte("int8", st.int8);
            lb.SetShort("int16", st.int16);
            lb.SetInt("int24", st.int24);
            lb.SetInt("int32", st.int32);
            lb.SetLong("int40", st.int40);
            lb.SetLong("int48", st.int48);
            lb.SetLong("int56", st.int56);
            lb.SetLong("int64", st.int64);

            // UInt
            lb.SetByte("uint8", st.uint8);
            lb.SetUShort("uint16", st.uint16);
            lb.SetUInt("uint24", st.uint24);
            lb.SetUInt("uint32", st.uint32);
            lb.SetULong("uint40", st.uint40);
            lb.SetULong("uint48", st.uint48);
            lb.SetULong("uint56", st.uint56);
            lb.SetULong("uint64", st.uint64);

            // Float
            lb.SetFloat("float8", st.float8);
            lb.SetFloat("float16", st.float16);
            lb.SetFloat("float24", st.float24);
            lb.SetFloat("float32", st.float32);
            lb.SetDouble("float64", st.float64);

            // VarInt
            lb.SetShort("vint16", st.vint16);
            lb.SetInt("vint32", st.vint32);
            lb.SetLong("vint64", st.vint64);

            // VarUInt
            lb.SetUShort("vuint16", st.vuint16);
            lb.SetUInt("vuint32", st.vuint32);
            lb.SetULong("vuint64", st.vuint64);

            // String
            lb.SetString("utf8", st.utf8);
            lb.SetString("unicode", st.unicode);
            lb.SetString("ascii", st.ascii);

            // CustomType
            LBObject lbPosition = new LBObject();

            lbPosition.SetFloat("x", st.position.x);
            lbPosition.SetFloat("y", st.position.y);
            lbPosition.SetFloat("z", st.position.z);
            lb.SetObject("position", lbPosition);

            // BitArray
            lb.SetBoolArray("bit1Array", st.bit1Array);
            lb.SetByteArray("bit2Array", st.bit2Array);
            lb.SetByteArray("bit3Array", st.bit3Array);
            lb.SetByteArray("bit4Array", st.bit4Array);
            lb.SetByteArray("bit5Array", st.bit5Array);
            lb.SetByteArray("bit6Array", st.bit6Array);
            lb.SetByteArray("bit7Array", st.bit7Array);

            // IntArray
            lb.SetSByteArray("int8Array", st.int8Array);
            lb.SetShortArray("int16Array", st.int16Array);
            lb.SetIntArray("int24Array", st.int24Array);
            lb.SetIntArray("int32Array", st.int32Array);
            lb.SetLongArray("int40Array", st.int40Array);
            lb.SetLongArray("int48Array", st.int48Array);
            lb.SetLongArray("int56Array", st.int56Array);
            lb.SetLongArray("int64Array", st.int64Array);

            // UIntArray
            lb.SetByteArray("uint8Array", st.uint8Array);
            lb.SetUShortArray("uint16Array", st.uint16Array);
            lb.SetUIntArray("uint24Array", st.uint24Array);
            lb.SetUIntArray("uint32Array", st.uint32Array);
            lb.SetULongArray("uint40Array", st.uint40Array);
            lb.SetULongArray("uint48Array", st.uint48Array);
            lb.SetULongArray("uint56Array", st.uint56Array);
            lb.SetULongArray("uint64Array", st.uint64Array);

            // FloatArray
            lb.SetFloatArray("float8Array", st.float8Array);
            lb.SetFloatArray("float16Array", st.float16Array);
            lb.SetFloatArray("float24Array", st.float24Array);
            lb.SetFloatArray("float32Array", st.float32Array);
            lb.SetDoubleArray("float64Array", st.float64Array);

            // Variant-length Integer Array
            lb.SetShortArray("vint16Array", st.vint16Array);
            lb.SetIntArray("vint32Array", st.vint32Array);
            lb.SetLongArray("vint64Array", st.vint64Array);
            lb.SetUShortArray("vuint16Array", st.vuint16Array);
            lb.SetUIntArray("vuint32Array", st.vuint32Array);
            lb.SetULongArray("vuint64Array", st.vuint64Array);

            // StringArray
            lb.SetStringArray("utf8Array", st.utf8Array);
            lb.SetStringArray("unicodeArray", st.unicodeArray);
            lb.SetStringArray("asciiArray", st.asciiArray);

            ClassTest("AllType", st, lb);

            #if UNITY_EDITOR
            // Convert
            //print("==================== AllType Test ====================");
            //string structName = "AllType";
            //byte[] bytes = LBUtil.Serialize(structName, st);
            //print("ByteSize: " + bytes.Length);

            // Parse
            //ST_AllType vo = LBUtil.Deserialize<ST_AllType>(structName, bytes);
            //print("LB.ToObject:vo");

            // Bit
            //print("vo.bit1: " + vo.bit1);
            //print("vo.bit2: " + vo.bit2);
            //print("vo.bit3: " + vo.bit3);
            //print("vo.bit4: " + vo.bit4);
            //print("vo.bit5: " + vo.bit5);
            //print("vo.bit6: " + vo.bit6);
            //print("vo.bit7: " + vo.bit7);

            // Int
            //print("vo.int8: " + vo.int8);
            //print("vo.int16: " + vo.int16);
            //print("vo.int24: " + vo.int24);
            //print("vo.int32: " + vo.int32);
            //print("vo.int40: " + vo.int40);
            //print("vo.int48: " + vo.int48);
            //print("vo.int56: " + vo.int56);
            //print("vo.int64: " + vo.int64);

            // UInt
            //print("vo.uint8: " + vo.uint8);
            //print("vo.uint16: " + vo.uint16);
            //print("vo.uint24: " + vo.uint24);
            //print("vo.uint32: " + vo.uint32);
            //print("vo.uint40: " + vo.uint40);
            //print("vo.uint48: " + vo.uint48);
            //print("vo.uint56: " + vo.uint56);
            //print("vo.uint64: " + vo.uint64);

            // Float
            //print("vo.float8: " + vo.float8);
            //print("vo.float16: " + vo.float16);
            //print("vo.float24: " + vo.float24);
            //print("vo.float32: " + vo.float32);
            //print("vo.float64: " + vo.float64);

            // VarInt
            //print("vo.vint16: " + vo.vint16);
            //print("vo.vint32: " + vo.vint32);
            //print("vo.vint64: " + vo.vint64);

            // VarUInt
            //print("vo.vunt16: " + vo.vint16);
            //print("vo.vuint32: " + vo.vint32);
            //print("vo.vuint64: " + vo.vint64);

            // BitArray
            //PrintArray("vo.bit1Array: ", vo.bit1Array);
            //PrintArray("vo.bit2Array: ", vo.bit2Array);
            //PrintArray("vo.bit3Array: ", vo.bit3Array);
            //PrintArray("vo.bit4Array: ", vo.bit4Array);
            //PrintArray("vo.bit5Array: ", vo.bit5Array);
            //PrintArray("vo.bit6Array: ", vo.bit6Array);
            //PrintArray("vo.bit7Array: ", vo.bit7Array);

            // IntArray
            //PrintArray("vo.int8Array: ", vo.int8Array);
            //PrintArray("vo.int16Array: ", vo.int16Array);
            //PrintArray("vo.int23Array: ", vo.int24Array);
            //PrintArray("vo.int32Array: ", vo.int32Array);
            //PrintArray("vo.int40Array: ", vo.int40Array);
            //PrintArray("vo.int48Array: ", vo.int48Array);
            //PrintArray("vo.int56Array: ", vo.int56Array);
            //PrintArray("vo.int64Array: ", vo.int64Array);

            // UIntArray
            //PrintArray("vo.uint8Array: ", vo.uint8Array);
            //PrintArray("vo.uint16Array: ", vo.uint16Array);
            //PrintArray("vo.uint24Array: ", vo.uint24Array);
            //PrintArray("vo.uint32Array: ", vo.uint32Array);
            //PrintArray("vo.uint40Array: ", vo.uint40Array);
            //PrintArray("vo.uint48Array: ", vo.uint48Array);
            //PrintArray("vo.uint56Array: ", vo.uint56Array);
            //PrintArray("vo.uint64Array: ", vo.uint64Array);

            // FloatArray
            //PrintArray("vo.float8Array: ", vo.float8Array);
            //PrintArray("vo.float16Array: ", vo.float16Array);
            //PrintArray("vo.float24Array: ", vo.float24Array);
            //PrintArray("vo.float32Array: ", vo.float32Array);
            //PrintArray("vo.float64Array: ", vo.float64Array);

            // VarIntArray
            //PrintArray("vo.vint16Array: ", vo.vint16Array);
            //PrintArray("vo.vint32Array: ", vo.vint32Array);
            //PrintArray("vo.vint64Array: ", vo.vint64Array);
            //PrintArray("vo.vlengthArray: ", vo.vlengthArray);

            //PrintArray("vo.vuint16Array: ", vo.vuint16Array);
            //PrintArray("vo.vuint32Array: ", vo.vuint32Array);
            //PrintArray("vo.vuint64Array: ", vo.vuint64Array);

            // StringArray
            //PrintArray("vo.utf8Array: ", vo.utf8Array);
            //PrintArray("vo.unicodeArray: ", vo.unicodeArray);
            //PrintArray("vo.asciiArray: ", vo.asciiArray);
            #endif
        }