!247 EL表达式组装需修改

Merge pull request !247 from 葛足澳/dev

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/AndELWrapper.java

@@ -39,40 +39,15 @@ public class AndELWrapper extends ELWrapper {
     }
 
     @Override
-    public AndELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public AndELWrapper data(String dataName, String jsonString) {
-        // 校验字符串符合Json格式
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public AndELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    protected AndELWrapper maxWaitSeconds(Integer maxWaitSeconds){
+    public AndELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
         return this;
     }
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         // 根据depth是否为null，决定输出是否格式化
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/CatchELWrapper.java

@@ -39,32 +39,6 @@ public class CatchELWrapper extends ELWrapper {
         return this;
     }
 
-    @Override
-    public CatchELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public CatchELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public CatchELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public CatchELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -73,6 +47,8 @@ public class CatchELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/ELWrapper.java

@@ -1,6 +1,7 @@
 package com.yomahub.liteflow.builder.el;
 
 import cn.hutool.core.util.StrUtil;
+import com.yomahub.liteflow.util.JsonUtil;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -111,7 +112,11 @@ public abstract class ELWrapper {
      * @param object   JavaBean
      * @return {@link ELWrapper}
      */
-    protected abstract ELWrapper data(String dataName, Object object);
+    protected ELWrapper data(String dataName, Object object){
+        setData("'" + JsonUtil.toJsonString(object) + "'");
+        setDataName(dataName);
+        return this;
+    }
 
     /**
      * 设置表达式data属性
@@ -120,7 +125,11 @@ public abstract class ELWrapper {
      * @param jsonString JSON格式字符串
      * @return {@link ELWrapper}
      */
-    protected abstract ELWrapper data(String dataName, String jsonString);
+    protected ELWrapper data(String dataName, String jsonString){
+        setData(jsonString);
+        setDataName(dataName);
+        return this;
+    }
 
     /**
      * 设置data属性
@@ -129,7 +138,12 @@ public abstract class ELWrapper {
      * @param jsonMap  键值映射
      * @return {@link ELWrapper}
      */
-    protected abstract ELWrapper data(String dataName, Map<String, Object> jsonMap);
+    protected ELWrapper data(String dataName, Map<String, Object> jsonMap){
+        setData("'" + JsonUtil.toJsonString(jsonMap) + "'");
+        setDataName(dataName);
+        return this;
+    }
+
 
     protected ELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -144,7 +158,7 @@ public abstract class ELWrapper {
     public String toEL(){
         StringBuilder paramContext = new StringBuilder();
         String elContext = toEL(null, paramContext);
-        return paramContext.append(elContext).toString();
+        return paramContext.append(elContext).append(";").toString();
     }
 
     /**
@@ -161,7 +175,7 @@ public abstract class ELWrapper {
         } else {
             elContext = toEL(0, paramContext);
         }
-        return paramContext.append(elContext).toString();
+        return paramContext.append(elContext).append(";").toString();
     }
 
     /**
@@ -186,10 +200,6 @@ public abstract class ELWrapper {
         if(this.getTag() != null){
             elContext.append(StrUtil.format(".tag(\"{}\")", this.getTag()));
         }
-        if(this.getData() != null){
-            elContext.append(StrUtil.format(".data({})", this.getDataName()));
-            paramContext.append(StrUtil.format("{} = '{}';\n", this.getDataName(), this.getData()));
-        }
         if(this.getMaxWaitSeconds() != null){
             elContext.append(StrUtil.format(".maxWaitSeconds({})", String.valueOf(this.getMaxWaitSeconds())));
         }
@@ -218,4 +228,15 @@ public abstract class ELWrapper {
             elContext.append(StrUtil.repeat(ELBus.TAB, depth));
         }
     }
+
+    /**
+     * 检查子表达式是否有最长等待秒数定义
+     */
+    protected void checkMaxWaitSeconds(){
+        for(ELWrapper sonElWrapper : this.getElWrapperList()){
+            if(sonElWrapper != null && sonElWrapper.getMaxWaitSeconds() != null){
+                throw new IllegalArgumentException("maxWaitSeconds必须定义在完整的语义之后！");
+            }
+        }
+    }
 }

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/FinallyELWrapper.java

@@ -31,32 +31,6 @@ public class FinallyELWrapper extends ELWrapper {
         return this;
     }
 
-    @Override
-    public FinallyELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public FinallyELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public FinallyELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     /**
      * 后置组件无法设置maxWaitSeconds属性，重载用protected修饰
      *
@@ -71,6 +45,8 @@ public class FinallyELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 
@@ -108,9 +84,5 @@ public class FinallyELWrapper extends ELWrapper {
         if(this.getTag() != null){
             elContext.append(StrUtil.format(".tag(\"{}\")", this.getTag()));
         }
-        if(this.getData() != null){
-            elContext.append(StrUtil.format(".data({})", this.getDataName()));
-            paramContext.append(StrUtil.format("{} = '{}'\n", this.getDataName(), this.getData()));
-        }
     }
 }

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/ForELWrapper.java

@@ -55,32 +55,6 @@ public class ForELWrapper extends LoopELWrapper {
         return this;
     }
 
-    @Override
-    public ForELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public ForELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public ForELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public ForELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/IfELWrapper.java

@@ -213,32 +213,6 @@ public class IfELWrapper extends ELWrapper {
         return this;
     }
 
-    @Override
-    public IfELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public IfELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public IfELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public IfELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -247,6 +221,8 @@ public class IfELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/IteratorELWrapper.java

@@ -43,32 +43,6 @@ public class IteratorELWrapper extends LoopELWrapper {
         return this;
     }
 
-    @Override
-    public IteratorELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public IteratorELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public IteratorELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public IteratorELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/LoopELWrapper.java

@@ -54,32 +54,6 @@ public abstract class LoopELWrapper extends ELWrapper {
         return this;
     }
 
-    @Override
-    public LoopELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public LoopELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public LoopELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public LoopELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -88,6 +62,8 @@ public abstract class LoopELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/NodeELWrapper.java

@@ -60,18 +60,18 @@ public class NodeELWrapper extends ELWrapper {
 
     @Override
     public NodeELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
+        setData("'" + JsonUtil.toJsonString(object) + "'");
         setDataName(dataName);
         return this;
     }
 
     @Override
     public NodeELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
+//        try {
+//            JsonUtil.parseObject(jsonString);
+//        } catch (Exception e){
+//            throw new RuntimeException("字符串不符合Json格式！");
+//        }
         setData(jsonString);
         setDataName(dataName);
         return this;
@@ -79,7 +79,7 @@ public class NodeELWrapper extends ELWrapper {
 
     @Override
     public NodeELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
+        setData("'" + JsonUtil.toJsonString(jsonMap) + "'");
         setDataName(dataName);
         return this;
     }
@@ -114,7 +114,8 @@ public class NodeELWrapper extends ELWrapper {
         }
         if(this.getData() != null){
             elContext.append(StrUtil.format(".data({})", this.getDataName()));
-            paramContext.append(StrUtil.format("{} = '{}'\n", this.getDataName(), this.getData()));
+//            paramContext.append(StrUtil.format("{} = '{}'\n", this.getDataName(), this.getData()));
+            paramContext.append(StrUtil.format("{} = {}", this.getDataName(), this.getData())).append(";\n");
         }
         if(this.getMaxWaitSeconds() != null){
             elContext.append(StrUtil.format(".maxWaitSeconds({})", String.valueOf(this.getMaxWaitSeconds())));

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/NotELWrapper.java

@@ -30,32 +30,6 @@ public class NotELWrapper extends ELWrapper {
         return this;
     }
 
-    @Override
-    public NotELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public NotELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public NotELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public NotELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -64,6 +38,8 @@ public class NotELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/OrELWrapper.java

@@ -38,32 +38,6 @@ public class OrELWrapper extends ELWrapper {
         return this;
     }
 
-    @Override
-    public OrELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public OrELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public OrELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public OrELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -72,6 +46,8 @@ public class OrELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/PreELWrapper.java

@@ -30,32 +30,6 @@ public class PreELWrapper extends ELWrapper {
         return this;
     }
 
-    @Override
-    public PreELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public PreELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public PreELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public PreELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -64,6 +38,8 @@ public class PreELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/SwitchELWrapper.java

@@ -50,32 +50,6 @@ public class SwitchELWrapper extends ELWrapper {
         return this;
     }
 
-    @Override
-    public SwitchELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public SwitchELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public SwitchELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public SwitchELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -84,6 +58,8 @@ public class SwitchELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/ThenELWrapper.java

@@ -76,39 +76,6 @@ public class ThenELWrapper extends ELWrapper {
         return this;
     }
 
-    /**
-     * data关键字的约束：允许以Bean、jsonString、map类型输入数据，必须包含dataName参数。
-     *
-     * @param dataName data名称
-     * @param javaBean JavaBean
-     * @return {@link ThenELWrapper}
-     */
-    @Override
-    public ThenELWrapper data(String dataName, Object javaBean) {
-        setData(JsonUtil.toJsonString(javaBean));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public ThenELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public ThenELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public ThenELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -117,6 +84,8 @@ public class ThenELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/WhenELWrapper.java

@@ -69,32 +69,6 @@ public class WhenELWrapper extends ELWrapper {
         return this;
     }
 
-    @Override
-    public WhenELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public WhenELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public WhenELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public WhenELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);
@@ -103,6 +77,8 @@ public class WhenELWrapper extends ELWrapper {
 
     @Override
     protected String toEL(Integer depth, StringBuilder paramContext) {
+        checkMaxWaitSeconds();
+
         Integer sonDepth = depth == null ? null : depth + 1;
         StringBuilder sb = new StringBuilder();
 

liteflow-el-builder/src/main/java/com/yomahub/liteflow/builder/el/WhileELWrapper.java

@@ -50,32 +50,6 @@ public class WhileELWrapper extends LoopELWrapper {
         return this;
     }
 
-    @Override
-    public WhileELWrapper data(String dataName, Object object) {
-        setData(JsonUtil.toJsonString(object));
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public WhileELWrapper data(String dataName, String jsonString) {
-        try {
-            JsonUtil.parseObject(jsonString);
-        } catch (Exception e){
-            throw new RuntimeException("字符串不符合Json格式！");
-        }
-        setData(jsonString);
-        setDataName(dataName);
-        return this;
-    }
-
-    @Override
-    public WhileELWrapper data(String dataName, Map<String, Object> jsonMap) {
-        setData(JsonUtil.toJsonString(jsonMap));
-        setDataName(dataName);
-        return this;
-    }
-
     @Override
     public WhileELWrapper maxWaitSeconds(Integer maxWaitSeconds){
         setMaxWaitSeconds(maxWaitSeconds);

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/CatchELBuilderTest.java

@@ -1,6 +1,7 @@
 package com.yomahub.liteflow.test.builder;
 
 import com.yomahub.liteflow.builder.el.ELBus;
+import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
 import com.yomahub.liteflow.test.BaseTest;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -22,68 +23,76 @@ public class CatchELBuilderTest extends BaseTest {
     // catch捕获异常调用测试
     @Test
     public void testCatch1(){
-        String expectedStr = "CATCH(THEN(node(\"a\"),node(\"b\"))).DO(node(\"c\"))";
+        String expectedStr = "CATCH(THEN(node(\"a\"),node(\"b\"))).DO(node(\"c\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.catchException(ELBus.then("a", "b")).doOpt("c").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.then("a", "b")).doOpt("c").toEL()));
     }
     @Test
     public void testCatch2(){
-        String expectedStr = "CATCH(\n\tTHEN(\n\t\tnode(\"a\"),\n\t\tnode(\"b\")\n\t)\n).DO(\n\tnode(\"c\")\n)";
+        String expectedStr = "CATCH(\n\tTHEN(\n\t\tnode(\"a\"),\n\t\tnode(\"b\")\n\t)\n).DO(\n\tnode(\"c\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.catchException(ELBus.then("a", "b")).doOpt("c").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.then("a", "b")).doOpt("c").toEL(true)));
     }
     // 属性设置测试
     @Test
     public void testCatch3(){
-        String expectedStr = "CATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3)";
+        String expectedStr = "CATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
         Assertions.assertEquals(expectedStr,
                 ELBus.catchException("a").doOpt(ELBus.then("b", "c")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", "c")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL()));
     }
     @Test
     public void testCatch4(){
-        String expectedStr = "CATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3)";
+        String expectedStr = "CATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
         Assertions.assertEquals(expectedStr,
                 ELBus.catchException("a").doOpt(ELBus.then("b", "c")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", "c")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true)));
     }
     // data 设置 jsonStr
     @Test
     public void testCatch5(){
-        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).data(catchData)";
+        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(catchData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.catchException("a").doOpt(ELBus.then("b", "c")).data("catchData", "{\"name\":\"zhangsan\",\"age\":18}").toEL());
+                ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).toEL()));
     }
     @Test
     public void testCatch6(){
-        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).data(catchData)";
+        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(catchData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.catchException("a").doOpt(ELBus.then("b", "c")).data("catchData", "{\"name\":\"zhangsan\",\"age\":18}").toEL(true));
+                ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).toEL(true));
         System.out.println(expectedStr);
-    }
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).toEL(true)));
+   }
     // data 设置 map
     @Test
     public void testCatch7(){
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).data(catchData)";
+        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(catchData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.catchException("a").doOpt(ELBus.then("b", "c")).data("catchData", name2Value).toEL());
+                ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL()));
     }
     @Test
     public void testCatch8(){
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).data(catchData)";
+        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(catchData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.catchException("a").doOpt(ELBus.then("b", "c")).data("catchData", name2Value).toEL(true));
+                ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL(true)));
     }
     private static class ParamClass{
         private String name;
@@ -101,19 +110,21 @@ public class CatchELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).data(catchData)";
+        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(catchData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.catchException("a").doOpt(ELBus.then("b", "c")).data("catchData", name2Value).toEL());
+                ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL()));
     }
     @Test
     public void testCatch10(){
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).data(catchData)";
+        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(catchData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.catchException("a").doOpt(ELBus.then("b", "c")).data("catchData", name2Value).toEL(true));
+                ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException("a").doOpt(ELBus.then("b", ELBus.node("c").data("catchData", name2Value))).toEL(true)));
     }
 }

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/ComplexELBuilderTest.java

