diff --git a/src/test/java/encoding/EncoderTest.java b/src/test/java/encoding/EncoderTest.java
new file mode 100644
index 0000000..144ec17
--- /dev/null
+++ b/src/test/java/encoding/EncoderTest.java
@@ -0,0 +1,525 @@
+package encoding;
+
+import org.junit.Test;
+import util.ByteHelper;
+
+
+import java.math.BigInteger;
+
+import static org.junit.Assert.*;
+
+/*
+ * @Author: feng Zhao
+ * @Description:
+ * @Version: 1.0.0
+ * @Date: 22:40 2021/3/14
+ * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
+ */
+
+public class EncoderTest {
+    int MaxPacketSize = 8800;
+    @Test
+    public void TestEmpty() {
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        estimator.estimatorReset();
+
+        assertTrue(encoder.empty());
+        assertTrue(estimator.empty());
+
+        encoder.prependByte((byte)20);
+        estimator.prependByte((byte)20);
+
+        assertFalse(encoder.empty());
+        assertFalse(estimator.empty());
+
+
+    }
+
+    @Test
+    public void TestEncoder_PrependByte(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        estimator.estimatorReset();
+        // 测试前向添加 MaxPacketSize 次是否正常
+        for (int i = 0; i < MaxPacketSize; i++) {
+            int num = encoder.prependByte((byte) 97);
+            estimator.prependByte((byte) 97);
+            assertEquals(encoder.left,MaxPacketSize-i-2);
+            assertEquals(encoder.buffer[MaxPacketSize-i-1],(byte)97);
+            //todo 这里要用encoder.size().getVlIntValue2Int()，还是encoder.size().size()
+//            assertEquals(encoder.size().size(),i+1);
+//            assertEquals(estimator.size().size(),i+1);
+            assertEquals(encoder.size().getVlIntValue2Int(),i+1);
+            assertEquals(estimator.size().getVlIntValue2Int(),i+1);
+            assertFalse(encoder.empty());
+            assertFalse(estimator.empty());
+            assertEquals(num,1);
+        }
+//        for (int i = 0; i < MaxPacketSize; i++) {
+//            int num = encoder.prependByte((byte) 97);
+//            estimator.prependByte((byte) 97);
+//            if ((encoder.left == MaxPacketSize-i-2) ||
+//                    (encoder.buffer[MaxPacketSize-i-1] != (byte)97) ||
+//                    (encoder.size() != new SizeT(i+1)) ||
+//                    (estimator.size() != new SizeT(i+1)) ||
+//                    encoder.empty() || estimator.empty()|| (num != 1))
+//            {
+//                System.out.println("PrependByte Failed"+ i);
+//                return;
+//            }
+//        }
+
+        // 测试超出最大包大小的情况
+        int a = encoder.prependByte((byte)1);
+        assertEquals(a,0);
+    }
+
+    @Test
+    public void TestEncoder_AppendByte(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
+        estimator.estimatorReset();
+
+        // 测试后向添加 MaxPacketSize 次是否正常
+        for (int i = 0; i < MaxPacketSize; i++) {
+            int num = encoder.appendByte((byte) 97);
+            estimator.appendByte((byte) 97);
+            assertEquals(encoder.right, i + 1);
+            assertEquals(encoder.buffer[i],(byte)97);
+            //todo 这里要用encoder.size().getVlIntValue2Int()，还是encoder.size().size()
+//            assertEquals(encoder.size().size(),i+1);
+//            assertEquals(estimator.size().size(),i+1);
+            assertEquals(encoder.size().getVlIntValue2Int(),i+1);
+            assertEquals(estimator.size().getVlIntValue2Int(),i+1);
+            assertFalse(encoder.empty());
+            assertFalse(estimator.empty());
+            assertEquals(num,1);
+        }
+
+        // 测试超出最大包大小的情况
+        int a = encoder.appendByte((byte) 1);
+        assertEquals(a,0);
+        int b = encoder.prependByte((byte) 1);
+        assertEquals(b,0);
+
+    }
+
+    @Test
+    public void TestEncoder_PrependByteArray(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        estimator.estimatorReset();
+
+        byte[] arr = new byte[]{1,2,3,4,5};
+        int length = arr.length;
+        // 测试prepend，没有超过MaxPacketSize
+        int num1 = encoder.prependByteArray(arr, new SizeT(length));
+        estimator.prependByteArray(arr, new SizeT(length));
+        assertEquals(encoder.size().getVlIntValue2Int(), length);
+        assertEquals(estimator.size().getVlIntValue2Int(), length);
+        assertEquals(num1,length);
+
+        // 检查插入的数据是否正确
+        byte[] newSlice = ByteHelper.getLenBytes(encoder.buffer, new VlInt(MaxPacketSize - length), length);
+        for (int i = 0; i < length; i++) {
+            assertEquals(arr[i],newSlice[i]);
+        }
+
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
+        // 测试prepend，超过MaxPacketSize的情况
+        int times = MaxPacketSize / arr.length + 1;
+        for (int i = 0; i < times - 1; i++) {
+            int num2 = encoder.prependByteArray(arr, new SizeT(length));
+            assertEquals(num2,length);
+        }
+        int num3 = encoder.prependByteArray(arr, new SizeT(length));
+        assertEquals(num3,0);
+    }
+
+    @Test
+    public void TestEncoder_AppendByteArray(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
+        estimator.estimatorReset();
+
+        byte[] arr = new byte[]{1, 2, 3, 4, 5};
+        int length = arr.length;
+
+        // 测试append，没有超过MaxPacketSize
+        int num1 = encoder.appendByteArray(arr, new SizeT(length));
+        estimator.appendByteArray(arr, new SizeT(length));
+        assertEquals(encoder.size().getVlIntValue2Int(), length);
+        assertEquals(estimator.size().getVlIntValue2Int(), length);
+        assertEquals(num1, length);
+
+        // 检查插入的数据是否正确
+        byte[] newSlice = ByteHelper.getLenBytes(encoder.buffer, new VlInt(0), length);
+        for (int i = 0; i < length; i++) {
+            assertEquals(arr[i],newSlice[i]);
+        }
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
+
+        // 测试prepend，超过MaxPacketSize的情况
+        int times = MaxPacketSize / arr.length + 1;
+        for (int i = 0; i < times - 1; i++) {
+            int num2 = encoder.appendByteArray(arr, new SizeT(length));
+            assertEquals(num2,length);
+        }
+        int num3 = encoder.appendByteArray(arr, new SizeT(length));
+        assertEquals(num3,0);
+
+
+    }
+
+    //error
+    @Test
+    public void TestPrependVarNumber(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        estimator.estimatorReset();
+
+        // 测试添加240
+        int addLen = encoder.prependVarNumber(new VlInt(240));
+        byte[] buffer1 = encoder.getBuffer();
+        assertEquals(buffer1[0], (byte) 240);
+        assertEquals(buffer1.length,1);
+        assertEquals(addLen, 1);
+
+        // 测试添加16位整型所能表示的最大值
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        encoder.prependVarNumber(new VlInt(65535));
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp = ByteHelper.getLenBytes(buffer1, new VlInt(1), 2);
+        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
+        assertEquals(buffer1.length,3);
+        assertEquals(buffer1[0], (byte) 241);
+        assertEquals(num1,65535);
+
+        // 测试添加16位整型所能表示的最大值 + 1
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        encoder.prependVarNumber(new VlInt(65536));
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp2 = ByteHelper.getLenBytes(buffer1, new VlInt(1), 4);
+        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
+        assertEquals(buffer1.length,5);
+        assertEquals(buffer1[0], (byte) 242);
+        assertEquals(num2,65536);
+
+        // 测试添加32位整型所能表示的最大值 + 1
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        encoder.prependVarNumber(new VlInt(4294967296L));
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp3 = ByteHelper.getLenBytes(buffer1, new VlInt(1), 8);
+//        for (int i = 0; i < buf_tmp3.length; i++) {
+//            System.out.println(buf_tmp3[i]);
+//        }
+//        System.out.println("buf_tmp3.length:"+buf_tmp3.length);
+        long num3 = ByteHelper.uint64ToLong(buf_tmp3);
+        System.out.println("num3:"+num3);
+        assertEquals(buffer1.length,9);
+        assertEquals(buffer1[0], (byte) 243);
+        assertEquals(num3,4294967296L);
+
+        // TODO 测试添加64位整型所能表示的最大值
+        // uint64最大值在java中无法表示
+
+    }
+
+
+
+
+    @Test
+    public void TestAppendVarNumber(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
+        estimator.estimatorReset();
+
+        // 测试添加240
+        int addLen = encoder.appendVarNumber(new VlInt(240));
+        byte[] buffer1 = encoder.getBuffer();
+        assertEquals(buffer1[0], (byte) 240);
+        assertEquals(buffer1.length,1);
+        assertEquals(addLen, 1);
+
+        // 测试添加16位整型所能表示的最大值
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        encoder.appendVarNumber(new VlInt(65535));
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp = ByteHelper.getLenBytes(buffer1, new VlInt(1), 2);
+        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
+        assertEquals(buffer1.length,3);
+        assertEquals(buffer1[0], (byte) 241);
+        assertEquals(num1,65535);
+
+        // 测试添加16位整型所能表示的最大值 + 1
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        encoder.appendVarNumber(new VlInt(65536));
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp2 = ByteHelper.getLenBytes(buffer1, new VlInt(1), 4);
+        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
+        assertEquals(buffer1.length,5);
+        assertEquals(buffer1[0], (byte) 242);
+        assertEquals(num2,65536);
+
+        // 测试添加32位整型所能表示的最大值 + 1
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        encoder.appendVarNumber(new VlInt(4294967296L));
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp3 = ByteHelper.getLenBytes(buffer1, new VlInt(1), 8);
+        long num3 = ByteHelper.uint64ToLong(buf_tmp3);
+        System.out.println("num3:"+num3);
+        assertEquals(buffer1.length,9);
+        assertEquals(buffer1[0], (byte) 243);
+        assertEquals(num3,4294967296L);
+
+        // TODO 测试添加64位整型所能表示的最大值
+        // uint64最大值在java中无法表示
+    }
+
+    @Test
+    public void TestPrependNonNegativeInteger(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
+        estimator.estimatorReset();
+
+        // 测试添加255
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
+        int addLen1 = encoder.prependNonNegativeInteger(255);
+        assertEquals(addLen1, 1);
+        byte[] buffer1 = encoder.getBuffer();
+        assertEquals(buffer1[0], (byte) 255);
+        assertEquals(buffer1.length,1);
+
+
+        // 添加 MaxUint16
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        int addLen2 = encoder.prependNonNegativeInteger(65535);
+        assertEquals(addLen2, 2);
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp = ByteHelper.getLenBytes(buffer1, new VlInt(0), 2);
+        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
+        assertEquals(buffer1.length,2);
+        assertEquals(num1,65535);
+
+        // 添加 MaxUint32
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        int addLen3 = encoder.prependNonNegativeInteger(4294967295L);
+        assertEquals(addLen3, 4);
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp2 = ByteHelper.getLenBytes(buffer1, new VlInt(0), 4);
+//        long num2 = ByteHelper.new_byteArrayToLong(buf_tmp2);
+        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
+        assertEquals(buffer1.length,4);
+        assertEquals(num2,4294967295L);
+
+        // 添加 MaxUint64
+        // TODO 测试添加64位整型所能表示的最大值
+    }
+
+    @Test
+    public void TestAppendNonNegativeInteger(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
+        estimator.estimatorReset();
+
+        // 测试添加255
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
+        int addLen1 = encoder.appendNonNegativeInteger(255);
+        assertEquals(addLen1, 1);
+        byte[] buffer1 = encoder.getBuffer();
+        assertEquals(buffer1[0], (byte) 255);
+        assertEquals(buffer1.length,1);
+
+        // 添加 MaxUint16
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        int addLen2 = encoder.appendNonNegativeInteger(65535);
+        assertEquals(addLen2, 2);
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp = ByteHelper.getLenBytes(buffer1, new VlInt(0), 2);
+        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
+        assertEquals(buffer1.length,2);
+        assertEquals(num1,65535);
+
+        // 添加 MaxUint32
+        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+        int addLen3 = encoder.appendNonNegativeInteger(4294967295L);
+        assertEquals(addLen3, 4);
+        buffer1 = encoder.getBuffer();
+        byte[] buf_tmp2 = ByteHelper.getLenBytes(buffer1, new VlInt(0), 4);
+        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
+        assertEquals(buffer1.length,4);
+        assertEquals(num2,4294967295L);
+
+        // 添加 MaxUint64
+        // TODO 测试添加64位整型所能表示的最大值
+//        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
+//        int addLen4 = encoder.appendNonNegativeInteger(18446744073709551615L);
+//        assertEquals(addLen4, 8);
+//        buffer1 = encoder.getBuffer();
+//        byte[] buf_tmp3 = ByteHelper.getLenBytes(buffer1, new VlInt(0), 8);
+//        long num3 = ByteHelper.new_byteArrayToLong(buf_tmp3);
+//        assertEquals(buffer1.length,8);
+//        assertEquals(num2,18446744073709551615L);
+    }
+
+    @Test
+    public void TestPrependByteArrayBlock(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
+        estimator.estimatorReset();
+
+        byte[] buf = new byte[8000];
+        for (int i = 1; i < 8000; i++) {
+            buf[i] = (byte)(buf[i-1] +1);
+        }
+        //测试插入数据正确性
+        int addLen = encoder.prependByteArrayBlock(new VlInt(241), buf, new SizeT(buf.length));
+        assertEquals(addLen,3+8000+3);
+        byte[] buf1 = encoder.getBuffer();
+        assertEquals(addLen,8006);
+        assertEquals(buf1.length,8006);
+        assertEquals(buf1[0],(byte)241);
+        assertEquals(buf1[3],(byte)241);
+        //buf1[1:3] == 241
+        byte[] buf_tmp = ByteHelper.getLenBytes(buf1, new VlInt(1), 2);
+        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
+        assertEquals(num1,241);
+        //buf1[4:6]==8000
+        byte[] buf_tmp2 = ByteHelper.getLenBytes(buf1, new VlInt(4), 2);
+        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
+        assertEquals(num2,8000);
+
+        //测试字节数组插入数据是否正确
+        int std = 0;  //uint:std
+        for (int i = 0; i < 8000; i++) {
+            assertEquals(buf1[6+i],std);
+            std = (std+1)%256;
+        }
+
+    }
+
+    @Test
+    public void TestAppendByteArrayBlock(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
+        estimator.estimatorReset();
+
+        byte[] buf = new byte[8000];
+        for (int i = 1; i < 8000; i++) {
+            buf[i] = (byte)(buf[i-1] +1);
+        }
+        //测试插入数据正确性
+        int addLen = encoder.appendByteArrayBlock(new VlInt(241), buf, new SizeT(buf.length));
+        assertEquals(addLen,3+8000+3);
+        byte[] buf1 = encoder.getBuffer();
+        assertEquals(addLen,8006);
+        assertEquals(buf1.length,8006);
+        assertEquals(buf1[0],(byte)241);
+        assertEquals(buf1[3],(byte)241);
+        //buf1[1:3] == 241
+        byte[] buf_tmp = ByteHelper.getLenBytes(buf1, new VlInt(1), 2);
+        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
+        assertEquals(num1,241);
+        //buf1[4:6]==8000
+        byte[] buf_tmp2 = ByteHelper.getLenBytes(buf1, new VlInt(4), 2);
+        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
+        assertEquals(num2,8000);
+
+        //测试字节数组插入数据是否正确
+        int std = 0;  //uint:std
+        for (int i = 0; i < 8000; i++) {
+            assertEquals(buf1[6+i],std);
+            std = (std+1)%256;
+        }
+
+    }
+
+    @Test
+    public void TestPrependBlock(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
+        estimator.estimatorReset();
+
+        byte[] buf = new byte[8000];
+        Block block = new Block();
+        block.setType(new VlInt(241));
+        block.setLength(new VlInt(8000));
+        block.setValue(buf);
+
+        int addLen = encoder.prependBlock(block);
+        assertEquals(addLen,8006);
+
+        byte[] buf1 = encoder.getBuffer();
+        assertEquals(addLen,8006);
+        assertEquals(buf1.length,8006);
+        assertEquals(buf1[0],(byte)241);
+        assertEquals(buf1[3],(byte)241);
+        //buf1[1:3] == 241
+        byte[] buf_tmp = ByteHelper.getLenBytes(buf1, new VlInt(1), 2);
+        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
+        assertEquals(num1,241);
+        //buf1[4:6]==8000
+        byte[] buf_tmp2 = ByteHelper.getLenBytes(buf1, new VlInt(4), 2);
+        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
+        assertEquals(num2,8000);
+    }
+
+    @Test
+    public void TestAppendBlock(){
+        Encoder encoder = new Encoder();
+        Encoder estimator = new Encoder();
+        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
+        estimator.estimatorReset();
+
+        byte[] buf = new byte[8000];
+        Block block = new Block();
+        block.setType(new VlInt(241));
+        block.setLength(new VlInt(8000));
+        block.setValue(buf);
+
+        int addLen = encoder.appendBlock(block);
+        assertEquals(addLen,8006);
+
+        byte[] buf1 = encoder.getBuffer();
+        assertEquals(addLen,8006);
+        assertEquals(buf1.length,8006);
+        assertEquals(buf1[0],(byte)241);
+        assertEquals(buf1[3],(byte)241);
+        //buf1[1:3] == 241
+        byte[] buf_tmp = ByteHelper.getLenBytes(buf1, new VlInt(1), 2);
+        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
+        assertEquals(num1,241);
+        //buf1[4:6]==8000
+        byte[] buf_tmp2 = ByteHelper.getLenBytes(buf1, new VlInt(4), 2);
+        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
+        assertEquals(num2,8000);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}