bug #IBMPPW 组件参数中含字符单英文引号"'"时，在构建EL时会解析失败

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

@@ -4,9 +4,9 @@ import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.util.StrUtil;
 import com.yomahub.liteflow.builder.el.vo.RetryELVo;
 import com.yomahub.liteflow.util.JsonUtil;
+import org.apache.commons.lang.StringEscapeUtils;
 
 import java.util.*;
-import java.util.function.Consumer;
 
 /**
  * ELWrapper是所有组件的抽象父类
@@ -142,7 +142,7 @@ public abstract class ELWrapper {
      * @return {@link ELWrapper}
      */
     protected ELWrapper data(String dataName, Object object){
-        setData("'" + JsonUtil.toJsonString(object) + "'");
+        setData(StrUtil.format("\"{}\"",StringEscapeUtils.escapeJava(JsonUtil.toJsonString(object))));
         setDataName(dataName);
         return this;
     }
@@ -155,7 +155,7 @@ public abstract class ELWrapper {
      * @return {@link ELWrapper}
      */
     protected ELWrapper data(String dataName, String jsonString){
-        setData("'" + jsonString + "'");
+        setData(StrUtil.format("\"{}\"",StringEscapeUtils.escapeJava(jsonString)));
         setDataName(dataName);
         return this;
     }
@@ -168,7 +168,7 @@ public abstract class ELWrapper {
      * @return {@link ELWrapper}
      */
     protected ELWrapper data(String dataName, Map<String, Object> jsonMap){
-        setData("'" + JsonUtil.toJsonString(jsonMap) + "'");
+        setData(StrUtil.format("\"{}\"", StringEscapeUtils.escapeJava(JsonUtil.toJsonString(jsonMap))));
         setDataName(dataName);
         return this;
     }
@@ -242,14 +242,14 @@ public abstract class ELWrapper {
             elContext.append(StrUtil.format(".id(\"{}\")", this.getId()));
         }
         if(this.getTag() != null){
-            elContext.append(StrUtil.format(".tag(\"{}\")", this.getTag()));
+            elContext.append(StrUtil.format(".tag(\"{}\")", StringEscapeUtils.escapeJava(this.getTag())));
         }
         if(this.getData() != null){
             elContext.append(StrUtil.format(".data({})", this.getDataName()));
             paramContext.append(StrUtil.format("{} = {}", this.getDataName(), this.getData())).append(";\n");
         }
         if(MapUtil.isNotEmpty(this.getBindData())){
-            this.getBindData().forEach((key, value) -> elContext.append(StrUtil.format(".bind(\"{}\", \"{}\")", key, value)));
+            this.getBindData().forEach((key, value) -> elContext.append(StrUtil.format(".bind(\"{}\", \"{}\")", key, StringEscapeUtils.escapeJava(value))));
         }
         if(this.getMaxWaitSeconds() != null){
             elContext.append(StrUtil.format(".maxWaitSeconds({})", String.valueOf(this.getMaxWaitSeconds())));

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

@@ -32,8 +32,8 @@ public class BindELBuilderTest extends BaseTest {
 
     @Test
     public void testBind3(){
-        String actualEl = ELBus.then("a", ELBus.node("b").bind("k1", "v1")).toEL();
-        String expected = "THEN(a,node(\"b\").bind(\"k1\", \"v1\"));";
+        String actualEl = ELBus.then("a", ELBus.element("b").bind("k1", "v1")).toEL();
+        String expected = "THEN(a,b.bind(\"k1\", \"v1\"));";
         System.out.println(actualEl);
         Assertions.assertEquals(expected, actualEl);
     }

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

@@ -3,6 +3,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.apache.commons.lang.StringEscapeUtils;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@@ -23,53 +24,48 @@ public class CatchELBuilderTest extends BaseTest {
     // catch捕获异常调用测试
     @Test
     public void testCatch1(){
-        String expectedStr = "CATCH(THEN(node(\"a\"),node(\"b\"))).DO(node(\"c\"));";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.then(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).toEL());
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.then(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).toEL()));
+        String el = ELBus.catchException(ELBus.then(ELBus.element("a"), ELBus.element("b"))).doOpt(ELBus.element("c")).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "CATCH(THEN(a,b)).DO(c);";
+        Assertions.assertEquals(expect, el);
     }
     @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);";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.then(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).toEL(true));
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.then(ELBus.node("a"), ELBus.node("b"))).doOpt(ELBus.node("c")).toEL(true)));
+        String el = ELBus.catchException(ELBus.then(ELBus.element("a"), ELBus.element("b"))).doOpt(ELBus.element("c")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "CATCH(\n\tTHEN(\n\t\ta,\n\t\tb\n\t)\n).DO(\n\tc\n);";
+        Assertions.assertEquals(expect, el);
     }
     // 属性设置测试
     @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);";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL());
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL()));
+        String el = ELBus.catchException(ELBus.element("a")).doOpt(ELBus.then(ELBus.element("b"), ELBus.element("c"))).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "CATCH(a).DO(THEN(b,c)).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
+        Assertions.assertEquals(expect, el);
     }
+
     @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);";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c"))).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true)));