@@ -1,12 +1,28 @@
 package com.yomahub.liteflow.test.builder;
 
+import cn.hutool.core.date.DateUtil;
+import com.yomahub.liteflow.builder.LiteFlowNodeBuilder;
 import com.yomahub.liteflow.builder.el.ELBus;
+import com.yomahub.liteflow.builder.el.ELWrapper;
+import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
 import com.yomahub.liteflow.builder.el.ThenELWrapper;
+import com.yomahub.liteflow.core.FlowExecutor;
+import com.yomahub.liteflow.enums.NodeTypeEnum;
+import com.yomahub.liteflow.flow.FlowBus;
+import com.yomahub.liteflow.flow.LiteflowResponse;
+import com.yomahub.liteflow.slot.DefaultContext;
 import com.yomahub.liteflow.test.BaseTest;
+import com.yomahub.liteflow.test.builder.cmp.ACmp;
+import com.yomahub.liteflow.test.builder.cmp.BCmp;
+import com.yomahub.liteflow.test.builder.vo.User;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.ComponentScan;
+
+import javax.annotation.Resource;
+import java.util.Date;
 
 /**
  * 复杂编排例子测试
@@ -16,7 +32,12 @@ import org.springframework.boot.test.context.SpringBootTest;
  */
 @SpringBootTest(classes = ComplexELBuilderTest.class)
 @EnableAutoConfiguration
+@ComponentScan({ "com.yomahub.liteflow.test.builder.ComplexELBuilderTest" })
 public class ComplexELBuilderTest extends BaseTest {
+
+    @Resource
+    private FlowExecutor flowExecutor;
+
     /*
     复杂编排例子1
     THEN(
@@ -52,12 +73,12 @@ public class ComplexELBuilderTest extends BaseTest {
                 ),
                 "Z"
         );
-        String expectedStr = "THEN(node(\"A\"),WHEN(THEN(node(\"B\"),node(\"C\")),THEN(node(\"D\"),node(\"E\"),node(\"F\")),THEN(SWITCH(node(\"G\")).TO(THEN(node(\"H\"),node(\"I\"),WHEN(node(\"J\"),node(\"K\"))).id(\"t1\"),THEN(node(\"L\"),node(\"M\")).id(\"t2\")),node(\"N\"))),node(\"Z\"))";
+        String expectedStr = "THEN(node(\"A\"),WHEN(THEN(node(\"B\"),node(\"C\")),THEN(node(\"D\"),node(\"E\"),node(\"F\")),THEN(SWITCH(node(\"G\")).TO(THEN(node(\"H\"),node(\"I\"),WHEN(node(\"J\"),node(\"K\"))).id(\"t1\"),THEN(node(\"L\"),node(\"M\")).id(\"t2\")),node(\"N\"))),node(\"Z\"));";
         Assertions.assertEquals(expectedStr,
                 complexEl1.toEL());
         System.out.println(expectedStr);
 
-        expectedStr = "THEN(\n\tnode(\"A\"),\n\tWHEN(\n\t\tTHEN(\n\t\t\tnode(\"B\"),\n\t\t\tnode(\"C\")\n\t\t),\n\t\tTHEN(\n\t\t\tnode(\"D\"),\n\t\t\tnode(\"E\"),\n\t\t\tnode(\"F\")\n\t\t),\n\t\tTHEN(\n\t\t\tSWITCH(node(\"G\")).TO(\n\t\t\t\tTHEN(\n\t\t\t\t\tnode(\"H\"),\n\t\t\t\t\tnode(\"I\"),\n\t\t\t\t\tWHEN(\n\t\t\t\t\t\tnode(\"J\"),\n\t\t\t\t\t\tnode(\"K\")\n\t\t\t\t\t)\n\t\t\t\t).id(\"t1\"),\n\t\t\t\tTHEN(\n\t\t\t\t\tnode(\"L\"),\n\t\t\t\t\tnode(\"M\")\n\t\t\t\t).id(\"t2\")\n\t\t\t),\n\t\t\tnode(\"N\")\n\t\t)\n\t),\n\tnode(\"Z\")\n)";
+        expectedStr = "THEN(\n\tnode(\"A\"),\n\tWHEN(\n\t\tTHEN(\n\t\t\tnode(\"B\"),\n\t\t\tnode(\"C\")\n\t\t),\n\t\tTHEN(\n\t\t\tnode(\"D\"),\n\t\t\tnode(\"E\"),\n\t\t\tnode(\"F\")\n\t\t),\n\t\tTHEN(\n\t\t\tSWITCH(node(\"G\")).TO(\n\t\t\t\tTHEN(\n\t\t\t\t\tnode(\"H\"),\n\t\t\t\t\tnode(\"I\"),\n\t\t\t\t\tWHEN(\n\t\t\t\t\t\tnode(\"J\"),\n\t\t\t\t\t\tnode(\"K\")\n\t\t\t\t\t)\n\t\t\t\t).id(\"t1\"),\n\t\t\t\tTHEN(\n\t\t\t\t\tnode(\"L\"),\n\t\t\t\t\tnode(\"M\")\n\t\t\t\t).id(\"t2\")\n\t\t\t),\n\t\t\tnode(\"N\")\n\t\t)\n\t),\n\tnode(\"Z\")\n);";
         Assertions.assertEquals(expectedStr,
                 complexEl1.toEL(true));
         System.out.println(expectedStr);
@@ -106,15 +127,62 @@ public class ComplexELBuilderTest extends BaseTest {
                 ),
                 ELBus.node("Z")
         );
-        String expectedStr = "THEN(node(\"A\"),SWITCH(node(\"B\")).TO(THEN(node(\"D\"),node(\"E\"),node(\"F\")).id(\"t1\"),THEN(node(\"C\"),WHEN(THEN(SWITCH(node(\"G\")).TO(THEN(node(\"H\"),node(\"I\")).id(\"t2\"),node(\"J\")),node(\"K\")),THEN(node(\"L\"),node(\"M\")))).id(\"t3\")),node(\"Z\"))";
+        String expectedStr = "THEN(node(\"A\"),SWITCH(node(\"B\")).TO(THEN(node(\"D\"),node(\"E\"),node(\"F\")).id(\"t1\"),THEN(node(\"C\"),WHEN(THEN(SWITCH(node(\"G\")).TO(THEN(node(\"H\"),node(\"I\")).id(\"t2\"),node(\"J\")),node(\"K\")),THEN(node(\"L\"),node(\"M\")))).id(\"t3\")),node(\"Z\"));";
         Assertions.assertEquals(expectedStr,
                 complexEl2.toEL());
         System.out.println(expectedStr);
 
-        expectedStr = "THEN(\n\tnode(\"A\"),\n\tSWITCH(node(\"B\")).TO(\n\t\tTHEN(\n\t\t\tnode(\"D\"),\n\t\t\tnode(\"E\"),\n\t\t\tnode(\"F\")\n\t\t).id(\"t1\"),\n\t\tTHEN(\n\t\t\tnode(\"C\"),\n\t\t\tWHEN(\n\t\t\t\tTHEN(\n\t\t\t\t\tSWITCH(node(\"G\")).TO(\n\t\t\t\t\t\tTHEN(\n\t\t\t\t\t\t\tnode(\"H\"),\n\t\t\t\t\t\t\tnode(\"I\")\n\t\t\t\t\t\t).id(\"t2\"),\n\t\t\t\t\t\tnode(\"J\")\n\t\t\t\t\t),\n\t\t\t\t\tnode(\"K\")\n\t\t\t\t),\n\t\t\t\tTHEN(\n\t\t\t\t\tnode(\"L\"),\n\t\t\t\t\tnode(\"M\")\n\t\t\t\t)\n\t\t\t)\n\t\t).id(\"t3\")\n\t),\n\tnode(\"Z\")\n)";
+        expectedStr = "THEN(\n\tnode(\"A\"),\n\tSWITCH(node(\"B\")).TO(\n\t\tTHEN(\n\t\t\tnode(\"D\"),\n\t\t\tnode(\"E\"),\n\t\t\tnode(\"F\")\n\t\t).id(\"t1\"),\n\t\tTHEN(\n\t\t\tnode(\"C\"),\n\t\t\tWHEN(\n\t\t\t\tTHEN(\n\t\t\t\t\tSWITCH(node(\"G\")).TO(\n\t\t\t\t\t\tTHEN(\n\t\t\t\t\t\t\tnode(\"H\"),\n\t\t\t\t\t\t\tnode(\"I\")\n\t\t\t\t\t\t).id(\"t2\"),\n\t\t\t\t\t\tnode(\"J\")\n\t\t\t\t\t),\n\t\t\t\t\tnode(\"K\")\n\t\t\t\t),\n\t\t\t\tTHEN(\n\t\t\t\t\tnode(\"L\"),\n\t\t\t\t\tnode(\"M\")\n\t\t\t\t)\n\t\t\t)\n\t\t).id(\"t3\")\n\t),\n\tnode(\"Z\")\n);";
         Assertions.assertEquals(expectedStr,
                 complexEl2.toEL(true));
         System.out.println(expectedStr);
     }
 
+    /**
+     * 创建Node，创建EL表达式，创建Chain
+     * 执行Chain，校验Data参数
+     */
+    @Test
+    public void test3(){
+        LiteFlowNodeBuilder.createNode()
+                .setId("a")
+                .setName("组件A")
+                .setType(NodeTypeEnum.COMMON)
+                .setClazz(ACmp.class)
+                .build();
+        LiteFlowNodeBuilder.createNode()
+                .setId("b")
+                .setName("组件B")
+                .setType(NodeTypeEnum.COMMON)
+                .setClazz(BCmp.class)
+                .build();
+
+        ELWrapper el = ELBus.then(ELBus.node("a").data("sql", "\"select * from member t where t.id=10001\""),
+                ELBus.node("b").data("cmpData", "'{\"name\":\"jack\",\"age\":27,\"birth\":\"1995-10-01\"}'"));
+
+        String expectStr = "sql = \"select * from member t\n" +
+                "                where t.id=10001\";\n" +
+                "                cmpData = '{\"name\":\"jack\",\"age\":27,\"birth\":\"1995-10-01\"}';\n" +
+                "\n" +
+                "        THEN(\n" +
+                "                node(\"a\").data(sql),\n" +
+                "                node(\"b\").data(cmpData)\n" +
+                "        );";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(expectStr));
+
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(el.toEL()));
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(el.toEL(true)));
+        LiteFlowChainELBuilder.createChain().setChainId("chain1").setEL(
+                el.toEL(true)
+        ).build();
+
+        LiteflowResponse response = flowExecutor.execute2Resp("chain1", "arg");
+        Assertions.assertTrue(response.isSuccess());
+
+        DefaultContext context = response.getFirstContextBean();
+        User user = context.getData("user");
+        Assertions.assertEquals(27, user.getAge());
+        Assertions.assertEquals("jack", user.getName());
+        Assertions.assertEquals(0, user.getBirth().compareTo(DateUtil.parseDate("1995-10-01").toJdkDate()));
+    }
 }

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/IfELBuilderTest.java

