Add tests for Jce

mirai-debug/build.gradle.kts

@@ -41,8 +41,11 @@ fun ktor(id: String, version: String) = "io.ktor:ktor-$id:$version"
 
 dependencies {
 
+    runtimeOnly(files("../mirai-core/build/classes/kotlin/jvm/main")) // IDE bug
     runtimeOnly(files("../mirai-core-timpc/build/classes/kotlin/jvm/main")) // IDE bug
     implementation(project(":mirai-core-timpc"))
+    runtimeOnly(files("../mirai-core-qqandroid/build/classes/kotlin/jvm/main")) // IDE bug
+    implementation(project(":mirai-core-qqandroid"))
     // runtimeOnly(files("../mirai-core/build/classes/kotlin/jvm/main")) // classpath is not added correctly by IDE
 
     implementation("org.bouncycastle:bcprov-jdk15on:1.64")
@@ -70,4 +73,9 @@ dependencies {
     implementation(ktor("client-core", ktorVersion))
     implementation(ktor("network", ktorVersion))
 
+    testImplementation(kotlin("test-annotations-common"))
+    testImplementation(kotlin("test"))
+    testImplementation(kotlin("test-junit"))
+    testImplementation(kotlin("script-runtime"))
+
 }
\ No newline at end of file

mirai-debug/src/test/java/jce/jce/HexUtil.java

+package jce.jce;
+
+import java.io.UnsupportedEncodingException;
+
+public class HexUtil {
+   private static final char[] digits = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+   public static final byte[] emptybytes = new byte[0];
+
+   public static String byte2HexStr(byte var0) {
+      char var1 = digits[var0 & 15];
+      var0 = (byte) (var0 >>> 4);
+      return new String(new char[]{digits[var0 & 15], var1});
+   }
+
+   public static String bytes2HexStr(byte[] var0) {
+      if (var0 != null && var0.length != 0) {
+         char[] var3 = new char[var0.length * 2];
+
+         for (int var1 = 0; var1 < var0.length; ++var1) {
+            byte var2 = var0[var1];
+            var3[var1 * 2 + 1] = digits[var2 & 15];
+            var2 = (byte) (var2 >>> 4);
+            var3[var1 * 2 + 0] = digits[var2 & 15];
+         }
+
+         return new String(var3);
+      } else {
+         return null;
+      }
+   }
+
+   public static byte char2Byte(char var0) {
+      if (var0 >= '0' && var0 <= '9') {
+         return (byte) (var0 - 48);
+      } else if (var0 >= 'a' && var0 <= 'f') {
+         return (byte) (var0 - 97 + 10);
+      } else {
+         return var0 >= 'A' && var0 <= 'F' ? (byte) (var0 - 65 + 10) : 0;
+      }
+   }
+
+   public static byte hexStr2Byte(String var0) {
+      byte var2 = 0;
+      byte var1 = var2;
+      if (var0 != null) {
+         var1 = var2;
+         if (var0.length() == 1) {
+            var1 = char2Byte(var0.charAt(0));
+         }
+      }
+
+      return var1;
+   }
+
+   public static byte[] hexStr2Bytes(String var0) {
+      if (var0 != null && !var0.equals("")) {
+         byte[] var4 = new byte[var0.length() / 2];
+
+         for (int var3 = 0; var3 < var4.length; ++var3) {
+            char var1 = var0.charAt(var3 * 2);
+            char var2 = var0.charAt(var3 * 2 + 1);
+            var4[var3] = (byte) (char2Byte(var1) * 16 + char2Byte(var2));
+         }
+
+         return var4;
+      } else {
+         return emptybytes;
+      }
+   }
+
+   public static void main(String[] var0) {
+      try {
+         byte[] var2 = "Hello WebSocket World?".getBytes("gbk");
+         System.out.println(bytes2HexStr(var2));
+      } catch (UnsupportedEncodingException var1) {
+         var1.printStackTrace();
+      }
+   }
+}

mirai-debug/src/test/java/jce/jce/JceDecodeException.java

+package jce.jce;
+
+public class JceDecodeException extends RuntimeException {
+    public JceDecodeException(String var1) {
+        super(var1);
+    }
+}

mirai-debug/src/test/java/jce/jce/JceEncodeException.java

+package jce.jce;
+
+public class JceEncodeException extends RuntimeException {
+    public JceEncodeException(String var1) {
+        super(var1);
+    }
+}

mirai-debug/src/test/java/jce/jce/JceInputStream$HeadData.java

+package jce.jce;
+
+public class JceInputStream$HeadData {
+    public int tag;
+    public byte type;
+
+    public void clear() {
+        this.type = 0;
+        this.tag = 0;
+    }
+}

mirai-debug/src/test/java/jce/jce/JceInputStream.java

+package jce.jce;
+
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Array;
+import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public final class JceInputStream {
+    // $FF: renamed from: bs java.nio.ByteBuffer
+    private ByteBuffer buffer;
+    protected String sServerEncoding = "GBK";
+
+    public JceInputStream() {
+    }
+
+    public JceInputStream(ByteBuffer var1) {
+        this.buffer = var1;
+    }
+
+    public JceInputStream(byte[] var1) {
+        this.buffer = ByteBuffer.wrap(var1);
+    }
+
+    public JceInputStream(byte[] var1, int var2) {
+        this.buffer = ByteBuffer.wrap(var1);
+        this.buffer.position(var2);
+    }
+
+    public static void main(String[] var0) {
+    }
+
+    private int peakHead(JceInputStream$HeadData var1) {
+        return readHead(var1, this.buffer.duplicate());
+    }
+
+    private <T> T[] readArrayImpl(T var1, int var2, boolean var3) {
+        Object[] var7;
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var5 = new JceInputStream$HeadData();
+            this.readHead(var5);
+            if (var5.type == 9) {
+                int var4 = this.read(0, 0, true);
+                if (var4 < 0) {
+                    throw new JceDecodeException("size invalid: " + var4);
+                } else {
+                    Object[] var6 = (Object[]) Array.newInstance(var1.getClass(), var4);
+                    var2 = 0;
+
+                    while (true) {
+                        var7 = var6;
+                        if (var2 >= var4) {
+                            return (T[]) var7;
+                        }
+
+                        var6[var2] = this.read(var1, 0, true);
+                        ++var2;
+                    }
+                }
+            }
+            throw new JceDecodeException("type mismatch.");
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            var7 = null;
+            return (T[]) var7;
+        }
+    }
+
+    public static int readHead(JceInputStream$HeadData var0, ByteBuffer var1) {
+        byte var2 = var1.get();
+        var0.type = (byte) (var2 & 15);
+        var0.tag = (var2 & 240) >> 4;
+        if (var0.tag == 15) {
+            var0.tag = var1.get() & 255;
+            return 2;
+        } else {
+            return 1;
+        }
+    }
+
+    private <K, V> Map<K, V> readMap(Map<K, V> var1, Map<K, V> var2, int var3, boolean var4) {
+        Map<K, V> var8;
+        if (var2 != null && !var2.isEmpty()) {
+            Entry<K, V> var9 = var2.entrySet().iterator().next();
+            K var6 = var9.getKey();
+            V var7 = var9.getValue();
+            if (this.skipToTag(var3)) {
+                JceInputStream$HeadData var10 = new JceInputStream$HeadData();
+                this.readHead(var10);
+                if (var10.type == 8) {
+                    int var5 = this.read(0, 0, true);
+                    if (var5 < 0) {
+                        throw new JceDecodeException("size invalid: " + var5);
+                    }
+
+                    var3 = 0;
+
+                    while (true) {
+                        var8 = var1;
+                        if (var3 >= var5) {
+                            return var8;
+                        }
+
+                        var1.put((K) this.read(var6, 0, true), (V) this.read(var7, 1, true));
+                        ++var3;
+                    }
+                }
+                throw new JceDecodeException("type mismatch.");
+            } else {
+                var8 = var1;
+                if (var4) {
+                    throw new JceDecodeException("require field not exist.");
+                }
+            }
+        } else {
+            var8 = new HashMap<>();
+        }
+
+        return var8;
+    }
+
+    private void skip(int var1) {
+        this.buffer.position(this.buffer.position() + var1);
+    }
+
+    private void skipField() {
+        JceInputStream$HeadData var1 = new JceInputStream$HeadData();
+        this.readHead(var1);
+        this.skipField(var1.type);
+    }
+
+    private void skipField(byte var1) {
+        byte var3 = 0;
+        byte var2 = 0;
+        int var5;
+        switch (var1) {
+            case 0:
+                this.skip(1);
+                break;
+            case 1:
+                this.skip(2);
+                return;
+            case 2:
+                this.skip(4);
+                return;
+            case 3:
+                this.skip(8);
+                return;
+            case 4:
+                this.skip(4);
+                return;
+            case 5:
+                this.skip(8);
+                return;
+            case 6:
+                byte var7 = this.buffer.get();
+                var5 = var7;
+                if (var7 < 0) {
+                    var5 = var7 + 256;
+                }
+
+                this.skip(var5);
+                return;
+            case 7:
+                this.skip(this.buffer.getInt());
+                return;
+            case 8:
+                int var8 = this.read(0, 0, true);
+
+                for (var5 = var2; var5 < var8 * 2; ++var5) {
+                    this.skipField();
+                }
+
+                return;
+            case 9:
+                int var6 = this.read(0, 0, true);
+
+                for (var5 = var3; var5 < var6; ++var5) {
+                    this.skipField();
+                }
+
+                return;
+            case 10:
+                this.skipToStructEnd();
+                return;
+            case 11:
+            case 12:
+                break;
+            case 13:
+                JceInputStream$HeadData var4 = new JceInputStream$HeadData();
+                this.readHead(var4);
+                if (var4.type != 0) {
+                    throw new JceDecodeException("skipField with invalid type, type value: " + var1 + ", " + var4.type);
+                }
+
+                this.skip(this.read(0, 0, true));
+                return;
+            default:
+                throw new JceDecodeException("invalid type.");
+        }
+
+    }
+
+    public JceStruct directRead(JceStruct var1, int var2, boolean var3) {
+        JceInputStream$HeadData var4 = null;
+        if (this.skipToTag(var2)) {
+            try {
+                var1 = var1.newInit();
+            } catch (Exception var5) {
+                throw new JceDecodeException(var5.getMessage());
+            }
+
+            var4 = new JceInputStream$HeadData();
+            this.readHead(var4);
+            if (var4.type != 10) {
+                throw new JceDecodeException("type mismatch.");
+            }
+
+            var1.readFrom(this);
+            this.skipToStructEnd();
+        } else {
+            var1 = null;
+            if (var3) {
+                throw new JceDecodeException("require field not exist.");
+            }
+        }
+
+        return var1;
+    }
+
+    public ByteBuffer getBs() {
+        return this.buffer;
+    }
+
+    public byte read(byte var1, int var2, boolean var3) {
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var4 = new JceInputStream$HeadData();
+            this.readHead(var4);
+            switch (var4.type) {
+                case 0:
+                    return this.buffer.get();
+                case 12:
+                    return 0;
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public double read(double var1, int var3, boolean var4) {
+        if (this.skipToTag(var3)) {
+            JceInputStream$HeadData var5 = new JceInputStream$HeadData();
+            this.readHead(var5);
+            switch (var5.type) {
+                case 4:
+                    return this.buffer.getFloat();
+                case 5:
+                    return this.buffer.getDouble();
+                case 12:
+                    return 0.0D;
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var4) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public float read(float var1, int var2, boolean var3) {
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var4 = new JceInputStream$HeadData();
+            this.readHead(var4);
+            switch (var4.type) {
+                case 4:
+                    return this.buffer.getFloat();
+                case 12:
+                    return 0.0F;
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public int read(int var1, int var2, boolean var3) {
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var4 = new JceInputStream$HeadData();
+            this.readHead(var4);
+            switch (var4.type) {
+                case 0:
+                    return this.buffer.get();
+                case 1:
+                    return this.buffer.getShort();
+                case 2:
+                    return this.buffer.getInt();
+                case 12:
+                    return 0;
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public long read(long var1, int var3, boolean var4) {
+        if (this.skipToTag(var3)) {
+            JceInputStream$HeadData var5 = new JceInputStream$HeadData();
+            this.readHead(var5);
+            switch (var5.type) {
+                case 0:
+                    return this.buffer.get();
+                case 1:
+                    return this.buffer.getShort();
+                case 2:
+                    return this.buffer.getInt();
+                case 3:
+                    return this.buffer.getLong();
+                case 12:
+                    return 0L;
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var4) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public JceStruct read(JceStruct var1, int var2, boolean var3) {
+        JceInputStream$HeadData var4 = null;
+        if (this.skipToTag(var2)) {
+            try {
+                var1 = var1.getClass().newInstance();
+            } catch (Exception var5) {
+                throw new JceDecodeException(var5.getMessage());
+            }
+
+            var4 = new JceInputStream$HeadData();
+            this.readHead(var4);
+            if (var4.type != 10) {
+                throw new JceDecodeException("type mismatch.");
+            }
+
+            var1.readFrom(this);
+            this.skipToStructEnd();
+        } else {
+            var1 = null;
+            if (var3) {
+                throw new JceDecodeException("require field not exist.");
+            }
+        }
+
+        return var1;
+    }
+
+    public <T> Object read(T var1, int var2, boolean var3) {
+        if (var1 instanceof Byte) {
+            return this.read((byte) 0, var2, var3);
+        } else if (var1 instanceof Boolean) {
+            return this.read(false, var2, var3);
+        } else if (var1 instanceof Short) {
+            return this.read((short) 0, var2, var3);
+        } else if (var1 instanceof Integer) {
+            return this.read(0, var2, var3);
+        } else if (var1 instanceof Long) {
+            return this.read(0L, var2, var3);
+        } else if (var1 instanceof Float) {
+            return this.read(0.0F, var2, var3);
+        } else if (var1 instanceof Double) {
+            return this.read(0.0D, var2, var3);
+        } else if (var1 instanceof String) {
+            return this.readString(var2, var3);
+        } else if (var1 instanceof Map) {
+            return this.readMap((Map) var1, var2, var3);
+        } else if (var1 instanceof List) {
+            return this.readArray((List) var1, var2, var3);
+        } else if (var1 instanceof JceStruct) {
+            return this.read((JceStruct) var1, var2, var3);
+        } else if (var1.getClass().isArray()) {
+            if (!(var1 instanceof byte[]) && !(var1 instanceof Byte[])) {
+                if (var1 instanceof boolean[]) {
+                    return this.read((boolean[]) null, var2, var3);
+                } else if (var1 instanceof short[]) {
+                    return this.read((short[]) null, var2, var3);
+                } else if (var1 instanceof int[]) {
+                    return this.read((int[]) null, var2, var3);
+                } else if (var1 instanceof long[]) {
+                    return this.read((long[]) null, var2, var3);
+                } else if (var1 instanceof float[]) {
+                    return this.read((float[]) null, var2, var3);
+                } else {
+                    return var1 instanceof double[] ? this.read((double[]) null, var2, var3) : this.readArray((Object[]) var1, var2, var3);
+                }
+            } else {
+                return this.read((byte[]) null, var2, var3);
+            }
+        } else {
+            throw new JceDecodeException("read object error: unsupport type.");
+        }
+    }
+
+    public String read(String var1, int var2, boolean var3) {
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var8 = new JceInputStream$HeadData();
+            this.readHead(var8);
+            String var5;
+            byte[] var9;
+            switch (var8.type) {
+                case 6:
+                    byte var4 = this.buffer.get();
+                    var2 = var4;
+                    if (var4 < 0) {
+                        var2 = var4 + 256;
+                    }
+
+                    var9 = new byte[var2];
+                    this.buffer.get(var9);
+
+                    try {
+                        var5 = new String(var9, this.sServerEncoding);
+                        return var5;
+                    } catch (UnsupportedEncodingException var7) {
+                        return new String(var9);
+                    }
+                case 7:
+                    var2 = this.buffer.getInt();
+                    if (var2 <= 104857600 && var2 >= 0 && var2 <= this.buffer.capacity()) {
+                        var9 = new byte[var2];
+                        this.buffer.get(var9);
+
+                        try {
+                            var5 = new String(var9, this.sServerEncoding);
+                            return var5;
+                        } catch (UnsupportedEncodingException var6) {
+                            return new String(var9);
+                        }
+                    }
+
+                    throw new JceDecodeException("String too long: " + var2);
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public short read(short var1, int var2, boolean var3) {
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var4 = new JceInputStream$HeadData();
+            this.readHead(var4);
+            switch (var4.type) {
+                case 0:
+                    return this.buffer.get();
+                case 1:
+                    return this.buffer.getShort();
+                case 12:
+                    return 0;
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public boolean read(boolean var1, int var2, boolean var3) {
+        var1 = this.read((byte) 0, var2, var3) != 0;
+
+        return var1;
+    }
+
+    public byte[] read(byte[] var1, int var2, boolean var3) {
+        var1 = null;
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var6 = new JceInputStream$HeadData();
+            this.readHead(var6);
+            int var4;
+            switch (var6.type) {
+                case 9:
+                    var4 = this.read(0, 0, true);
+                    if (var4 >= 0 && var4 <= this.buffer.capacity()) {
+                        byte[] var7 = new byte[var4];
+                        var2 = 0;
+
+                        while (true) {
+                            var1 = var7;
+                            if (var2 >= var4) {
+                                return var1;
+                            }
+
+                            var7[var2] = this.read(var7[0], 0, true);
+                            ++var2;
+                        }
+                    }
+
+                    throw new JceDecodeException("size invalid: " + var4);
+                case 13:
+                    JceInputStream$HeadData var5 = new JceInputStream$HeadData();
+                    this.readHead(var5);
+                    if (var5.type != 0) {
+                        throw new JceDecodeException("type mismatch, tag: " + var2 + ", type: " + var6.type + ", " + var5.type);
+                    }
+
+                    var4 = this.read(0, 0, true);
+                    if (var4 < 0 || var4 > this.buffer.capacity()) {
+                        throw new JceDecodeException("invalid size, tag: " + var2 + ", type: " + var6.type + ", " + var5.type + ", size: " + var4);
+                    }
+
+                    var1 = new byte[var4];
+                    this.buffer.get(var1);
+                    break;
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        }
+
+        return var1;
+    }
+
+    public double[] read(double[] var1, int var2, boolean var3) {
+        var1 = null;
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var6 = new JceInputStream$HeadData();
+            this.readHead(var6);
+            if (var6.type == 9) {
+                int var4 = this.read(0, 0, true);
+                if (var4 < 0) {
+                    throw new JceDecodeException("size invalid: " + var4);
+                } else {
+                    double[] var5 = new double[var4];
+                    var2 = 0;
+
+                    while (true) {
+                        var1 = var5;
+                        if (var2 >= var4) {
+                            return var1;
+                        }
+
+                        var5[var2] = this.read(var5[0], 0, true);
+                        ++var2;
+                    }
+                }
+            }
+            throw new JceDecodeException("type mismatch.");
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public float[] read(float[] var1, int var2, boolean var3) {
+        var1 = null;
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var6 = new JceInputStream$HeadData();
+            this.readHead(var6);
+            if (var6.type == 9) {
+                int var4 = this.read(0, 0, true);
+                if (var4 < 0) {
+                    throw new JceDecodeException("size invalid: " + var4);
+                } else {
+                    float[] var5 = new float[var4];
+                    var2 = 0;
+
+                    while (true) {
+                        var1 = var5;
+                        if (var2 >= var4) {
+                            return var1;
+                        }
+
+                        var5[var2] = this.read(var5[0], 0, true);
+                        ++var2;
+                    }
+                }
+            }
+            throw new JceDecodeException("type mismatch.");
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public int[] read(int[] var1, int var2, boolean var3) {
+        var1 = null;
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var6 = new JceInputStream$HeadData();
+            this.readHead(var6);
+            if (var6.type == 9) {
+                int var4 = this.read(0, 0, true);
+                if (var4 < 0) {
+                    throw new JceDecodeException("size invalid: " + var4);
+                } else {
+                    int[] var5 = new int[var4];
+                    var2 = 0;
+
+                    while (true) {
+                        var1 = var5;
+                        if (var2 >= var4) {
+                            return var1;
+                        }
+
+                        var5[var2] = this.read(var5[0], 0, true);
+                        ++var2;
+                    }
+                }
+            }
+            throw new JceDecodeException("type mismatch.");
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public long[] read(long[] var1, int var2, boolean var3) {
+        var1 = null;
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var6 = new JceInputStream$HeadData();
+            this.readHead(var6);
+            if (var6.type == 9) {
+                int var4 = this.read(0, 0, true);
+                if (var4 < 0) {
+                    throw new JceDecodeException("size invalid: " + var4);
+                } else {
+                    long[] var5 = new long[var4];
+                    var2 = 0;
+
+                    while (true) {
+                        var1 = var5;
+                        if (var2 >= var4) {
+                            return var1;
+                        }
+
+                        var5[var2] = this.read(var5[0], 0, true);
+                        ++var2;
+                    }
+                }
+            }
+            throw new JceDecodeException("type mismatch.");
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public JceStruct[] read(JceStruct[] var1, int var2, boolean var3) {
+        return (JceStruct[]) this.readArray((Object[]) var1, var2, var3);
+    }
+
+    public String[] read(String[] var1, int var2, boolean var3) {
+        return (String[]) this.readArray((Object[]) var1, var2, var3);
+    }
+
+    public short[] read(short[] var1, int var2, boolean var3) {
+        var1 = null;
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var6 = new JceInputStream$HeadData();
+            this.readHead(var6);
+            if (var6.type == 9) {
+                int var4 = this.read(0, 0, true);
+                if (var4 < 0) {
+                    throw new JceDecodeException("size invalid: " + var4);
+                } else {
+                    short[] var5 = new short[var4];
+                    var2 = 0;
+
+                    while (true) {
+                        var1 = var5;
+                        if (var2 >= var4) {
+                            return var1;
+                        }
+
+                        var5[var2] = this.read(var5[0], 0, true);
+                        ++var2;
+                    }
+                }
+            }
+            throw new JceDecodeException("type mismatch.");
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public boolean[] read(boolean[] var1, int var2, boolean var3) {
+        var1 = null;
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var6 = new JceInputStream$HeadData();
+            this.readHead(var6);
+            if (var6.type == 9) {
+                int var4 = this.read(0, 0, true);
+                if (var4 < 0) {
+                    throw new JceDecodeException("size invalid: " + var4);
+                } else {
+                    boolean[] var5 = new boolean[var4];
+                    var2 = 0;
+
+                    while (true) {
+                        var1 = var5;
+                        if (var2 >= var4) {
+                            return var1;
+                        }
+
+                        var5[var2] = this.read(var5[0], 0, true);
+                        ++var2;
+                    }
+                }
+            }
+            throw new JceDecodeException("type mismatch.");
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public <T> List<T> readArray(List<T> var1, int var2, boolean var3) {
+        byte var4 = 0;
+        if (var1 != null && !var1.isEmpty()) {
+            Object[] var6 = this.readArrayImpl(var1.get(0), var2, var3);
+            if (var6 == null) {
+                return null;
+            } else {
+                ArrayList var5 = new ArrayList();
+
+                for (var2 = var4; var2 < var6.length; ++var2) {
+                    var5.add(var6[var2]);
+                }
+
+                return var5;
+            }
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+    public <T> T[] readArray(T[] var1, int var2, boolean var3) {
+        if (var1 != null && var1.length != 0) {
+            return this.readArrayImpl(var1[0], var2, var3);
+        } else {
+            throw new JceDecodeException("unable to get type of key and value.");
+        }
+    }
+
+    public String readByteString(String var1, int var2, boolean var3) {
+        if (this.skipToTag(var2)) {
+            JceInputStream$HeadData var5 = new JceInputStream$HeadData();
+            this.readHead(var5);
+            byte[] var6;
+            switch (var5.type) {
+                case 6:
+                    byte var4 = this.buffer.get();
+                    var2 = var4;
+                    if (var4 < 0) {
+                        var2 = var4 + 256;
+                    }
+
+                    var6 = new byte[var2];
+                    this.buffer.get(var6);
+                    return HexUtil.bytes2HexStr(var6);
+                case 7:
+                    var2 = this.buffer.getInt();
+                    if (var2 <= 104857600 && var2 >= 0 && var2 <= this.buffer.capacity()) {
+                        var6 = new byte[var2];
+                        this.buffer.get(var6);
+                        return HexUtil.bytes2HexStr(var6);
+                    }
+
+                    throw new JceDecodeException("String too long: " + var2);
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var3) {
+            throw new JceDecodeException("require field not exist.");
+        } else {
+            return var1;
+        }
+    }
+
+    public void readHead(JceInputStream$HeadData var1) {
+        readHead(var1, this.buffer);
+    }
+
+    public List<java.io.Serializable> readList(int var1, boolean var2) {
+        ArrayList<java.io.Serializable> var6 = new ArrayList<java.io.Serializable>();
+        if (this.skipToTag(var1)) {
+            JceInputStream$HeadData var7 = new JceInputStream$HeadData();
+            this.readHead(var7);
+            if (var7.type == 9) {
+                int var5 = this.read(0, 0, true);
+                if (var5 < 0) {
+                    throw new JceDecodeException("size invalid: " + var5);
+                }
+
+                var1 = 0;
+
+                for (; var1 < var5; ++var1) {
+                    var7 = new JceInputStream$HeadData();
+                    this.readHead(var7);
+                    switch (var7.type) {
+                        case 0:
+                            this.skip(1);
+                            break;
+                        case 1:
+                            this.skip(2);
+                            break;
+                        case 2:
+                            this.skip(4);
+                            break;
+                        case 3:
+                            this.skip(8);
+                            break;
+                        case 4:
+                            this.skip(4);
+                            break;
+                        case 5:
+                            this.skip(8);
+                            break;
+                        case 6:
+                            byte var4 = this.buffer.get();
+                            int var3 = var4;
+                            if (var4 < 0) {
+                                var3 = var4 + 256;
+                            }
+
+                            this.skip(var3);
+                            break;
+                        case 7:
+                            this.skip(this.buffer.getInt());
+                        case 8:
+                        case 9:
+                            break;
+                        case 10:
+                            try {
+                                JceStruct var9 = (JceStruct) Class.forName(JceStruct.class.getName()).getConstructor().newInstance();
+                                var9.readFrom(this);
+                                this.skipToStructEnd();
+                                var6.add(var9);
+                                break;
+                            } catch (Exception var8) {
+                                var8.printStackTrace();
+                                throw new JceDecodeException("type mismatch." + var8);
+                            }
+                        case 11:
+                        default:
+                            throw new JceDecodeException("type mismatch.");
+                        case 12:
+                            var6.add(new Integer(0));
+                    }
+                }
+            } else {
+                throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var2) {
+            throw new JceDecodeException("require field not exist.");
+        }
+
+        return var6;
+    }
+
+    public <K, V> HashMap<K, V> readMap(Map<K, V> var1, int var2, boolean var3) {
+        return (HashMap<K, V>) this.readMap(new HashMap<K, V>(), var1, var2, var3);
+    }
+
+    public String readString(int var1, boolean var2) {
+        String var4 = null;
+        if (this.skipToTag(var1)) {
+            JceInputStream$HeadData var8 = new JceInputStream$HeadData();
+            this.readHead(var8);
+            switch (var8.type) {
+                case 6:
+                    byte var3 = this.buffer.get();
+                    var1 = var3;
+                    if (var3 < 0) {
+                        var1 = var3 + 256;
+                    }
+
+                    byte[] var10 = new byte[var1];
+                    this.buffer.get(var10);
+
+                    try {
+                        var4 = new String(var10, this.sServerEncoding);
+                        break;
+                    } catch (UnsupportedEncodingException var7) {
+                        return new String(var10);
+                    }
+                case 7:
+                    var1 = this.buffer.getInt();
+                    if (var1 <= 104857600 && var1 >= 0 && var1 <= this.buffer.capacity()) {
+                        byte[] var9 = new byte[var1];
+                        this.buffer.get(var9);
+
+                        try {
+                            String var5 = new String(var9, this.sServerEncoding);
+                            return var5;
+                        } catch (UnsupportedEncodingException var6) {
+                            return new String(var9);
+                        }
+                    }
+
+                    throw new JceDecodeException("String too long: " + var1);
+                default:
+                    throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var2) {
+            throw new JceDecodeException("require field not exist.");
+        }
+
+        return var4;
+    }
+
+    public Map<String, String> readStringMap(int var1, boolean var2) {
+        HashMap<String, String> var4 = new HashMap<>();
+        if (this.skipToTag(var1)) {
+            JceInputStream$HeadData var5 = new JceInputStream$HeadData();
+            this.readHead(var5);
+            if (var5.type == 8) {
+                int var3 = this.read(0, 0, true);
+                if (var3 < 0) {
+                    throw new JceDecodeException("size invalid: " + var3);
+                }
+
+                for (var1 = 0; var1 < var3; ++var1) {
+                    var4.put(this.readString(0, true), this.readString(1, true));
+                }
+            } else {
+                throw new JceDecodeException("type mismatch.");
+            }
+        } else if (var2) {
+            throw new JceDecodeException("require field not exist.");
+        }
+
+        return var4;
+    }
+
+    public int setServerEncoding(String var1) {
+        this.sServerEncoding = var1;
+        return 0;
+    }
+
+    public void skipToStructEnd() {
+        JceInputStream$HeadData var1 = new JceInputStream$HeadData();
+
+        do {
+            this.readHead(var1);
+            this.skipField(var1.type);
+        } while (var1.type != 11);
+
+    }
+
+    public boolean skipToTag(int n2) {
+        try {
+            JceInputStream$HeadData jceInputStream$HeadData = new JceInputStream$HeadData();
+            do {
+                int n3 = this.peakHead(jceInputStream$HeadData);
+                if (jceInputStream$HeadData.type == 11) {
+                    return false;
+                }
+                if (n2 <= jceInputStream$HeadData.tag) {
+                    return n2 == jceInputStream$HeadData.tag;
+                }
+                this.skip(n3);
+                this.skipField(jceInputStream$HeadData.type);
+            } while (true);
+        } catch (JceDecodeException jceDecodeException) {
+            return false;
+        } catch (BufferUnderflowException bufferUnderflowException) {
+            // empty catch block
+        }
+        return false;
+    }
+
+    public void warp(byte[] var1) {
+        this.wrap(var1);
+    }
+
+    public void wrap(byte[] var1) {
+        this.buffer = ByteBuffer.wrap(var1);
+    }
+}

mirai-debug/src/test/java/jce/jce/JceOutputStream.java

+package jce.jce;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class JceOutputStream {
+   // $FF: renamed from: bs java.nio.ByteBuffer
+   private ByteBuffer field_80728;
+   private OnIllegalArgumentException exceptionHandler;
+   protected String sServerEncoding;
+
+   public JceOutputStream() {
+      this(128);
+   }
+
+   public JceOutputStream(int var1) {
+      this.sServerEncoding = "GBK";
+      this.field_80728 = ByteBuffer.allocate(var1);
+   }
+
+   public JceOutputStream(ByteBuffer var1) {
+      this.sServerEncoding = "GBK";
+      this.field_80728 = var1;
+   }
+
+   public static void main(String[] var0) {
+      JceOutputStream var2 = new JceOutputStream();
+      var2.write(1311768467283714885L, 0);
+      ByteBuffer var1 = var2.getByteBuffer();
+      System.out.println(HexUtil.bytes2HexStr(var1.array()));
+      System.out.println(Arrays.toString(var2.toByteArray()));
+   }
+
+   private void writeArray(Object[] var1, int var2) {
+      this.reserve(8);
+      this.writeHead((byte) 9, var2);
+      this.write(var1.length, 0);
+      int var3 = var1.length;
+
+      for (var2 = 0; var2 < var3; ++var2) {
+         this.write(var1[var2], 0);
+      }
+
+   }
+
+   public ByteBuffer getByteBuffer() {
+      return this.field_80728;
+   }
+
+   public OnIllegalArgumentException getExceptionHandler() {
+      return this.exceptionHandler;
+   }
+
+   public void reserve(int var1) {
+      if (this.field_80728.remaining() < var1) {
+         int var2 = (this.field_80728.capacity() + var1) * 2;
+
+         ByteBuffer var3;
+         try {
+            var3 = ByteBuffer.allocate(var2);
+            var3.put(this.field_80728.array(), 0, this.field_80728.position());
+         } catch (IllegalArgumentException var4) {
+            if (this.exceptionHandler != null) {
+               this.exceptionHandler.onException(var4, this.field_80728, var1, var2);
+            }
+
+            throw var4;
+         }
+
+         this.field_80728 = var3;
+      }
+
+   }
+
+   public void setExceptionHandler(OnIllegalArgumentException var1) {
+      this.exceptionHandler = var1;
+   }
+
+   public int setServerEncoding(String var1) {
+      this.sServerEncoding = var1;
+      return 0;
+   }
+
+   public byte[] toByteArray() {
+      byte[] var1 = new byte[this.field_80728.position()];
+      System.arraycopy(this.field_80728.array(), 0, var1, 0, this.field_80728.position());
+      return var1;
+   }
+
+   public void write(byte var1, int var2) {
+      this.reserve(3);
+      if (var1 == 0) {
+         this.writeHead((byte) 12, var2);
+      } else {
+         this.writeHead((byte) 0, var2);
+         this.field_80728.put(var1);
+      }
+   }
+
+   public void write(double var1, int var3) {
+      this.reserve(10);
+      this.writeHead((byte) 5, var3);
+      this.field_80728.putDouble(var1);
+   }
+
+   public void write(float var1, int var2) {
+      this.reserve(6);
+      this.writeHead((byte) 4, var2);
+      this.field_80728.putFloat(var1);
+   }
+
+   public void write(int var1, int var2) {
+      this.reserve(6);
+      if (var1 >= -32768 && var1 <= 32767) {
+         this.write((short) var1, var2);
+      } else {
+         this.writeHead((byte) 2, var2);
+         this.field_80728.putInt(var1);
+      }
+   }
+
+   public void write(long var1, int id) {
+      this.reserve(10);
+      if (var1 >= -2147483648L && var1 <= 2147483647L) {
+         this.write((int) var1, id);
+      } else {
+         this.writeHead((byte) 3, id);
+         this.field_80728.putLong(var1);
+      }
+   }
+
+   public void write(JceStruct var1, int var2) {
+      this.reserve(2);
+      this.writeHead((byte) 10, var2);
+      var1.writeTo(this);
+      this.reserve(2);
+      this.writeHead((byte) 11, 0);
+   }
+
+   public void write(Boolean var1, int var2) {
+      this.write((boolean) var1, var2);
+   }
+
+   public void write(Byte var1, int var2) {
+      this.write((byte) var1, var2);
+   }
+
+   public void write(Double var1, int var2) {
+      this.write((double) var1, var2);
+   }
+
+   public void write(Float var1, int var2) {
+      this.write((float) var1, var2);
+   }
+
+   public void write(Integer var1, int var2) {
+      this.write((int) var1, var2);
+   }
+
+   public void write(Long var1, int var2) {
+      this.write((long) var1, var2);
+   }
+
+   public void write(Object var1, int var2) {
+      if (var1 instanceof Byte) {
+         this.write((Byte) var1, var2);
+      } else if (var1 instanceof Boolean) {
+         this.write((Boolean) var1, var2);
+      } else if (var1 instanceof Short) {
+         this.write((Short) var1, var2);
+      } else if (var1 instanceof Integer) {
+         this.write((Integer) var1, var2);
+      } else if (var1 instanceof Long) {
+         this.write((Long) var1, var2);
+      } else if (var1 instanceof Float) {
+         this.write((Float) var1, var2);
+      } else if (var1 instanceof Double) {
+         this.write((Double) var1, var2);
+      } else if (var1 instanceof String) {
+         this.write((String) var1, var2);
+      } else if (var1 instanceof Map) {
+         this.write((Map) var1, var2);
+      } else if (var1 instanceof List) {
+         this.write((List) var1, var2);
+      } else if (var1 instanceof JceStruct) {
+         this.write((JceStruct) var1, var2);
+      } else if (var1 instanceof byte[]) {
+         this.write((byte[]) var1, var2);
+      } else if (var1 instanceof boolean[]) {
+         this.write((boolean[]) var1, var2);
+      } else if (var1 instanceof short[]) {
+         this.write((short[]) var1, var2);
+      } else if (var1 instanceof int[]) {
+         this.write((int[]) var1, var2);
+      } else if (var1 instanceof long[]) {
+         this.write((long[]) var1, var2);
+      } else if (var1 instanceof float[]) {
+         this.write((float[]) var1, var2);
+      } else if (var1 instanceof double[]) {
+         this.write((double[]) var1, var2);
+      } else if (var1.getClass().isArray()) {
+         this.writeArray((Object[]) var1, var2);
+      } else if (var1 instanceof Collection) {
+         this.write((Collection) var1, var2);
+      } else {
+         throw new JceEncodeException("write object error: unsupport type. " + var1.getClass());
+      }
+   }
+
+   public void write(Short var1, int var2) {
+      this.write((short) var1, var2);
+   }
+
+   public void write(String var1, int var2) {
+      byte[] var5;
+      label16:
+      {
+         byte[] var3;
+         try {
+            var3 = var1.getBytes(this.sServerEncoding);
+         } catch (UnsupportedEncodingException var4) {
+            var5 = var1.getBytes();
+            break label16;
+         }
+
+         var5 = var3;
+      }
+
+      this.reserve(var5.length + 10);
+      if (var5.length > 255) {
+         this.writeHead((byte) 7, var2);
+         this.field_80728.putInt(var5.length);
+      } else {
+         this.writeHead((byte) 6, var2);
+         this.field_80728.put((byte) var5.length);
+      }
+      this.field_80728.put(var5);
+   }
+
+   public <T> void write(Collection<T> var1, int var2) {
+      this.reserve(8);
+      this.writeHead((byte) 9, var2);
+      if (var1 == null) {
+         var2 = 0;
+      } else {
+         var2 = var1.size();
+      }
+
+      this.write(var2, 0);
+      if (var1 != null) {
+
+         for (T t : var1) {
+            this.write(t, 0);
+         }
+      }
+
+   }
+
+   public <K, V> void write(Map<K, V> var1, int var2) {
+      this.reserve(8);
+      this.writeHead((byte) 8, var2);
+      if (var1 == null) {
+         var2 = 0;
+      } else {
+         var2 = var1.size();
+      }
+
+      this.write(var2, 0);
+      if (var1 != null) {
+
+         for (Entry<K, V> kvEntry : var1.entrySet()) {
+            this.write(((Entry) kvEntry).getKey(), 0);
+            this.write(((Entry) kvEntry).getValue(), 1);
+         }
+      }
+
+   }
+
+   public void write(short var1, int var2) {
+      this.reserve(4);
+      if (var1 >= -128 && var1 <= 127) {
+         this.write((byte) var1, var2);
+      } else {
+         this.writeHead((byte) 1, var2);
+         this.field_80728.putShort(var1);
+      }
+   }
+
+   public void write(boolean var1, int var2) {
+      byte var3;
+      if (var1) {
+         var3 = 1;
+      } else {
+         var3 = 0;
+      }
+
+      this.write(var3, var2);
+   }
+
+   public void write(byte[] var1, int var2) {
+      this.reserve(var1.length + 8);
+      this.writeHead((byte) 13, var2);
+      this.writeHead((byte) 0, 0);
+      this.write(var1.length, 0);
+      this.field_80728.put(var1);
+   }
+
+   public void write(double[] var1, int var2) {
+      this.reserve(8);
+      this.writeHead((byte) 9, var2);
+      this.write(var1.length, 0);
+      int var3 = var1.length;
+
+      for (var2 = 0; var2 < var3; ++var2) {
+         this.write(var1[var2], 0);
+      }
+
+   }
+
+   public void write(float[] var1, int var2) {
+      this.reserve(8);
+      this.writeHead((byte) 9, var2);
+      this.write(var1.length, 0);
+      int var3 = var1.length;
+
+      for (var2 = 0; var2 < var3; ++var2) {
+         this.write(var1[var2], 0);
+      }
+
+   }
+
+   public void write(int[] var1, int var2) {
+      this.reserve(8);
+      this.writeHead((byte) 9, var2);
+      this.write(var1.length, 0);
+      int var3 = var1.length;
+
+      for (var2 = 0; var2 < var3; ++var2) {
+         this.write(var1[var2], 0);
+      }
+
+   }
+
+   public void write(long[] var1, int var2) {
+      this.reserve(8);
+      this.writeHead((byte) 9, var2);
+      this.write(var1.length, 0);
+      int var3 = var1.length;
+
+      for (var2 = 0; var2 < var3; ++var2) {
+         this.write(var1[var2], 0);
+      }
+
+   }
+
+   public <T> void write(T[] var1, int var2) {
+      this.writeArray(var1, var2);
+   }
+
+   public void write(short[] var1, int var2) {
+      this.reserve(8);
+      this.writeHead((byte) 9, var2);
+      this.write(var1.length, 0);
+      int var3 = var1.length;
+
+      for (var2 = 0; var2 < var3; ++var2) {
+         this.write(var1[var2], 0);
+      }
+
+   }
+
+   public void write(boolean[] var1, int var2) {
+      this.reserve(8);
+      this.writeHead((byte) 9, var2);
+      this.write(var1.length, 0);
+      int var3 = var1.length;
+
+      for (var2 = 0; var2 < var3; ++var2) {
+         this.write(var1[var2], 0);
+      }
+
+   }
+
+   public void writeByteString(String var1, int var2) {
+      this.reserve(var1.length() + 10);
+      byte[] var3 = HexUtil.hexStr2Bytes(var1);
+      if (var3.length > 255) {
+         this.writeHead((byte) 7, var2);
+         this.field_80728.putInt(var3.length);
+         this.field_80728.put(var3);
+      } else {
+         this.writeHead((byte) 6, var2);
+         this.field_80728.put((byte) var3.length);
+         this.field_80728.put(var3);
+      }
+   }
+
+   public void writeHead(byte var1, int var2) {
+      byte var3;
+      if (var2 < 15) {
+         var3 = (byte) (var2 << 4 | var1);
+         this.field_80728.put(var3);
+      } else if (var2 < 256) {
+         var3 = (byte) (var1 | 240);
+         this.field_80728.put(var3);
+         this.field_80728.put((byte) var2);
+      } else {
+         throw new JceEncodeException("tag is too large: " + var2);
+      }
+   }
+
+   public void writeStringByte(String var1, int var2) {
+      byte[] var3 = HexUtil.hexStr2Bytes(var1);
+      this.reserve(var3.length + 10);
+      if (var3.length > 255) {
+         this.writeHead((byte) 7, var2);
+         this.field_80728.putInt(var3.length);
+         this.field_80728.put(var3);
+      } else {
+         this.writeHead((byte) 6, var2);
+         this.field_80728.put((byte) var3.length);
+         this.field_80728.put(var3);
+      }
+   }
+}

mirai-debug/src/test/java/jce/jce/JceStruct.java

+package jce.jce;
+
+import java.io.Serializable;
+
+public abstract class JceStruct implements Serializable {
+   public static final byte BYTE = 0;
+   public static final byte DOUBLE = 5;
+   public static final byte FLOAT = 4;
+   public static final byte INT = 2;
+   public static final int JCE_MAX_STRING_LENGTH = 104857600;
+   public static final byte LIST = 9;
+   public static final byte LONG = 3;
+   public static final byte MAP = 8;
+   public static final byte SHORT = 1;
+   public static final byte SIMPLE_LIST = 13;
+   public static final byte STRING1 = 6;
+   public static final byte STRING4 = 7;
+   public static final byte STRUCT_BEGIN = 10;
+   public static final byte STRUCT_END = 11;
+   public static final byte ZERO_TAG = 12;
+
+   public static String toDisplaySimpleString(JceStruct var0) {
+      if (var0 == null) {
+         return null;
+      } else {
+         StringBuilder var1 = new StringBuilder();
+         var0.displaySimple(var1, 0);
+         return var1.toString();
+      }
+   }
+
+   public boolean containField(String var1) {
+      return false;
+   }
+
+   public void display(StringBuilder var1, int var2) {
+   }
+
+   public void displaySimple(StringBuilder var1, int var2) {
+   }
+
+   public Object getFieldByName(String var1) {
+      return null;
+   }
+
+   public JceStruct newInit() {
+      return null;
+   }
+
+   public abstract void readFrom(JceInputStream var1);
+
+   public void recyle() {
+   }
+
+   public void setFieldByName(String var1, Object var2) {
+   }
+
+   public byte[] toByteArray() {
+      JceOutputStream var1 = new JceOutputStream();
+      this.writeTo(var1);
+      return var1.toByteArray();
+   }
+
+   public byte[] toByteArray(String var1) {
+      JceOutputStream var2 = new JceOutputStream();
+      var2.setServerEncoding(var1);
+      this.writeTo(var2);
+      return var2.toByteArray();
+   }
+
+   public String toString() {
+      StringBuilder var1 = new StringBuilder();
+      this.display(var1, 0);
+      return var1.toString();
+   }
+
+   public abstract void writeTo(JceOutputStream var1);
+}

mirai-debug/src/test/java/jce/jce/JceUtil.java

+package jce.jce;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+import java.util.List;
+
+public final class JceUtil {
+    private static final byte[] highDigits;
+    private static final int iConstant = 37;
+    private static final int iTotal = 17;
+    private static final byte[] lowDigits;
+
+    static {
+        byte[] var1 = new byte[]{48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70};
+        byte[] var2 = new byte[256];
+        byte[] var3 = new byte[256];
+
+        for (int var0 = 0; var0 < 256; ++var0) {
+            var2[var0] = var1[var0 >>> 4];
+            var3[var0] = var1[var0 & 15];
+        }
+
+        highDigits = var2;
+        lowDigits = var3;
+    }
+
+    public static int compareTo(byte var0, byte var1) {
+        if (var0 < var1) {
+            return -1;
+        } else {
+            return var0 > var1 ? 1 : 0;
+        }
+    }
+
+    public static int compareTo(char var0, char var1) {
+        if (var0 < var1) {
+            return -1;
+        } else {
+            return var0 > var1 ? 1 : 0;
+        }
+    }
+
+    public static int compareTo(double var0, double var2) {
+        if (var0 < var2) {
+            return -1;
+        } else {
+            return var0 > var2 ? 1 : 0;
+        }
+    }
+
+    public static int compareTo(float var0, float var1) {
+        if (var0 < var1) {
+            return -1;
+        } else {
+            return var0 > var1 ? 1 : 0;
+        }
+    }
+
+    public static int compareTo(int var0, int var1) {
+        if (var0 < var1) {
+            return -1;
+        } else {
+            return var0 > var1 ? 1 : 0;
+        }
+    }
+
+    public static int compareTo(long var0, long var2) {
+        if (var0 < var2) {
+            return -1;
+        } else {
+            return var0 > var2 ? 1 : 0;
+        }
+    }
+
+    public static <T extends Comparable<T>> int compareTo(T var0, T var1) {
+        return var0.compareTo(var1);
+    }
+
+    public static <T extends Comparable<T>> int compareTo(List<T> var0, List<T> var1) {
+        Iterator var3 = var0.iterator();
+        Iterator var4 = var1.iterator();
+
+        while (var3.hasNext() && var4.hasNext()) {
+            int var2 = ((Comparable) var3.next()).compareTo(var4.next());
+            if (var2 != 0) {
+                return var2;
+            }
+        }
+
+        return compareTo(var3.hasNext(), var4.hasNext());
+    }
+
+    public static int compareTo(short var0, short var1) {
+        if (var0 < var1) {
+            return -1;
+        } else {
+            return var0 > var1 ? 1 : 0;
+        }
+    }
+
+    public static int compareTo(boolean var0, boolean var1) {
+        byte var3 = 1;
+        byte var2;
+        if (var0) {
+            var2 = 1;
+        } else {
+            var2 = 0;
+        }
+
+        if (!var1) {
+            var3 = 0;
+        }
+
+        return var2 - var3;
+    }
+
+    public static int compareTo(byte[] var0, byte[] var1) {
+        int var3 = 0;
+
+        for (int var2 = 0; var2 < var0.length && var3 < var1.length; ++var2) {
+            int var4 = compareTo(var0[var2], var1[var3]);
+            if (var4 != 0) {
+                return var4;
+            }
+
+            ++var3;
+        }
+
+        return compareTo(var0.length, var1.length);
+    }
+
+    public static int compareTo(char[] var0, char[] var1) {
+        int var3 = 0;
+
+        for (int var2 = 0; var2 < var0.length && var3 < var1.length; ++var2) {
+            int var4 = compareTo(var0[var2], var1[var3]);
+            if (var4 != 0) {
+                return var4;
+            }
+
+            ++var3;
+        }
+
+        return compareTo(var0.length, var1.length);
+    }
+
+    public static int compareTo(double[] var0, double[] var1) {
+        int var3 = 0;
+
+        for (int var2 = 0; var2 < var0.length && var3 < var1.length; ++var2) {
+            int var4 = compareTo(var0[var2], var1[var3]);
+            if (var4 != 0) {
+                return var4;
+            }
+
+            ++var3;
+        }
+
+        return compareTo(var0.length, var1.length);
+    }
+
+    public static int compareTo(float[] var0, float[] var1) {
+        int var3 = 0;
+
+        for (int var2 = 0; var2 < var0.length && var3 < var1.length; ++var2) {
+            int var4 = compareTo(var0[var2], var1[var3]);
+            if (var4 != 0) {
+                return var4;
+            }
+
+            ++var3;
+        }
+
+        return compareTo(var0.length, var1.length);
+    }
+
+    public static int compareTo(int[] var0, int[] var1) {
+        int var3 = 0;
+
+        for (int var2 = 0; var2 < var0.length && var3 < var1.length; ++var2) {
+            int var4 = compareTo(var0[var2], var1[var3]);
+            if (var4 != 0) {
+                return var4;
+            }
+
+            ++var3;
+        }
+
+        return compareTo(var0.length, var1.length);
+    }
+
+    public static int compareTo(long[] var0, long[] var1) {
+        int var3 = 0;
+
+        for (int var2 = 0; var2 < var0.length && var3 < var1.length; ++var2) {
+            int var4 = compareTo(var0[var2], var1[var3]);
+            if (var4 != 0) {
+                return var4;
+            }
+
+            ++var3;
+        }
+
+        return compareTo(var0.length, var1.length);
+    }
+
+    public static <T extends Comparable<T>> int compareTo(T[] var0, T[] var1) {
+        int var3 = 0;
+
+        for (int var2 = 0; var2 < var0.length && var3 < var1.length; ++var2) {
+            int var4 = var0[var2].compareTo(var1[var3]);
+            if (var4 != 0) {
+                return var4;
+            }
+
+            ++var3;
+        }
+
+        return compareTo(var0.length, var1.length);
+    }
+
+    public static int compareTo(short[] var0, short[] var1) {
+        int var3 = 0;
+
+        for (int var2 = 0; var2 < var0.length && var3 < var1.length; ++var2) {
+            int var4 = compareTo(var0[var2], var1[var3]);
+            if (var4 != 0) {
+                return var4;
+            }
+
+            ++var3;
+        }
+
+        return compareTo(var0.length, var1.length);
+    }
+
+    public static int compareTo(boolean[] var0, boolean[] var1) {
+        int var3 = 0;
+
+        for (int var2 = 0; var2 < var0.length && var3 < var1.length; ++var2) {
+            int var4 = compareTo(var0[var2], var1[var3]);
+            if (var4 != 0) {
+                return var4;
+            }
+
+            ++var3;
+        }
+
+        return compareTo(var0.length, var1.length);
+    }
+
+    public static boolean equals(byte var0, byte var1) {
+        return var0 == var1;
+    }
+
+    public static boolean equals(char var0, char var1) {
+        return var0 == var1;
+    }
+
+    public static boolean equals(double var0, double var2) {
+        return var0 == var2;
+    }
+
+    public static boolean equals(float var0, float var1) {
+        return var0 == var1;
+    }
+
+    public static boolean equals(int var0, int var1) {
+        return var0 == var1;
+    }
+
+    public static boolean equals(long var0, long var2) {
+        return var0 == var2;
+    }
+
+    public static boolean equals(Object var0, Object var1) {
+        return var0.equals(var1);
+    }
+
+    public static boolean equals(short var0, short var1) {
+        return var0 == var1;
+    }
+
+    public static boolean equals(boolean var0, boolean var1) {
+        return var0 == var1;
+    }
+
+    public static String getHexdump(ByteBuffer var0) {
+        int var1 = var0.remaining();
+        if (var1 == 0) {
+            return "empty";
+        } else {
+            StringBuffer var4 = new StringBuffer(var0.remaining() * 3 - 1);
+            int var2 = var0.position();
+            int var3 = var0.get() & 255;
+            var4.append((char) highDigits[var3]);
+            var4.append((char) lowDigits[var3]);
+            --var1;
+
+            while (var1 > 0) {
+                var4.append(' ');
+                var3 = var0.get() & 255;
+                var4.append((char) highDigits[var3]);
+                var4.append((char) lowDigits[var3]);
+                --var1;
+            }
+
+            var0.position(var2);
+            return var4.toString();
+        }
+    }
+
+    public static String getHexdump(byte[] var0) {
+        return getHexdump(ByteBuffer.wrap(var0));
+    }
+
+    public static byte[] getJceBufArray(ByteBuffer var0) {
+        byte[] var1 = new byte[var0.position()];
+        System.arraycopy(var0.array(), 0, var1, 0, var1.length);
+        return var1;
+    }
+
+    public static int hashCode(byte var0) {
+        return var0 + 629;
+    }
+
+    public static int hashCode(char var0) {
+        return var0 + 629;
+    }
+
+    public static int hashCode(double var0) {
+        return hashCode(Double.doubleToLongBits(var0));
+    }
+
+    public static int hashCode(float var0) {
+        return Float.floatToIntBits(var0) + 629;
+    }
+
+    public static int hashCode(int var0) {
+        return var0 + 629;
+    }
+
+    public static int hashCode(long var0) {
+        return (int) (var0 >> 32 ^ var0) + 629;
+    }
+
+    public static int hashCode(Object var0) {
+        if (var0 == null) {
+            return 629;
+        } else if (var0.getClass().isArray()) {
+            if (var0 instanceof long[]) {
+                return hashCode((long[]) ((long[]) var0));
+            } else if (var0 instanceof int[]) {
+                return hashCode((int[]) ((int[]) var0));
+            } else if (var0 instanceof short[]) {
+                return hashCode((short[]) ((short[]) var0));
+            } else if (var0 instanceof char[]) {
+                return hashCode((char[]) ((char[]) var0));
+            } else if (var0 instanceof byte[]) {
+                return hashCode((byte[]) ((byte[]) var0));
+            } else if (var0 instanceof double[]) {
+                return hashCode((double[]) ((double[]) var0));
+            } else if (var0 instanceof float[]) {
+                return hashCode((float[]) ((float[]) var0));
+            } else if (var0 instanceof boolean[]) {
+                return hashCode((boolean[]) ((boolean[]) var0));
+            } else {
+                return var0 instanceof JceStruct[] ? hashCode((JceStruct[]) ((JceStruct[]) var0)) : hashCode((Object) ((Object[]) ((Object[]) var0)));
+            }
+        } else {
+            return var0 instanceof JceStruct ? var0.hashCode() : var0.hashCode() + 629;
+        }
+    }
+
+    public static int hashCode(short var0) {
+        return var0 + 629;
+    }
+
+    public static int hashCode(boolean var0) {
+        byte var1;
+        if (var0) {
+            var1 = 0;
+        } else {
+            var1 = 1;
+        }
+
+        return var1 + 629;
+    }
+
+    public static int hashCode(byte[] var0) {
+        int var3;
+        if (var0 == null) {
+            var3 = 629;
+        } else {
+            int var1 = 17;
+            int var2 = 0;
+
+            while (true) {
+                var3 = var1;
+                if (var2 >= var0.length) {
+                    break;
+                }
+
+                var1 = var1 * 37 + var0[var2];
+                ++var2;
+            }
+        }
+
+        return var3;
+    }
+
+    public static int hashCode(char[] var0) {
+        int var3;
+        if (var0 == null) {
+            var3 = 629;
+        } else {
+            int var1 = 17;
+            int var2 = 0;
+
+            while (true) {
+                var3 = var1;
+                if (var2 >= var0.length) {
+                    break;
+                }
+
+                var1 = var1 * 37 + var0[var2];
+                ++var2;
+            }
+        }
+
+        return var3;
+    }
+
+    public static int hashCode(double[] var0) {
+        int var3;
+        if (var0 == null) {
+            var3 = 629;
+        } else {
+            int var1 = 17;
+            int var2 = 0;
+
+            while (true) {
+                var3 = var1;
+                if (var2 >= var0.length) {
+                    break;
+                }
+
+                var1 = var1 * 37 + (int) (Double.doubleToLongBits(var0[var2]) ^ Double.doubleToLongBits(var0[var2]) >> 32);
+                ++var2;
+            }
+        }
+
+        return var3;
+    }
+
+    public static int hashCode(float[] var0) {
+        int var3;
+        if (var0 == null) {
+            var3 = 629;
+        } else {
+            int var1 = 17;
+            int var2 = 0;
+
+            while (true) {
+                var3 = var1;
+                if (var2 >= var0.length) {
+                    break;
+                }
+
+                var1 = var1 * 37 + Float.floatToIntBits(var0[var2]);
+                ++var2;
+            }
+        }
+
+        return var3;
+    }
+
+    public static int hashCode(int[] var0) {
+        int var3;
+        if (var0 == null) {
+            var3 = 629;
+        } else {
+            int var1 = 17;
+            int var2 = 0;
+
+            while (true) {
+                var3 = var1;
+                if (var2 >= var0.length) {
+                    break;
+                }
+
+                var1 = var1 * 37 + var0[var2];
+                ++var2;
+            }
+        }
+
+        return var3;
+    }
+
+    public static int hashCode(long[] var0) {
+        int var3;
+        if (var0 == null) {
+            var3 = 629;
+        } else {
+            int var1 = 17;
+            int var2 = 0;
+
+            while (true) {
+                var3 = var1;
+                if (var2 >= var0.length) {
+                    break;
+                }
+
+                var1 = var1 * 37 + (int) (var0[var2] ^ var0[var2] >> 32);
+                ++var2;
+            }
+        }
+
+        return var3;
+    }
+
+    public static int hashCode(JceStruct[] var0) {
+        int var3;
+        if (var0 == null) {
+            var3 = 629;
+        } else {
+            int var1 = 17;
+            int var2 = 0;
+
+            while (true) {
+                var3 = var1;
+                if (var2 >= var0.length) {
+                    break;
+                }
+
+                var1 = var1 * 37 + var0[var2].hashCode();
+                ++var2;
+            }
+        }
+
+        return var3;
+    }
+
+    public static int hashCode(short[] var0) {
+        int var3;
+        if (var0 == null) {
+            var3 = 629;
+        } else {
+            int var1 = 17;
+            int var2 = 0;
+
+            while (true) {
+                var3 = var1;
+                if (var2 >= var0.length) {
+                    break;
+                }
+
+                var1 = var1 * 37 + var0[var2];
+                ++var2;
+            }
+        }
+
+        return var3;
+    }
+
+    public static int hashCode(boolean[] var0) {
+        int var3;
+        if (var0 == null) {
+            var3 = 629;
+        } else {
+            int var1 = 17;
+            int var2 = 0;
+
+            while (true) {
+                var3 = var1;
+                if (var2 >= var0.length) {
+                    break;
+                }
+
+                byte var4;
+                if (var0[var2]) {
+                    var4 = 0;
+                } else {
+                    var4 = 1;
+                }
+
+                var1 = var4 + var1 * 37;
+                ++var2;
+            }
+        }
+
+        return var3;
+    }
+}

mirai-debug/src/test/java/jce/jce/OnIllegalArgumentException.java

+package jce.jce;
+
+import java.nio.ByteBuffer;
+
+public interface OnIllegalArgumentException {
+   void onException(IllegalArgumentException var1, ByteBuffer var2, int var3, int var4);
+}

mirai-debug/src/test/kotlin/jceTest/jceTest.kt

+package jceTest
+
+import io.ktor.util.InternalAPI
+import jce.jce.JceInputStream
+import jce.jce.JceOutputStream
+import jce.jce.JceStruct
+import kotlinx.io.core.ByteReadPacket
+import kotlinx.io.core.readBytes
+import net.mamoe.mirai.qqandroid.network.io.JceInput
+import net.mamoe.mirai.qqandroid.network.io.JceOutput
+import net.mamoe.mirai.qqandroid.network.io.buildJcePacket
+import net.mamoe.mirai.utils.io.toUHexString
+import org.junit.Test
+
+private infix fun ByteReadPacket.shouldEqualTo(another: ByteArray) {
+    this.readBytes().let {
+        check(it.contentEquals(another)) {
+            """actual:   ${it.toUHexString()}
+              |required: ${another.toUHexString()} 
+        """.trimMargin()
+        }
+    }
+}
+
+@UseExperimental(InternalAPI::class)
+private fun qqJce(block: JceOutputStream.() -> Unit): ByteArray {
+    return JceOutputStream().apply(block).toByteArray()
+}
+
+internal class JceOutputTest {
+
+    @Test
+    fun writeByte() {
+        buildJcePacket {
+            writeByte(1, 1)
+            writeByte(-128, 2)
+        } shouldEqualTo qqJce {
+            write(1.toByte(), 1)
+            write((-128).toByte(), 2)
+        }
+    }
+
+    @Test
+    fun writeDouble() {
+        buildJcePacket {
+            writeDouble(1.0, 1)
+            writeDouble(-128.0, 2)
+        } shouldEqualTo qqJce {
+            write(1.toDouble(), 1)
+            write((-128).toDouble(), 2)
+        }
+    }
+
+    @Test
+    fun writeFloat() {
+        buildJcePacket {
+            writeFloat(1.0f, 1)
+            writeFloat(-128.0f, 2)
+        } shouldEqualTo qqJce {
+            write(1.toFloat(), 1)
+            write((-128).toFloat(), 2)
+        }
+    }
+
+    @Test
+    fun writeFully() {
+        buildJcePacket {
+            writeFully(byteArrayOf(1, 2), 1)
+            writeFully(byteArrayOf(1, 2), 2)
+        } shouldEqualTo qqJce {
+            write(byteArrayOf(1, 2), 1)
+            write(byteArrayOf(1, 2), 2)
+        }
+    }
+
+    @Test
+    fun testWriteFully() {
+        buildJcePacket {
+            writeFully(intArrayOf(1, 2), 1)
+            writeFully(intArrayOf(1, 2), 2)
+        } shouldEqualTo qqJce {
+            write(intArrayOf(1, 2), 1)
+            write(intArrayOf(1, 2), 2)
+        }
+    }
+
+    @Test
+    fun testWriteFully1() {
+        buildJcePacket {
+            writeFully(shortArrayOf(1, 2), 1)
+            writeFully(shortArrayOf(1, 2), 2)
+        } shouldEqualTo qqJce {
+            write(shortArrayOf(1, 2), 1)
+            write(shortArrayOf(1, 2), 2)
+        }
+    }
+
+    @Test
+    fun testWriteFully2() {
+        buildJcePacket {
+            writeFully(booleanArrayOf(true, false), 1)
+            writeFully(booleanArrayOf(true, false), 2)
+        } shouldEqualTo qqJce {
+            write(booleanArrayOf(true, false), 1)
+            write(booleanArrayOf(true, false), 2)
+        }
+    }
+
+    @Test
+    fun testWriteFully3() {
+        buildJcePacket {
+            writeFully(longArrayOf(1, 2), 1)
+            writeFully(longArrayOf(1, 2), 2)
+        } shouldEqualTo qqJce {
+            write(longArrayOf(1, 2), 1)
+            write(longArrayOf(1, 2), 2)
+        }
+    }
+
+    @Test
+    fun testWriteFully4() {
+        buildJcePacket {
+            writeFully(floatArrayOf(1f, 2f), 1)
+            writeFully(floatArrayOf(1f, 2f), 2)
+        } shouldEqualTo qqJce {
+            write(floatArrayOf(1f, 2f), 1)
+            write(floatArrayOf(1f, 2f), 2)
+        }
+    }
+
+    @Test
+    fun testWriteFully5() {
+        buildJcePacket {
+            writeFully(doubleArrayOf(1.0, 2.0), 1)
+            writeFully(doubleArrayOf(1.0, 2.0), 2)
+        } shouldEqualTo qqJce {
+            write(doubleArrayOf(1.0, 2.0), 1)
+            write(doubleArrayOf(1.0, 2.0), 2)
+        }
+    }
+
+    @Test
+    fun testWriteFully6() {
+        buildJcePacket {
+            writeFully(arrayOf("123", "哈哈"), 1)
+            writeFully(arrayOf("123", "哈哈"), 2)
+        } shouldEqualTo qqJce {
+            write(arrayOf("123", "哈哈"), 1)
+            write(arrayOf("123", "哈哈"), 2)
+        }
+    }
+
+    @Test
+    fun writeInt() {
+        buildJcePacket {
+            writeInt(1, 1)
+            writeInt(-128, 2)
+        } shouldEqualTo qqJce {
+            write(1, 1)
+            write(-128, 2)
+        }
+    }
+
+    @Test
+    fun writeLong() {
+        buildJcePacket {
+            writeLong(1, 1)
+            writeLong(-128, 2)
+        } shouldEqualTo qqJce {
+            write(1L, 1)
+            write(-128L, 2)
+        }
+    }
+
+    @Test
+    fun writeShort() {
+        buildJcePacket {
+            writeShort(1, 1)
+            writeShort(-128, 2)
+        } shouldEqualTo qqJce {
+            write(1.toShort(), 1)
+            write((-128).toShort(), 2)
+        }
+    }
+
+    @Test
+    fun writeBoolean() {
+        buildJcePacket {
+            writeBoolean(true, 1)
+            writeBoolean(false, 2)
+        } shouldEqualTo qqJce {
+            write(true, 1)
+            write(false, 2)
+        }
+    }
+
+    @Test
+    fun writeString() {
+        buildJcePacket {
+            writeString("1", 1)
+            writeString("哈啊", 2)
+        } shouldEqualTo qqJce {
+            write("1", 1)
+            write("哈啊", 2)
+        }
+    }
+
+    @Test
+    fun writeMap() {
+        buildJcePacket {
+            writeMap(mapOf("" to ""), 1)
+            writeMap(mapOf("" to 123), 2)
+            writeMap(mapOf(123.0 to "Hello"), 3)
+        } shouldEqualTo qqJce {
+            write(mapOf("" to ""), 1)
+            write(mapOf("" to 123), 2)
+            write(mapOf(123.0 to "Hello"), 3)
+        }
+    }
+
+    @Test
+    fun writeCollection() {
+        buildJcePacket {
+            writeMap(mapOf("" to ""), 1)
+            writeMap(mapOf("" to 123), 2)
+            writeMap(mapOf(123.0 to "Hello"), 3)
+        } shouldEqualTo qqJce {
+            write(mapOf("" to ""), 1)
+            write(mapOf("" to 123), 2)
+            write(mapOf(123.0 to "Hello"), 3)
+        }
+    }
+
+    data class TestMiraiStruct(
+        val message: String
+    ) : net.mamoe.mirai.qqandroid.network.io.JceStruct() {
+        override fun writeTo(builder: JceOutput) {
+            builder.writeString(message, 0)
+        }
+
+        companion object : Factory<TestMiraiStruct> {
+            override fun newInstanceFrom(input: JceInput): TestMiraiStruct {
+                return TestMiraiStruct(input.readString(0))
+            }
+        }
+    }
+
+    class TestQQStruct(
+        private var message: String
+    ) : JceStruct() {
+        override fun readFrom(var1: JceInputStream) {
+            message = var1.read("", 0, true)
+        }
+
+        override fun writeTo(var1: JceOutputStream) {
+            var1.write(message, 0)
+        }
+    }
+
+    @Test
+    fun writeJceStruct() {
+        buildJcePacket {
+            writeJceStruct(TestMiraiStruct("Hello"), 0)
+            writeJceStruct(TestMiraiStruct("嗨"), 1)
+        } shouldEqualTo qqJce {
+            write(TestQQStruct("Hello"), 0)
+            write(TestQQStruct("嗨"), 1)
+        }
+    }
+
+    @Test
+    fun writeObject() {
+        buildJcePacket {
+            writeObject(0.toByte(), 1)
+            writeObject(0.toShort(), 2)
+            writeObject(0, 3)
+            writeObject(0L, 4)
+            writeObject(0f, 5)
+            writeObject(0.0, 6)
+            writeObject("hello", 7)
+            writeObject(TestMiraiStruct("Hello"), 8)
+        } shouldEqualTo qqJce {
+            write(0.toByte(), 1)
+            write(0.toShort(), 2)
+            write(0, 3)
+            write(0L, 4)
+            write(0f, 5)
+            write(0.0, 6)
+            write("hello", 7)
+            write(TestQQStruct("Hello"), 8)
+        }
+    }
+}
\ No newline at end of file