+        String el = ELBus.catchException(ELBus.element("a")).doOpt(ELBus.then(ELBus.element("b"), ELBus.element("c"))).id("this is a id").tag("this is a tag").maxWaitSeconds(3).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "CATCH(\n\ta\n).DO(\n\tTHEN(\n\t\tb,\n\t\tc\n\t)\n).id(\"this is a id\").tag(\"this is a tag\").maxWaitSeconds(3);";
+        Assertions.assertEquals(expect, el);
     }
     // data 设置 jsonStr
     @Test
     public void testCatch5(){
-        String expectedStr = "catchData = '{\"name\":\"zhangsan\",\"age\":18}';\nCATCH(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(catchData)));";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL());
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL()));
+        String el = ELBus.catchException(ELBus.element("a")).doOpt(ELBus.then(ELBus.element("b"), ELBus.element("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "catchData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nCATCH(a).DO(THEN(b,c.data(catchData)));";
+        Assertions.assertEquals(expect, el);
     }
     @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\").data(catchData)\n\t)\n);";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true));
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true)));
+        String el = ELBus.catchException(ELBus.element("a")).doOpt(ELBus.then(ELBus.element("b"), ELBus.element("c").data("catchData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "catchData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nCATCH(\n\ta\n).DO(\n\tTHEN(\n\t\tb,\n\t\tc.data(catchData)\n\t)\n);";
+        Assertions.assertEquals(expect, el);
    }
     // data 设置 map
     @Test
@@ -77,23 +73,23 @@ public class CatchELBuilderTest extends BaseTest {
         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)));";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL());
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL()));
+        String el = ELBus.catchException(ELBus.element("a")).doOpt(ELBus.then(ELBus.element("b"), ELBus.element("c").data("catchData", name2Value))).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "catchData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nCATCH(a).DO(THEN(b,c.data(catchData)));";
+        Assertions.assertEquals(expect, el);
     }
+
     @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\").data(catchData)\n\t)\n);";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL(true));
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL(true)));
+        String el = ELBus.catchException(ELBus.element("a")).doOpt(ELBus.then(ELBus.element("b"), ELBus.element("c").data("catchData", name2Value))).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "catchData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nCATCH(\n\ta\n).DO(\n\tTHEN(\n\t\tb,\n\t\tc.data(catchData)\n\t)\n);";
+        Assertions.assertEquals(expect, el);
     }
+
     private static class ParamClass{
         private String name;
         private Integer age;
@@ -110,21 +106,20 @@ 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)));";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL());
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL()));
+        String el = ELBus.catchException(ELBus.element("a")).doOpt(ELBus.then(ELBus.element("b"), ELBus.element("c").data("catchData", name2Value))).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "catchData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nCATCH(a).DO(THEN(b,c.data(catchData)));";
+        Assertions.assertEquals(expect, el);
     }
+
     @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\").data(catchData)\n\t)\n);";
-        Assertions.assertEquals(expectedStr,
-                ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL(true));
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.catchException(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("catchData", name2Value))).toEL(true)));
+        String el = ELBus.catchException(ELBus.element("a")).doOpt(ELBus.then(ELBus.element("b"), ELBus.element("c").data("catchData", name2Value))).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "catchData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nCATCH(\n\ta\n).DO(\n\tTHEN(\n\t\tb,\n\t\tc.data(catchData)\n\t)\n);";
+        Assertions.assertEquals(expect, el);
     }
 }

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

