add test: MutableDangerousFieldTest

src/main/java/component/MutableDangerousField.java

@@ -12,129 +12,135 @@ import encoding.*;
 public class MutableDangerousField implements TlvComponentBase, IEncodingAble {
     private ElementContainer blocks;
 
-    public MutableDangerousField(){
-        blocks=new ElementContainer();
+    public MutableDangerousField() {
+        blocks = new ElementContainer();
     }
 
     /**
      * 往可变非受保护区添加一个Block
+     *
      * @param block
      */
-    public void addBlock(Block block){
+    public void addBlock(Block block) {
         blocks.addElement(block);
     }
 
     /**
      * 获取可变非受保护区指定位置的 Block
+     *
      * @return
      */
     public Block getBlock(int index) throws ComponentException {
         try {
             return this.blocks.getBlock(index);
         } catch (BlockException e) {
-            throw new ComponentException("MutableDangerousField.getBlock: "+e.getMessage());
+            throw new ComponentException("MutableDangerousField.getBlock: " + e.getMessage());
         }
     }
 
     /**
      * 清空可变非受保护区中，所有的子 Block
      */
-    public void clearBlocks(){
+    public void clearBlocks() {
         this.blocks.clear();
     }
 
     /**
      * 获取可变非受保护区所有的 Block
+     *
      * @return
      */
-    public ElementContainer getBlocks(){
+    public ElementContainer getBlocks() {
         return this.blocks;
     }
 
     /**
      * 获取可变非受保护区中，第一个指定TLV-TYPE的子 TLV Block
+     *
      * @return
      */
     public Block getBlockByType(VlInt tlvType) throws ComponentException {
         try {
             return this.blocks.getBlockByType(tlvType);
         } catch (BlockException e) {
-            throw new ComponentException("MutableDangerousField.getBlockByType: "+e.getMessage());
+            throw new ComponentException("MutableDangerousField.getBlockByType: " + e.getMessage());
         }
     }
 
     /**
      * 将可变非受保护区线速编码为一个 TLV
+     *
      * @param encoder
      * @return
      */
     @Override
     public int wireEncode(Encoder encoder) throws ComponentException {
-        try{
-        // 如果可变非受保护区没有任何子 TLV，则可以去掉可变非受保护区 TLV
-        if(this.blocks.length()==0){
-            return -1;
-        }
-
-        int totalLength=0;
-        // 编码TLV-VALUE
-        // 反向遍历，可以保证解码的时候正向输出
-        for(int i=this.blocks.length()-1;i>=0;i++){
-            int tmplen= 0;
-                tmplen = encoder.prependBlock(this.blocks.getBlock(i));
-            if(tmplen<=0){
+        try {
+            // 如果可变非受保护区没有任何子 TLV，则可以去掉可变非受保护区 TLV
+            if (this.blocks.length() == 0) {
                 return -1;
             }
-            totalLength+=tmplen;
-        }
 
-        // 编码 TLV-LENGTH
-        int tmplen= 0;
+            int totalLength = 0;
+            // 编码TLV-VALUE
+            // 反向遍历，可以保证解码的时候正向输出
+            for (int i = this.blocks.length() - 1; i >= 0; i--) {
+                int tmplen = 0;
+                tmplen = encoder.prependBlock(this.blocks.getBlock(i));
+                if (tmplen <= 0) {
+                    return -1;
+                }
+                totalLength += tmplen;
+            }
+
+            // 编码 TLV-LENGTH
+            int tmplen = 0;
             tmplen = encoder.prependVarNumber(new VlInt(totalLength));
-        if(tmplen<=0){
-            return -1;
-        }
-        totalLength+=tmplen;
+            if (tmplen <= 0) {
+                return -1;
+            }
+            totalLength += tmplen;
 
-        // 编码 TLV-TYPE
-        try {
-            tmplen=encoder.prependVarNumber(new VlInt(TLV.TlvReadOnlyField));
-        } catch (EncoderException e) {
-            throw new ComponentException("MutableDangerousField.wireEncode: "+e.getMessage());
-        }
-        if(tmplen<=0){
-            return -1;
-        }
-        totalLength+=tmplen;
+            // 编码 TLV-TYPE
+            try {
+                tmplen = encoder.prependVarNumber(new VlInt(TLV.TlvMutableDangerousField));
+            } catch (EncoderException e) {
+                throw new ComponentException("MutableDangerousField.wireEncode: " + e.getMessage());
+            }
+            if (tmplen <= 0) {
+                return -1;
+            }
+            totalLength += tmplen;
 
-        return totalLength;
+            return totalLength;
         } catch (EncoderException | BlockException e) {
-            throw new ComponentException("MutableDangerousField.wireEncode: "+e.getMessage());
+            throw new ComponentException("MutableDangerousField.wireEncode: " + e.getMessage());
         }
     }
 
     /**
      * 从 TLV Block 中解码出一个 ReadOnlyField
+     *
      * @param block
      * @return
      */
     @Override
     public boolean wireDecode(Block block) throws ComponentException {
         // 检查 Type 是否正确
-        if(!TLV.expectType(block.getType(),new VlInt(TLV.TlvReadOnlyField))){
+        if (!TLV.expectType(block.getType(), new VlInt(TLV.TlvMutableDangerousField))) {
             return false;
         }
 
         // 解析子 TLV
         try {
-            if(!block.parseSubElements()){
+            if (!block.parseSubElements()) {
                 return false;
             }
         } catch (BlockException e) {
-            throw new ComponentException("MutableDangerousField.wireDecode: "+e.getMessage());
+            throw new ComponentException("MutableDangerousField.wireDecode: " + e.getMessage());
         }
 
-        this.blocks=block.getSubElements();
+        this.blocks = block.getSubElements();
         return true;
     }
 }