@@ -1,6 +1,7 @@
 package com.yomahub.liteflow.test.builder;
 
 import com.yomahub.liteflow.builder.el.ELBus;
+import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
 import com.yomahub.liteflow.test.BaseTest;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -22,194 +23,224 @@ public class IfELBuilderTest extends BaseTest {
     // if三元函数测试
     @Test
     public void testIf1(){
-        String expectedStr = "IF(node(\"a\"),THEN(node(\"c\"),node(\"d\")),WHEN(node(\"e\"),node(\"f\")))";
+        String expectedStr = "IF(node(\"a\"),THEN(node(\"c\"),node(\"d\")),WHEN(node(\"e\"),node(\"f\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", ELBus.then("c", "d"), ELBus.when("e", "f")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", ELBus.then("c", "d"), ELBus.when("e", "f")).toEL()));
     }
     // 格式化输出测试
     @Test
     public void testIf2(){
-        String expectedStr = "IF(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t),\n\tWHEN(\n\t\tnode(\"e\"),\n\t\tnode(\"f\")\n\t)\n)";
+        String expectedStr = "IF(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t),\n\tWHEN(\n\t\tnode(\"e\"),\n\t\tnode(\"f\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.node("a"), ELBus.then("c", "d"), ELBus.when("e", "f")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.then("c", "d"), ELBus.when("e", "f")).toEL(true)));
     }
     // If二元函数测试
     @Test
     public void testIf3(){
-        String expectedStr = "IF(node(\"a\"),THEN(node(\"b\"),node(\"c\"))).ELSE(WHEN(node(\"c\"),node(\"d\")))";
+        String expectedStr = "IF(node(\"a\"),THEN(node(\"b\"),node(\"c\"))).ELSE(WHEN(node(\"c\"),node(\"d\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.node("a"), ELBus.then("b", "c")).elseOpt(ELBus.when("c", "d")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.node("a"), ELBus.then("b", "c")).elseOpt(ELBus.when("c", "d")).toEL()));
     }
     // 格式化输出测试
     @Test
     public void testIf4(){
-        String expectedStr = "IF(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).ELSE(\n\tWHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n)";
+        String expectedStr = "IF(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).ELSE(\n\tWHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", ELBus.then("b", "c")).elseOpt(ELBus.when("c", "d")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", ELBus.then("b", "c")).elseOpt(ELBus.when("c", "d")).toEL(true)));
     }
     // ELIF调用测试
     @Test
     public void testIf5(){
-        String expectedStr = "IF(node(\"a\"),node(\"b\")).ELIF(node(\"f1\"),node(\"c\")).ELIF(node(\"f2\"),node(\"d\")).ELSE(node(\"e\"))";
+        String expectedStr = "IF(node(\"a\"),node(\"b\")).ELIF(node(\"f1\"),node(\"c\")).ELIF(node(\"f2\"),node(\"d\")).ELSE(node(\"e\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", "b").elIfOpt("f1", "c").elIfOpt("f2","d").elseOpt("e").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b").elIfOpt("f1", "c").elIfOpt("f2","d").elseOpt("e").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testIf6(){
-        String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\")\n).ELIF(\n\tnode(\"f1\"),\n\tnode(\"c\")\n).ELIF(\n\tnode(\"f2\"),\n\tnode(\"d\")\n).ELSE(\n\tnode(\"e\")\n)";
+        String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\")\n).ELIF(\n\tnode(\"f1\"),\n\tnode(\"c\")\n).ELIF(\n\tnode(\"f2\"),\n\tnode(\"d\")\n).ELSE(\n\tnode(\"e\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", "b").elIfOpt("f1", "c").elIfOpt("f2","d").elseOpt("e").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b").elIfOpt("f1", "c").elIfOpt("f2","d").elseOpt("e").toEL(true)));
     }
     // IF嵌套调用测试
     @Test
     public void testIf7(){
-        String expectedStr = "IF(node(\"a\"),node(\"b\"),IF(node(\"c\"),node(\"d\")).ELSE(node(\"e\")))";
+        String expectedStr = "IF(node(\"a\"),node(\"b\"),IF(node(\"c\"),node(\"d\")).ELSE(node(\"e\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", "b", ELBus.ifOpt("c", "d").elseOpt("e")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.ifOpt("c", "d").elseOpt("e")).toEL()));
     }
     // 格式化输出测试
     @Test
     public void testIf8(){
-        String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tIF(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t).ELSE(\n\t\tnode(\"e\")\n\t)\n)";
+        String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tIF(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t).ELSE(\n\t\tnode(\"e\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", "b", ELBus.ifOpt("c", "d").elseOpt("e")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.ifOpt("c", "d").elseOpt("e")).toEL(true)));
     }
     // IF嵌套调用测试
     @Test
     public void testIf9(){
-        String expectedStr = "IF(node(\"a\"),node(\"b\")).ELSE(IF(node(\"c\"),node(\"d\"),node(\"e\")))";
+        String expectedStr = "IF(node(\"a\"),node(\"b\")).ELSE(IF(node(\"c\"),node(\"d\"),node(\"e\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", "b").elseOpt(ELBus.ifOpt("c", "d", "e")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b").elseOpt(ELBus.ifOpt("c", "d", "e")).toEL()));
     }
     // 格式化输出测试
     @Test
     public void testIf10(){
-        String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\")\n).ELSE(\n\tIF(\n\t\tnode(\"c\"),\n\t\tnode(\"d\"),\n\t\tnode(\"e\")\n\t)\n)";
+        String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\")\n).ELSE(\n\tIF(\n\t\tnode(\"c\"),\n\t\tnode(\"d\"),\n\t\tnode(\"e\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", "b").elseOpt(ELBus.ifOpt("c", "d", "e")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b").elseOpt(ELBus.ifOpt("c", "d", "e")).toEL(true)));
     }
     // 与表达式输出测试
     @Test
     public void testIf11(){
-        String expectedStr = "IF(AND(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\"),node(\"e\"))";
+        String expectedStr = "IF(AND(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\"),node(\"e\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.and("a", "b", "c"), "d", "e").toEL());
         System.out.println(expectedStr);
-        expectedStr = "IF(AND(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELSE(node(\"e\"))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d", "e").toEL()));
+        expectedStr = "IF(AND(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELSE(node(\"e\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elseOpt("e").toEL());
         System.out.println(expectedStr);