@@ -14,6 +14,7 @@ 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.apache.commons.lang.StringEscapeUtils;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@@ -56,31 +57,29 @@ public class ComplexELBuilderTest extends BaseTest {
      */
     @Test
     public void testComplexEL1() {
-        ThenELWrapper complexEl1 = ELBus.then(
-                ELBus.node("A"),
+        ThenELWrapper complexEl = ELBus.then(
+                ELBus.element("A"),
                 ELBus.when(
-                        ELBus.then(ELBus.node("B"), ELBus.node("C")),
-                        ELBus.then(ELBus.node("D")).then(ELBus.node("E")).then(ELBus.node("F")),
+                        ELBus.then(ELBus.element("B"), ELBus.element("C")),
+                        ELBus.then(ELBus.element("D")).then(ELBus.element("E")).then(ELBus.element("F")),
                         ELBus.then(
-                                ELBus.switchOpt(ELBus.node("G")).to(
-                                        ELBus.then(ELBus.node("H"), ELBus.node("I"), ELBus.when(ELBus.node("J")).when(ELBus.node("K"))).id("t1"),
-                                        ELBus.then(ELBus.node("L"), ELBus.node("M")).id("t2")
+                                ELBus.switchOpt(ELBus.element("G")).to(
+                                        ELBus.then(ELBus.element("H"), ELBus.element("I"), ELBus.when(ELBus.element("J")).when(ELBus.element("K"))).id("t1"),
+                                        ELBus.then(ELBus.element("L"), ELBus.element("M")).id("t2")
                                 ),
-                                ELBus.node("N")
+                                ELBus.element("N")
                         )
                 ),
-                ELBus.node("Z")
+                ELBus.element("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);";
-        Assertions.assertEquals(expectedStr,
-                complexEl1.toEL(true));
-        System.out.println(expectedStr);
+        System.out.println(StringEscapeUtils.escapeJava(complexEl.toEL()));
+        String expect1 = "THEN(A,WHEN(THEN(B,C),THEN(D,E,F),THEN(SWITCH(G).TO(THEN(H,I,WHEN(J,K)).id(\"t1\"),THEN(L,M).id(\"t2\")),N)),Z);";
+        Assertions.assertEquals(expect1, complexEl.toEL());
 
+        System.out.println(StringEscapeUtils.escapeJava(complexEl.toEL(true)));
+        String expect2 = "THEN(\n\tA,\n\tWHEN(\n\t\tTHEN(\n\t\t\tB,\n\t\t\tC\n\t\t),\n\t\tTHEN(\n\t\t\tD,\n\t\t\tE,\n\t\t\tF\n\t\t),\n\t\tTHEN(\n\t\t\tSWITCH(G).TO(\n\t\t\t\tTHEN(\n\t\t\t\t\tH,\n\t\t\t\t\tI,\n\t\t\t\t\tWHEN(\n\t\t\t\t\t\tJ,\n\t\t\t\t\t\tK\n\t\t\t\t\t)\n\t\t\t\t).id(\"t1\"),\n\t\t\t\tTHEN(\n\t\t\t\t\tL,\n\t\t\t\t\tM\n\t\t\t\t).id(\"t2\")\n\t\t\t),\n\t\t\tN\n\t\t)\n\t),\n\tZ\n);";
+        Assertions.assertEquals(expect2, complexEl.toEL(true));
     }
 
     /*
@@ -105,35 +104,34 @@ public class ComplexELBuilderTest extends BaseTest {
      */
     @Test
     public void testComplexEl2(){
-        ThenELWrapper complexEl2 = ELBus.then(
-                ELBus.node("A"),
-                ELBus.switchOpt(ELBus.node("B")).to(
-                        ELBus.then(ELBus.node("D"),ELBus.node("E")).then(ELBus.node("F")).id("t1"),
+        ThenELWrapper complexEl = ELBus.then(
+                ELBus.element("A"),
+                ELBus.switchOpt(ELBus.element("B")).to(
+                        ELBus.then(ELBus.element("D"),ELBus.element("E")).then(ELBus.element("F")).id("t1"),
                         ELBus.then(
-                                ELBus.node("C"),
+                                ELBus.element("C"),
                                 ELBus.when(
                                         ELBus.then(
-                                                ELBus.switchOpt(ELBus.node("G")).to(
-                                                        ELBus.then(ELBus.node("H"), ELBus.node("I")).id("t2"),
-                                                        ELBus.node("J")
+                                                ELBus.switchOpt(ELBus.element("G")).to(
+                                                        ELBus.then(ELBus.element("H"), ELBus.element("I")).id("t2"),
+                                                        ELBus.element("J")
                                                 ),
-                                                ELBus.node("K")
+                                                ELBus.element("K")
                                         ),
-                                        ELBus.then(ELBus.node("L"), ELBus.node("M"))
+                                        ELBus.then(ELBus.element("L"), ELBus.element("M"))
                                 )
                         ).id("t3")
                 ),
-                ELBus.node("Z")
+                ELBus.element("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);";
-        Assertions.assertEquals(expectedStr,
-                complexEl2.toEL(true));
-        System.out.println(expectedStr);
+
+        System.out.println(StringEscapeUtils.escapeJava(complexEl.toEL()));
+        String expect1 = "THEN(A,SWITCH(B).TO(THEN(D,E,F).id(\"t1\"),THEN(C,WHEN(THEN(SWITCH(G).TO(THEN(H,I).id(\"t2\"),J),K),THEN(L,M))).id(\"t3\")),Z);";
+        Assertions.assertEquals(expect1, complexEl.toEL());
+
+        System.out.println(StringEscapeUtils.escapeJava(complexEl.toEL(true)));
+        String expect2 = "THEN(\n\tA,\n\tSWITCH(B).TO(\n\t\tTHEN(\n\t\t\tD,\n\t\t\tE,\n\t\t\tF\n\t\t).id(\"t1\"),\n\t\tTHEN(\n\t\t\tC,\n\t\t\tWHEN(\n\t\t\t\tTHEN(\n\t\t\t\t\tSWITCH(G).TO(\n\t\t\t\t\t\tTHEN(\n\t\t\t\t\t\t\tH,\n\t\t\t\t\t\t\tI\n\t\t\t\t\t\t).id(\"t2\"),\n\t\t\t\t\t\tJ\n\t\t\t\t\t),\n\t\t\t\t\tK\n\t\t\t\t),\n\t\t\t\tTHEN(\n\t\t\t\t\tL,\n\t\t\t\t\tM\n\t\t\t\t)\n\t\t\t)\n\t\t).id(\"t3\")\n\t),\n\tZ\n);";
+        Assertions.assertEquals(expect2, complexEl.toEL(true));
     }
 
     /**
@@ -155,23 +153,25 @@ public class ComplexELBuilderTest extends BaseTest {
                 .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\"}"));
+        ELWrapper elWrapper = ELBus.then(ELBus.element("a").data("sql", "select * from member t where t.id=10001"),
+                ELBus.element("b").data("cmpData", "{\"name\":\"jack\",\"age\":27,\"birth\":\"1995-10-01\"}"));
+
+        System.out.println(elWrapper.toEL());
 
-        String expectStr = "sql = 'select * from member t\n" +
-                "                where t.id=10001';\n" +
-                "                cmpData = '{\"name\":\"jack\",\"age\":27,\"birth\":\"1995-10-01\"}';\n" +
+        String expectStr = "sql = \"select * from member t 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" +
+                "                a.data(sql),\n" +
+                "                b.data(cmpData)\n" +
                 "        );";
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(expectStr));
 
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(el.toEL()));
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(el.toEL(true)));
+
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(expectStr));
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(elWrapper.toEL()));
+        Assertions.assertTrue(LiteFlowChainELBuilder.validate(elWrapper.toEL(true)));
         LiteFlowChainELBuilder.createChain().setChainId("chain1").setEL(
-                el.toEL(true)
+                elWrapper.toEL(true)
         ).build();
 
         LiteflowResponse response = flowExecutor.execute2Resp("chain1", "arg");

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

@@ -248,7 +248,7 @@ 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(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL());
         System.out.println(expectedStr);
@@ -260,7 +260,7 @@ 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\").data(ifData)\n);";
+        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(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL(true));
         System.out.println(expectedStr);
@@ -269,7 +269,7 @@ public class IfELBuilderTest extends BaseTest {
     // 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(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL());
         System.out.println(expectedStr);
@@ -278,7 +278,7 @@ public class IfELBuilderTest extends BaseTest {
     // 格式化输出
     @Test
     public void testIf22(){
-        String expectedStr = "ifData = '{\"name\":\"zhangsan\",\"age\":18}';\nIF(\n\tnode(\"a\"),\n\tnode(\"b\"),\n\tnode(\"c\").data(ifData)\n);";
+        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(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", "{\"name\":\"zhangsan\",\"age\":18}")).toEL(true));
         System.out.println(expectedStr);
@@ -300,7 +300,7 @@ 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(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL());
         System.out.println(expectedStr);
@@ -312,7 +312,7 @@ 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\").data(ifData)\n);";
+        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(ELBus.node("a"), ELBus.node("b"), ELBus.node("c").data("ifData", name2Value)).toEL(true));
         System.out.println(expectedStr);

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

@@ -73,7 +73,7 @@ public class LogicELBuilderTest extends BaseTest {
     }
     @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(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL());
         System.out.println(expectedStr);
@@ -81,7 +81,7 @@ public class LogicELBuilderTest extends BaseTest {
     }
     @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\").data(andData)\n\t)\n);";
+        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(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("andData", "{\"name\":\"zhangsan\",\"age\":18}"))).toEL(true));
         System.out.println(expectedStr);
@@ -92,7 +92,7 @@ public class LogicELBuilderTest extends BaseTest {
         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(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL());
         System.out.println(expectedStr);
@@ -103,7 +103,7 @@ public class LogicELBuilderTest extends BaseTest {
         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\").data(orData)\n\t)\n);";
+        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(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("orData", name2Value))).toEL(true));
         System.out.println(expectedStr);
@@ -124,7 +124,7 @@ 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(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL());
         System.out.println(expectedStr);
@@ -135,7 +135,7 @@ public class LogicELBuilderTest extends BaseTest {
         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\").data(notData)\n\t)\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(ELBus.node("a"), ELBus.or(ELBus.node("b"), ELBus.node("c")), ELBus.not(ELBus.node("d").data("notData", name2Value))).toEL(true));
         System.out.println(expectedStr);

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

@@ -75,7 +75,7 @@ public class LoopELBuilderTest extends BaseTest {
     // 属性测试
     @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\").data(forData)).id(\"this is a id\").tag(\"this is a tag\").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(ELBus.node("a")).doOpt(ELBus.when(ELBus.node("b"), ELBus.node("c"), ELBus.node("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);
@@ -83,7 +83,7 @@ public class LoopELBuilderTest extends BaseTest {
     }
     @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\").data(forData)\n).id(\"this is a id\").tag(\"this is a tag\").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(ELBus.node("b"), ELBus.node("c"), ELBus.node("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);
@@ -149,7 +149,7 @@ public class LoopELBuilderTest extends BaseTest {
     // 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\").data(whileData)).id(\"this is a ig\").tag(\"this is a tag\").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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("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);
@@ -157,7 +157,7 @@ public class LoopELBuilderTest extends BaseTest {
     }
     @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\").data(whileData)\n).id(\"this is a ig\").tag(\"this is a tag\").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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("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);
@@ -193,7 +193,7 @@ public class LoopELBuilderTest extends BaseTest {
     // iterator 属性测试
     @Test
     public void testLoop15(){
-        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);";
+        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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("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);
@@ -201,7 +201,7 @@ public class LoopELBuilderTest extends BaseTest {
     }
     @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\").data(iteratorData)\n\t)\n).id(\"this is a ig\").tag(\"this is a tag\").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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("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);
@@ -213,19 +213,19 @@ public class LoopELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "forData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "FOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(forData)));";
         Assertions.assertEquals(expectedStr,
                 ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL());
         System.out.println(expectedStr);
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL()));
-        expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        expectedStr = "whileData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(whileData)));";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL());
         System.out.println(expectedStr);
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL()));
-        expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        expectedStr = "iteratorData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "ITERATOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(iteratorData)));";
         Assertions.assertEquals(expectedStr,
                 ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL());
@@ -238,19 +238,19 @@ public class LoopELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "forData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL(true));
         System.out.println(expectedStr);
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL(true)));
-        expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        expectedStr = "whileData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL(true));
         System.out.println(expectedStr);
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL(true)));
-        expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        expectedStr = "iteratorData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL(true));
@@ -273,19 +273,19 @@ public class LoopELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.age = 18;
         name2Value.name = "zhangsan";
-        String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "forData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "FOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(forData)));";
         Assertions.assertEquals(expectedStr,
                 ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL());
         System.out.println(expectedStr);
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL()));
-        expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        expectedStr = "whileData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "WHILE(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(whileData)));";
         Assertions.assertEquals(expectedStr,
                 ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL());
         System.out.println(expectedStr);
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL()));
-        expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        expectedStr = "iteratorData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "ITERATOR(node(\"a\")).DO(THEN(node(\"b\"),node(\"c\").data(iteratorData)));";
         Assertions.assertEquals(expectedStr,
                 ELBus.iteratorOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("iteratorData", name2Value))).toEL());
@@ -298,19 +298,19 @@ public class LoopELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.age = 18;
         name2Value.name = "zhangsan";
-        String expectedStr = "forData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "forData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL(true));
         System.out.println(expectedStr);
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.forOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("forData", name2Value))).toEL(true)));
-        expectedStr = "whileData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        expectedStr = "whileData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL(true));
         System.out.println(expectedStr);
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.whileOpt(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("b"), ELBus.node("c").data("whileData", name2Value))).toEL(true)));
-        expectedStr = "iteratorData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        expectedStr = "iteratorData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "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(ELBus.node("a")).doOpt(ELBus.then(ELBus.node("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

@@ -38,7 +38,7 @@ public class NodeELBuilderTest extends BaseTest {
     @Test
     public void testNodeEL1(){
         String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "nodeData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", jsonStr);
         Assertions.assertEquals(expectedStr,
@@ -49,7 +49,7 @@ public class NodeELBuilderTest extends BaseTest {
     @Test
     public void testNodeEL2(){
         String jsonStr = "{\"name\":\"zhangsan\",\"age\":18}";
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "nodeData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", jsonStr);
         Assertions.assertEquals(expectedStr,
@@ -62,7 +62,7 @@ public class NodeELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "nodeData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
         Assertions.assertEquals(expectedStr,
@@ -75,7 +75,7 @@ public class NodeELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "nodeData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
         Assertions.assertEquals(expectedStr,
@@ -98,7 +98,7 @@ public class NodeELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.age = 18;
         name2Value.name = "zhangsan";
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "nodeData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
         Assertions.assertEquals(expectedStr,
@@ -111,7 +111,7 @@ public class NodeELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.age = 18;
         name2Value.name = "zhangsan";
-        String expectedStr = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\n" +
+        String expectedStr = "nodeData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\n" +
                 "node(\"a\").tag(\"node a tag\").data(nodeData).maxWaitSeconds(4);";
         CommonNodeELWrapper node = ELBus.node("a").maxWaitSeconds(4).tag("node a tag").data("nodeData", name2Value);
         Assertions.assertEquals(expectedStr,
@@ -134,20 +134,17 @@ public class NodeELBuilderTest extends BaseTest {
                 .setClazz(BCmp.class)
                 .build();
 
-        String expectedStr = "sql = 'select * from member t\n" +
-                "            where t.id=10001';\n" +
-                "jsonstr = '{\"name\":\"jack\",\"age\":27,\"birth\":\"1995-10-01\"}';\n" +
+        String expectedStr = "sql = \"select * from member t where t.id=10001\";\n" +
+                "jsonstr = \"{\\\"name\\\":\\\"jack\\\",\\\"age\\\":27,\\\"birth\\\":\\\"1995-10-01\\\"}\";\n" +
                 "THEN(\n" +
                 "\tnode(\"a\").data(sql),\n" +
                 "\tnode(\"b\").data(jsonstr)\n" +
                 ");";
-        String param1 = "select * from member t\n" +
-                "            where t.id=10001";
+        String param1 = "select * from member t where t.id=10001";
         String param2 = "{\"name\":\"jack\",\"age\":27,\"birth\":\"1995-10-01\"}";
         ThenELWrapper el = ELBus.then(ELBus.node("a").data("sql", param1),
                 ELBus.node("b").data("jsonstr", param2));
-        Assertions.assertEquals(expectedStr,
-                el.toEL(true));
+        Assertions.assertEquals(expectedStr, el.toEL(true));
 
         LiteFlowChainELBuilder.createChain().setChainName("chain1").setEL(
                 el.toEL()

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

@@ -134,7 +134,7 @@ public class ParELBuilderTest extends BaseTest {
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
         System.out.println(JsonUtil.toJsonString(name2Value));
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(node(\"a\"),PAR(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
+        String expectedStr = "whenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nPAR(node(\"a\"),PAR(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
                 ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(false));
         System.out.println(expectedStr);
@@ -146,7 +146,7 @@ public class ParELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(\n\tnode(\"a\"),\n\tPAR(\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\");";
+        String expectedStr = "whenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nPAR(\n\tnode(\"a\"),\n\tPAR(\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.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true));
         System.out.println(expectedStr);
@@ -155,7 +155,7 @@ public class ParELBuilderTest extends BaseTest {
     // data属性测试 Json字符串赋值data
     @Test
     public void testPar15(){
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(node(\"a\"),PAR(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
+        String expectedStr = "whenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nPAR(node(\"a\"),PAR(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
                 ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL());
         System.out.println(expectedStr);
@@ -164,7 +164,7 @@ public class ParELBuilderTest extends BaseTest {
     // 格式化输出测试 Json字符串赋值data
     @Test
     public void testPar16(){
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(\n\tnode(\"a\"),\n\tPAR(\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\");";
+        String expectedStr = "whenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nPAR(\n\tnode(\"a\"),\n\tPAR(\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.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true));
         System.out.println(expectedStr);
@@ -186,7 +186,7 @@ public class ParELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(node(\"a\"),PAR(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
+        String expectedStr = "whenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nPAR(node(\"a\"),PAR(node(\"b\"),node(\"c\").data(whenData)).id(\"this is a id\"),node(\"d\")).tag(\"this is a tag\");";
         Assertions.assertEquals(expectedStr,
                 ELBus.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL());
         System.out.println(expectedStr);
@@ -198,7 +198,7 @@ public class ParELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        String expectedStr = "whenData = '{\"name\":\"zhangsan\",\"age\":18}';\nPAR(\n\tnode(\"a\"),\n\tPAR(\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\");";
+        String expectedStr = "whenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nPAR(\n\tnode(\"a\"),\n\tPAR(\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.par(ELBus.node("a"), ELBus.par(ELBus.node("b")).par(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).par(ELBus.node("d")).tag("this is a tag").toEL(true));
         System.out.println(expectedStr);

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

@@ -1,9 +1,12 @@
 package com.yomahub.liteflow.test.builder;
 
+import cn.hutool.core.util.EscapeUtil;
+import cn.hutool.core.util.StrUtil;
 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.apache.commons.lang.StringEscapeUtils;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@@ -26,99 +29,92 @@ public class SerELBuilderTest extends BaseTest {
     // then组件测试
     @Test
     public void testSer1(){
-        Assertions.assertEquals("SER(node(\"a\"),node(\"b\"));",
-                ELBus.ser(ELBus.node("a"), ELBus.node("b")).toEL());
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.node("b")).toEL()));
+        String el = ELBus.ser("a", "b").toEL();
+        Assertions.assertEquals("SER(a,b);",  el);
     }
     // 格式化输出测试
     @Test
     public void testSer2(){
-        Assertions.assertEquals("SER(\n\tnode(\"a\")," +
-                        "\n\tnode(\"b\")\n);",
-                ELBus.ser(ELBus.node("a"), ELBus.node("b")).toEL(true));
-        System.out.println("SER(\n\tnode(\"a\")," +
-                "\n\tnode(\"b\")\n);");
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.node("b")).toEL(true)));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.element("b")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        Assertions.assertEquals("SER(\n\ta,\n\tb\n);", el);
     }
     // then组件then方法调用测试
     @Test
     public void testSer3(){
-        Assertions.assertEquals("SER(node(\"a\"),node(\"b\"),node(\"c\"));",
-                ELBus.ser(ELBus.node("a"), ELBus.node("b")).ser(ELBus.node("c")).toEL());
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.node("b")).ser(ELBus.node("c")).toEL()));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.element("b")).ser(ELBus.element("c")).toEL();
+        System.out.println(el);
+        Assertions.assertEquals("SER(a,b,c);", el);
     }
     // 格式化输出测试
     @Test
     public void testSer4(){
-        Assertions.assertEquals("SER(\n\tnode(\"a\"),\n\tnode(\"b\")," +
-                        "\n\tnode(\"c\")\n);",
-                ELBus.ser(ELBus.node("a"), ELBus.node("b")).ser(ELBus.node("c")).toEL(true));
-        System.out.println("SER(\n\tnode(\"a\"),\n\tnode(\"b\")," +
-                "\n\tnode(\"c\")\n);");
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.node("b")).ser(ELBus.node("c")).toEL(true)));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.element("b")).ser(ELBus.element("c")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        Assertions.assertEquals("SER(\n\ta,\n\tb,\n\tc\n);", el);
     }
     // then组件嵌套调用测试
     @Test
     public void testSer5(){
-        Assertions.assertEquals("SER(node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"));",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).toEL());
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).toEL()));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c"))).ser(ELBus.element("d")).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        Assertions.assertEquals("SER(a,SER(b,c),d);", el);
     }
     // 格式化输出测试
     @Test
     public void testSer6(){
-        Assertions.assertEquals("SER(\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).toEL(true));
-        System.out.println("SER(\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);");
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).toEL(true)));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c"))).ser(ELBus.element("d")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "SER(\n\ta,\n\tSER(\n\t\tb,\n\t\tc\n\t),\n\td\n);";
+        Assertions.assertEquals(expect, el);
     }
     // pre组件测试
     @Test
     public void testSer7(){
-        Assertions.assertEquals("SER(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"));",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL());
-        System.out.println("SER(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"));");
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL()));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c"))).ser(ELBus.element("d")).pre(ELBus.element("p")).pre(ELBus.element("pp")).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "SER(PRE(p),PRE(pp),a,SER(b,c),d);";
+        Assertions.assertEquals(expect, el);
     }
     // 格式化输出测试
     @Test
     public void testSer8(){
-        Assertions.assertEquals("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL(true));
-        System.out.println("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tPRE(\n\t\tnode(\"pp\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\")\n);");
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL(true)));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c"))).ser(ELBus.element("d")).pre(ELBus.element("p")).pre(ELBus.element("pp")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "SER(\n\tPRE(\n\t\tp\n\t),\n\tPRE(\n\t\tpp\n\t),\n\ta,\n\tSER(\n\t\tb,\n\t\tc\n\t),\n\td\n);";
+        Assertions.assertEquals(expect, el);
     }
     // pre finally 格式测试
     @Test
     public void testSer9(){
-        Assertions.assertEquals("SER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")));",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
-        System.out.println("SER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")));");
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c"))).ser(ELBus.element("d")).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "SER(PRE(p),a,SER(b,c),d,FINALLY(f));";
+        Assertions.assertEquals(expect, el);
     }
     // 格式化输出测试
     @Test
     public void testSer10(){
-        Assertions.assertEquals("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\n\t\tnode(\"b\"),\n\t\tnode(\"c\")\n\t),\n\tnode(\"d\"),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n);",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
-        System.out.println("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c"))).ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c"))).ser(ELBus.element("d")).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "SER(\n\tPRE(\n\t\tp\n\t),\n\ta,\n\tSER(\n\t\tb,\n\t\tc\n\t),\n\td,\n\tFINALLY(\n\t\tf\n\t)\n);";
+        Assertions.assertEquals(expect, el);
     }
     // 属性设置测试
     @Test
     public void testSer11(){
-        Assertions.assertEquals("SER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
-        System.out.println("SER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\"),FINALLY(node(\"f\"))).tag(\"this is a tag\");");
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c")).id("this is a id")).tag("this is a tag").ser(ELBus.element("d")).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "SER(PRE(p),a,SER(b,c).id(\"this is a id\"),d,FINALLY(f)).tag(\"this is a tag\");";
+        Assertions.assertEquals(expect, el);
     }
     // 格式化输出测试
     @Test
     public void testSer12(){
-        Assertions.assertEquals("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
-        System.out.println("SER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c")).id("this is a id")).tag("this is a tag").ser(ELBus.element("d")).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "SER(\n\tPRE(\n\t\tp\n\t),\n\ta,\n\tSER(\n\t\tb,\n\t\tc\n\t).id(\"this is a id\"),\n\td,\n\tFINALLY(\n\t\tf\n\t)\n).tag(\"this is a tag\");";
+        Assertions.assertEquals(expect, el);
     }
     // data属性测试
     @Test
@@ -126,11 +122,10 @@ public class SerELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        System.out.println(JsonUtil.toJsonString(name2Value));
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c")).id("this is a id")).tag("this is a tag").ser(ELBus.element("d").data("thenData", name2Value)).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL();
+        System.out.println(el);
+        String expect = "thenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nSER(PRE(p),a,SER(b,c).id(\"this is a id\"),d.data(thenData),FINALLY(f)).tag(\"this is a tag\");";
+        Assertions.assertEquals(expect, el);
     }
     // 格式化输出测试
     @Test
@@ -138,26 +133,26 @@ public class SerELBuilderTest 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}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c")).id("this is a id")).tag("this is a tag").ser(ELBus.element("d").data("thenData", name2Value)).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "thenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nSER(\n\tPRE(\n\t\tp\n\t),\n\ta,\n\tSER(\n\t\tb,\n\t\tc\n\t).id(\"this is a id\"),\n\td.data(thenData),\n\tFINALLY(\n\t\tf\n\t)\n).tag(\"this is a tag\");";
+        Assertions.assertEquals(expect, el);
     }
     // data属性测试 Json字符串赋值data
     @Test
     public void testSer15(){
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
-//        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c")).id("this is a id")).tag("this is a tag").ser(ELBus.element("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "thenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nSER(PRE(p),a,SER(b,c).id(\"this is a id\"),d.data(thenData),FINALLY(f)).tag(\"this is a tag\");";
+        Assertions.assertEquals(expect, el);
     }
     // 格式化输出测试 Json字符串赋值data
     @Test
     public void testSer16(){
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
-//        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c")).id("this is a id")).tag("this is a tag").ser(ELBus.element("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "thenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nSER(\n\tPRE(\n\t\tp\n\t),\n\ta,\n\tSER(\n\t\tb,\n\t\tc\n\t).id(\"this is a id\"),\n\td.data(thenData),\n\tFINALLY(\n\t\tf\n\t)\n).tag(\"this is a tag\");";
+        Assertions.assertEquals(expect, el);
     }
     private static class ParamClass{
         private String name;
@@ -175,10 +170,10 @@ public class SerELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(node(\"b\"),node(\"c\")).id(\"this is a id\"),node(\"d\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
-                ELBus.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(PRE(node(\"p\")),node(\"a\"),SER(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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c")).id("this is a id")).tag("this is a tag").ser(ELBus.element("d").data("thenData", name2Value)).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "thenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nSER(PRE(p),a,SER(b,c).id(\"this is a id\"),d.data(thenData),FINALLY(f)).tag(\"this is a tag\");";
+        Assertions.assertEquals(expect, el);
     }
     // 格式化输出测试
     @Test
@@ -186,27 +181,27 @@ public class SerELBuilderTest extends BaseTest {
         ParamClass name2Value = new ParamClass();
         name2Value.name = "zhangsan";
         name2Value.age = 18;
-        Assertions.assertEquals("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true));
-        System.out.println("thenData = '{\"name\":\"zhangsan\",\"age\":18}';\nSER(\n\tPRE(\n\t\tnode(\"p\")\n\t),\n\tnode(\"a\"),\n\tSER(\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.ser(ELBus.node("a"), ELBus.ser(ELBus.node("b")).ser(ELBus.node("c")).id("this is a id")).tag("this is a tag").ser(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
+
+        String el = ELBus.ser(ELBus.element("a"), ELBus.ser(ELBus.element("b")).ser(ELBus.element("c")).id("this is a id")).tag("this is a tag").ser(ELBus.element("d").data("thenData", name2Value)).pre(ELBus.element("p")).finallyOpt(ELBus.element("f")).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "thenData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nSER(\n\tPRE(\n\t\tp\n\t),\n\ta,\n\tSER(\n\t\tb,\n\t\tc\n\t).id(\"this is a id\"),\n\td.data(thenData),\n\tFINALLY(\n\t\tf\n\t)\n).tag(\"this is a tag\");";
+        Assertions.assertEquals(expect, el);
     }
     // maxWaitSecond测试
     @Test
     public void testSer19(){
-        String expectedStr = "SER(node(\"a\"),node(\"b\")).maxWaitSeconds(5);";
-        Assertions.assertEquals(expectedStr,
-                ELBus.ser(ELBus.node("a")).ser(ELBus.node("b")).maxWaitSeconds(5).toEL());
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a")).ser(ELBus.node("b")).maxWaitSeconds(5).toEL()));
+        String el = ELBus.ser(ELBus.element("a")).ser(ELBus.element("b")).maxWaitSeconds(5).toEL();
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "SER(a,b).maxWaitSeconds(5);";
+        Assertions.assertEquals(expect, el);
+
     }
     // 格式化输出测试
     @Test
     public void testSer20(){
-        String expectedStr = "SER(\n\tnode(\"a\"),\n\tnode(\"b\")\n).maxWaitSeconds(5);";
-        Assertions.assertEquals(expectedStr,
-                ELBus.ser(ELBus.node("a")).ser(ELBus.node("b")).maxWaitSeconds(5).toEL(true));
-        System.out.println(expectedStr);
-        Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.ser(ELBus.node("a")).ser(ELBus.node("b")).maxWaitSeconds(5).toEL(true)));
+        String el = ELBus.ser(ELBus.element("a")).ser(ELBus.element("b")).maxWaitSeconds(5).toEL(true);
+        System.out.println(StringEscapeUtils.escapeJava(el));
+        String expect = "SER(\n\ta,\n\tb\n).maxWaitSeconds(5);";
+        Assertions.assertEquals(expect, el);
     }
 }

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

@@ -87,7 +87,7 @@ 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(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL());
         System.out.println(expectedStr);
@@ -99,7 +99,7 @@ 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\").data(switchData)\n);";
+        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(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL(true));
         System.out.println(expectedStr);
@@ -109,7 +109,7 @@ public class SwitchELBuilderTest extends BaseTest {
     @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 expectedStr = "switchData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nSWITCH(node(\"a\")).TO(node(\"b\"),node(\"c\"),node(\"d\").data(switchData));";
         Assertions.assertEquals(expectedStr,
                 ELBus.switchOpt(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", jsonStr)).toEL());
         System.out.println(expectedStr);
@@ -119,7 +119,7 @@ public class SwitchELBuilderTest extends BaseTest {
     @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\").data(switchData)\n);";
+        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(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", jsonStr)).toEL(true));
         System.out.println(expectedStr);
@@ -142,7 +142,7 @@ 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(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL());
         System.out.println(expectedStr);
@@ -154,7 +154,7 @@ 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\").data(switchData)\n);";
+        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(ELBus.node("a")).to(ELBus.node("b"), ELBus.node("c"), ELBus.node("d").data("switchData", name2Value)).toEL(true));
         System.out.println(expectedStr);

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

@@ -27,9 +27,8 @@ public class ThenELBuilderTest extends BaseTest {
         Map<String, Object> name2Value = new HashMap<String, Object>();
         name2Value.put("name", "zhangsan");
         name2Value.put("age", 18);
-        String expected = "nodeData = '{\"name\":\"zhangsan\",\"age\":18}';\nTHEN(\n\ta.tag(\"tagA\").data(nodeData).maxWaitSeconds(10).retry(2),\n\tnode(\"b\")\n);";
+        String expected = "nodeData = \"{\\\"name\\\":\\\"zhangsan\\\",\\\"age\\\":18}\";\nTHEN(\n\ta.tag(\"tagA\").data(nodeData).maxWaitSeconds(10).retry(2),\n\tnode(\"b\")\n);";
         String actualEl = ELBus.then(ELBus.element("a").data("nodeData", name2Value).tag("tagA").maxWaitSeconds(10).retry(2), ELBus.node("b")).toEL(true);
-        System.out.println(actualEl);
         Assertions.assertEquals(expected, actualEl);
     }
 
@@ -46,8 +45,6 @@ public class ThenELBuilderTest extends BaseTest {
         Assertions.assertEquals("THEN(\n\tnode(\"a\")," +
                         "\n\tnode(\"b\")\n);",
                 ELBus.then(ELBus.node("a"), ELBus.node("b")).toEL(true));
-        System.out.println("THEN(\n\tnode(\"a\")," +
-                "\n\tnode(\"b\")\n);");
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.node("b")).toEL(true)));
     }
     // then组件then方法调用测试
@@ -63,8 +60,6 @@ public class ThenELBuilderTest extends BaseTest {
         Assertions.assertEquals("THEN(\n\tnode(\"a\"),\n\tnode(\"b\")," +
                         "\n\tnode(\"c\")\n);",
                 ELBus.then(ELBus.node("a"), ELBus.node("b")).then(ELBus.node("c")).toEL(true));
-        System.out.println("THEN(\n\tnode(\"a\"),\n\tnode(\"b\")," +
-                "\n\tnode(\"c\")\n);");
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.node("b")).then(ELBus.node("c")).toEL(true)));
     }
     // then组件嵌套调用测试
@@ -79,7 +74,6 @@ public class ThenELBuilderTest extends BaseTest {
     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);",
                 ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("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);");
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).toEL(true)));
     }
     // pre组件测试
@@ -87,7 +81,6 @@ public class ThenELBuilderTest extends BaseTest {
     public void testThen7(){
         Assertions.assertEquals("THEN(PRE(node(\"p\")),PRE(node(\"pp\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"));",
                 ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL());
-        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL()));
     }
     // 格式化输出测试
@@ -95,7 +88,6 @@ public class ThenELBuilderTest extends BaseTest {
     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);",
                 ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("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);");
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).pre(ELBus.node("pp")).toEL(true)));
     }
     // pre finally 格式测试
@@ -103,7 +95,6 @@ public class ThenELBuilderTest extends BaseTest {
     public void testThen9(){
         Assertions.assertEquals("THEN(PRE(node(\"p\")),node(\"a\"),THEN(node(\"b\"),node(\"c\")),node(\"d\"),FINALLY(node(\"f\")));",
                 ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL());
-        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
     }
     // 格式化输出测试
@@ -111,7 +102,6 @@ public class ThenELBuilderTest extends BaseTest {
     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);",
                 ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("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);");
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c"))).then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
     }
     // 属性设置测试
@@ -119,7 +109,6 @@ public class ThenELBuilderTest extends BaseTest {
     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\");",
                 ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("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\");");
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
     }
     // 格式化输出测试
@@ -127,7 +116,6 @@ public class ThenELBuilderTest extends BaseTest {
     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\");",
                 ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("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\");");
         Assertions.assertTrue(LiteFlowChainELBuilder.validate(ELBus.then(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
     }
     // data属性测试
@@ -137,9 +125,8 @@ 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\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
+        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
     }
     // 格式化输出测试
@@ -148,25 +135,22 @@ 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\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
+        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("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\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
+        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("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\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
+        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", "{\"name\":\"zhangsan\",\"age\":18}")).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
     }
     private static class ParamClass{
@@ -185,9 +169,9 @@ 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\").data(thenData),FINALLY(node(\"f\"))).tag(\"this is a tag\");",
+        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("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\");");
+        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL()));
     }
     // 格式化输出测试
@@ -196,9 +180,9 @@ 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\").data(thenData),\n\tFINALLY(\n\t\tnode(\"f\")\n\t)\n).tag(\"this is a tag\");",
+        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("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\");");
+        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(ELBus.node("a"), ELBus.then(ELBus.node("b")).then(ELBus.node("c")).id("this is a id")).tag("this is a tag").then(ELBus.node("d").data("thenData", name2Value)).pre(ELBus.node("p")).finallyOpt(ELBus.node("f")).toEL(true)));
     }
     // maxWaitSecond测试

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

@@ -134,7 +134,7 @@ 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\").data(whenData)).id(\"this is a id\"),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(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(false));
         System.out.println(expectedStr);
@@ -146,7 +146,7 @@ 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\").data(whenData)\n\t).id(\"this is a id\"),\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(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true));
         System.out.println(expectedStr);
@@ -155,7 +155,7 @@ public class WhenELBuilderTest extends BaseTest {
     // data属性测试 Json字符串赋值data
     @Test
     public void testWhen15(){
-        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\");";
+        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(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL());
         System.out.println(expectedStr);
@@ -164,7 +164,7 @@ public class WhenELBuilderTest extends BaseTest {
     // 格式化输出测试 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\").data(whenData)\n\t).id(\"this is a id\"),\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(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", "{\"name\":\"zhangsan\",\"age\":18}")).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true));
         System.out.println(expectedStr);
@@ -186,7 +186,7 @@ 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\").data(whenData)).id(\"this is a id\"),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(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL());
         System.out.println(expectedStr);
@@ -198,7 +198,7 @@ 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\").data(whenData)\n\t).id(\"this is a id\"),\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(ELBus.node("a"), ELBus.when(ELBus.node("b")).when(ELBus.node("c").data("whenData", name2Value)).id("this is a id")).when(ELBus.node("d")).tag("this is a tag").toEL(true));
         System.out.println(expectedStr);

liteflow-testcase-el/liteflow-testcase-el-springnative/src/test/resources/base/application.xml

@@ -17,7 +17,7 @@
         <property name="ruleSource" value="base/flow.el.xml"/>
     </bean>
 
-    <bean id="flowExecutor" class="com.yomahub.liteflow.core.FlowExecutor">
+    <bean id="flowExecutor" class="com.yomahub.liteflow.core.FlowExecutor" depends-on="springAware">
         <constructor-arg name="liteflowConfig" ref="liteflowConfig"/>
     </bean>
 </beans>