added request and response classes with tests

li.strolch.soql/src/main/java/li/strolch/soql/core/CompiledStatement.java

@@ -8,6 +8,9 @@ import java.util.Map;
 import li.strolch.soql.core.expresssion.SelectClause;
 import li.strolch.soql.core.expresssion.WhereExpression;
 
+/**
+ * @author msmock
+ */
 public class CompiledStatement {
 
 	// the map of entities declared in the FROM clause with their nicknames as keys

li.strolch.soql/src/main/java/li/strolch/soql/core/QueryRequest.java

@@ -0,0 +1,79 @@
+package li.strolch.soql.core;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import li.strolch.model.Tags;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author msmock
+ */
+public class QueryRequest {
+
+    public static final String STATEMENT = "statement";
+    public static final String PARAMETER = "parameter";
+
+    // the SOQL query string
+    private String statement;
+
+    // the parameter of the SOQL query
+    private Map<String, String> parameter = new HashMap<>();
+
+    public String getStatement() {
+        return statement;
+    }
+
+    public void setStatement(String statement) {
+        this.statement = statement;
+    }
+
+    public Map<String, String> getParameter() {
+        return parameter;
+    }
+
+    /**
+     * @return the query as JsonObject
+     */
+    public JsonObject toJson() {
+
+        final JsonObject rootJ = new JsonObject();
+        rootJ.addProperty(Tags.Json.OBJECT_TYPE, "QueryRequest");
+        rootJ.addProperty(STATEMENT, statement);
+
+        final JsonObject parameterJ = new JsonObject();
+        rootJ.add(PARAMETER, parameterJ);
+
+        final Set<String> keys = parameter.keySet();
+        for (Iterator<String> iterator = keys.iterator(); iterator.hasNext(); ) {
+            final String key = iterator.next();
+            final Object param = parameter.get(key);
+            parameterJ.addProperty(key, param.toString());
+        }
+
+        return rootJ;
+    }
+
+    /**
+     * build request from Json object
+     *
+     * @return
+     */
+    public QueryRequest fromJson(JsonObject jsonObject) {
+
+        final String statement = jsonObject.get(STATEMENT).getAsString();
+        setStatement(statement);
+
+        final JsonObject params = jsonObject.getAsJsonObject(PARAMETER);
+        final Set<Map.Entry<String, JsonElement>> entrySet = params.entrySet();
+        for (final Map.Entry<String, JsonElement> entry : entrySet) {
+            parameter.put(entry.getKey(), entry.getValue().getAsString());
+        }
+
+        return this;
+    }
+
+}

li.strolch.soql/src/main/java/li/strolch/soql/core/QueryResponse.java

@@ -0,0 +1,45 @@
+package li.strolch.soql.core;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import li.strolch.model.StrolchRootElement;
+import li.strolch.model.Tags;
+import li.strolch.model.json.StrolchElementToJsonVisitor;
+
+import java.util.*;
+
+/**
+ * @author msmock
+ */
+public class QueryResponse extends QueryRequest {
+
+    // the returned objects
+    static final String RESULT_SET = "resultSet";
+    public List<StrolchRootElement> resultSet = new ArrayList<>();
+
+    // an exception or error message in case of error
+    public String message;
+
+    /**
+     * @return the query as JsonObject
+     */
+    public JsonObject toJson(final StrolchElementToJsonVisitor visitor) {
+
+        final JsonObject rootJ = super.toJson();
+
+        if (message != null && !message.isEmpty()) {
+            rootJ.addProperty("Message", message);
+        }
+
+        final JsonArray resultSetJ = new JsonArray();
+        rootJ.add(RESULT_SET, resultSetJ);
+
+        for (Iterator<StrolchRootElement> iter = resultSet.iterator(); iter.hasNext(); ) {
+            resultSetJ.add(iter.next().accept(visitor));
+        }
+
+        return rootJ;
+    }
+
+}

li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLEvaluationException.java

@@ -1,5 +1,8 @@
 package li.strolch.soql.core;
 
+/**
+ * @author msmock
+ */
 public class SOQLEvaluationException extends RuntimeException {
 
 	private static final long serialVersionUID = 1L;

li.strolch.soql/src/main/java/li/strolch/soql/core/SOQLParseException.java

@@ -1,5 +1,8 @@
 package li.strolch.soql.core;
 
+/**
+ * @author msmock
+ */
 public class SOQLParseException extends RuntimeException {
 
 	private static final long serialVersionUID = 1L;

li.strolch.soql/src/test/java/li/strolch/soql/core/BaseTest.java

@@ -0,0 +1,125 @@
+package li.strolch.soql.core;
+
+import li.strolch.model.*;
+import li.strolch.model.parameter.FloatParameter;
+import li.strolch.model.parameter.Parameter;
+import li.strolch.model.query.ActivityQuery;
+import li.strolch.model.query.OrderQuery;
+import li.strolch.model.query.ResourceQuery;
+import li.strolch.model.query.StrolchElementQuery;
+import li.strolch.soql.antlr4.generated.SOQLLexer;
+import li.strolch.soql.antlr4.generated.SOQLParser;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.junit.Test;
+
+import java.util.*;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author msmock
+ */
+public abstract class BaseTest {
+
+    /**
+     * parse the string and return the antlr tree
+     *
+     * @throws Exception
+     */
+    ParseTree parseString(final String s) throws Exception {
+
+        final CharStream input = CharStreams.fromString(s);
+        final SOQLLexer lexer = new SOQLLexer(input); // create a buffer of tokens pulled from the lexer
+
+        final CommonTokenStream tokens = new CommonTokenStream(lexer); // create a parser that feeds off the tokens buffer
+        final SOQLParser parser = new SOQLParser(tokens);
+        parser.addErrorListener(new VerboseListener());
+
+        final ParseTree tree = parser.select_statement(); // begin parsing at block
+
+        // System.out.println(tree.toStringTree(parser)); // print LISP-style tree
+
+        return tree;
+    }
+
+    /**
+     * compile the antlr tree to executable
+     *
+     * @param tree
+     * @return CompiledSOQLStatement
+     * @throws Exception
+     */
+    CompiledStatement compile(final ParseTree tree) throws Exception {
+
+        final ParseTreeWalker walker = new ParseTreeWalker();
+        final SOQLListener listener = new SOQLListener();
+        walker.walk(listener, tree);
+
+        final CompiledStatement soqlStatement = new CompiledStatement();
+        soqlStatement.entities = listener.getEntities();
+        soqlStatement.whereExpression = listener.getWhereExpression();
+        soqlStatement.selectClause = listener.getSelectClause();
+
+        return soqlStatement;
+    }
+
+    /**
+     * @return a test resource
+     */
+    StrolchRootElement getTestResource(final String id) {
+        final Resource resource = new Resource();
+        resource.setId(id);
+
+        final ParameterBag bag = new ParameterBag();
+        bag.setId("testBag");
+        resource.addParameterBag(bag);
+
+        final Parameter parameter = new FloatParameter();
+        parameter.setId("testId");
+        parameter.setValue(100d);
+
+        resource.addParameter("testBag", parameter);
+        return resource;
+    }
+
+    /**
+     * @return a test order
+     */
+    StrolchRootElement getTestOrder(final String id) {
+        final Order order = new Order();
+        order.setId("testId");
+
+        final ParameterBag bag = new ParameterBag();
+        bag.setId("testBag");
+        order.addParameterBag(bag);
+
+        final Parameter parameter = new FloatParameter();
+        parameter.setId("testId");
+        parameter.setValue(100d);
+
+        order.addParameter("testBag", parameter);
+        return order;
+    }
+
+    List<StrolchRootElement> getTestRessources(int n) {
+        final List<StrolchRootElement> result = new ArrayList<>(n);
+        for (int i = 0; i < n; i++) {
+            result.add(getTestResource(String.valueOf(n)));
+        }
+        return result;
+    }
+
+    List<StrolchRootElement> getTestOrders(int n) {
+        final List<StrolchRootElement> result = new ArrayList<>(n);
+        for (int i = 0; i < n; i++) {
+            result.add(getTestOrder(String.valueOf(n)));
+        }
+        return result;
+    }
+
+}

li.strolch.soql/src/test/java/li/strolch/soql/core/ComparisonExpressionTest.java

@@ -1,4 +1,4 @@
-package li.strolch.soql.core.expression;
+package li.strolch.soql.core;
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -12,6 +12,9 @@ import li.strolch.soql.core.expresssion.ComparisonExpression;
 import li.strolch.soql.core.expresssion.ParameterReference;
 import li.strolch.soql.core.expresssion.ValueDeclaration;
 
+/**
+ * @author msmock
+ */
 public class ComparisonExpressionTest {
 
 	@Test
@@ -130,7 +133,7 @@ public class ComparisonExpressionTest {
 	}
 	
 	@Test
-	public void testNumericLessEuals() {
+	public void testNumericLessEquals() {
 
 		ParameterReference vd_1 = new ParameterReference();
 		vd_1.varName = "a";

li.strolch.soql/src/test/java/li/strolch/soql/core/MethodExpressionTest.java

@@ -0,0 +1,114 @@
+package li.strolch.soql.core;
+
+import com.google.gson.JsonObject;
+import li.strolch.model.ParameterBag;
+import li.strolch.model.Resource;
+import li.strolch.model.StrolchElement;
+import li.strolch.model.StrolchRootElement;
+import li.strolch.model.json.StrolchElementToJsonVisitor;
+import li.strolch.model.parameter.Parameter;
+import li.strolch.model.parameter.StringParameter;
+import li.strolch.soql.core.expresssion.ChainedMethodExpression;
+import li.strolch.soql.core.expresssion.MethodArgumentDeclaration;
+import li.strolch.soql.core.expresssion.MethodExpression;
+import li.strolch.soql.core.expresssion.ParameterReference;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author msmock
+ */
+public class MethodExpressionTest {
+
+    public StrolchRootElement getTestElement() {
+        final Resource resource = new Resource();
+        resource.setId("testId");
+
+        final ParameterBag bag = new ParameterBag();
+        bag.setId("testBag");
+        resource.addParameterBag(bag);
+
+        final Parameter parameter = new StringParameter();
+        parameter.setId("testId");
+        parameter.setValue("testValue");
+
+        resource.addParameter("testBag", parameter);
+        return resource;
+    }
+
+    @Test
+    public void testMethod() {
+
+        MethodExpression methodExpression = new MethodExpression();
+        methodExpression.setMethodName("getParameter");
+        methodExpression.setObject(getTestElement());
+
+        MethodArgumentDeclaration argument = new MethodArgumentDeclaration();
+
+        ParameterReference parameterReference = new ParameterReference();
+        parameterReference.varName = "p_1";
+        argument.addParameterReference(parameterReference);
+
+        parameterReference = new ParameterReference();
+        parameterReference.varName = "p_2";
+        argument.addParameterReference(parameterReference);
+
+        methodExpression.setMethodArguments(argument);
+
+        Map<String, Object> queryParameter = new HashMap<>();
+        queryParameter.put("p_1", "testBag");
+        queryParameter.put("p_2", "testId");
+
+        Object result = methodExpression.evaluate(null, queryParameter);
+
+        assertEquals(StringParameter.class, result.getClass());
+
+    }
+
+    @Test
+    public void testChained() {
+
+        MethodArgumentDeclaration argument = new MethodArgumentDeclaration();
+
+        ParameterReference parameterReference = new ParameterReference();
+        parameterReference.varName = "p_1";
+        argument.addParameterReference(parameterReference);
+
+        parameterReference = new ParameterReference();
+        parameterReference.varName = "p_2";
+        argument.addParameterReference(parameterReference);
+
+        MethodExpression methodExpression_1 = new MethodExpression();
+        methodExpression_1.setMethodName("getParameter");
+        methodExpression_1.setMethodArguments(argument);
+
+        MethodExpression methodExpression_2 = new MethodExpression();
+        methodExpression_2.setMethodName("getType");
+        methodExpression_2.setMethodArguments(new MethodArgumentDeclaration());
+
+        // build the chained expression
+        ChainedMethodExpression chainedMethodExpression = new ChainedMethodExpression();
+        chainedMethodExpression.setObjectKey("a");
+        chainedMethodExpression.addMethodExpression(methodExpression_1);
+        chainedMethodExpression.addMethodExpression(methodExpression_2);
+
+        // prepare the runtime objects
+
+        Map<String, Object> inputObjects = new HashMap<>();
+        inputObjects.put("a", getTestElement());
+
+        Map<String, Object> queryParameter = new HashMap<>();
+        queryParameter.put("p_1", "testBag");
+        queryParameter.put("p_2", "testId");
+
+        // evaluate the chained expression
+        Object result = chainedMethodExpression.evaluate(inputObjects, queryParameter);
+
+        assertEquals("String", result);
+    }
+
+}

li.strolch.soql/src/test/java/li/strolch/soql/core/QueryTest.java

@@ -0,0 +1,79 @@
+package li.strolch.soql.core;
+
+import li.strolch.model.Order;
+import li.strolch.model.ParameterBag;
+import li.strolch.model.Resource;
+import li.strolch.model.StrolchElement;
+import li.strolch.model.parameter.FloatParameter;
+import li.strolch.model.parameter.Parameter;
+import li.strolch.model.query.ActivityQuery;
+import li.strolch.model.query.OrderQuery;
+import li.strolch.model.query.ResourceQuery;
+import li.strolch.model.query.StrolchElementQuery;
+import li.strolch.soql.antlr4.generated.SOQLLexer;
+import li.strolch.soql.antlr4.generated.SOQLParser;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.junit.Test;
+
+import java.util.*;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author msmock
+ */
+public class QueryTest extends BaseTest {
+
+    /**
+     * @param entities
+     * @return Map<String   ,   StrolchElementQuery> of queries for the entities
+     */
+    public Map<String, StrolchElementQuery> resolveEntities(final Map<String, String> entities) {
+
+        final Map<String, StrolchElementQuery> result = new HashMap<>();
+
+        final Set<String> keys = entities.keySet();
+        for (Iterator<String> iterator = keys.iterator(); iterator.hasNext(); ) {
+
+            final String key = iterator.next();
+            final String clazzKey = entities.get(key);
+
+            // System.out.println("key = " + key + ", class = " + clazzKey);
+
+            switch (clazzKey) {
+                case "Resource":
+                    result.put(key, new ResourceQuery());
+                    break;
+                case "Order":
+                    result.put(key, new OrderQuery());
+                    break;
+                case "Activity":
+                    result.put(key, new ActivityQuery());
+                    break;
+            }
+        }
+        return result;
+    }
+
+    @Test
+    public void testQuery() throws Exception {
+
+        final String s = "SELECT a, r, o FROM Activity a, Resource r, Order o";
+
+        final ParseTree tree = parseString(s);
+        final CompiledStatement compiledStatement = compile(tree);
+        final Map<String, String> entities = compiledStatement.entities;
+
+        final Map<String, StrolchElementQuery> queries = resolveEntities(entities);
+
+        assertEquals(ActivityQuery.class, queries.get("a").getClass());
+        assertEquals(ResourceQuery.class, queries.get("r").getClass());
+        assertEquals(OrderQuery.class, queries.get("o").getClass());
+    }
+
+}

li.strolch.soql/src/test/java/li/strolch/soql/core/SerialisationTest.java

@@ -0,0 +1,94 @@
+package li.strolch.soql.core;
+
+import com.google.gson.JsonObject;
+import li.strolch.model.StrolchRootElement;
+import li.strolch.model.json.StrolchElementToJsonVisitor;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author msmock
+ */
+public class SerialisationTest extends BaseTest {
+
+    final StrolchElementToJsonVisitor visitor = new StrolchElementToJsonVisitor();
+
+    private QueryRequest buildTestRequest() {
+        String s = "SELECT a FROM Activity a WHERE a.getId() = :p";
+        final QueryRequest request = new QueryRequest();
+        request.setStatement(s);
+        request.getParameter().put("r", "Just a string!");
+        return request;
+    }
+
+    private QueryResponse buildTestResponse() {
+        String s = "SELECT a FROM Activity a WHERE a.getId() = :p";
+        final QueryResponse response = new QueryResponse();
+        response.setStatement(s);
+        response.getParameter().put("r", "Just a string!");
+        return response;
+    }
+
+    @Test
+    public void testSerialization() {
+        final StrolchRootElement element = getTestResource("testId");
+        final JsonObject jsonObject = element.accept(visitor);
+        // System.out.println(jsonObject);
+
+        String expected = "{\"objectType\":\"Resource\",\"id\":\"testId\",\"name\":null,\"type\":null,\"parameterBags\"" +
+                ":{\"testBag\":{\"id\":\"testBag\",\"name\":null,\"type\":null,\"parameters\":{\"testId\":" +
+                "{\"id\":\"testId\",\"name\":null,\"type\":\"Float\",\"value\":\"100.0\"}}}}}\n";
+
+        assertEquals(expected.trim(), jsonObject.toString());
+    }
+
+    @Test
+    public void testQuery2JSON() {
+        final QueryRequest query = buildTestRequest();
+        JsonObject jsonObject = query.toJson();
+
+        String expected = "{\"objectType\":\"QueryRequest\",\"statement\":\"SELECT a FROM Activity a WHERE a.getId() " +
+                "= :p\",\"parameter\":{\"r\":\"Just a string!\"}}";
+        assertEquals(expected.trim(), jsonObject.toString());
+    }
+
+    @Test
+    public void testJSON2Query() {
+
+        String s = "SELECT a FROM Activity a WHERE a.getId() = :p";
+
+        final QueryRequest initial = new QueryRequest();
+        initial.setStatement(s);
+        initial.getParameter().put("p", "10010");
+        final JsonObject jsonObject = initial.toJson();
+
+        final QueryRequest query = new QueryRequest();
+        query.fromJson(jsonObject);
+
+        assertEquals(s, query.getStatement());
+        assertEquals("10010", query.getParameter().get("p"));
+    }
+
+    @Test
+    public void testResponse2JSON() {
+        final QueryResponse response = buildTestResponse();
+        response.resultSet = getTestRessources(2);
+
+        String expected = "{\"objectType\":\"QueryRequest\",\"statement\":\"SELECT a FROM Activity a WHERE a.getId() " +
+                "= :p\",\"parameter\":{\"r\":\"Just a string!\"},\"resultSet\":[{\"objectType\":" +
+                "\"Resource\",\"id\":\"2\",\"name\":null,\"type\":null,\"parameterBags\":" +
+                "{\"testBag\":{\"id\":\"testBag\",\"name\":null,\"type\":null,\"parameters\":{\"testId\":{\"id\":" +
+                "\"testId\",\"name\":null,\"type\":\"Float\",\"value\":\"100.0\"}}}}},{\"objectType\":\"Resource\"," +
+                "\"id\":\"2\",\"name\":null,\"type\":null,\"parameterBags\":{\"testBag\":{\"id\":\"testBag\",\"name\"" +
+                ":null,\"type\":null,\"parameters\":{\"testId\":{\"id\":\"testId\",\"name\":null,\"type\":\"Float\"," +
+                "\"value\":\"100.0\"}}}}}]}\n";
+
+        final JsonObject jsonObject = response.toJson(visitor);
+        assertEquals(expected.trim(), jsonObject.toString());
+    }
+
+}

li.strolch.soql/src/test/java/li/strolch/soql/core/StatementTest.java

@@ -1,84 +1,17 @@
 package li.strolch.soql.core;
 
-import li.strolch.model.ParameterBag;
-import li.strolch.model.Resource;
-import li.strolch.model.StrolchElement;
-import li.strolch.model.parameter.FloatParameter;
-import li.strolch.model.parameter.Parameter;
-import li.strolch.soql.antlr4.generated.SOQLLexer;
-import li.strolch.soql.antlr4.generated.SOQLParser;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.CharStreams;
-import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.junit.Test;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-public class StatementTest {
-
-    /**
-     * @throws Exception
-     */
-    private ParseTree parseString(final String s) throws Exception {
-
-        CharStream input = CharStreams.fromString(s);
-        SOQLLexer lexer = new SOQLLexer(input); // create a buffer of tokens pulled from the lexer
-
-        CommonTokenStream tokens = new CommonTokenStream(lexer); // create a parser that feeds off the tokens buffer
-        SOQLParser parser = new SOQLParser(tokens);
-        parser.addErrorListener(new VerboseListener());
-
-        ParseTree tree = parser.select_statement(); // begin parsing at block
-
-        System.out.println(tree.toStringTree(parser)); // print LISP-style tree
-
-        return tree;
-    }
-
-    /**
-     * @param tree
-     * @return CompiledSOQLStatement the compiled SOQL statement
-     * @throws Exception
-     */
-    private CompiledStatement compile(final ParseTree tree) throws Exception {
-
-        final ParseTreeWalker walker = new ParseTreeWalker();
-        final SOQLListener listener = new SOQLListener();
-        walker.walk(listener, tree);
-
-        final CompiledStatement soqlStatement = new CompiledStatement();
-        soqlStatement.entities = listener.getEntities();
-        soqlStatement.whereExpression = listener.getWhereExpression();
-        soqlStatement.selectClause = listener.getSelectClause();
-
-        return soqlStatement;
-    }
-
-    /**
-     * @return a test parameter with String value
-     */
-    public StrolchElement getTestElement() {
-        final Resource resource = new Resource();
-        resource.setId("testId");
-
-        final ParameterBag bag = new ParameterBag();
-        bag.setId("testBag");
-        resource.addParameterBag(bag);
-
-        final Parameter parameter = new FloatParameter();
-        parameter.setId("testId");
-        parameter.setValue(100d);
-
-        resource.addParameter("testBag", parameter);
-        return resource;
-    }
+/**
+ * @author msmock
+ */
+public class StatementTest extends BaseTest{
 
     @Test
     public void test0() throws Exception {
@@ -91,14 +24,13 @@ public class StatementTest {
         // System.out.println(compiledStatement);
 
         final Map<String, Object> inputObjects = new HashMap<>();
-        inputObjects.put("r", getTestElement());
+        inputObjects.put("r", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
 
         final List<Object> result = compiledStatement.evaluate(inputObjects, queryParameter);
 
         assertEquals(1, result.size());
-
     }
 
     @Test
@@ -112,15 +44,14 @@ public class StatementTest {
         // System.out.println(compiledStatement);
 
         final Map<String, Object> inputObjects = new HashMap<>();
-        inputObjects.put("r", getTestElement());
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("r", getTestResource("testId"));
+        inputObjects.put("a", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
 
         final List<Object> result = compiledStatement.evaluate(inputObjects, queryParameter);
 
         assertEquals(3, result.size());
-
     }
 
     /**
@@ -136,7 +67,7 @@ public class StatementTest {
         final CompiledStatement compiledStatement = compile(tree);
 
         final Map<String, Object> inputObjects = new HashMap<>();
-        inputObjects.put("r", getTestElement());
+        inputObjects.put("r", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
 
@@ -158,14 +89,13 @@ public class StatementTest {
         final CompiledStatement compiledStatement = compile(tree);
 
         final Map<String, Object> inputObjects = new HashMap<>();
-        inputObjects.put("r", getTestElement());
+        inputObjects.put("r", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
 
         final List<Object> result = compiledStatement.evaluate(inputObjects, queryParameter);
 
         assertTrue(result.isEmpty());
-
     }
 
     /**
@@ -180,8 +110,8 @@ public class StatementTest {
         final CompiledStatement compiledStatement = compile(tree);
 
         final Map<String, Object> inputObjects = new HashMap<>();
-        inputObjects.put("r", getTestElement());
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("r", getTestResource("testId"));
+        inputObjects.put("a", getTestResource("testId"));
 
         final Map<String, Object> parameter = new HashMap<>();
 
@@ -205,7 +135,7 @@ public class StatementTest {
         queryParameter.put("outer_var", "testId");
 
         final Map<String, Object> inputObjects = new HashMap<>();
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         final List<Object> result = compiledStatement.evaluate(inputObjects, queryParameter);
 
@@ -224,7 +154,7 @@ public class StatementTest {
         final CompiledStatement compiledStatement = compile(tree);
 
         final Map<String, Object> inputObjects = new HashMap<>();
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
         queryParameter.put("p_1", "testBag");
@@ -248,7 +178,7 @@ public class StatementTest {
         final CompiledStatement compiledStatement = compile(tree);
 
         final Map<String, Object> inputObjects = new HashMap<>();
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
         queryParameter.put("p_1", "testBag");
@@ -273,7 +203,7 @@ public class StatementTest {
 
         final Map<String, Object> inputObjects = new HashMap<>();
 
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         Map<String, Object> queryParameter = new HashMap<>();
         queryParameter.put("param_1", "testBag");
@@ -305,7 +235,7 @@ public class StatementTest {
 
         final Map<String, Object> inputObjects = new HashMap<>();
 
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         Map<String, Object> queryParameter = new HashMap<>();
         queryParameter.put("param_1", "testBag");
@@ -337,7 +267,7 @@ public class StatementTest {
 
         final Map<String, Object> inputObjects = new HashMap<>();
 
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
         queryParameter.put("param_1", "testBag");
@@ -362,7 +292,7 @@ public class StatementTest {
 
         final Map<String, Object> inputObjects = new HashMap<>();
 
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
         queryParameter.put("p_1", "testBag");
@@ -371,7 +301,6 @@ public class StatementTest {
         List<Object> result = compiledStatement.evaluate(inputObjects, queryParameter);
 
         assertEquals(1, result.size());
-
     }
 
     /**
@@ -387,7 +316,7 @@ public class StatementTest {
 
         final Map<String, Object> inputObjects = new HashMap<>();
 
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
         queryParameter.put("p_1", "testBag");
@@ -412,7 +341,7 @@ public class StatementTest {
 
         final Map<String, Object> inputObjects = new HashMap<>();
 
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
         queryParameter.put("p_1", "testBag");
@@ -436,8 +365,7 @@ public class StatementTest {
         final CompiledStatement compiledStatement = compile(tree);
 
         final Map<String, Object> inputObjects = new HashMap<>();
-
-        inputObjects.put("a", getTestElement());
+        inputObjects.put("a", getTestResource("testId"));
 
         final Map<String, Object> queryParameter = new HashMap<>();
         queryParameter.put("p_1", "testBag");

li.strolch.soql/src/test/java/li/strolch/soql/core/VerboseListener.java

@@ -9,6 +9,9 @@ import org.antlr.v4.runtime.Parser;
 import org.antlr.v4.runtime.RecognitionException;
 import org.antlr.v4.runtime.Recognizer;
 
+/**
+ * @author msmock
+ */
 public class VerboseListener extends BaseErrorListener implements ANTLRErrorListener {
 
 	@Override

li.strolch.soql/src/test/java/li/strolch/soql/core/expression/ChainedMethodExpressionTest.java

@@ -1,118 +0,0 @@
-package li.strolch.soql.core.expression;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import li.strolch.model.ParameterBag;
-import li.strolch.model.Resource;
-import li.strolch.model.StrolchElement;
-import li.strolch.model.parameter.Parameter;
-import li.strolch.model.parameter.StringParameter;
-import org.junit.Test;
-
-import li.strolch.soql.core.expresssion.ChainedMethodExpression;
-import li.strolch.soql.core.expresssion.MethodArgumentDeclaration;
-import li.strolch.soql.core.expresssion.MethodExpression;
-import li.strolch.soql.core.expresssion.ParameterReference;
-
-public class ChainedMethodExpressionTest {
-
-	/**
-	 * @return a test parameter with String value
-	 */
-	public StrolchElement getTestElement() {
-		final Resource resource = new Resource();
-		resource.setId("testId");
-
-		final ParameterBag bag = new ParameterBag();
-		bag.setId("testBag");
-		resource.addParameterBag(bag);
-
-		final Parameter parameter = new StringParameter();
-		parameter.setId("testId");
-		parameter.setValue("testValue");
-
-		resource.addParameter("testBag", parameter);
-		return resource;
-	}
-
-	@Test
-	public void test() {
-
-		String matchingKey = "testString";
-
-		// build the message expression
-		ParameterReference parameterReference = new ParameterReference();
-		parameterReference.varName = "param_1";
-
-		MethodArgumentDeclaration argument = new MethodArgumentDeclaration();
-		argument.addParameterReference(parameterReference);
-
-		MethodExpression methodExpression = new MethodExpression();
-		methodExpression.setMethodName("getParameter");
-		methodExpression.setMethodArguments(argument);
-
-		// build the chained expression
-		ChainedMethodExpression chainedMethodExpression = new ChainedMethodExpression();
-		chainedMethodExpression.setObjectKey("a");
-		chainedMethodExpression.addMethodExpression(methodExpression);
-
-		// prepare the runtime objects
-
-		Map<String, Object> inputObjects = new HashMap<>();
-		inputObjects.put("a", getTestElement());
-
-		Map<String, Object> queryParameter = new HashMap<>();
-		queryParameter.put("param_1", matchingKey);
-
-		// evaluate the chained expression
-		Object result = chainedMethodExpression.evaluate(inputObjects, queryParameter);
-
-		assertEquals(StringParameter.class, result.getClass());
-
-	}
-
-	@Test
-	public void testChained() {
-
-		String matchingKey = "testString";
-
-		// build the message expression
-		ParameterReference parameterReference = new ParameterReference();
-		parameterReference.varName = "param_1";
-
-		MethodArgumentDeclaration argument = new MethodArgumentDeclaration();
-		argument.addParameterReference(parameterReference);
-
-		MethodExpression methodExpression_1 = new MethodExpression();
-		methodExpression_1.setMethodName("getParameter");
-		methodExpression_1.setMethodArguments(argument);
-		
-		MethodExpression methodExpression_2 = new MethodExpression();
-		methodExpression_2.setMethodName("getType");
-		methodExpression_2.setMethodArguments(new MethodArgumentDeclaration());
-
-		// build the chained expression
-		ChainedMethodExpression chainedMethodExpression = new ChainedMethodExpression();
-		chainedMethodExpression.setObjectKey("a");
-		chainedMethodExpression.addMethodExpression(methodExpression_1);
-		chainedMethodExpression.addMethodExpression(methodExpression_2);
-
-		// prepare the runtime objects
-
-		Map<String, Object> inputObjects = new HashMap<>();
-		inputObjects.put("a", getTestElement());
-
-		Map<String, Object> queryParameter = new HashMap<>();
-		queryParameter.put("param_1", matchingKey);
-
-		// evaluate the chained expression
-		Object result = chainedMethodExpression.evaluate(inputObjects, queryParameter);
-
-		assertEquals("testType", result);
-
-	}
-
-}

li.strolch.soql/src/test/java/li/strolch/soql/core/expression/MethodExpressionTest.java

@@ -1,67 +0,0 @@
-package li.strolch.soql.core.expression;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import li.strolch.model.ParameterBag;
-import li.strolch.model.Resource;
-import li.strolch.model.StrolchElement;
-import li.strolch.model.parameter.Parameter;
-import li.strolch.model.parameter.StringListParameter;
-import li.strolch.model.parameter.StringParameter;
-import org.junit.Test;
-
-import li.strolch.soql.core.expresssion.MethodArgumentDeclaration;
-import li.strolch.soql.core.expresssion.MethodExpression;
-import li.strolch.soql.core.expresssion.ParameterReference;
-
-public class MethodExpressionTest {
-
-	/**
-	 * @return a test parameter with String value
-	 */
-	public StrolchElement getTestElement() {
-		final Resource resource = new Resource();
-		resource.setId("testId");
-
-		final ParameterBag bag = new ParameterBag();
-		bag.setId("testBag");
-		resource.addParameterBag(bag);
-
-		final Parameter parameter = new StringParameter();
-		parameter.setId("testId");
-		parameter.setValue("testValue");
-
-		resource.addParameter("testBag", parameter);
-		return resource;
-	}
-
-	@Test
-	public void test() {
-
-		String matchingKey = "testString";
-
-		MethodExpression methodExpression = new MethodExpression();
-		methodExpression.setMethodName("getParameter");
-		methodExpression.setObject(getTestElement());
-
-		ParameterReference parameterReference = new ParameterReference();
-		parameterReference.varName = "param_1";
-
-		MethodArgumentDeclaration argument = new MethodArgumentDeclaration();
-		argument.addParameterReference(parameterReference);
-
-		methodExpression.setMethodArguments(argument);
-
-		Map<String, Object> queryParameter = new HashMap<>();
-		queryParameter.put("param_1", matchingKey);
-
-		Object result = methodExpression.evaluate(null, queryParameter);
-		
-		assertEquals(StringParameter.class, result.getClass());
-
-	}
-
-}