-        expectedStr = "IF(AND(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELIF(AND(node(\"f1\"),node(\"f2\")),node(\"e\"))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elseOpt("e").toEL()));
+        expectedStr = "IF(AND(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELIF(AND(node(\"f1\"),node(\"f2\")),node(\"e\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elIfOpt(ELBus.and("f1", "f2"), "e").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elIfOpt(ELBus.and("f1", "f2"), "e").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testIf12(){
-        String expectedStr = "IF(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tnode(\"e\")\n)";
+        String expectedStr = "IF(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tnode(\"e\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.and("a", "b", "c"), "d", "e").toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "IF(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELSE(\n\tnode(\"e\")\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d", "e").toEL(true)));
+        expectedStr = "IF(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELSE(\n\tnode(\"e\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elseOpt("e").toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "IF(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELIF(\n\tAND(\n\t\tnode(\"f1\"),\n\t\tnode(\"f2\")\n\t),\n\tnode(\"e\")\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elseOpt("e").toEL(true)));
+        expectedStr = "IF(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELIF(\n\tAND(\n\t\tnode(\"f1\"),\n\t\tnode(\"f2\")\n\t),\n\tnode(\"e\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elIfOpt(ELBus.and("f1", "f2"), "e").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.and("a", "b", "c"), "d").elIfOpt(ELBus.and("f1", "f2"), "e").toEL(true)));
     }
     // 或表达式测试
     @Test
     public void testIf13(){
-        String expectedStr = "IF(OR(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\"),node(\"e\"))";
+        String expectedStr = "IF(OR(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\"),node(\"e\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.or("a", "b", "c"), "d", "e").toEL());
         System.out.println(expectedStr);
-        expectedStr = "IF(OR(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELSE(node(\"e\"))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d", "e").toEL()));
+        expectedStr = "IF(OR(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELSE(node(\"e\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elseOpt("e").toEL());
         System.out.println(expectedStr);
-        expectedStr = "IF(OR(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELIF(OR(node(\"f1\"),node(\"f2\")),node(\"e\"))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elseOpt("e").toEL()));
+        expectedStr = "IF(OR(node(\"a\"),node(\"b\"),node(\"c\")),node(\"d\")).ELIF(OR(node(\"f1\"),node(\"f2\")),node(\"e\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elIfOpt(ELBus.or("f1", "f2"), "e").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elIfOpt(ELBus.or("f1", "f2"), "e").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testIf14(){
-        String expectedStr = "IF(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tnode(\"e\")\n)";
+        String expectedStr = "IF(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tnode(\"e\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.or("a", "b", "c"), "d", "e").toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "IF(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELSE(\n\tnode(\"e\")\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d", "e").toEL(true)));
+        expectedStr = "IF(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELSE(\n\tnode(\"e\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elseOpt("e").toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "IF(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELIF(\n\tOR(\n\t\tnode(\"f1\"),\n\t\tnode(\"f2\")\n\t),\n\tnode(\"e\")\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elseOpt("e").toEL(true)));
+        expectedStr = "IF(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n).ELIF(\n\tOR(\n\t\tnode(\"f1\"),\n\t\tnode(\"f2\")\n\t),\n\tnode(\"e\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elIfOpt(ELBus.or("f1", "f2"), "e").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.or("a", "b", "c"), "d").elIfOpt(ELBus.or("f1", "f2"), "e").toEL(true)));
     }
     // 非表达式测试
     @Test
     public void testIf15(){
-        String expectedStr = "IF(NOT(node(\"a\")),node(\"b\"),node(\"c\"))";
+        String expectedStr = "IF(NOT(node(\"a\")),node(\"b\"),node(\"c\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.not("a"), "b", "c").toEL());
         System.out.println(expectedStr);
-        expectedStr = "IF(NOT(node(\"a\")),node(\"b\")).ELSE(node(\"c\"))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b", "c").toEL()));
+        expectedStr = "IF(NOT(node(\"a\")),node(\"b\")).ELSE(node(\"c\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.not("a"), "b").elseOpt("c").toEL());
         System.out.println(expectedStr);
-        expectedStr = "IF(NOT(node(\"a\")),node(\"b\")).ELIF(NOT(node(\"f\")),node(\"c\"))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b").elseOpt("c").toEL()));
+        expectedStr = "IF(NOT(node(\"a\")),node(\"b\")).ELIF(NOT(node(\"f\")),node(\"c\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.not("a"), "b").elIfOpt(ELBus.not("f"), "c").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b").elIfOpt(ELBus.not("f"), "c").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testIf16(){
-        String expectedStr = "IF(\n\tNOT(\n\t\tnode(\"a\")\n\t),\n\tnode(\"b\"),\n\tnode(\"c\")\n)";
+        String expectedStr = "IF(\n\tNOT(\n\t\tnode(\"a\")\n\t),\n\tnode(\"b\"),\n\tnode(\"c\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.not("a"), "b", "c").toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "IF(\n\tNOT(\n\t\tnode(\"a\")\n\t),\n\tnode(\"b\")\n).ELSE(\n\tnode(\"c\")\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b", "c").toEL(true)));
+        expectedStr = "IF(\n\tNOT(\n\t\tnode(\"a\")\n\t),\n\tnode(\"b\")\n).ELSE(\n\tnode(\"c\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.not("a"), "b").elseOpt("c").toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "IF(\n\tNOT(\n\t\tnode(\"a\")\n\t),\n\tnode(\"b\")\n).ELIF(\n\tNOT(\n\t\tnode(\"f\")\n\t),\n\tnode(\"c\")\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b").elseOpt("c").toEL(true)));
+        expectedStr = "IF(\n\tNOT(\n\t\tnode(\"a\")\n\t),\n\tnode(\"b\")\n).ELIF(\n\tNOT(\n\t\tnode(\"f\")\n\t),\n\tnode(\"c\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt(ELBus.not("a"), "b").elIfOpt(ELBus.not("f"), "c").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt(ELBus.not("a"), "b").elIfOpt(ELBus.not("f"), "c").toEL(true)));
     }
     // 属性测试
     @Test
     public void testIf17(){
-        String expectedStr = "IF(node(\"a\"),node(\"b\"),node(\"c\")).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(6)";
+        String expectedStr = "IF(node(\"a\"),node(\"b\"),node(\"c\")).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(6);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", "b", "c").id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", "c").id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL()));
     }
     // 格式化输出
     @Test
     public void testIf18(){
-        String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(6)";
+        String expectedStr = "IF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(6);";
         Assertions.assertEquals(expectedStr,
                 ELBus.ifOpt("a", "b", "c").id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", "c").id("this is a id").tag("this is a tag").maxWaitSeconds(6).toEL(true)));
     }
     // data map 测试
     @Test
@@ -217,10 +248,11 @@ public class IfELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(node(\"a\"),node(\"b\"),node(\"c\")).data(ifData)";
+        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(node(\"a\"),node(\"b\"),node(\"c\").data(ifData));";
         Assertions.assertEquals(expectedStr,
-                ELBus.ifOpt("a", "b", "c").data("ifData", name2Value).toEL());
+                ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL()));
     }
     // 格式化输出
     @Test
@@ -228,26 +260,29 @@ public class IfELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n).data(ifData)";
+        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\").data(ifData)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.ifOpt("a", "b", "c").data("ifData", name2Value).toEL(true));
+                ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL(true)));
     }
     // data JsonStr 测试
     @Test
     public void testIf21(){
-        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(node(\"a\"),node(\"b\"),node(\"c\")).data(ifData)";
+        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(node(\"a\"),node(\"b\"),node(\"c\").data(ifData));";
         Assertions.assertEquals(expectedStr,
-                ELBus.ifOpt("a", "b", "c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}").toEL());
+                ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", "'{\"name\":\"zhangsan\",\"age\":18}'")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", "'{\"name\":\"zhangsan\",\"age\":18}'")).toEL()));
     }
     // 格式化输出
     @Test
     public void testIf22(){
-        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n).data(ifData)";
+        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\").data(ifData)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.ifOpt("a", "b", "c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}").toEL(true));
+                ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", "'{\"name\":\"zhangsan\",\"age\":18}'")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", "'{\"name\":\"zhangsan\",\"age\":18}'")).toEL(true)));
     }
     private static class ParamClass{
         private String name;
@@ -265,10 +300,11 @@ public class IfELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(node(\"a\"),node(\"b\"),node(\"c\")).data(ifData)";
+        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(node(\"a\"),node(\"b\"),node(\"c\").data(ifData));";
         Assertions.assertEquals(expectedStr,
-                ELBus.ifOpt("a", "b", "c").data("ifData", name2Value).toEL());
+                ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL()));
     }
     // 格式化输出
     @Test
@@ -276,10 +312,11 @@ public class IfELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n).data(ifData)";
+        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\").data(ifData)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.ifOpt("a", "b", "c").data("ifData", name2Value).toEL(true));
+                ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ifOpt("a", "b", ELBus.node("c").data("ifData", name2Value)).toEL(true)));
     }
 
 }

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/LogicELBuilderTest.java

@@ -1,6 +1,6 @@
 package com.yomahub.liteflow.test.builder;
 
-import com.yomahub.liteflow.builder.el.ELBus;
+import com.yomahub.liteflow.builder.el.*;
 import com.yomahub.liteflow.test.BaseTest;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -22,82 +22,92 @@ public class LogicELBuilderTest extends BaseTest {
     // 与或非表达式调用 测试
     @Test
     public void testlogic1(){
-        String expectedStr = "AND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\")))";
+        String expectedStr = "AND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).toEL()));
     }
     @Test
     public void testlogic2(){
-        String expectedStr = "AND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\")\n\t)\n)";
+        String expectedStr = "AND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).toEL(true)));
     }
 
     @Test
     public void testlogic3(){
-        String expectedStr = "AND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\")))";
+        String expectedStr = "AND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.and("a").and(ELBus.or("b").or("c")).and(ELBus.not("d")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a").and(ELBus.or("b").or("c")).and(ELBus.not("d")).toEL()));
     }
 
     @Test
     public void testlogic4(){
-        String expectedStr = "AND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\")\n\t)\n)";
+        String expectedStr = "AND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.and("a").and(ELBus.or("b").or("c")).and(ELBus.not("d")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a").and(ELBus.or("b").or("c")).and(ELBus.not("d")).toEL(true)));
     }
     // 属性设置
     @Test
     public void testlogic5(){
-        String expectedStr = "AND(node(\"a\"),OR(node(\"b\"),node(\"c\")).id(\"this is a id\").maxWaitSeconds(4),NOT(node(\"d\")).tag(\"this is a tag\"))";
+        String expectedStr = "AND(node(\"a\"),OR(node(\"b\"),node(\"c\")).id(\"this is a id\"),NOT(node(\"d\")).tag(\"this is a tag\")).maxWaitSeconds(4);";
         Assertions.assertEquals(expectedStr,
-                ELBus.and("a", ELBus.or("b", "c").id("this is a id").maxWaitSeconds(4), ELBus.not("d").tag("this is a tag")).toEL());
+                ELBus.and("a", ELBus.or("b", "c").id("this is a id"), ELBus.not("d").tag("this is a tag")).maxWaitSeconds(4).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c").id("this is a id"), ELBus.not("d").tag("this is a tag")).maxWaitSeconds(4).toEL()));
     }
     @Test
     public void testlogic6(){
-        String expectedStr = "AND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\").maxWaitSeconds(4),\n\tNOT(\n\t\tnode(\"d\")\n\t).tag(\"this is a tag\")\n)";
+        String expectedStr = "AND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tNOT(\n\t\tnode(\"d\")\n\t).tag(\"this is a tag\")\n).maxWaitSeconds(4);";
         Assertions.assertEquals(expectedStr,
-                ELBus.and("a", ELBus.or("b", "c").id("this is a id").maxWaitSeconds(4), ELBus.not("d").tag("this is a tag")).toEL(true));
+                ELBus.and("a", ELBus.or("b", "c").id("this is a id"), ELBus.not("d").tag("this is a tag")).maxWaitSeconds(4).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c").id("this is a id"), ELBus.not("d").tag("this is a tag")).maxWaitSeconds(4).toEL(true)));
     }
     @Test
     public void testlogic7(){
-        String expectedStr = "andData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\"))).data(andData)";
+        String expectedStr = "andData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\").data(andData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).data("andData", "{\"name\":\"zhangsan\",\"age\":18}").toEL());
+                ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("andData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("andData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).toEL()));
     }
     @Test
     public void testlogic8(){
-        String expectedStr = "andData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\")\n\t)\n).data(andData)";
+        String expectedStr = "andData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\").data(andData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).data("andData", "{\"name\":\"zhangsan\",\"age\":18}").toEL(true));
+                ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("andData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("andData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).toEL(true)));
     }
     @Test
     public void testlogic9(){
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "orData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\"))).data(orData)";
+        String expectedStr = "orData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\").data(orData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).data("orData", name2Value).toEL());
+                ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL()));
     }
     @Test
     public void testlogic10(){
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "orData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\")\n\t)\n).data(orData)";
+        String expectedStr = "orData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\").data(orData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d")).data("orData", name2Value).toEL(true));
+                ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL(true)));
     }
     private static class ParamClass{
         private String name;
@@ -114,58 +124,83 @@ public class LogicELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "notData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\")).data(notData))";
+        String expectedStr = "notData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(node(\"a\"),OR(node(\"b\"),node(\"c\")),NOT(node(\"d\").data(notData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d").data("notData", name2Value)).toEL());
+                ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL()));
     }
     @Test
     public void testlogic12(){
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "notData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\")\n\t).data(notData)\n)";
+        String expectedStr = "notData = '{\"name\":\"zhangsan\",\"age\":18}';\nAND(\n\tnode(\"a\"),\n\tOR(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tNOT(\n\t\tnode(\"d\").data(notData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.and("a", ELBus.or("b", "c"), ELBus.not("d").data("notData", name2Value)).toEL(true));
+                ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.and("a", ELBus.or("b", "c"), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL(true)));
     }
     // NOT调用方法补充测试
     @Test
     public void testLogic13(){
-        String expectedStr = "NOT(node(\"a\"))";
+        String expectedStr = "NOT(node(\"a\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.not(ELBus.node("a")).toEL());
         System.out.println(expectedStr);
-        expectedStr = "NOT(AND(node(\"a\"),node(\"b\"),node(\"c\")))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.node("a")).toEL()));
+        expectedStr = "NOT(AND(node(\"a\"),node(\"b\"),node(\"c\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.not(ELBus.and("a", "b", "c")).toEL());
         System.out.println(expectedStr);
-        expectedStr = "NOT(OR(node(\"a\"),node(\"b\"),node(\"c\")))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.and("a", "b", "c")).toEL()));
+        expectedStr = "NOT(OR(node(\"a\"),node(\"b\"),node(\"c\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.not(ELBus.or("a", "b", "c")).toEL());
         System.out.println(expectedStr);
-        expectedStr = "NOT(NOT(node(\"a\")))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.or("a", "b", "c")).toEL()));
+        expectedStr = "NOT(NOT(node(\"a\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.not(ELBus.not(ELBus.node("a"))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.not(ELBus.node("a"))).toEL()));
     }
     @Test
     public void testLogic14(){
-        String expectedStr = "NOT(\n\tnode(\"a\")\n)";
+        String expectedStr = "NOT(\n\tnode(\"a\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.not(ELBus.node("a")).toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "NOT(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.node("a")).toEL(true)));
+        expectedStr = "NOT(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.not(ELBus.and("a", "b", "c")).toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "NOT(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.and("a", "b", "c")).toEL(true)));
+        expectedStr = "NOT(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.not(ELBus.or("a", "b", "c")).toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "NOT(\n\tNOT(\n\t\tnode(\"a\")\n\t)\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.or("a", "b", "c")).toEL(true)));
+        expectedStr = "NOT(\n\tNOT(\n\t\tnode(\"a\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.not(ELBus.not(ELBus.node("a"))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.not(ELBus.not(ELBus.node("a"))).toEL(true)));
+    }
+
+    @Test
+    public void testLogic(){
+        AndELWrapper andEl = ELBus.and("a", "b").id("this is a id").tag("this is a tag").maxWaitSeconds(5);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(andEl.toEL()));
+        OrELWrapper orEl = ELBus.or("a", "b").maxWaitSeconds(3);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(orEl.toEL()));
+        NotELWrapper notEl = ELBus.not("a").maxWaitSeconds(2);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(notEl.toEL()));
+
+//        Assertions.assertTrue(LiteFlowChainELBuilder.validate("AND(node(\"a\"),OR(node(\"b\"),node(\"c\")).id(\"this is a id\"),NOT(node(\"d\")).tag(\"this is a tag\").maxWaitSeconds(3))"));
+
+//        ThenELWrapper thenELWrapper = ELBus.then(ELBus.when("a", "b", ELBus.when("c", "d").maxWaitSeconds(3)));
+//        Assertions.assertTrue(LiteFlowChainELBuilder.validate(thenELWrapper.toEL()));
     }
 }

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/LoopELBuilderTest.java

@@ -1,6 +1,7 @@
 package com.yomahub.liteflow.test.builder;
 
 import com.yomahub.liteflow.builder.el.ELBus;
+import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
 import com.yomahub.liteflow.test.BaseTest;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -22,159 +23,189 @@ public class LoopELBuilderTest extends BaseTest {
     // for 限定次数循环
     @Test
     public void testLoop1(){
-        String expectedStr = "FOR(3).DO(THEN(node(\"a\"),node(\"b\"),node(\"c\"))).BREAK(node(\"d\"))";
+        String expectedStr = "FOR(3).DO(THEN(node(\"a\"),node(\"b\"),node(\"c\"))).BREAK(node(\"d\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.forOpt(3).doOpt(ELBus.then("a", "b", "c")).breakOpt("d").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(3).doOpt(ELBus.then("a", "b", "c")).breakOpt("d").toEL()));
     }
     // 格式化输出
     @Test
     public void testLoop2(){
-        String expectedStr = "FOR(3).DO(\n\tTHEN(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).BREAK(\n\tnode(\"d\")\n)";
+        String expectedStr = "FOR(3).DO(\n\tTHEN(\n\t\tnode(\"a\"),\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).BREAK(\n\tnode(\"d\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.forOpt(3).doOpt(ELBus.then("a", "b", "c")).breakOpt("d").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(3).doOpt(ELBus.then("a", "b", "c")).breakOpt("d").toEL(true)));
     }
     // for 单节点循环测试
     @Test
     public void testLoop3(){
-        String expectedStr = "FOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\"),node(\"d\"))).BREAK(AND(node(\"e\"),node(\"f\")))";
+        String expectedStr = "FOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\"),node(\"d\"))).BREAK(AND(node(\"e\"),node(\"f\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.and("e", "f")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.and("e", "f")).toEL()));
     }
     @Test
     public void testLoop4(){
-        String expectedStr = "FOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n).BREAK(\n\tAND(\n\t\tnode(\"e\"),\n\t\tnode(\"f\")\n\t)\n)";
+        String expectedStr = "FOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n).BREAK(\n\tAND(\n\t\tnode(\"e\"),\n\t\tnode(\"f\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.and("e", "f")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.and("e", "f")).toEL(true)));
     }
     // parallel语句测试
     @Test
     public void testLoop5(){
-        String expectedStr = "FOR(node(\"a\")).parallel(true).DO(WHEN(node(\"b\"),node(\"c\"),node(\"d\"))).BREAK(node(\"e\"))";
+        String expectedStr = "FOR(node(\"a\")).parallel(true).DO(WHEN(node(\"b\"),node(\"c\"),node(\"d\"))).BREAK(node(\"e\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt("e").parallel(true).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt("e").parallel(true).toEL()));
     }
     @Test
     public void testLoop6(){
-        String expectedStr = "FOR(\n\tnode(\"a\")\n).parallel(true).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n).BREAK(\n\tnode(\"e\")\n)";
+        String expectedStr = "FOR(\n\tnode(\"a\")\n).parallel(true).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n).BREAK(\n\tnode(\"e\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt("e").parallel(true).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt("e").parallel(true).toEL(true)));
     }
     // 属性测试
     @Test
     public void testLoop7(){
-        String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\nFOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\"),node(\"d\"))).BREAK(node(\"e\")).id(\"this is a id\").tag(\"this is a tag\").data(forData).maxWaitSeconds(3)";
+        String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\nFOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\"),node(\"d\"))).BREAK(node(\"e\").data(forData)).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
         Assertions.assertEquals(expectedStr,
-                ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt("e").id("this is a id").tag("this is a tag").maxWaitSeconds(3).data("forData", "{\"name\":\"zhangsan\",\"age\":18}").toEL());
+                ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.node("e").data("forData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.node("e").data("forData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL()));
     }
     @Test
     public void testLoop8(){
-        String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\nFOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n).BREAK(\n\tnode(\"e\")\n).id(\"this is a id\").tag(\"this is a tag\").data(forData).maxWaitSeconds(3)";
+        String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\nFOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t)\n).BREAK(\n\tnode(\"e\").data(forData)\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
         Assertions.assertEquals(expectedStr,
-                ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c", "d")).breakOpt("e").id("this is a id").tag("this is a tag").maxWaitSeconds(3).data("forData", "{\"name\":\"zhangsan\",\"age\":18}").toEL(true));
+                ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.node("e").data("forData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c", "d")).breakOpt(ELBus.node("e").data("forData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true)));
     }
     // while调用测试
     @Test
     public void testLoop9(){
-        String expectedStr = "WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).BREAK(node(\"f\"))";
+        String expectedStr = "WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).BREAK(node(\"f\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("f").toEL());
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then("b", "c")).breakOpt("f").toEL());
         System.out.println(expectedStr);
-        expectedStr = "WHILE(AND(node(\"a\"),node(\"b\"))).DO(node(\"c\")).BREAK(node(\"d\"))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("f").toEL()));
+
+        expectedStr = "WHILE(AND(node(\"a\"),node(\"b\"))).DO(node(\"c\")).BREAK(node(\"d\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.and("a", "b")).doOpt("c").breakOpt("d").toEL());
         System.out.println(expectedStr);
-        expectedStr = "WHILE(OR(node(\"a\"),node(\"b\"))).DO(node(\"c\")).BREAK(node(\"d\"))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.and("a", "b")).doOpt("c").breakOpt("d").toEL()));
+
+        expectedStr = "WHILE(OR(node(\"a\"),node(\"b\"))).DO(node(\"c\")).BREAK(node(\"d\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.or("a", "b")).doOpt("c").breakOpt("d").toEL());
         System.out.println(expectedStr);
-        expectedStr = "WHILE(NOT(node(\"a\"))).DO(node(\"c\")).BREAK(node(\"d\"))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.or("a", "b")).doOpt("c").breakOpt("d").toEL()));
+
+        expectedStr = "WHILE(NOT(node(\"a\"))).DO(node(\"c\")).BREAK(node(\"d\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.not("a")).doOpt("c").breakOpt("d").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.not("a")).doOpt("c").breakOpt("d").toEL()));
     }
     @Test
     public void testLoop10(){
-        String expectedStr = "WHILE(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).BREAK(\n\tnode(\"f\")\n)";
+        String expectedStr = "WHILE(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).BREAK(\n\tnode(\"f\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("f").toEL(true));
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then("b", "c")).breakOpt("f").toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "WHILE(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\")\n\t)\n).DO(\n\tnode(\"c\")\n).BREAK(\n\tnode(\"d\")\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("f").toEL(true)));
+
+        expectedStr = "WHILE(\n\tAND(\n\t\tnode(\"a\"),\n\t\tnode(\"b\")\n\t)\n).DO(\n\tnode(\"c\")\n).BREAK(\n\tnode(\"d\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.and("a", "b")).doOpt("c").breakOpt("d").toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "WHILE(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\")\n\t)\n).DO(\n\tnode(\"c\")\n).BREAK(\n\tnode(\"d\")\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.and("a", "b")).doOpt("c").breakOpt("d").toEL(true)));
+
+        expectedStr = "WHILE(\n\tOR(\n\t\tnode(\"a\"),\n\t\tnode(\"b\")\n\t)\n).DO(\n\tnode(\"c\")\n).BREAK(\n\tnode(\"d\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.or("a", "b")).doOpt("c").breakOpt("d").toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "WHILE(\n\tNOT(\n\t\tnode(\"a\")\n\t)\n).DO(\n\tnode(\"c\")\n).BREAK(\n\tnode(\"d\")\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.or("a", "b")).doOpt("c").breakOpt("d").toEL(true)));
+
+        expectedStr = "WHILE(\n\tNOT(\n\t\tnode(\"a\")\n\t)\n).DO(\n\tnode(\"c\")\n).BREAK(\n\tnode(\"d\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.not("a")).doOpt("c").breakOpt("d").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.not("a")).doOpt("c").breakOpt("d").toEL(true)));
     }
     // while属性调用测试
     @Test
     public void testLoop11(){
-        String expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHILE(node(\"a\")).parallel(true).DO(THEN(node(\"b\"),node(\"c\"))).BREAK(node(\"d\")).id(\"this is a ig\").tag(\"this is a tag\").data(whileData).maxWaitSeconds(3)";
+        String expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHILE(node(\"a\")).parallel(true).DO(THEN(node(\"b\"),node(\"c\"))).BREAK(node(\"d\").data(whileData)).id(\"this is a ig\").tag(\"this is a tag\").maxWaitSeconds(3);";
         Assertions.assertEquals(expectedStr,
-                ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("d").id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).data("whileData", "{\"name\":\"zhangsan\",\"age\":18}").toEL());
+                ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt(ELBus.node("d").data("whileData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt(ELBus.node("d").data("whileData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL()));
     }
     @Test
     public void testLoop12(){
-        String expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHILE(\n\tnode(\"a\")\n).parallel(true).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).BREAK(\n\tnode(\"d\")\n).id(\"this is a ig\").tag(\"this is a tag\").data(whileData).maxWaitSeconds(3)";
+        String expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHILE(\n\tnode(\"a\")\n).parallel(true).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).BREAK(\n\tnode(\"d\").data(whileData)\n).id(\"this is a ig\").tag(\"this is a tag\").maxWaitSeconds(3);";
         Assertions.assertEquals(expectedStr,
-                ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt("d").id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).data("whileData", "{\"name\":\"zhangsan\",\"age\":18}").toEL(true));
+                ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt(ELBus.node("d").data("whileData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).breakOpt(ELBus.node("d").data("whileData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true)));
     }
     // Iterator 调用测试
     @Test
     public void testLoop13(){
-        String expectedStr = "ITERATOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\")))";
+        String expectedStr = "ITERATOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.iteratorOpt("a").doOpt(ELBus.when("b", "c")).toEL());
         System.out.println(expectedStr);
-        expectedStr = "ITERATOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\")))";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.when("b", "c")).toEL()));
+        expectedStr = "ITERATOR(node(\"a\")).DO(WHEN(node(\"b\"),node(\"c\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c")).toEL()));
     }
     @Test
     public void testLoop14(){
-        String expectedStr = "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n)";
+        String expectedStr = "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.iteratorOpt("a").doOpt(ELBus.when("b", "c")).toEL(true));
         System.out.println(expectedStr);
-        expectedStr = "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n)";
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.when("b", "c")).toEL(true)));
+        expectedStr = "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.when("b", "c")).toEL(true)));
     }
     // iterator 属性测试
     @Test
     public void testLoop15(){
-        String expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\nITERATOR(node(\"a\")).parallel(true).DO(THEN(node(\"b\"),node(\"c\"))).id(\"this is a ig\").tag(\"this is a tag\").data(iteratorData).maxWaitSeconds(3)";
+        String expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\nITERATOR(node(\"a\")).parallel(true).DO(THEN(node(\"b\"),node(\"c\").data(iteratorData))).id(\"this is a ig\").tag(\"this is a tag\").maxWaitSeconds(3);";
         Assertions.assertEquals(expectedStr,
-                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", "c")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}").toEL());
+                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL()));
     }
     @Test
     public void testLoop16(){
-        String expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\nITERATOR(\n\tnode(\"a\")\n).parallel(true).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).id(\"this is a ig\").tag(\"this is a tag\").data(iteratorData).maxWaitSeconds(3)";
+        String expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\nITERATOR(\n\tnode(\"a\")\n).parallel(true).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(iteratorData)\n\t)\n).id(\"this is a ig\").tag(\"this is a tag\").maxWaitSeconds(3);";
         Assertions.assertEquals(expectedStr,
-                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", "c")).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).data("iteratorData", "{\"name\":\"zhangsan\",\"age\":18}").toEL(true));
+                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", "'{\"name\":\"zhangsan\",\"age\":18}'"))).id("this is a ig").tag("this is a tag").maxWaitSeconds(3).parallel(true).toEL(true)));
     }
     // data Map 参数 测试
     @Test
@@ -183,20 +214,23 @@ public class LoopELBuilderTest extends BaseTest {
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
         String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "FOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).data(forData)";
+                "FOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(forData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.forOpt("a").doOpt(ELBus.then("b", "c")).data("forData", name2Value).toEL());
+                ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL()));
         expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).data(whileData)";
+                "WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(whileData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).data("whileData", name2Value).toEL());
+                ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL()));
         expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "ITERATOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).data(iteratorData)";
+                "ITERATOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(iteratorData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", "c")).data("iteratorData", name2Value).toEL());
+                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL()));
     }
 
     @Test
@@ -205,20 +239,23 @@ public class LoopELBuilderTest extends BaseTest {
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
         String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "FOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).data(forData)";
+                "FOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(forData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.forOpt("a").doOpt(ELBus.then("b", "c")).data("forData", name2Value).toEL(true));
+                ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL(true)));
         expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "WHILE(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).data(whileData)";
+                "WHILE(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whileData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).data("whileData", name2Value).toEL(true));
+                ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL(true)));
         expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).data(iteratorData)";
+                "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(iteratorData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", "c")).data("iteratorData", name2Value).toEL(true));
+                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL(true)));
     }
     private static class ParamClass{
         private String name;
@@ -237,20 +274,23 @@ public class LoopELBuilderTest extends BaseTest {
         name2Value.age = 18;
         name2Value.name = "zhangsan";
         String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "FOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).data(forData)";
+                "FOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(forData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.forOpt("a").doOpt(ELBus.then("b", "c")).data("forData", name2Value).toEL());
+                ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL()));
         expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).data(whileData)";
+                "WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(whileData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).data("whileData", name2Value).toEL());
+                ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL()));
         expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "ITERATOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\"))).data(iteratorData)";
+                "ITERATOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(iteratorData)));";
         Assertions.assertEquals(expectedStr,
-                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", "c")).data("iteratorData", name2Value).toEL());
+                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL()));
     }
 
     @Test
@@ -259,20 +299,23 @@ public class LoopELBuilderTest extends BaseTest {
         name2Value.age = 18;
         name2Value.name = "zhangsan";
         String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "FOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).data(forData)";
+                "FOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(forData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.forOpt("a").doOpt(ELBus.then("b", "c")).data("forData", name2Value).toEL(true));
+                ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("forData", name2Value))).toEL(true)));
         expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "WHILE(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).data(whileData)";
+                "WHILE(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whileData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.whileOpt("a").doOpt(ELBus.then("b", "c")).data("whileData", name2Value).toEL(true));
+                ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("whileData", name2Value))).toEL(true)));
         expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
-                "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t)\n).data(iteratorData)";
+                "ITERATOR(\n\tnode(\"a\")\n).DO(\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(iteratorData)\n\t)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", "c")).data("iteratorData", name2Value).toEL(true));
+                ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.iteratorOpt("a").doOpt(ELBus.then("b", ELBus.node("c").data("iteratorData", name2Value))).toEL(true)));
     }
 
 }

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/NodeELBuilderTest.java

@@ -1,6 +1,7 @@
 package com.yomahub.liteflow.test.builder;
 
 import com.yomahub.liteflow.builder.el.ELBus;
+import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
 import com.yomahub.liteflow.builder.el.NodeELWrapper;
 import com.yomahub.liteflow.test.BaseTest;
 import org.junit.jupiter.api.Assertions;
@@ -22,47 +23,51 @@ import java.util.Map;
 public class NodeELBuilderTest extends BaseTest {
     @Test
     public void testNodeEL1(){
-        String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}'\n" +
-                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4)";
+        String jsonStr = "'{\"name\":\"zhangsan\",\"age\":18}'";
+        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", jsonStr);
         Assertions.assertEquals(expectedStr,
                 node.toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(node.toEL()));
     }
     @Test
     public void testNodeEL2(){
-        String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}'\n" +
-                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4)";
+        String jsonStr = "'{\"name\":\"zhangsan\",\"age\":18}'";
+        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", jsonStr);
         Assertions.assertEquals(expectedStr,
                 node.toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(node.toEL(true)));
     }
     @Test
     public void testNodeEL3(){
         Map<String, Object> name2Value = new HashMap<>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}'\n" +
-                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4)";
+        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
         Assertions.assertEquals(expectedStr,
                 node.toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(node.toEL()));
     }
     @Test
     public void testNodeEL4(){
         Map<String, Object> name2Value = new HashMap<>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}'\n" +
-                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4)";
+        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
         Assertions.assertEquals(expectedStr,
                 node.toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(node.toEL(true)));
     }
     private static class ParamClass{
         private String name;
@@ -79,23 +84,25 @@ public class NodeELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.age = 18;
         name2Value.name = "zhangsan";
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}'\n" +
-                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4)";
+        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
         Assertions.assertEquals(expectedStr,
                 node.toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(node.toEL()));
     }
     @Test
     public void testNodeEL6(){
         ParamClass name2Value = new ParamClass();
         name2Value.age = 18;
         name2Value.name = "zhangsan";
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}'\n" +
-                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4)";
+        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+                "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         NodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
         Assertions.assertEquals(expectedStr,
                 node.toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(node.toEL(true)));
     }
 }

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/SwitchELBuilderTest.java

@@ -1,6 +1,7 @@
 package com.yomahub.liteflow.test.builder;
 
 import com.yomahub.liteflow.builder.el.ELBus;
+import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
 import com.yomahub.liteflow.test.BaseTest;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -23,55 +24,61 @@ public class SwitchELBuilderTest extends BaseTest {
     // Switch调用方法测试
     @Test
     public void testSwitch1(){
-        String expectedStr = "SWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\")).DEFAULT(node(\"f\"))";
+        String expectedStr = "SWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\")).DEFAULT(node(\"f\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.switchOpt("a").to("b", "c", "d").defaultOpt("f").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", "d").defaultOpt("f").toEL()));
     }
 
     // 格式化输出测试
     @Test
     public void testSwitch2(){
-        String expectedStr = "SWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\")\n).DEFAULT(\n\tnode(\"f\")\n)";
+        String expectedStr = "SWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\")\n).DEFAULT(\n\tnode(\"f\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.switchOpt("a").to("b", "c", "d").defaultOpt("f").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", "d").defaultOpt("f").toEL(true)));
     }
 
     // switch和THEN when嵌套调用测试
     @Test
     public void testSwitch3(){
-        String expectedStr = "SWITCH(node(\"a\")).TO(node(\"b\"),THEN(node(\"c\"),node(\"d\")),WHEN(node(\"e\"),node(\"f\"))).DEFAULT(THEN(node(\"g\"),node(\"h\")))";
+        String expectedStr = "SWITCH(node(\"a\")).TO(node(\"b\"),THEN(node(\"c\"),node(\"d\")),WHEN(node(\"e\"),node(\"f\"))).DEFAULT(THEN(node(\"g\"),node(\"h\")));";
         Assertions.assertEquals(expectedStr,
                 ELBus.switchOpt("a").to("b", ELBus.then("c", "d"), ELBus.when("e", "f")).defaultOpt(ELBus.then("g", "h")).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", ELBus.then("c", "d"), ELBus.when("e", "f")).defaultOpt(ELBus.then("g", "h")).toEL()));
     }
 
     // 格式化输出测试
     @Test
     public void testSwitch4(){
-        String expectedStr = "SWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tTHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t),\n\tWHEN(\n\t\tnode(\"e\"),\n\t\tnode(\"f\")\n\t)\n).DEFAULT(\n\tTHEN(\n\t\tnode(\"g\"),\n\t\tnode(\"h\")\n\t)\n)";
+        String expectedStr = "SWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tTHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t),\n\tWHEN(\n\t\tnode(\"e\"),\n\t\tnode(\"f\")\n\t)\n).DEFAULT(\n\tTHEN(\n\t\tnode(\"g\"),\n\t\tnode(\"h\")\n\t)\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.switchOpt("a").to("b", ELBus.then("c", "d"), ELBus.when("e", "f")).defaultOpt(ELBus.then("g", "h")).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", ELBus.then("c", "d"), ELBus.when("e", "f")).defaultOpt(ELBus.then("g", "h")).toEL(true)));
     }
 
     // 属性设置测试
     @Test
     public void testSwitch5(){
-        String expectedStr = "SWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\")).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(5)";
+        String expectedStr = "SWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\")).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(5);";
         Assertions.assertEquals(expectedStr,
                 ELBus.switchOpt("a").to("b", "c", "d").id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", "d").id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL()));
     }
 
     // 格式化输出测试
     @Test
     public void testSwitch6(){
-        String expectedStr = "SWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\")\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(5)";
+        String expectedStr = "SWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\")\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(5);";
         Assertions.assertEquals(expectedStr,
                 ELBus.switchOpt("a").to("b", "c", "d").id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", "d").id("this is a id").tag("this is a tag").maxWaitSeconds(5).toEL(true)));
     }
 
     // data属性测试
@@ -80,10 +87,11 @@ public class SwitchELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\")).data(switchData)";
+        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\").data(switchData));";
         Assertions.assertEquals(expectedStr,
-                ELBus.switchOpt("a").to("b", "c", "d").data("switchData", name2Value).toEL());
+                ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c",ELBus.node("d").data("switchData", name2Value)).toEL()));
     }
 
     @Test
@@ -91,28 +99,31 @@ public class SwitchELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\")\n).data(switchData)";
+        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\").data(switchData)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.switchOpt("a").to("b", "c", "d").data("switchData", name2Value).toEL(true));
+                ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL(true)));
     }
 
     @Test
     public void testSwitch9(){
-        String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
-        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\")).data(switchData)";
+        String jsonStr = "'{\"name\":\"zhangsan\",\"age\":18}'";
+        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\").data(switchData));";
         Assertions.assertEquals(expectedStr,
-                ELBus.switchOpt("a").to("b", "c", "d").data("switchData", jsonStr).toEL());
+                ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", jsonStr)).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", jsonStr)).toEL()));
     }
 
     @Test
     public void testSwitch10(){
-        String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
-        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\")\n).data(switchData)";
+        String jsonStr = "'{\"name\":\"zhangsan\",\"age\":18}'";
+        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\").data(switchData)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.switchOpt("a").to("b", "c", "d").data("switchData", jsonStr).toEL(true));
+                ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", jsonStr)).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", jsonStr)).toEL(true)));
     }
 
     private static class ParamClass{
@@ -131,10 +142,11 @@ public class SwitchELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\")).data(switchData)";
+        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\").data(switchData));";
         Assertions.assertEquals(expectedStr,
-                ELBus.switchOpt("a").to("b", "c", "d").data("switchData", name2Value).toEL());
+                ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL()));
     }
 
     @Test
@@ -142,10 +154,11 @@ public class SwitchELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\")\n).data(switchData)";
+        String expectedStr = "switchData = '{\"name\":\"zhangsan\",\"age\":18}';\nSWITCH(node(\"a\")).TO(\n\tnode(\"b\"),\n\tnode(\"c\"),\n\tnode(\"d\").data(switchData)\n);";
         Assertions.assertEquals(expectedStr,
-                ELBus.switchOpt("a").to("b", "c", "d").data("switchData", name2Value).toEL(true));
+                ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.switchOpt("a").to("b", "c", ELBus.node("d").data("switchData", name2Value)).toEL(true)));
     }
 
 }

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/TestContext.java

@@ -0,0 +1,25 @@
+package com.yomahub.liteflow.test.builder;
+
+import cn.hutool.core.collection.ConcurrentHashSet;
+
+import java.util.Set;
+
+/**
+ * EL表达式装配并执行测试
+ *
+ * @author gezuao
+ * @since 2.11.1
+ */
+public class TestContext {
+
+	private Set<String> set = new ConcurrentHashSet<>();
+
+	public void add2Set(String str) {
+		set.add(str);
+	}
+
+	public Set<String> getSet() {
+		return set;
+	}
+
+}

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/ThenELBuilderTest.java

@@ -1,6 +1,7 @@
 package com.yomahub.liteflow.test.builder;
 
 import com.yomahub.liteflow.builder.el.ELBus;
+import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
 import com.yomahub.liteflow.test.BaseTest;
 import com.yomahub.liteflow.util.JsonUtil;
 import org.junit.jupiter.api.Assertions;
@@ -24,87 +25,99 @@ public class ThenELBuilderTest extends BaseTest {
     // then组件测试
     @Test
     public void testThen1(){
-        Assertions.assertEquals("THEN(node(\"a\"),node(\"b\"))",
+        Assertions.assertEquals("THEN(node(\"a\"),node(\"b\"));",
                 ELBus.then("a", "b").toEL());
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", "b").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testThen2(){
         Assertions.assertEquals("THEN(\n\tnode(\"a\")," +
-                        "\n\tnode(\"b\")\n)",
+                        "\n\tnode(\"b\")\n);",
                 ELBus.then("a", "b").toEL(true));
         System.out.println("THEN(\n\tnode(\"a\")," +
-                "\n\tnode(\"b\")\n)");
+                "\n\tnode(\"b\")\n);");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", "b").toEL(true)));
     }
     // then组件then方法调用测试
     @Test
     public void testThen3(){
-        Assertions.assertEquals("THEN(node(\"a\"),node(\"b\"),node(\"c\"))",
+        Assertions.assertEquals("THEN(node(\"a\"),node(\"b\"),node(\"c\"));",
                 ELBus.then("a", "b").then("c").toEL());
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", "b").then("c").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testThen4(){
         Assertions.assertEquals("THEN(\n\tnode(\"a\"),\n\tnode(\"b\")," +
-                        "\n\tnode(\"c\")\n)",
+                        "\n\tnode(\"c\")\n);",
                 ELBus.then("a", "b").then("c").toEL(true));
         System.out.println("THEN(\n\tnode(\"a\"),\n\tnode(\"b\")," +
-                "\n\tnode(\"c\")\n)");
+                "\n\tnode(\"c\")\n);");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", "b").then("c").toEL(true)));
     }
     // then组件嵌套调用测试
     @Test
     public void testThen5(){
-        Assertions.assertEquals("THEN(node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"))",
+        Assertions.assertEquals("THEN(node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"));",
                 ELBus.then("a", ELBus.then("b").then("c")).then("d").toEL());
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testThen6(){
-        Assertions.assertEquals("THEN(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n)",
+        Assertions.assertEquals("THEN(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);",
                 ELBus.then("a", ELBus.then("b").then("c")).then("d").toEL(true));
-        System.out.println("THEN(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n)");
+        System.out.println("THEN(\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").toEL(true)));
     }
     // pre组件测试
     @Test
     public void testThen7(){
-        Assertions.assertEquals("THEN(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"))",
+        Assertions.assertEquals("THEN(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"));",
                 ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").pre("pp").toEL());
-        System.out.println("THEN(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"))");
+        System.out.println("THEN(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"));");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").pre("pp").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testThen8(){
-        Assertions.assertEquals("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n)",
+        Assertions.assertEquals("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);",
                 ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").pre("pp").toEL(true));
-        System.out.println("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n)");
+        System.out.println("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").pre("pp").toEL(true)));
     }
     // pre finally 格式测试
     @Test
     public void testThen9(){
-        Assertions.assertEquals("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")))",
+        Assertions.assertEquals("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")));",
                 ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").finallyOpt("f").toEL());
-        System.out.println("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")))");
+        System.out.println("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")));");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").finallyOpt("f").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testThen10(){
-        Assertions.assertEquals("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n)",
+        Assertions.assertEquals("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n);",
                 ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").finallyOpt("f").toEL(true));
-        System.out.println("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n)");
+        System.out.println("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n);");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c")).then("d").pre("p").finallyOpt("f").toEL(true)));
     }
     // 属性设置测试
     @Test
     public void testThen11(){
-        Assertions.assertEquals("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\")",
+        Assertions.assertEquals("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
                 ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").pre("p").finallyOpt("f").toEL());
-        System.out.println("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\")");
+        System.out.println("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").pre("p").finallyOpt("f").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testThen12(){
-        Assertions.assertEquals("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\")",
+        Assertions.assertEquals("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
                 ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").pre("p").finallyOpt("f").toEL(true));
-        System.out.println("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\")");
+        System.out.println("THEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").pre("p").finallyOpt("f").toEL(true)));
     }
     // data属性测试
     @Test
@@ -113,9 +126,10 @@ public class ThenELBuilderTest extends BaseTest {
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
         System.out.println(JsonUtil.toJsonString(name2Value));
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\").data(thenData)",
-                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").data("thenData", name2Value).pre("p").finallyOpt("f").toEL());
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\").data(thenData)");
+        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
+                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL());
+        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL()));
     }
     // 格式化输出测试
     @Test
@@ -123,23 +137,26 @@ public class ThenELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\").data(thenData)",
-                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").data("thenData", name2Value).pre("p").finallyOpt("f").toEL(true));
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\").data(thenData)");
+        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
+                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true));
+        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true)));
     }
     // data属性测试 Json字符串赋值data
     @Test
     public void testThen15(){
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\").data(thenData)",
-                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}").pre("p").finallyOpt("f").toEL());
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\").data(thenData)");
+        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
+                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "'{\"name\":\"zhangsan\",\"age\":18}'")).pre("p").finallyOpt("f").toEL());
+        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "'{\"name\":\"zhangsan\",\"age\":18}'")).pre("p").finallyOpt("f").toEL()));
     }
     // 格式化输出测试 Json字符串赋值data
     @Test
     public void testThen16(){
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\").data(thenData)",
-                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}").pre("p").finallyOpt("f").toEL(true));
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\").data(thenData)");
+        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
+                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "'{\"name\":\"zhangsan\",\"age\":18}'")).pre("p").finallyOpt("f").toEL(true));
+        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "'{\"name\":\"zhangsan\",\"age\":18}'")).pre("p").finallyOpt("f").toEL(true)));
     }
     private static class ParamClass{
         private String name;
@@ -157,9 +174,10 @@ public class ThenELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\").data(thenData)",
-                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").data("thenData", name2Value).pre("p").finallyOpt("f").toEL());
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\").data(thenData)");
+        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
+                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL());
+        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL()));
     }
     // 格式化输出测试
     @Test
@@ -167,24 +185,27 @@ public class ThenELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\").data(thenData)",
-                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then("d").data("thenData", name2Value).pre("p").finallyOpt("f").toEL(true));
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\").data(thenData)");
+        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
+                ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true));
+        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tTHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a", ELBus.then("b").then("c").id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre("p").finallyOpt("f").toEL(true)));
     }
     // maxWaitSecond测试
     @Test
     public void testThen19(){
-        String expectedStr = "THEN(node(\"a\"),node(\"b\")).maxWaitSeconds(5)";
+        String expectedStr = "THEN(node(\"a\"),node(\"b\")).maxWaitSeconds(5);";
         Assertions.assertEquals(expectedStr,
                 ELBus.then("a").then("b").maxWaitSeconds(5).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a").then("b").maxWaitSeconds(5).toEL()));
     }
     // 格式化输出测试
     @Test
     public void testThen20(){
-        String expectedStr = "THEN(\n\tnode(\"a\"),\n\tnode(\"b\")\n).maxWaitSeconds(5)";
+        String expectedStr = "THEN(\n\tnode(\"a\"),\n\tnode(\"b\")\n).maxWaitSeconds(5);";
         Assertions.assertEquals(expectedStr,
                 ELBus.then("a").then("b").maxWaitSeconds(5).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then("a").then("b").maxWaitSeconds(5).toEL(true)));
     }
 }

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/WhenELBuilderTest.java

@@ -1,6 +1,8 @@
 package com.yomahub.liteflow.test.builder;
 
 import com.yomahub.liteflow.builder.el.ELBus;
+import com.yomahub.liteflow.builder.el.LiteFlowChainELBuilder;
+import com.yomahub.liteflow.builder.el.WhenELWrapper;
 import com.yomahub.liteflow.test.BaseTest;
 import com.yomahub.liteflow.util.JsonUtil;
 import org.junit.jupiter.api.Assertions;
@@ -8,6 +10,7 @@ import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.test.context.SpringBootTest;
 
+import javax.annotation.meta.When;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -23,95 +26,107 @@ public class WhenELBuilderTest extends BaseTest {
     // then组件测试
     @Test
     public void testWhen1(){
-        String expectedStr = "WHEN(node(\"a\"),node(\"b\"))";
+        String expectedStr = "WHEN(node(\"a\"),node(\"b\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", "b").toEL());
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testWhen2(){
-        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\")\n)";
+        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", "b").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").toEL(true)));
     }
     // then组件then方法调用测试
     @Test
     public void testWhen3(){
-        String expectedStr = "WHEN(node(\"a\"),node(\"b\"),node(\"c\"))";
+        String expectedStr = "WHEN(node(\"a\"),node(\"b\"),node(\"c\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", "b").when("c").toEL());
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").when("c").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testWhen4(){
-        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n)";
+        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", "b").when("c").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").when("c").toEL(true)));
     }
     // then组件嵌套调用测试
     @Test
     public void testWhen5(){
-        String expectedStr = "WHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\")),node(\"d\"))";
+        String expectedStr = "WHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\")),node(\"d\"));";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", ELBus.when("b").when("c")).when("d").toEL());
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when("c")).when("d").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testWhen6(){
-        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n)";
+        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", ELBus.when("b").when("c")).when("d").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when("c")).when("d").toEL(true)));
     }
     // WHEN特有属性测试 any ignoreError customThreadExecutor must
     @Test
     public void testWhen7(){
-        String expectedStr = "WHEN(node(\"a\"),node(\"b\"),WHEN(node(\"c\"),node(\"d\")).any(true).threadPool(\"WhenELBuilderTest.customThreadPool\").id(\"node1\")).ignoreError(true).must(\"a\", \"task1\", \"node1\")";
+        String expectedStr = "WHEN(node(\"a\"),node(\"b\"),WHEN(node(\"c\"),node(\"d\")).any(true).threadPool(\"com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1\").id(\"node1\")).ignoreError(true).must(\"a\", \"task1\", \"node1\");";
         Assertions.assertEquals(expectedStr,
-                ELBus.when("a", "b", ELBus.when("c").when("d").customThreadExecutor("WhenELBuilderTest.customThreadPool").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL());
+                ELBus.when("a", "b", ELBus.when("c").when("d").id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b", ELBus.when("c").when("d").id("node1").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testWhen8(){
-        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tWHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t).any(true).threadPool(\"WhenELBuilderTest.customThreadPool\").id(\"node1\")\n).ignoreError(true).must(\"a\", \"task1\", \"node1\")";
+        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tWHEN(\n\t\tnode(\"c\"),\n\t\tnode(\"d\")\n\t).any(true).threadPool(\"com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1\").id(\"node1\")\n).ignoreError(true).must(\"a\", \"task1\", \"node1\");";
         Assertions.assertEquals(expectedStr,
-                ELBus.when("a", "b", ELBus.when("c").when("d").customThreadExecutor("WhenELBuilderTest.customThreadPool").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL(true));
+                ELBus.when("a", "b", ELBus.when("c").when("d").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b", ELBus.when("c").when("d").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1").id("node1").any(true)).ignoreError(true).must("a", "task1", "node1").toEL(true)));
     }
     // maxWaitSeconds 属性测试
     @Test
     public void testWhen9(){
-        String expectedStr = "WHEN(node(\"a\"),node(\"b\")).maxWaitSeconds(5)";
+        String expectedStr = "WHEN(node(\"a\"),node(\"b\")).maxWaitSeconds(5);";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", "b").maxWaitSeconds(5).toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").maxWaitSeconds(5).toEL()));
     }
     // 格式化输出测试
     @Test
     public void testWhen10(){
-        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\")\n).maxWaitSeconds(5)";
+        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tnode(\"b\")\n).maxWaitSeconds(5);";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", "b").maxWaitSeconds(5).toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", "b").maxWaitSeconds(5).toEL(true)));
     }
     // 属性设置测试
     @Test
     public void testWhen11(){
-        String expectedStr = "WHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\")";
+        String expectedStr = "WHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", ELBus.when("b").when("c").id("this is a id")).when("d").tag("this is a tag").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when("c").id("this is a id")).when("d").tag("this is a tag").toEL()));
     }
     // 格式化输出测试
     @Test
     public void testWhen12(){
-        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\")";
+        String expectedStr = "WHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
                 ELBus.when("a", ELBus.when("b").when("c").id("this is a id")).when("d").tag("this is a tag").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when("c").id("this is a id")).when("d").tag("this is a tag").toEL(true)));
     }
     // data属性测试
     @Test
@@ -120,10 +135,11 @@ public class WhenELBuilderTest extends BaseTest {
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
         System.out.println(JsonUtil.toJsonString(name2Value));
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\")).id(\"this is a id\").data(whenData),node(\"d\")).tag(\"this is a tag\")";
+        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
-                ELBus.when("a", ELBus.when("b").when("c").data("whenData", name2Value).id("this is a id")).when("d").tag("this is a tag").toEL(false));
+                ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(false));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(false)));
     }
     // 格式化输出测试
     @Test
@@ -131,26 +147,29 @@ public class WhenELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\").data(whenData),\n\tnode(\"d\")\n).tag(\"this is a tag\")";
+        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whenData)\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
-                ELBus.when("a", ELBus.when("b").when("c").data("whenData", name2Value).id("this is a id")).when("d").tag("this is a tag").toEL(true));
+                ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(true)));
     }
     // data属性测试 Json字符串赋值data
     @Test
     public void testWhen15(){
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\")).id(\"this is a id\").data(whenData),node(\"d\")).tag(\"this is a tag\")";
+        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
-                ELBus.when("a", ELBus.when("b").when("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}").id("this is a id")).when("d").tag("this is a tag").toEL());
+                ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a id")).when("d").tag("this is a tag").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a id")).when("d").tag("this is a tag").toEL()));
     }
     // 格式化输出测试 Json字符串赋值data
     @Test
     public void testWhen16(){
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\").data(whenData),\n\tnode(\"d\")\n).tag(\"this is a tag\")";
+        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whenData)\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
-                ELBus.when("a", ELBus.when("b").when("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}").id("this is a id")).when("d").tag("this is a tag").toEL(true));
+                ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a id")).when("d").tag("this is a tag").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", "'{\"name\":\"zhangsan\",\"age\":18}'")).id("this is a id")).when("d").tag("this is a tag").toEL(true)));
     }
     private static class ParamClass{
         private String name;
@@ -168,10 +187,11 @@ public class WhenELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\")).id(\"this is a id\").data(whenData),node(\"d\")).tag(\"this is a tag\")";
+        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(node(\"a\"),WHEN(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
-                ELBus.when("a", ELBus.when("b").when("c").data("whenData", name2Value).id("this is a id")).when("d").tag("this is a tag").toEL());
+                ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL());
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL()));
     }
     // 格式化输出测试
     @Test
@@ -179,9 +199,16 @@ public class WhenELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t).id(\"this is a id\").data(whenData),\n\tnode(\"d\")\n).tag(\"this is a tag\")";
+        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nWHEN(\n\tnode(\"a\"),\n\tWHEN(\n\t\tnode(\"b\"),\n\t\tnode(\"c\").data(whenData)\n\t).id(\"this is a id\"),\n\tnode(\"d\")\n).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
-                ELBus.when("a", ELBus.when("b").when("c").data("whenData", name2Value).id("this is a id")).when("d").tag("this is a tag").toEL(true));
+                ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(true));
         System.out.println(expectedStr);
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.when("a", ELBus.when("b").when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when("d").tag("this is a tag").toEL(true)));
+    }
+
+    @Test
+    public void testWHEN(){
+        WhenELWrapper el = ELBus.when("a", "b", "c").customThreadExecutor("com.yomahub.liteflow.test.builder.customTreadExecutor.CustomThreadExecutor1");
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(el.toEL()));
     }
 }

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/cmp/ACmp.java

@@ -0,0 +1,21 @@
+package com.yomahub.liteflow.test.builder.cmp;
+
+import com.yomahub.liteflow.core.NodeComponent;
+import org.springframework.stereotype.Component;
+
+/**
+ * EL表达式装配并执行测试
+ *
+ * @author gezuao
+ * @since 2.11.1
+ */
+@Component("a")
+public class ACmp extends NodeComponent {
+
+	@Override
+	public void process() {
+		System.out.println(this.getCmpData(String.class));
+		System.out.println("ACmp executed!");
+	}
+
+}

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/cmp/BCmp.java

@@ -0,0 +1,25 @@
+package com.yomahub.liteflow.test.builder.cmp;
+
+import com.yomahub.liteflow.core.NodeComponent;
+import com.yomahub.liteflow.slot.DefaultContext;
+import com.yomahub.liteflow.test.builder.vo.User;
+import org.springframework.stereotype.Component;
+
+/**
+ * EL表达式装配并执行测试
+ *
+ * @author gezuao
+ * @since 2.11.1
+ */
+@Component("b")
+public class BCmp extends NodeComponent {
+
+	@Override
+	public void process() {
+		User user = this.getCmpData(User.class);
+		DefaultContext context = this.getFirstContextBean();
+		context.setData("user", user);
+		System.out.println("BCmp executed!");
+	}
+
+}

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/cmp/CCmp.java

@@ -0,0 +1,24 @@
+package com.yomahub.liteflow.test.builder.cmp;
+
+import com.yomahub.liteflow.core.NodeComponent;
+import com.yomahub.liteflow.test.builder.TestContext;
+import org.springframework.stereotype.Component;
+
+/**
+ * EL表达式装配并执行测试
+ *
+ * @author gezuao
+ * @since 2.11.1
+ */
+@Component("c")
+public class CCmp extends NodeComponent {
+
+	@Override
+	public void process() {
+		String data = this.getCmpData(String.class);
+		TestContext context = this.getFirstContextBean();
+		context.add2Set(data);
+		System.out.println("CCmp executed!");
+	}
+
+}

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/customTreadExecutor/CustomThreadExecutor1.java

@@ -0,0 +1,29 @@
+package com.yomahub.liteflow.test.builder.customTreadExecutor;
+
+import cn.hutool.core.util.ObjectUtil;
+import com.yomahub.liteflow.property.LiteflowConfig;
+import com.yomahub.liteflow.property.LiteflowConfigGetter;
+import com.yomahub.liteflow.thread.ExecutorBuilder;
+
+import java.util.concurrent.ExecutorService;
+
+/**
+ * EL表达式装配并执行测试
+ *
+ * @author gezuao
+ * @since 2.11.1
+ */
+public class CustomThreadExecutor1 implements ExecutorBuilder {
+
+	@Override
+	public ExecutorService buildExecutor() {
+		LiteflowConfig liteflowConfig = LiteflowConfigGetter.get();
+		// 只有在非spring的场景下liteflowConfig才会为null
+		if (ObjectUtil.isNull(liteflowConfig)) {
+			liteflowConfig = new LiteflowConfig();
+		}
+		return buildDefaultExecutor(liteflowConfig.getWhenMaxWorkers(), liteflowConfig.getWhenMaxWorkers(),
+				liteflowConfig.getWhenQueueLimit(), "customer-when-1-thead-");
+	}
+
+}

liteflow-testcase-el/liteflow-testcase-el-builder/src/test/java/com/yomahub/liteflow/test/builder/vo/User.java

@@ -0,0 +1,43 @@
+package com.yomahub.liteflow.test.builder.vo;
+
+import java.util.Date;
+
+/**
+ * EL表达式装配并执行测试
+ *
+ * @author gezuao
+ * @since 2.11.1
+ */
+public class User {
+
+	private String name;
+
+	private int age;
+
+	private Date birth;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public int getAge() {
+		return age;
+	}
+
+	public void setAge(int age) {
+		this.age = age;
+	}
+
+	public Date getBirth() {
+		return birth;
+	}
+
+	public void setBirth(Date birth) {
+		this.birth = birth;
+	}
+
+}