Repository: authorjapps/zerocode
Pull request #288 (2019-08-06 05:24:34)

ISS-278 # clean code (part1)


Patch:
diff --git a/core/src/main/java/org/jsmart/zerocode/core/di/main/ApplicationMainModule.java b/core/src/main/java/org/jsmart/zerocode/core/di/main/ApplicationMainModule.java
index 9fb929aa..237d8427 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/di/main/ApplicationMainModule.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/di/main/ApplicationMainModule.java
@@ -1,6 +1,5 @@
 package org.jsmart.zerocode.core.di.main;
 
-
 import com.google.inject.AbstractModule;
 import com.google.inject.name.Names;
 import org.jsmart.zerocode.core.di.module.CsvParserModule;
@@ -8,10 +7,12 @@ import org.jsmart.zerocode.core.di.module.GsonModule;
 import org.jsmart.zerocode.core.di.module.HttpClientModule;
 import org.jsmart.zerocode.core.di.module.ObjectMapperModule;
 import org.jsmart.zerocode.core.di.module.PropertiesInjectorModule;
-import org.jsmart.zerocode.core.engine.executor.JavaExecutor;
-import org.jsmart.zerocode.core.engine.executor.JavaExecutorImpl;
-import org.jsmart.zerocode.core.engine.executor.JsonServiceExecutor;
-import org.jsmart.zerocode.core.engine.executor.JsonServiceExecutorImpl;
+import org.jsmart.zerocode.core.engine.executor.httpapi.HttpApiExecutor;
+import org.jsmart.zerocode.core.engine.executor.httpapi.HttpApiExecutorImpl;
+import org.jsmart.zerocode.core.engine.executor.javaapi.JavaMethodExecutor;
+import org.jsmart.zerocode.core.engine.executor.javaapi.JavaMethodExecutorImpl;
+import org.jsmart.zerocode.core.engine.executor.ApiServiceExecutor;
+import org.jsmart.zerocode.core.engine.executor.ApiServiceExecutorImpl;
 import org.jsmart.zerocode.core.engine.preprocessor.ZeroCodeExternalFileProcessor;
 import org.jsmart.zerocode.core.engine.preprocessor.ZeroCodeExternalFileProcessorImpl;
 import org.jsmart.zerocode.core.engine.preprocessor.ZeroCodeJsonTestProcesor;
@@ -53,8 +54,9 @@ public class ApplicationMainModule extends AbstractModule {
          * Bind Direct classes, classes to interfaces etc
          */
         bind(ZeroCodeMultiStepsScenarioRunner.class).to(ZeroCodeMultiStepsScenarioRunnerImpl.class);
-        bind(JsonServiceExecutor.class).to(JsonServiceExecutorImpl.class);
-        bind(JavaExecutor.class).to(JavaExecutorImpl.class);
+        bind(ApiServiceExecutor.class).to(ApiServiceExecutorImpl.class);
+        bind(HttpApiExecutor.class).to(HttpApiExecutorImpl.class);
+        bind(JavaMethodExecutor.class).to(JavaMethodExecutorImpl.class);
         bind(ZeroCodeJsonTestProcesor.class).to(ZeroCodeJsonTestProcesorImpl.class);
         bind(ZeroCodeReportGenerator.class).to(ZeroCodeReportGeneratorImpl.class);
         bind(ZeroCodeExternalFileProcessor.class).to(ZeroCodeExternalFileProcessorImpl.class);
@@ -87,17 +89,17 @@ public class ApplicationMainModule extends AbstractModule {
 
     private void checkAndLoadOldProperties(Properties properties) {
 
-        if(properties.get(WEB_APPLICATION_ENDPOINT_HOST) == null && properties.get(RESTFUL_APPLICATION_ENDPOINT_HOST) != null){
+        if (properties.get(WEB_APPLICATION_ENDPOINT_HOST) == null && properties.get(RESTFUL_APPLICATION_ENDPOINT_HOST) != null) {
             Object oldPropertyValue = properties.get(RESTFUL_APPLICATION_ENDPOINT_HOST);
             properties.setProperty(WEB_APPLICATION_ENDPOINT_HOST, oldPropertyValue != null ? oldPropertyValue.toString() : null);
         }
 
-        if(properties.get(WEB_APPLICATION_ENDPOINT_PORT) == null && properties.get(RESTFUL_APPLICATION_ENDPOINT_PORT) != null){
+        if (properties.get(WEB_APPLICATION_ENDPOINT_PORT) == null && properties.get(RESTFUL_APPLICATION_ENDPOINT_PORT) != null) {
             Object oldPropertyValue = properties.get(RESTFUL_APPLICATION_ENDPOINT_PORT);
             properties.setProperty(WEB_APPLICATION_ENDPOINT_PORT, oldPropertyValue != null ? oldPropertyValue.toString() : null);
         }
 
-        if(properties.get(WEB_APPLICATION_ENDPOINT_CONTEXT) == null && properties.get(RESTFUL_APPLICATION_ENDPOINT_CONTEXT) != null){
+        if (properties.get(WEB_APPLICATION_ENDPOINT_CONTEXT) == null && properties.get(RESTFUL_APPLICATION_ENDPOINT_CONTEXT) != null) {
             Object oldPropertyValue = properties.get(RESTFUL_APPLICATION_ENDPOINT_CONTEXT);
             properties.setProperty(WEB_APPLICATION_ENDPOINT_CONTEXT, oldPropertyValue != null ? oldPropertyValue.toString() : null);
         }
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/ArrayIsEmptyAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/ArrayIsEmptyAsserter.java
deleted file mode 100644
index 039672ae..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/ArrayIsEmptyAsserter.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package org.jsmart.zerocode.core.engine.assertion;
-
-import net.minidev.json.JSONArray;
-
-public class ArrayIsEmptyAsserter implements JsonAsserter {
-    private final String path;
-
-    public ArrayIsEmptyAsserter(String path) {
-        this.path = path;
-    }
-
-    @Override
-    public String getPath() {
-        return path;
-    }
-
-    @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
-        if(result instanceof JSONArray){
-
-            final JSONArray actualArrayValue = (JSONArray) result;
-
-            if(actualArrayValue.isEmpty()){
-
-                return AssertionReport.createFieldMatchesReport();
-            }
-
-            return AssertionReport.createFieldDoesNotMatchReport(path, "[]", result);
-
-        } else {
-
-            return AssertionReport.createFieldDoesNotMatchReport(path, "[]", result);
-
-        }
-    }
-}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/AssertionReport.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/AssertionReport.java
deleted file mode 100644
index 4e09e145..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/AssertionReport.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package org.jsmart.zerocode.core.engine.assertion;
-
-public class AssertionReport {
-
-    private final String path;
-    private final Object expected;
-    private final Object actual;
-
-    private AssertionReport(String path, Object expected, Object actual) {
-        this.path = path;
-        this.expected = expected;
-        this.actual = actual;
-
-    }
-
-    public boolean matches() {
-        /*
-         * For SUCCESS no need of sending the path. Framework is only concerned about failures i.e. un-matching values.
-         */
-        return path == null;
-    }
-
-
-    public static AssertionReport createFieldMatchesReport() {
-        return new AssertionReport(null,null,null);
-    }
-
-    public static AssertionReport createFieldDoesNotMatchReport(String path, Object expected, Object actual) {
-        return new AssertionReport(path, expected, actual);
-    }
-
-    @Override
-    public String toString() {
-        return String.format("Assertion path '%s' with actual value '%s' did not match the expected value '%s'", path, actual, expected);
-    }
-}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldAssertionMatcher.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldAssertionMatcher.java
new file mode 100644
index 00000000..825f25d7
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldAssertionMatcher.java
@@ -0,0 +1,56 @@
+
+package org.jsmart.zerocode.core.engine.assertion;
+
+public class FieldAssertionMatcher {
+
+    private final Object expected;
+    private final Object actual;
+    private final String jsonPath;
+
+    FieldAssertionMatcher(String path, Object expected, Object actual) {
+        this.jsonPath = path;
+        this.expected = expected;
+        this.actual = actual;
+
+    }
+
+    FieldAssertionMatcher(String path) {
+        this(path, null, null);
+    }
+
+    public boolean matches() {
+        return null == getJsonPath();
+    }
+
+
+    public static FieldAssertionMatcher createMatchingMessage() {
+        // -------------------------------------------------------------------
+        // Because the values were matching, path is not relevant in this case
+        // -------------------------------------------------------------------
+        return new FieldAssertionMatcher(null);
+    }
+
+    public static FieldAssertionMatcher createNotMatchingMessage(String path, Object expected, Object actual) {
+        return new FieldAssertionMatcher(path, expected, actual);
+    }
+
+    public Object getExpected() {
+        return expected;
+    }
+
+    public Object getActual() {
+        return actual;
+    }
+
+    public String getJsonPath() {
+        return jsonPath;
+    }
+
+    @Override
+    public String toString() {
+        return matches() ?
+                "Actual field value matched the expected field value" :
+                String.format("Assertion jsonPath '%s' with actual value '%s' did not match the expected value '%s'",
+                        jsonPath, actual, expected);
+    }
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasDateAfterValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasDateAfterValueAsserter.java
deleted file mode 100644
index add71c1a..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasDateAfterValueAsserter.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.jsmart.zerocode.core.engine.assertion;
-
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.time.format.DateTimeParseException;
-
-public class FieldHasDateAfterValueAsserter implements JsonAsserter {
-	private final String path;
-	private final LocalDateTime expected;
-
-	public FieldHasDateAfterValueAsserter(String path, LocalDateTime expected) {
-		this.path = path;
-		this.expected = expected;
-	}
-
-	@Override
-	public String getPath() {
-		return path;
-	}
-
-	@Override
-	public AssertionReport actualEqualsToExpected(Object result) {
-		boolean areEqual;
-
-		if (result == null && expected == null) {
-			areEqual = true;
-		} else if (result == null) {
-			areEqual = false;
-		} else {
-			LocalDateTime resultDT = null;
-			try {
-				resultDT = LocalDateTime.parse((String) result,
-						DateTimeFormatter.ISO_DATE_TIME);
-				areEqual = resultDT.isAfter(expected);
-			} catch (DateTimeParseException ex) {
-				areEqual = false;
-			}
-		}
-
-		return areEqual ? AssertionReport.createFieldMatchesReport()
-				: AssertionReport.createFieldDoesNotMatchReport(path,
-						"Date After:" + expected, result);
-	}
-}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasDateBeforeValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasDateBeforeValueAsserter.java
deleted file mode 100644
index a9c642b5..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasDateBeforeValueAsserter.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.jsmart.zerocode.core.engine.assertion;
-
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.time.format.DateTimeParseException;
-
-public class FieldHasDateBeforeValueAsserter implements JsonAsserter {
-	private final String path;
-	private final LocalDateTime expected;
-
-	public FieldHasDateBeforeValueAsserter(String path, LocalDateTime expected) {
-		this.path = path;
-		this.expected = expected;
-	}
-
-	@Override
-	public String getPath() {
-		return path;
-	}
-
-	@Override
-	public AssertionReport actualEqualsToExpected(Object result) {
-		boolean areEqual;
-
-		if (result == null && expected == null) {
-			areEqual = true;
-		} else if (result == null) {
-			areEqual = false;
-		} else {
-			LocalDateTime resultDT = null;
-			try {
-				resultDT = LocalDateTime.parse((String) result,
-						DateTimeFormatter.ISO_DATE_TIME);
-				areEqual = resultDT.isBefore(expected);
-			} catch (DateTimeParseException ex) {
-				areEqual = false;
-			}
-		}
-
-		return areEqual ? AssertionReport.createFieldMatchesReport()
-				: AssertionReport.createFieldDoesNotMatchReport(path, "Date Before:"
-						+ expected, result);
-	}
-}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasSubStringValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasSubStringValueAsserter.java
deleted file mode 100644
index 074cc962..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasSubStringValueAsserter.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package org.jsmart.zerocode.core.engine.assertion;
-
-public class FieldHasSubStringValueAsserter implements JsonAsserter {
-    private final String path;
-    private final String expected;
-
-    public FieldHasSubStringValueAsserter(String path, String expected) {
-        this.path = path;
-        this.expected = expected;
-    }
-
-    @Override
-    public String getPath() {
-        return path;
-    }
-
-    @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
-        boolean areEqual;
-        if (result instanceof String && expected instanceof String) {
-            String s1 = (String) result;
-            String s2 = expected;
-            areEqual = s1.contains(s2);
-        } else {
-            areEqual = false;
-        }
-
-        return areEqual ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, "containing sub-string:" + expected, result);
-    }
-}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldIsNotNullAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldIsNotNullAsserter.java
deleted file mode 100644
index c3ae76eb..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldIsNotNullAsserter.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package org.jsmart.zerocode.core.engine.assertion;
-
-public class FieldIsNotNullAsserter implements JsonAsserter {
-    private final String path;
-
-    public FieldIsNotNullAsserter(String path) {
-        this.path = path;
-    }
-
-    @Override
-    public String getPath() {
-        return path;
-    }
-
-    @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
-        return result != null ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, "NOT NULL", result);
-    }
-}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldIsNullAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldIsNullAsserter.java
deleted file mode 100644
index 5f774079..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldIsNullAsserter.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package org.jsmart.zerocode.core.engine.assertion;
-
-public class FieldIsNullAsserter implements JsonAsserter {
-    private final String path;
-
-    public FieldIsNullAsserter(String path) {
-        this.path = path;
-    }
-
-    @Override
-    public String getPath() {
-        return path;
-    }
-
-    @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
-        return result == null ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, "NULL", result);
-    }
-}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/JsonAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/JsonAsserter.java
index d71cff2e..386d26fd 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/JsonAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/JsonAsserter.java
@@ -14,9 +14,9 @@ public interface JsonAsserter {
      */
     String getPath();
 
-    AssertionReport actualEqualsToExpected(Object result);
+    FieldAssertionMatcher actualEqualsToExpected(Object result);
 
-    default AssertionReport assertWithJson(String jsonSource) {
+    default FieldAssertionMatcher assertWithJson(String jsonSource) {
 
         Object result = null;
         try{
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/NumberComparator.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/NumberComparator.java
index efcb9167..be01a36c 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/NumberComparator.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/NumberComparator.java
@@ -3,14 +3,13 @@ package org.jsmart.zerocode.core.engine.assertion;
 import java.math.BigDecimal;
 import java.util.Comparator;
 
-class NumberComparator implements Comparator<Number> {
+public class NumberComparator implements Comparator<Number> {
 
     /**
      * Compares two numbers and returns their differences.
      * e.g. 3 compare 3.0 = 0, 3.0 compare 3 = 0, 3 compare 3.12 = -1, 3.12 compare 3 = 1
-     * Did you like the above example? Was it simple enough to understand?
      *
-     * @param a One fo two numbers to compare
+     * @param a One of two numbers to compare
      * @param b Two of two numbers to compare
      * @return a-b
      */
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/array/ArrayIsEmptyAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/array/ArrayIsEmptyAsserter.java
new file mode 100644
index 00000000..3be40107
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/array/ArrayIsEmptyAsserter.java
@@ -0,0 +1,42 @@
+
+package org.jsmart.zerocode.core.engine.assertion.array;
+
+import net.minidev.json.JSONArray;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
+
+public class ArrayIsEmptyAsserter implements JsonAsserter {
+    private final String path;
+
+    public ArrayIsEmptyAsserter(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
+        if(result instanceof JSONArray){
+
+            final JSONArray actualArrayValue = (JSONArray) result;
+
+            if(actualArrayValue.isEmpty()){
+
+                return createMatchingMessage();
+            }
+
+            return createNotMatchingMessage(path, "[]", result);
+
+        } else {
+
+            return createNotMatchingMessage(path, "[]", result);
+
+        }
+    }
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/ArraySizeAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/array/ArraySizeAsserter.java
similarity index 72%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/assertion/ArraySizeAsserter.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/assertion/array/ArraySizeAsserter.java
index 5b93abe6..c2f044bc 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/ArraySizeAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/array/ArraySizeAsserter.java
@@ -1,7 +1,12 @@
-package org.jsmart.zerocode.core.engine.assertion;
+
+package org.jsmart.zerocode.core.engine.assertion.array;
 
 import net.minidev.json.JSONArray;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
 
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
 import static org.jsmart.zerocode.core.engine.preprocessor.ZeroCodeJsonTestProcesorImpl.*;
 
 public class ArraySizeAsserter implements JsonAsserter {
@@ -27,7 +32,7 @@ public class ArraySizeAsserter implements JsonAsserter {
     }
 
     @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
         if (result instanceof JSONArray) {
 
             final JSONArray actualArrayValue = (JSONArray) result;
@@ -40,45 +45,45 @@ public class ArraySizeAsserter implements JsonAsserter {
 
             if (actualArrayValue.size() == this.expectedSize) {
 
-                return AssertionReport.createFieldMatchesReport();
+                return createMatchingMessage();
             }
 
-            return AssertionReport.createFieldDoesNotMatchReport(
+            return createNotMatchingMessage(
                     path,
                     String.format("Array of size %d", expectedSize),
                     actualArrayValue.size());
 
         } else {
 
-            return AssertionReport.createFieldDoesNotMatchReport(path, "[]", result);
+            return createNotMatchingMessage(path, "[]", result);
 
         }
     }
 
-    public AssertionReport processRelationalExpression(JSONArray actualArrayValue) {
+    public FieldAssertionMatcher processRelationalExpression(JSONArray actualArrayValue) {
         if (expectedSizeExpression.startsWith(ASSERT_VALUE_GREATER_THAN)) {
             String greaterThan = this.expectedSizeExpression.substring(ASSERT_VALUE_GREATER_THAN.length());
             if (actualArrayValue.size() > Integer.parseInt(greaterThan)) {
-                return AssertionReport.createFieldMatchesReport();
+                return createMatchingMessage();
             }
         } else if (expectedSizeExpression.startsWith(ASSERT_VALUE_LESSER_THAN)) {
             String lesserThan = this.expectedSizeExpression.substring(ASSERT_VALUE_LESSER_THAN.length());
             if (actualArrayValue.size() < Integer.parseInt(lesserThan)) {
-                return AssertionReport.createFieldMatchesReport();
+                return createMatchingMessage();
             }
         } else if (expectedSizeExpression.startsWith(ASSERT_VALUE_EQUAL_TO_NUMBER)) {
             String equalTo = this.expectedSizeExpression.substring(ASSERT_VALUE_EQUAL_TO_NUMBER.length());
             if (actualArrayValue.size() == Integer.parseInt(equalTo)) {
-                return AssertionReport.createFieldMatchesReport();
+                return createMatchingMessage();
             }
         } else if (expectedSizeExpression.startsWith(ASSERT_VALUE_NOT_EQUAL_TO_NUMBER)) {
             String notEqualTo = this.expectedSizeExpression.substring(ASSERT_VALUE_NOT_EQUAL_TO_NUMBER.length());
             if (actualArrayValue.size() != Integer.parseInt(notEqualTo)) {
-                return AssertionReport.createFieldMatchesReport();
+                return createMatchingMessage();
             }
         }
 
-        return AssertionReport.createFieldDoesNotMatchReport(
+        return createNotMatchingMessage(
                 path,
                 String.format("Array of size %s", expectedSizeExpression),
                 actualArrayValue.size());
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldContainsStringAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldContainsStringAsserter.java
new file mode 100644
index 00000000..da5adb7f
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldContainsStringAsserter.java
@@ -0,0 +1,39 @@
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
+
+public class FieldContainsStringAsserter implements JsonAsserter {
+    private final String path;
+    private final String expected;
+
+    public FieldContainsStringAsserter(String path, String expected) {
+        this.path = path;
+        this.expected = expected;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
+        boolean areEqual;
+        if (result instanceof String && expected instanceof String) {
+            String s1 = (String) result;
+            String s2 = expected;
+            areEqual = s1.contains(s2);
+        } else {
+            areEqual = false;
+        }
+
+        return areEqual ?
+                createMatchingMessage() :
+                createNotMatchingMessage(path, "containing sub-string:" + expected, result);
+    }
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasDateAfterValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasDateAfterValueAsserter.java
new file mode 100644
index 00000000..0bdec843
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasDateAfterValueAsserter.java
@@ -0,0 +1,49 @@
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
+
+public class FieldHasDateAfterValueAsserter implements JsonAsserter {
+    private final String path;
+    private final LocalDateTime expected;
+
+    public FieldHasDateAfterValueAsserter(String path, LocalDateTime expected) {
+        this.path = path;
+        this.expected = expected;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
+        boolean areEqual;
+
+        if (result == null && expected == null) {
+            areEqual = true;
+        } else if (result == null) {
+            areEqual = false;
+        } else {
+            LocalDateTime resultDT = null;
+            try {
+                resultDT = LocalDateTime.parse((String) result,
+                        DateTimeFormatter.ISO_DATE_TIME);
+                areEqual = resultDT.isAfter(expected);
+            } catch (DateTimeParseException ex) {
+                areEqual = false;
+            }
+        }
+
+        return areEqual ? createMatchingMessage()
+                : createNotMatchingMessage(path, "Date After:" + expected, result);
+    }
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasDateBeforeValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasDateBeforeValueAsserter.java
new file mode 100644
index 00000000..63b2f640
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasDateBeforeValueAsserter.java
@@ -0,0 +1,49 @@
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
+
+public class FieldHasDateBeforeValueAsserter implements JsonAsserter {
+    private final String path;
+    private final LocalDateTime expected;
+
+    public FieldHasDateBeforeValueAsserter(String path, LocalDateTime expected) {
+        this.path = path;
+        this.expected = expected;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
+        boolean areEqual;
+
+        if (result == null && expected == null) {
+            areEqual = true;
+        } else if (result == null) {
+            areEqual = false;
+        } else {
+            LocalDateTime resultDT = null;
+            try {
+                resultDT = LocalDateTime.parse((String) result,
+                        DateTimeFormatter.ISO_DATE_TIME);
+                areEqual = resultDT.isBefore(expected);
+            } catch (DateTimeParseException ex) {
+                areEqual = false;
+            }
+        }
+
+        return areEqual ? createMatchingMessage()
+                : createNotMatchingMessage(path, "Date Before:" + expected, result);
+    }
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasEqualNumberValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasEqualNumberValueAsserter.java
similarity index 57%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasEqualNumberValueAsserter.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasEqualNumberValueAsserter.java
index 513f9138..1e92fec7 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasEqualNumberValueAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasEqualNumberValueAsserter.java
@@ -1,4 +1,12 @@
-package org.jsmart.zerocode.core.engine.assertion;
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.NumberComparator;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
 
 public class FieldHasEqualNumberValueAsserter implements JsonAsserter {
     private final String path;
@@ -15,7 +23,7 @@ public class FieldHasEqualNumberValueAsserter implements JsonAsserter {
     }
 
     @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
         boolean areEqual;
 
         if (result instanceof Number && expected instanceof Number) {
@@ -34,8 +42,8 @@ public class FieldHasEqualNumberValueAsserter implements JsonAsserter {
         }
 
         return areEqual ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, expected+"(Number)", result+"(String)");
+                createMatchingMessage() :
+                createNotMatchingMessage(path, expected, result);
     }
 }
 
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasExactValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasExactValueAsserter.java
similarity index 61%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasExactValueAsserter.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasExactValueAsserter.java
index 10d10c22..2de684f3 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasExactValueAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasExactValueAsserter.java
@@ -1,4 +1,12 @@
-package org.jsmart.zerocode.core.engine.assertion;
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.NumberComparator;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
 
 public class FieldHasExactValueAsserter implements JsonAsserter {
     private final String path;
@@ -10,7 +18,7 @@ public class FieldHasExactValueAsserter implements JsonAsserter {
     }
 
     @Override
-    public AssertionReport actualEqualsToExpected(Object actualResult) {
+    public FieldAssertionMatcher actualEqualsToExpected(Object actualResult) {
         boolean areEqual;
 
         /*
@@ -41,8 +49,8 @@ public class FieldHasExactValueAsserter implements JsonAsserter {
         }
 
         return areEqual ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, expected, actualResult);
+                createMatchingMessage() :
+                createNotMatchingMessage(path, expected, actualResult);
     }
 
     public FieldHasExactValueAsserter(String path, Object expected) {
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasGreaterThanValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasGreaterThanValueAsserter.java
similarity index 57%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasGreaterThanValueAsserter.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasGreaterThanValueAsserter.java
index 26a9d9a2..ddaf162e 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasGreaterThanValueAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasGreaterThanValueAsserter.java
@@ -1,4 +1,12 @@
-package org.jsmart.zerocode.core.engine.assertion;
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.NumberComparator;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
 
 public class FieldHasGreaterThanValueAsserter implements JsonAsserter {
     private final String path;
@@ -15,7 +23,7 @@ public class FieldHasGreaterThanValueAsserter implements JsonAsserter {
     }
 
     @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
         boolean areEqual;
 
         if (result instanceof Number && expected instanceof Number) {
@@ -38,8 +46,8 @@ public class FieldHasGreaterThanValueAsserter implements JsonAsserter {
 
 
         return areEqual ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, "Greater Than:" + expected, result);
+                createMatchingMessage() :
+                createNotMatchingMessage(path, "Greater Than:" + expected, result);
     }
 }
 
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasInEqualNumberValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasInEqualNumberValueAsserter.java
similarity index 57%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasInEqualNumberValueAsserter.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasInEqualNumberValueAsserter.java
index 475291f4..c5fc6eab 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasInEqualNumberValueAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasInEqualNumberValueAsserter.java
@@ -1,4 +1,12 @@
-package org.jsmart.zerocode.core.engine.assertion;
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.NumberComparator;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
 
 public class FieldHasInEqualNumberValueAsserter implements JsonAsserter {
     private final String path;
@@ -15,7 +23,7 @@ public class FieldHasInEqualNumberValueAsserter implements JsonAsserter {
     }
 
     @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
         boolean areNotEqual;
 
         if (result instanceof Number && expected instanceof Number) {
@@ -34,8 +42,8 @@ public class FieldHasInEqualNumberValueAsserter implements JsonAsserter {
         }
 
         return areNotEqual ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, "not equals to " + expected, result);
+                createMatchingMessage() :
+                createNotMatchingMessage(path, "not equals to " + expected, result);
     }
 }
 
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasLesserThanValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasLesserThanValueAsserter.java
similarity index 56%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasLesserThanValueAsserter.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasLesserThanValueAsserter.java
index 3573fe6e..48117469 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasLesserThanValueAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasLesserThanValueAsserter.java
@@ -1,4 +1,12 @@
-package org.jsmart.zerocode.core.engine.assertion;
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.NumberComparator;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
 
 public class FieldHasLesserThanValueAsserter implements JsonAsserter {
     private final String path;
@@ -15,9 +23,9 @@ public class FieldHasLesserThanValueAsserter implements JsonAsserter {
     }
 
     @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
         boolean areEqual;
-        //
+
         if (result instanceof Number && expected instanceof Number) {
             NumberComparator comparator = new NumberComparator();
             areEqual = comparator.compare((Number) result, (Number) expected) == -1;
@@ -32,11 +40,10 @@ public class FieldHasLesserThanValueAsserter implements JsonAsserter {
             areEqual = false;
 
         }
-        //
 
         return areEqual ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, "Lesser Than:" + expected, result);
+                createMatchingMessage() :
+                createNotMatchingMessage(path, "Lesser Than:" + expected, result);
     }
 }
 
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasSubStringIgnoreCaseValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasSubStringIgnoreCaseValueAsserter.java
similarity index 60%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasSubStringIgnoreCaseValueAsserter.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasSubStringIgnoreCaseValueAsserter.java
index 25cdfc73..f55cbf1c 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldHasSubStringIgnoreCaseValueAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldHasSubStringIgnoreCaseValueAsserter.java
@@ -1,4 +1,8 @@
-package org.jsmart.zerocode.core.engine.assertion;
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
 
 public class FieldHasSubStringIgnoreCaseValueAsserter implements JsonAsserter {
     private final String path;
@@ -15,7 +19,7 @@ public class FieldHasSubStringIgnoreCaseValueAsserter implements JsonAsserter {
     }
 
     @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
         boolean areEqual;
         if (result instanceof String && expected instanceof String) {
             String s1 = (String) result;
@@ -26,7 +30,7 @@ public class FieldHasSubStringIgnoreCaseValueAsserter implements JsonAsserter {
         }
 
         return areEqual ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, "containing sub-string with ignoring case:" + expected, result);
+                FieldAssertionMatcher.createMatchingMessage() :
+                FieldAssertionMatcher.createNotMatchingMessage(path, "containing sub-string with ignoring case:" + expected, result);
     }
 }
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldIsNotNullAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldIsNotNullAsserter.java
new file mode 100644
index 00000000..67b7aa3d
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldIsNotNullAsserter.java
@@ -0,0 +1,29 @@
+
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
+
+public class FieldIsNotNullAsserter implements JsonAsserter {
+    private final String path;
+
+    public FieldIsNotNullAsserter(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
+        return result != null ?
+                createMatchingMessage() :
+                createNotMatchingMessage(path, "NOT NULL", result);
+    }
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldIsNullAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldIsNullAsserter.java
new file mode 100644
index 00000000..7a24498a
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldIsNullAsserter.java
@@ -0,0 +1,28 @@
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
+
+public class FieldIsNullAsserter implements JsonAsserter {
+    private final String path;
+
+    public FieldIsNullAsserter(String path) {
+        this.path = path;
+    }
+
+    @Override
+    public String getPath() {
+        return path;
+    }
+
+    @Override
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
+        return result == null ?
+                createMatchingMessage() :
+                createNotMatchingMessage(path, "NULL", result);
+    }
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldIsOneOfValueAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldIsOneOfValueAsserter.java
similarity index 76%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldIsOneOfValueAsserter.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldIsOneOfValueAsserter.java
index 53abd25a..85bfe0c4 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldIsOneOfValueAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldIsOneOfValueAsserter.java
@@ -1,66 +1,70 @@
-package org.jsmart.zerocode.core.engine.assertion;
-
-import java.util.Arrays;
-
-import static org.apache.commons.lang.StringUtils.substringBetween;
-
-public class FieldIsOneOfValueAsserter implements JsonAsserter {
-	private final String path;
-	final Object expected;
-
-	@Override
-	public String getPath() {
-		return path;
-	}
-
-	@Override
-	public AssertionReport actualEqualsToExpected(Object actualResult) {
-		boolean areEqual;
-
-		if (expected != null) {
-            String expectedString = substringBetween((String) expected, "[", "]");
-
-			// Store collection as a java array
-			String[] expectedArray = null;
-			
-			// Check if it's an empty json array
-			if (!expectedString.isEmpty()) {
-				// Split into an array
-				expectedArray = expectedString.split(",");
-			} else {
-				expectedArray = new String[] {};
-			}
-				
-			// Remove leading and trailing spaces
-			for (int i = 0; i < expectedArray.length; i++) {
-				// Checking that this is not a whitespace string (cannot use .isBlank() as we're
-				// targeting java 1.8)
-				if (!expectedArray[i].trim().isEmpty())
-					expectedArray[i] = expectedArray[i].trim();
-			}
-
-			if (actualResult != null) {
-				// Search list for value
-				areEqual = Arrays.asList(expectedArray).contains(actualResult);
-			} else {
-				areEqual = false;
-			}
-		} else {
-			// Both null
-			if (actualResult == null) {
-				areEqual = true;
-			} else {
-				areEqual = false;
-			}
-		}
-
-		return areEqual ? AssertionReport.createFieldMatchesReport()
-				: AssertionReport.createFieldDoesNotMatchReport(path, "One Of:" + expected, actualResult);
-	}
-
-	public FieldIsOneOfValueAsserter(String path, Object expected) {
-		this.path = path;
-		this.expected = expected;
-	}
-
+
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import java.util.Arrays;
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.apache.commons.lang.StringUtils.substringBetween;
+
+public class FieldIsOneOfValueAsserter implements JsonAsserter {
+	private final String path;
+	final Object expected;
+
+	@Override
+	public String getPath() {
+		return path;
+	}
+
+	@Override
+	public FieldAssertionMatcher actualEqualsToExpected(Object actualResult) {
+		boolean areEqual;
+
+		if (expected != null) {
+            String expectedString = substringBetween((String) expected, "[", "]");
+
+			// Store collection as a java array
+			String[] expectedArray = null;
+			
+			// Check if it's an empty json array
+			if (!expectedString.isEmpty()) {
+				// Split into an array
+				expectedArray = expectedString.split(",");
+			} else {
+				expectedArray = new String[] {};
+			}
+				
+			// Remove leading and trailing spaces
+			for (int i = 0; i < expectedArray.length; i++) {
+				// Checking that this is not a whitespace string (cannot use .isBlank() as we're
+				// targeting java 1.8)
+				if (!expectedArray[i].trim().isEmpty())
+					expectedArray[i] = expectedArray[i].trim();
+			}
+
+			if (actualResult != null) {
+				// Search list for value
+				areEqual = Arrays.asList(expectedArray).contains(actualResult);
+			} else {
+				areEqual = false;
+			}
+		} else {
+			// Both null
+			if (actualResult == null) {
+				areEqual = true;
+			} else {
+				areEqual = false;
+			}
+		}
+
+		return areEqual ? FieldAssertionMatcher.createMatchingMessage()
+				: FieldAssertionMatcher.createNotMatchingMessage(path, "One Of:" + expected, actualResult);
+	}
+
+	public FieldIsOneOfValueAsserter(String path, Object expected) {
+		this.path = path;
+		this.expected = expected;
+	}
+
 }
\ No newline at end of file
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldMatchesRegexPatternAsserter.java b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldMatchesRegexPatternAsserter.java
similarity index 52%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldMatchesRegexPatternAsserter.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldMatchesRegexPatternAsserter.java
index fa505ef6..ecafbd1a 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/FieldMatchesRegexPatternAsserter.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/assertion/field/FieldMatchesRegexPatternAsserter.java
@@ -1,4 +1,12 @@
-package org.jsmart.zerocode.core.engine.assertion;
+
+
+package org.jsmart.zerocode.core.engine.assertion.field;
+
+import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
+
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createMatchingMessage;
+import static org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher.createNotMatchingMessage;
 
 public class FieldMatchesRegexPatternAsserter implements JsonAsserter {
     private final String path;
@@ -15,7 +23,7 @@ public class FieldMatchesRegexPatternAsserter implements JsonAsserter {
     }
 
     @Override
-    public AssertionReport actualEqualsToExpected(Object result) {
+    public FieldAssertionMatcher actualEqualsToExpected(Object result) {
         boolean areEqual;
         if (result instanceof String && expected instanceof String) {
             String s1 = (String) result;
@@ -26,7 +34,7 @@ public class FieldMatchesRegexPatternAsserter implements JsonAsserter {
         }
 
         return areEqual ?
-                AssertionReport.createFieldMatchesReport() :
-                AssertionReport.createFieldDoesNotMatchReport(path, "containing sub-string:" + expected, result);
+                createMatchingMessage() :
+                createNotMatchingMessage(path, "containing sub-string:" + expected, result);
     }
 }
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/ApiServiceExecutor.java b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/ApiServiceExecutor.java
new file mode 100644
index 00000000..dcb91934
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/ApiServiceExecutor.java
@@ -0,0 +1,32 @@
+package org.jsmart.zerocode.core.engine.executor;
+
+public interface ApiServiceExecutor {
+    /**
+     *
+     * @param url A relative path to a http or https url
+     * @param methodName An HTTP method e.g. GET, PUT, POST, DELETE, HEAD etc supported by Apache HttpClient
+     * @param requestJson A body payload with http headers needed to executeWithParams the HTTP api
+     * @return String The response with http headers and body payload in JSON
+     */
+    String executeHttpApi(String url, String methodName, String requestJson);
+
+    /**
+     *
+     * @param className A fully qualified java class name
+     * @param methodName An accessible public method to executeWithParams
+     * @param requestJson A json with fields matching the method parameters
+     * @return String The result of the method execution in JSON
+     */
+    String executeJavaOperation(String className, String methodName, String requestJson);
+
+    /**
+     *
+     * @param kafkaServers Kafka brokers aka servers
+     * @param kafkaTopic Kafka topic(s) residing on the brokers
+     * @param methodName A produce or consume or poll operation
+     * @param requestJson RAW or JSON records for producing, config settings for consuming
+     * @return String The broker acknowledgement in JSON
+     */
+    String executeKafkaService(String kafkaServers, String kafkaTopic, String methodName, String requestJson);
+
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/ApiServiceExecutorImpl.java b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/ApiServiceExecutorImpl.java
new file mode 100644
index 00000000..173d8ddc
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/ApiServiceExecutorImpl.java
@@ -0,0 +1,60 @@
+package org.jsmart.zerocode.core.engine.executor;
+
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import org.jsmart.zerocode.core.engine.executor.httpapi.HttpApiExecutor;
+import org.jsmart.zerocode.core.engine.executor.javaapi.JavaMethodExecutor;
+import org.jsmart.zerocode.core.kafka.client.BasicKafkaClient;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ApiServiceExecutorImpl implements ApiServiceExecutor {
+    private static final Logger LOGGER = LoggerFactory.getLogger(ApiServiceExecutorImpl.class);
+
+    @Inject
+    private JavaMethodExecutor javaMethodExecutor;
+
+    @Inject
+    private HttpApiExecutor httpApiExecutor;
+
+    @Inject
+    private BasicKafkaClient kafkaClient;
+
+    @Inject(optional = true)
+    @Named("mock.api.port")
+    private int mockPort;
+
+    public ApiServiceExecutorImpl() {
+    }
+
+    @Override
+    public String executeHttpApi(String url, String methodName, String requestJson) {
+        try {
+            return httpApiExecutor.execute(url, methodName, requestJson);
+        } catch (Throwable severError) {
+            LOGGER.error("Ooooooooooops! Something unexpected happened while connecting to the url:{} " +
+                    "\n1) Check if the service is running at the host -or-" +
+                    "\n2) Check the corporate proxy has been configured correctly -or" +
+                    "\n3) Choose another mocking(if in use) port not to conflict with the port:{} -or-" +
+                    "\n4) Restart the service. -or- " +
+                    "See the full error details below-\n{}", url, mockPort, severError);
+
+            throw new RuntimeException(severError);
+        }
+    }
+
+    @Override
+    public String executeJavaOperation(String className, String methodName, String requestJson) {
+        try{
+            return javaMethodExecutor.execute(className, methodName, requestJson);
+        } catch (Exception e) {
+            LOGGER.error("Java method execution exception - " + e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public String executeKafkaService(String kafkaServers, String kafkaTopic, String operation, String requestJson) {
+        return kafkaClient.execute(kafkaServers, kafkaTopic, operation, requestJson);
+    }
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JavaExecutor.java b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JavaExecutor.java
deleted file mode 100755
index 11c7c52f..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JavaExecutor.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.jsmart.zerocode.core.engine.executor;
-
-import java.util.List;
-
-public interface JavaExecutor {
-
-	public Object execute(String qualifiedClassName, String methodName, Object... args);
-
-	public List<Class<?>> argumentTypes(String className, String methodName);
-}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JavaExecutorImpl.java b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JavaExecutorImpl.java
deleted file mode 100644
index 4da31784..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JavaExecutorImpl.java
+++ /dev/null
@@ -1,72 +0,0 @@
-package org.jsmart.zerocode.core.engine.executor;
-
-import com.google.inject.Inject;
-import com.google.inject.Injector;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.List;
-
-public class JavaExecutorImpl implements JavaExecutor {
-    private static final Logger LOGGER = LoggerFactory.getLogger(JavaExecutorImpl.class);
-
-    //guice
-    private final Injector injector;
-
-    @Inject
-    public JavaExecutorImpl(Injector injector) {
-        this.injector = injector;
-    }
-    //guice
-
-    /*
-     *
-     * @param qualifiedClassName : including package name: e.g. "AddService"
-     * @param methodName
-     * @param args
-     * @return
-     */
-    public Object execute(String qualifiedClassName, String methodName, Object... args) {
-
-        try {
-
-            return findMethod(qualifiedClassName, methodName)
-                    .invoke(injector.getInstance(getClass(qualifiedClassName)), args);
-        } catch (Exception e) {
-            LOGGER.error("Exception encountered while executing java method" + e);
-            throw new RuntimeException(e);
-        }
-    }
-
-    public List<Class<?>> argumentTypes(String className, String methodName) {
-        return Arrays.asList(findMethod(className, methodName).getParameterTypes());
-    }
-
-    private Method findMethod(String className, String methodName) {
-        Class<?> type = getClass(className);
-
-        Method[] declaredMethods = type.getDeclaredMethods();
-        for (Method declared : declaredMethods) {
-            if (declared.getName().equals(methodName)) {
-                return declared;
-            }
-        }
-
-        throw new RuntimeException(String.format("Java: Could not find method %s in class %s", methodName, className));
-
-    }
-
-    private Class<?> getClass(String className) {
-        Class<?> type;
-        try {
-            type = Class.forName(className);
-        } catch (ClassNotFoundException e) {
-            throw new RuntimeException(e);
-        }
-        return type;
-    }
-
-}
-
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JsonServiceExecutor.java b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JsonServiceExecutor.java
deleted file mode 100644
index 840fdb8d..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JsonServiceExecutor.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package org.jsmart.zerocode.core.engine.executor;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-
-public interface JsonServiceExecutor {
-    String executeJavaService(String serviceName, String methodName, String requestJson) throws JsonProcessingException;
-
-    String executeRESTService(String urlName, String methodName, String requestJson);
-
-    String executeKafkaService(String kafkaServers, String urlName, String methodName, String requestJson);
-
-
-}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/httpapi/HttpApiExecutor.java b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/httpapi/HttpApiExecutor.java
new file mode 100644
index 00000000..4f8d198d
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/httpapi/HttpApiExecutor.java
@@ -0,0 +1,5 @@
+package org.jsmart.zerocode.core.engine.executor.httpapi;
+
+public interface HttpApiExecutor {
+    String execute(String urlName, String methodName, String requestJson) throws Exception;
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JsonServiceExecutorImpl.java b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/httpapi/HttpApiExecutorImpl.java
similarity index 68%
rename from core/src/main/java/org/jsmart/zerocode/core/engine/executor/JsonServiceExecutorImpl.java
rename to core/src/main/java/org/jsmart/zerocode/core/engine/executor/httpapi/HttpApiExecutorImpl.java
index 7a6404b7..86a0ac1e 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/JsonServiceExecutorImpl.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/httpapi/HttpApiExecutorImpl.java
@@ -1,118 +1,49 @@
-package org.jsmart.zerocode.core.engine.executor;
+package org.jsmart.zerocode.core.engine.executor.httpapi;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.inject.Inject;
 import com.google.inject.name.Named;
 import com.jayway.jsonpath.JsonPath;
 import com.jayway.jsonpath.PathNotFoundException;
+import java.io.IOException;
+import java.util.HashMap;
+import javax.ws.rs.core.MultivaluedMap;
 import org.jsmart.zerocode.core.domain.MockSteps;
 import org.jsmart.zerocode.core.domain.Response;
 import org.jsmart.zerocode.core.httpclient.BasicHttpClient;
-import org.jsmart.zerocode.core.kafka.client.BasicKafkaClient;
 import org.jsmart.zerocode.core.utils.SmartUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.ws.rs.core.MultivaluedMap;
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.List;
-
 import static org.apache.commons.lang.StringUtils.isEmpty;
-import static org.jsmart.zerocode.core.engine.mocker.RestEndPointMocker.*;
+import static org.jsmart.zerocode.core.engine.mocker.RestEndPointMocker.createWithLocalMock;
+import static org.jsmart.zerocode.core.engine.mocker.RestEndPointMocker.createWithVirtuosoMock;
+import static org.jsmart.zerocode.core.engine.mocker.RestEndPointMocker.createWithWireMock;
 import static org.jsmart.zerocode.core.utils.SmartUtils.prettyPrintJson;
 
-public class JsonServiceExecutorImpl implements JsonServiceExecutor {
-    private static final Logger LOGGER = LoggerFactory.getLogger(JsonServiceExecutorImpl.class);
+public class HttpApiExecutorImpl implements HttpApiExecutor {
 
-    @Inject
-    private JavaExecutor javaExecutor;
-
-    @Inject
-    private ObjectMapper objectMapper;
+    private static final Logger LOGGER = LoggerFactory.getLogger(HttpApiExecutorImpl.class);
 
-    @Inject
-    private SmartUtils smartUtils;
+    private final BasicHttpClient httpClient;
+    private final ObjectMapper objectMapper;
 
     @Inject
-    private BasicHttpClient httpClient;
+    public HttpApiExecutorImpl(BasicHttpClient httpClient, ObjectMapper objectMapper) {
+        this.httpClient = httpClient;
+        this.objectMapper = objectMapper;
+    }
 
     @Inject
-    private BasicKafkaClient kafkaClient;
+    private SmartUtils smartUtils;
 
     @Inject(optional = true)
     @Named("mock.api.port")
     private int mockPort;
 
-    public JsonServiceExecutorImpl() {
-    }
-
-    @Override
-    public String executeJavaService(String serviceName, String methodName, String requestJson) throws JsonProcessingException {
-
-        if (javaExecutor == null) {
-            throw new RuntimeException("Can not proceed as the framework could not load the executors. ");
-        }
-
-        List<Class<?>> argumentTypes = javaExecutor.argumentTypes(serviceName, methodName);
-
-        try {
-            Object result;
-
-            if (argumentTypes == null || argumentTypes.size() == 0) {
-
-                result = javaExecutor.execute(serviceName, methodName);
-
-            } else {
-
-                Object request = objectMapper.readValue(requestJson, argumentTypes.get(0));
-                result = javaExecutor.execute(serviceName, methodName, request);
-
-            }
-
-            final String resultJson = objectMapper.writeValueAsString(result);
-
-            return prettyPrintJson(resultJson);
-
-        } catch (Exception e) {
-
-            e.printStackTrace();
-
-            throw new RuntimeException(e);
-
-        }
-    }
-
     @Override
-    public String executeRESTService(String urlName, String methodName, String requestJson) {
-
-        try {
-            String responseJson = executeRESTInternal(urlName, methodName, requestJson);
-
-            return responseJson;
-
-        } catch (Throwable severError) {
-
-            LOGGER.error("Ooooooooooops! Something unexpected happened while connecting to the url:{} " +
-                    "\n1) Check if the service is running at the host -or-" +
-                    "\n2) Check the corporate proxy has been configured correctly -or" +
-                    "\n3) Choose another mocking(if in use) port not to conflict with the port:{} -or-" +
-                    "\n4) Restart the service. -or- " +
-                    "See the full error details below-\n{}", urlName, mockPort, severError);
-
-            throw new RuntimeException(severError);
-
-        }
-    }
-
-    @Override
-    public String executeKafkaService(String kafkaServers, String topicName, String operation, String requestJson) {
-        return kafkaClient.execute(kafkaServers, topicName, operation, requestJson);
-    }
-
-    private String executeRESTInternal(String httpUrl, String methodName, String requestJson) throws Exception {
+    public String execute(String httpUrl, String methodName, String requestJson) throws Exception {
 
         HashMap queryParams = (HashMap) readJsonPathOrElseNull(requestJson, "$.queryParams");
         HashMap headers = (HashMap) readJsonPathOrElseNull(requestJson, "$.headers");
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/javaapi/JavaMethodExecutor.java b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/javaapi/JavaMethodExecutor.java
new file mode 100644
index 00000000..c2608a50
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/javaapi/JavaMethodExecutor.java
@@ -0,0 +1,5 @@
+package org.jsmart.zerocode.core.engine.executor.javaapi;
+
+public interface JavaMethodExecutor {
+    String execute(String qualifiedClassName, String methodName, String requestJson);
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/executor/javaapi/JavaMethodExecutorImpl.java b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/javaapi/JavaMethodExecutorImpl.java
new file mode 100644
index 00000000..f5efb462
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/executor/javaapi/JavaMethodExecutorImpl.java
@@ -0,0 +1,114 @@
+
+package org.jsmart.zerocode.core.engine.executor.javaapi;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import java.lang.reflect.Method;
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static java.lang.Class.forName;
+import static java.lang.String.format;
+import static java.util.Arrays.asList;
+import static org.jsmart.zerocode.core.utils.SmartUtils.prettyPrintJson;
+
+public class JavaMethodExecutorImpl implements JavaMethodExecutor {
+    private static final Logger LOGGER = LoggerFactory.getLogger(JavaMethodExecutorImpl.class);
+
+    //guice
+    private final Injector injector;
+
+    private final ObjectMapper objectMapper;
+
+    @Inject
+    public JavaMethodExecutorImpl(Injector injector, ObjectMapper objectMapper) {
+        this.injector = injector;
+        this.objectMapper = objectMapper;
+    }
+
+    //guice
+
+    @Override
+    public String execute(String qualifiedClassName, String methodName, String requestJson) {
+
+        try {
+            List<Class<?>> parameterTypes = getParameterTypes(qualifiedClassName, methodName);
+
+            Object result;
+
+            if (parameterTypes == null || parameterTypes.size() == 0) {
+
+                result = executeWithParams(qualifiedClassName, methodName);
+
+            } else {
+
+                Object request = objectMapper.readValue(requestJson, parameterTypes.get(0));
+                result = executeWithParams(qualifiedClassName, methodName, request);
+            }
+
+            final String resultJson = objectMapper.writeValueAsString(result);
+            return prettyPrintJson(resultJson);
+
+        } catch (Exception e) {
+            LOGGER.error("Exception - " + e);
+            throw new RuntimeException(e);
+
+        }
+    }
+
+    /*
+     *
+     * @param qualifiedClassName : including package name: e.g. "org.jsmart.zerocode.core.AddService"
+     * @param methodName : public method in this class
+     * @param params : parameters to this method
+     * @return
+     */
+    Object executeWithParams(String qualifiedClassName, String methodName, Object... params) {
+
+        /**
+         * Refer SOF example:
+         * Q. How do I invoke a Java method when given the method name as a string?
+         * Link: https://stackoverflow.com/questions/160970/how-do-i-invoke-a-java-method-when-given-the-method-name-as-a-string
+         */
+        try {
+            Method method = findMatchingMethod(qualifiedClassName, methodName);
+            Object objectToInvokeOn = injector.getInstance(forName(qualifiedClassName));
+
+            return method.invoke(objectToInvokeOn, params);
+        } catch (Exception e) {
+            String errMsg = format("Java exec(): Invocation failed for method %s in class %s", methodName, qualifiedClassName);
+            LOGGER.error(errMsg + ". Exception - " + e);
+            throw new RuntimeException(errMsg);
+        }
+    }
+
+    Method findMatchingMethod(String className, String methodName) {
+        try{
+            // See the method invocation JDK documentation here:
+            // Link: https://docs.oracle.com/javase/tutorial/reflect/member/methodInvocation.html
+            // TODO - Handle overloaded methods e.g. Thread.sleep(args...)
+
+            Class<?> clazz = forName(className);
+
+            Method[] allMethods = clazz.getDeclaredMethods();
+            for (Method m : allMethods) {
+                if (m.getName().equals(methodName)) {
+                    return m;
+                }
+            }
+
+            throw new RuntimeException(format("Java exec(): No matching method %s found in class %s", methodName, className));
+
+        } catch(Exception e){
+            LOGGER.error("Exception occurred while finding the matching method - " + e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    List<Class<?>> getParameterTypes(String className, String methodName) {
+        return asList(findMatchingMethod(className, methodName).getParameterTypes());
+    }
+
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/mocker/RestEndPointMocker.java b/core/src/main/java/org/jsmart/zerocode/core/engine/mocker/RestEndPointMocker.java
index 9999477c..26d5e7e1 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/mocker/RestEndPointMocker.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/mocker/RestEndPointMocker.java
@@ -11,7 +11,7 @@ import org.apache.commons.collections.map.HashedMap;
 import org.apache.commons.lang.StringUtils;
 import org.jsmart.zerocode.core.domain.MockStep;
 import org.jsmart.zerocode.core.domain.MockSteps;
-import org.jsmart.zerocode.core.engine.executor.JsonServiceExecutorImpl;
+import org.jsmart.zerocode.core.engine.executor.ApiServiceExecutorImpl;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -28,7 +28,7 @@ import static com.github.tomakehurst.wiremock.client.WireMock.urlEqualTo;
 import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig;
 
 public class RestEndPointMocker {
-    private static final Logger LOGGER = LoggerFactory.getLogger(JsonServiceExecutorImpl.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(RestEndPointMocker.class);
 
     public static WireMockServer wireMockServer;
 
@@ -63,7 +63,6 @@ public class RestEndPointMocker {
         });
     }
 
-
     public static void restartWireMock(int dynamicPort) {
         if ( wireMockServer != null ) {
             /*
@@ -85,6 +84,16 @@ public class RestEndPointMocker {
         return helperMap;
     }
 
+    public static void stopWireMockServer() {
+        if (null != wireMockServer) {
+            wireMockServer.stop();
+            wireMockServer = null;
+            LOGGER.info("Scenario: All mockings done via WireMock server. Dependant end points executed. Stopped WireMock.");
+        }
+    }
+
+
+
     private static MappingBuilder createPutRequestBuilder(MockStep mockStep) {
         final MappingBuilder requestBuilder = put(urlEqualTo(mockStep.getUrl()));
         return createRequestBuilderWithHeaders(mockStep, requestBuilder);
diff --git a/core/src/main/java/org/jsmart/zerocode/core/httpclient/BasicHttpClient.java b/core/src/main/java/org/jsmart/zerocode/core/httpclient/BasicHttpClient.java
index 8974685f..4c246eb5 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/httpclient/BasicHttpClient.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/httpclient/BasicHttpClient.java
@@ -181,7 +181,6 @@ public class BasicHttpClient {
      * @return  : A http response compatible with Charset received from the http server e.g. UTF-8, UTF-16 etc
      * @throws IOException
      *
-     * @author santhoshkumar santhoshTpixler
      */
     public Response createCharsetResponse(CloseableHttpResponse httpResponse) throws IOException {
         HttpEntity entity = httpResponse.getEntity();
@@ -215,7 +214,6 @@ public class BasicHttpClient {
      * @param queryParams - Query parameters to pass
      * @return : Effective url
      *
-     * @author santhoshkumar santhoshTpixler (Fixed empty queryParams map handling)
      */
     public String handleUrlAndQueryParams(String httpUrl, Map<String, Object> queryParams) throws IOException {
         if ((queryParams != null) && (!queryParams.isEmpty())) {
diff --git a/core/src/main/java/org/jsmart/zerocode/core/httpclient/RestEasyDefaultHttpClient.java b/core/src/main/java/org/jsmart/zerocode/core/httpclient/RestEasyDefaultHttpClient.java
deleted file mode 100644
index ee3f55e7..00000000
--- a/core/src/main/java/org/jsmart/zerocode/core/httpclient/RestEasyDefaultHttpClient.java
+++ /dev/null
@@ -1,131 +0,0 @@
-//package org.jsmart.zerocode.core.httpclient;
-//
-//import org.jboss.resteasy.client.ClientRequest;
-//import org.jboss.resteasy.client.ClientResponse;
-//import org.jboss.resteasy.client.core.executors.ApacheHttpClientExecutor;
-//import org.jsmart.zerocode.core.utils.HelperJsonUtils;
-//import org.slf4j.Logger;
-//import org.slf4j.LoggerFactory;
-//
-//import javax.ws.rs.core.MultivaluedMap;
-//import javax.ws.rs.core.Response;
-//import java.util.HashMap;
-//import java.util.Iterator;
-//import java.util.Map;
-//import java.util.Set;
-//
-//import static java.lang.String.format;
-//import static org.jsmart.zerocode.core.utils.HelperJsonUtils.getContentAsItIsJson;
-//
-//public class RestEasyDefaultHttpClient implements BasicHttpClient {
-//    private static final Logger logger = LoggerFactory.getLogger(RestEasyDefaultHttpClient.class);
-//
-//    private static ApacheHttpClientExecutor httpClientExecutor = new ApacheHttpClientExecutor();
-//
-//    private ClientRequest clientExecutor;
-//
-//    private Object COOKIE_JSESSIONID_VALUE;
-//
-//    @Override
-//    public Response execute(String httpUrl, String methodName, Map<String, Object> headers, Map<String, Object> queryParams, Object body) throws Exception {
-//        logger.info("###Used RestEasyDefaultHttpClient");
-//        /*
-//         * Get the request body content
-//         */
-//        String reqBodyAsString = getContentAsItIsJson(body);
-//
-//        /*
-//         * set the query parameters
-//         */
-//        if(queryParams != null){
-//            String qualifiedQueryParams = createQualifiedQueryParams(queryParams);
-//            httpUrl = httpUrl + qualifiedQueryParams;
-//        }
-//
-//        /*
-//         * set the end point with query params
-//         */
-//        clientExecutor = httpClientExecutor.createRequest(httpUrl);
-//
-//        /*
-//         * set the headers
-//         */
-//        if(headers != null){
-//            setRequestHeaders(headers, clientExecutor);
-//        }
-//
-//        /*
-//         * Setting cookies:
-//         *
-//         * Highly discouraged to use sessions, but in case of any server dependent upon session,
-//         * then it's taken care here.
-//         */
-//        if(COOKIE_JSESSIONID_VALUE != null) {
-//            clientExecutor.header("Cookie", COOKIE_JSESSIONID_VALUE);
-//        }
-//
-//        /*
-//         * set the request body
-//         */
-//        if(reqBodyAsString != null){
-//            clientExecutor.body("application/json", reqBodyAsString);
-//        }
-//
-//        // TODO: if none of the [GET POST PUT DELETE] then throw exception. Raise an issue.
-//        clientExecutor.setHttpMethod(methodName);
-//
-//        /*
-//         * now execute the request
-//         */
-//        ClientResponse serverResponsePre = clientExecutor.execute();
-//
-//        Response serverResponse = Response
-//                .status(serverResponsePre.getStatus())
-//                .entity(serverResponsePre.getEntity(String.class))
-//                .build();
-//
-//
-//        final MultivaluedMap headersMap = serverResponsePre.getHeaders();
-//        final Iterator iterator = headersMap.keySet().iterator();
-//        while(iterator.hasNext()){
-//
-//            Object key = iterator.next();
-//            serverResponse = Response.fromResponse(serverResponse).header((String)key, headersMap.get(key)).build();
-//
-//        }
-//
-//        Set headerKeySet = serverResponse.getMetadata().keySet();
-//
-//        for(Object key: headerKeySet){
-//            if("Set-Cookie".equals(key) ) {
-//                COOKIE_JSESSIONID_VALUE = serverResponse.getMetadata().get(key);
-//            }
-//        }
-//
-//        return serverResponse;
-//    }
-//
-//    private String createQualifiedQueryParams(Object queryParams) {
-//        String qualifiedQueryParam = "?";
-//        Map queryParamsMap = HelperJsonUtils.readHeadersAsMap(queryParams);
-//        for(Object key: queryParamsMap.keySet()){
-//            if("?".equals(qualifiedQueryParam)){
-//                qualifiedQueryParam = qualifiedQueryParam + format("%s=%s", (String)key, (String)queryParamsMap.get(key));
-//            }
-//            else{
-//                qualifiedQueryParam = qualifiedQueryParam + format("&%s=%s", (String)key, (String)queryParamsMap.get(key));
-//            }
-//        }
-//        return qualifiedQueryParam;
-//    }
-//
-//    private ClientRequest setRequestHeaders(Object headers, ClientRequest clientExecutor) {
-//        Map headersMap = (HashMap)headers;
-//        for(Object key: headersMap.keySet()){
-//            clientExecutor.header((String)key, headersMap.get(key));
-//        }
-//
-//        return clientExecutor;
-//    }
-//
-//}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/kafka/helper/KafkaCommonUtils.java b/core/src/main/java/org/jsmart/zerocode/core/kafka/helper/KafkaCommonUtils.java
new file mode 100644
index 00000000..35cf4620
--- /dev/null
+++ b/core/src/main/java/org/jsmart/zerocode/core/kafka/helper/KafkaCommonUtils.java
@@ -0,0 +1,20 @@
+package org.jsmart.zerocode.core.kafka.helper;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static java.lang.String.format;
+
+public class KafkaCommonUtils {
+    private static final Logger LOGGER = LoggerFactory.getLogger(KafkaConsumerHelper.class);
+
+    public static void printBrokerProperties(String kafkaServers) {
+
+        LOGGER.info("\n---------------------------------------------------------\n" +
+                format("kafka.bootstrap.servers - %s", kafkaServers) +
+                "\n---------------------------------------------------------");
+
+    }
+
+
+}
diff --git a/core/src/main/java/org/jsmart/zerocode/core/runner/StepNotificationHandler.java b/core/src/main/java/org/jsmart/zerocode/core/runner/StepNotificationHandler.java
index 12b10430..44b85323 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/runner/StepNotificationHandler.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/runner/StepNotificationHandler.java
@@ -5,7 +5,7 @@ import java.util.Comparator;
 import java.util.List;
 
 import org.apache.commons.lang.StringUtils;
-import org.jsmart.zerocode.core.engine.assertion.AssertionReport;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
 import org.junit.runner.Description;
 import org.junit.runner.notification.Failure;
 import org.junit.runner.notification.RunNotifier;
@@ -22,7 +22,7 @@ public class StepNotificationHandler {
                     Description description,
                     String scenarioName,
                     String stepName,
-                    List<AssertionReport> failureReportList) {
+                    List<FieldAssertionMatcher> failureReportList) {
         /**
          * Generate error report and display clearly which expectation(s) did not match
          */
@@ -55,7 +55,7 @@ public class StepNotificationHandler {
                     Description description,
                     String scenarioName,
                     String stepName,
-                    List<AssertionReport> failureReportList) {
+                    List<FieldAssertionMatcher> failureReportList) {
         LOGGER.info(String.format("\n***Step PASSED:%s->%s", scenarioName, stepName));
         
         return true;
@@ -77,7 +77,7 @@ public class StepNotificationHandler {
      * all private functions below
      */
     
-    private int maxEntryLengthOf(List<AssertionReport> failureReportList) {
+    private int maxEntryLengthOf(List<FieldAssertionMatcher> failureReportList) {
         final Integer maxLength = ofNullable(failureReportList).orElse(Collections.emptyList()).stream()
                         .map(report -> report.toString().length())
                         .max(Comparator.naturalOrder())
@@ -88,11 +88,11 @@ public class StepNotificationHandler {
     
     private String deckedUpLine(int stringLength) {
         final String DECKED_CHAR = "-";
-        String dottedlLine = "";
+        String dottedLine = "";
         for (int i = 0; i < stringLength; i++) {
-            dottedlLine = dottedlLine + DECKED_CHAR;
+            dottedLine = dottedLine + DECKED_CHAR;
         }
         
-        return dottedlLine;
+        return dottedLine;
     }
 }
diff --git a/core/src/main/java/org/jsmart/zerocode/core/runner/ZeroCodeMultiStepsScenarioRunnerImpl.java b/core/src/main/java/org/jsmart/zerocode/core/runner/ZeroCodeMultiStepsScenarioRunnerImpl.java
index bef80d3f..a43f69f9 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/runner/ZeroCodeMultiStepsScenarioRunnerImpl.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/runner/ZeroCodeMultiStepsScenarioRunnerImpl.java
@@ -14,9 +14,9 @@ import org.jsmart.zerocode.core.domain.ScenarioSpec;
 import org.jsmart.zerocode.core.domain.Step;
 import org.jsmart.zerocode.core.domain.builders.ZeroCodeExecResultBuilder;
 import org.jsmart.zerocode.core.domain.builders.ZeroCodeExecResultIoWriteBuilder;
-import org.jsmart.zerocode.core.engine.assertion.AssertionReport;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
 import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
-import org.jsmart.zerocode.core.engine.executor.JsonServiceExecutor;
+import org.jsmart.zerocode.core.engine.executor.ApiServiceExecutor;
 import org.jsmart.zerocode.core.engine.preprocessor.ScenarioExecutionState;
 import org.jsmart.zerocode.core.engine.preprocessor.StepExecutionState;
 import org.jsmart.zerocode.core.engine.preprocessor.ZeroCodeExternalFileProcessor;
@@ -54,7 +54,7 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
     private ZeroCodeParameterizedProcessor parameterizedProcessor;
 
     @Inject
-    private JsonServiceExecutor serviceExecutor;
+    private ApiServiceExecutor serviceExecutor;
 
     @Inject
     private CsvParser csvParser;
@@ -83,7 +83,7 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
 
     private ZeroCodeExecResultIoWriteBuilder reportBuilder;
 
-    private ZeroCodeExecResultBuilder execResultBuilder;
+    private ZeroCodeExecResultBuilder reportResultBuilder;
 
     private Boolean stepOutcomeGreen;
 
@@ -106,7 +106,7 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
         for (int scnCount = 0; scnCount < scenarioLoopTimes; scnCount++) {
 
             LOGGER.info("\n-------------------------------------------------------------------------" +
-                    "\n     Executing Scenario Count No. or parameter No. or Row No. | {} | {}", scnCount,
+                            "\n     Executing Scenario Count No. or parameter No. or Row No. | {} | {}", scnCount,
                     "\n-------------------------------------------------------------------------");
 
             ScenarioSpec parameterizedScenario = parameterizedProcessor.processParameterized(scenario, scnCount);
@@ -114,7 +114,7 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
             // ---------------------------------
             // Build Report scenario for each k
             // ---------------------------------
-            execResultBuilder = newInstance()
+            reportResultBuilder = newInstance()
                     .loop(scnCount)
                     .scenarioName(parameterizedScenario.getScenarioName());
 
@@ -191,7 +191,7 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
                                             .id(stepId)
                                             .request(prettyPrintJson(resolvedRequestJson));
 
-                                    executionResult = serviceExecutor.executeRESTService(serviceName, operationName, resolvedRequestJson);
+                                    executionResult = serviceExecutor.executeHttpApi(serviceName, operationName, resolvedRequestJson);
                                     break;
 
                                 case JAVA_CALL:
@@ -205,7 +205,7 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
                                             .method(operationName)
                                             .request(prettyPrintJson(resolvedRequestJson));
 
-                                    executionResult = serviceExecutor.executeJavaService(serviceName, operationName, resolvedRequestJson);
+                                    executionResult = serviceExecutor.executeJavaOperation(serviceName, operationName, resolvedRequestJson);
                                     break;
 
                                 case KAFKA_CALL:
@@ -268,7 +268,7 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
                             // logging assertion
                             // -----------------
                             List<JsonAsserter> asserters = zeroCodeJsonTestProcesor.createJsonAsserters(resolvedAssertionJson);
-                            List<AssertionReport> failureResults = zeroCodeJsonTestProcesor.assertAllAndReturnFailed(asserters, executionResult);
+                            List<FieldAssertionMatcher> failureResults = zeroCodeJsonTestProcesor.assertAllAndReturnFailed(asserters, executionResult);
 
                             if (!failureResults.isEmpty()) {
                                 StringBuilder builder = new StringBuilder();
@@ -400,13 +400,13 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
                              * Build step report for each step
                              * Add the report step to the result step list.
                              */
-                            execResultBuilder.step(logCorrelationshipPrinter.buildReportSingleStep());
+                            reportResultBuilder.step(logCorrelationshipPrinter.buildReportSingleStep());
 
                             /*
                              * FAILED and Exception reports are generated here
                              */
                             if (!stepOutcomeGreen) {
-                                reportBuilder.result(execResultBuilder.build());
+                                reportBuilder.result(reportResultBuilder.build());
                                 reportBuilder.printToFile(scenario.getScenarioName() + logCorrelationshipPrinter.getCorrelationId() + ".json");
                             }
                         }
@@ -416,7 +416,7 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
 
             } //<--- steps for-each
 
-            reportBuilder.result(execResultBuilder.build());
+            reportBuilder.result(reportResultBuilder.build());
 
         } //<-- Scenario Loop
 
@@ -468,30 +468,6 @@ public class ZeroCodeMultiStepsScenarioRunnerImpl implements ZeroCodeMultiStepsS
         this.applicationContext = applicationContext;
     }
 
-    private String getFullyQualifiedRestUrl(String serviceEndPoint) {
-
-        if (host == null || port == null) {
-            throw new RuntimeException("'" + PROPERTY_KEY_HOST + "' or 'port' - can not be null");
-        }
-
-        if (applicationContext == null) {
-            throw new RuntimeException("'" + PROPERTY_KEY_PORT + "' key must be present even if empty or blank");
-        }
-
-        if (serviceEndPoint.startsWith("http://") || serviceEndPoint.startsWith("https://")) {
-
-            return serviceEndPoint;
-
-        } else {
-            /*
-             * Make sure your property file contains context-path with a front slash like "/google-map".
-             * -OR-
-             * Empty context path is also ok if it requires. In this case do not put a front slash.
-             */
-            return String.format("%s:%s%s%s", host, port, applicationContext, serviceEndPoint);
-        }
-    }
-
     private void stopWireMockServer() {
         if (null != wireMockServer) {
             wireMockServer.stop();


Test patch:
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/listener/ZeroCodeTestReportListener.java b/core/src/main/java/org/jsmart/zerocode/core/engine/listener/ZeroCodeTestReportListener.java
index ad2d5900..3c9f432a 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/listener/ZeroCodeTestReportListener.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/listener/ZeroCodeTestReportListener.java
@@ -9,9 +9,6 @@ import org.junit.runner.notification.RunListener;
 
 import static org.slf4j.LoggerFactory.getLogger;
 
-/**
- * @author Siddha on 24-jul-2016
- */
 public class ZeroCodeTestReportListener extends RunListener {
     private static final org.slf4j.Logger LOGGER = getLogger(ZeroCodeTestReportListener.class);
 
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesor.java b/core/src/main/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesor.java
index 6da90a2c..b6a7bdd1 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesor.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesor.java
@@ -1,6 +1,6 @@
 package org.jsmart.zerocode.core.engine.preprocessor;
 
-import org.jsmart.zerocode.core.engine.assertion.AssertionReport;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
 import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
 
 import java.util.List;
@@ -17,5 +17,5 @@ public interface ZeroCodeJsonTestProcesor {
 
     List<JsonAsserter> createJsonAsserters(String resolvedAssertionJson);
 
-    List<AssertionReport> assertAllAndReturnFailed(List<JsonAsserter> asserters, String executionResult);
+    List<FieldAssertionMatcher> assertAllAndReturnFailed(List<JsonAsserter> asserters, String executionResult);
 }
diff --git a/core/src/main/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesorImpl.java b/core/src/main/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesorImpl.java
index 2e5f78c3..f6dd6592 100644
--- a/core/src/main/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesorImpl.java
+++ b/core/src/main/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesorImpl.java
@@ -19,23 +19,23 @@ import java.util.Map;
 import java.util.Properties;
 import net.minidev.json.JSONArray;
 import org.apache.commons.lang.text.StrSubstitutor;
-import org.jsmart.zerocode.core.engine.assertion.ArrayIsEmptyAsserter;
-import org.jsmart.zerocode.core.engine.assertion.ArraySizeAsserter;
-import org.jsmart.zerocode.core.engine.assertion.AssertionReport;
-import org.jsmart.zerocode.core.engine.assertion.FieldHasDateAfterValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldHasDateBeforeValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldHasEqualNumberValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldHasExactValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldHasGreaterThanValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldHasInEqualNumberValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldHasLesserThanValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldHasSubStringIgnoreCaseValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldHasSubStringValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldIsNotNullAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldIsNullAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldIsOneOfValueAsserter;
-import org.jsmart.zerocode.core.engine.assertion.FieldMatchesRegexPatternAsserter;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
 import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
+import org.jsmart.zerocode.core.engine.assertion.array.ArrayIsEmptyAsserter;
+import org.jsmart.zerocode.core.engine.assertion.array.ArraySizeAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldContainsStringAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldHasDateAfterValueAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldHasDateBeforeValueAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldHasEqualNumberValueAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldHasExactValueAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldHasGreaterThanValueAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldHasInEqualNumberValueAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldHasLesserThanValueAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldHasSubStringIgnoreCaseValueAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldIsNotNullAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldIsNullAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldIsOneOfValueAsserter;
+import org.jsmart.zerocode.core.engine.assertion.field.FieldMatchesRegexPatternAsserter;
 
 import static java.lang.String.format;
 import static org.apache.commons.lang.StringEscapeUtils.escapeJava;
@@ -200,7 +200,7 @@ public class ZeroCodeJsonTestProcesorImpl implements ZeroCodeJsonTestProcesor {
                     }
                 } else if (value instanceof String && ((String) value).startsWith(ASSERT_VALUE_CONTAINS_STRING)) {
                     String expected = ((String) value).substring(ASSERT_VALUE_CONTAINS_STRING.length());
-                    asserter = new FieldHasSubStringValueAsserter(path, expected);
+                    asserter = new FieldContainsStringAsserter(path, expected);
                 } else if (value instanceof String && ((String) value).startsWith(ASSERT_VALUE_MATCHES_STRING)) {
                     String expected = ((String) value).substring(ASSERT_VALUE_MATCHES_STRING.length());
                     asserter = new FieldMatchesRegexPatternAsserter(path, expected);
@@ -334,17 +334,17 @@ public class ZeroCodeJsonTestProcesorImpl implements ZeroCodeJsonTestProcesor {
     }
 
     @Override
-    public List<AssertionReport> assertAllAndReturnFailed(List<JsonAsserter> asserters, String executionResult) {
+    public List<FieldAssertionMatcher> assertAllAndReturnFailed(List<JsonAsserter> asserters, String executionResult) {
 
-        List<AssertionReport> failedReports = new ArrayList<>();
+        List<FieldAssertionMatcher> failedReports = new ArrayList<>();
 
         asserters.forEach(asserter -> {
 
-            final AssertionReport assertionReport = asserter.assertWithJson(executionResult);
+            final FieldAssertionMatcher fieldMatcher = asserter.assertWithJson(executionResult);
 
-            if (!assertionReport.matches()) {
+            if (!fieldMatcher.matches()) {
 
-                failedReports.add(assertionReport);
+                failedReports.add(fieldMatcher);
 
             }
         });
diff --git a/core/src/test/java/org/jsmart/zerocode/converter/ConverterEndToEndTest.java b/core/src/test/java/org/jsmart/zerocode/converter/ConverterEndToEndTest.java
index ec262f5e..d4ef8067 100644
--- a/core/src/test/java/org/jsmart/zerocode/converter/ConverterEndToEndTest.java
+++ b/core/src/test/java/org/jsmart/zerocode/converter/ConverterEndToEndTest.java
@@ -10,7 +10,7 @@ import org.junit.runner.RunWith;
 public class ConverterEndToEndTest {
     
     /**
-     * Mock end points are in test/resources: simulators/test_purpose_end_points.json
+     * Mocked/Stubbed end points are in test/resources: simulators/test_purpose_end_points.json
      */
 
     @Test
diff --git a/core/src/test/java/org/jsmart/zerocode/core/engine/assertion/FieldAssertionMatcherTest.java b/core/src/test/java/org/jsmart/zerocode/core/engine/assertion/FieldAssertionMatcherTest.java
new file mode 100644
index 00000000..21c841a5
--- /dev/null
+++ b/core/src/test/java/org/jsmart/zerocode/core/engine/assertion/FieldAssertionMatcherTest.java
@@ -0,0 +1,35 @@
+package org.jsmart.zerocode.core.engine.assertion;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class FieldAssertionMatcherTest {
+
+    FieldAssertionMatcher fieldAssertionMatcher;
+
+    @Before
+    public void setUp() throws Exception {
+
+        fieldAssertionMatcher = new FieldAssertionMatcher(null);
+    }
+
+    @Test
+    public void willCreateMatchingMessage() throws Exception {
+
+        assertThat(fieldAssertionMatcher.matches(), is(true));
+        assertThat(fieldAssertionMatcher.toString(), is("Actual field value matched the expected field value"));
+    }
+
+    @Test
+    public void willCreateUnMatchingMessage() throws Exception {
+
+        fieldAssertionMatcher = new FieldAssertionMatcher("$.a.path", "VJ", "VJ2");
+
+        assertThat(fieldAssertionMatcher.matches(), is(false));
+        assertThat(fieldAssertionMatcher.toString(), is("Assertion jsonPath '$.a.path' with actual value 'VJ2' did not match the expected value 'VJ'"));
+    }
+
+}
\ No newline at end of file
diff --git a/core/src/test/java/org/jsmart/zerocode/core/engine/executor/JsonServiceExecutorImplTest.java b/core/src/test/java/org/jsmart/zerocode/core/engine/executor/httpapi/ApiServiceExecutorImplTest.java
similarity index 91%
rename from core/src/test/java/org/jsmart/zerocode/core/engine/executor/JsonServiceExecutorImplTest.java
rename to core/src/test/java/org/jsmart/zerocode/core/engine/executor/httpapi/ApiServiceExecutorImplTest.java
index eedcf235..e9b98dfe 100644
--- a/core/src/test/java/org/jsmart/zerocode/core/engine/executor/JsonServiceExecutorImplTest.java
+++ b/core/src/test/java/org/jsmart/zerocode/core/engine/executor/httpapi/ApiServiceExecutorImplTest.java
@@ -1,12 +1,12 @@
-package org.jsmart.zerocode.core.engine.executor;
+package org.jsmart.zerocode.core.engine.executor.httpapi;
 
 import com.google.inject.Guice;
 import com.google.inject.Injector;
 import com.jayway.jsonpath.JsonPath;
-
 import org.jsmart.simulator.main.SimpleRestJsonSimulatorsMain;
 import org.jsmart.zerocode.core.di.main.ApplicationMainModule;
 import org.jsmart.zerocode.core.domain.ScenarioSpec;
+import org.jsmart.zerocode.core.engine.executor.ApiServiceExecutorImpl;
 import org.jsmart.zerocode.core.utils.SmartUtils;
 import org.junit.After;
 import org.junit.Before;
@@ -18,12 +18,12 @@ import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.junit.Assert.assertThat;
 
-public class JsonServiceExecutorImplTest {
+public class ApiServiceExecutorImplTest {
 
     public static final int PORT = 9999;
     public static final String HOST_WITH_CONTEXT = "http://localhost:" + PORT;
 
-    JsonServiceExecutorImpl jsonServiceExecutor;
+    ApiServiceExecutorImpl jsonServiceExecutor;
     Injector injector;
     SmartUtils smartUtils;
     SimpleRestJsonSimulatorsMain simulator ;
@@ -38,7 +38,7 @@ public class JsonServiceExecutorImplTest {
 
         injector = Guice.createInjector(new ApplicationMainModule("config_hosts_test.properties"));
         smartUtils = injector.getInstance(SmartUtils.class);
-        jsonServiceExecutor = injector.getInstance(JsonServiceExecutorImpl.class);
+        jsonServiceExecutor = injector.getInstance(ApiServiceExecutorImpl.class);
     }
 
     @After
@@ -67,7 +67,7 @@ public class JsonServiceExecutorImplTest {
         /*
          * End-point available: http://localhost:9998/home/bathroom/1
          */
-        String responseString = jsonServiceExecutor.executeRESTService(HOST_WITH_CONTEXT + "/home/bathroom/1", "GET", "{}");
+        String responseString = jsonServiceExecutor.executeHttpApi(HOST_WITH_CONTEXT + "/home/bathroom/1", "GET", "{}");
         assertThat(responseString, containsString("Shower"));
         JSONAssert.assertEquals("{\n" +
                 "  \"status\": 200,\n" +
@@ -91,7 +91,7 @@ public class JsonServiceExecutorImplTest {
         String methodName = scenarioSpec.getSteps().get(0).getOperation();
         String requestJson = scenarioSpec.getSteps().get(0).getRequest().toString();
 
-        final String responseString = jsonServiceExecutor.executeRESTService(HOST_WITH_CONTEXT + serviceName, methodName, requestJson);
+        final String responseString = jsonServiceExecutor.executeHttpApi(HOST_WITH_CONTEXT + serviceName, methodName, requestJson);
         assertThat(responseString, containsString("Shower"));
         JSONAssert.assertEquals("{\n" +
                 "    \"status\": 200,\n" +
@@ -129,7 +129,7 @@ public class JsonServiceExecutorImplTest {
         String methodName = scenarioSpec.getSteps().get(0).getOperation();
         String requestJson = scenarioSpec.getSteps().get(0).getRequest().toString();
 
-        final String responseString = jsonServiceExecutor.executeRESTService(HOST_WITH_CONTEXT + serviceName, methodName, requestJson);
+        final String responseString = jsonServiceExecutor.executeHttpApi(HOST_WITH_CONTEXT + serviceName, methodName, requestJson);
         assertThat(responseString, containsString("201"));
     }
     
@@ -143,7 +143,7 @@ public class JsonServiceExecutorImplTest {
         String requestJson = scenarioSpec.getSteps().get(0).getRequest().toString();
         String assertions = scenarioSpec.getSteps().get(0).getAssertions().toString();
         
-        final String responseString = jsonServiceExecutor.executeRESTService(HOST_WITH_CONTEXT + serviceName, methodName, requestJson);
+        final String responseString = jsonServiceExecutor.executeHttpApi(HOST_WITH_CONTEXT + serviceName, methodName, requestJson);
         assertThat(responseString, containsString("\"valid-text-node-json\"")); //<-- Mark: This is a JSON node, so held by double quotes.
         
         assertThat(assertions, is("{\"status\":201,\"body\":\"valid-text-node-json\"}"));
@@ -159,7 +159,7 @@ public class JsonServiceExecutorImplTest {
         String requestJson = scenarioSpec.getSteps().get(0).getRequest().toString();
         String assertions = scenarioSpec.getSteps().get(0).getAssertions().toString();
     
-        final String responseString = jsonServiceExecutor.executeRESTService(HOST_WITH_CONTEXT + serviceName, methodName, requestJson);
+        final String responseString = jsonServiceExecutor.executeHttpApi(HOST_WITH_CONTEXT + serviceName, methodName, requestJson);
         assertThat(responseString, containsString("non-json")); //<-- Mark: This is a non-JSON content which is simple String, hence not held by double quotes.
     
         assertThat(assertions, is("{\"status\":201,\"rawBody\":\"non-jsonX\"}"));
diff --git a/core/src/test/java/org/jsmart/zerocode/core/engine/executor/JavaExecutorImplTest.java b/core/src/test/java/org/jsmart/zerocode/core/engine/executor/javaapi/JavaMethodExecutorImplTest.java
similarity index 55%
rename from core/src/test/java/org/jsmart/zerocode/core/engine/executor/JavaExecutorImplTest.java
rename to core/src/test/java/org/jsmart/zerocode/core/engine/executor/javaapi/JavaMethodExecutorImplTest.java
index 304ca298..6fb9ed2e 100644
--- a/core/src/test/java/org/jsmart/zerocode/core/engine/executor/JavaExecutorImplTest.java
+++ b/core/src/test/java/org/jsmart/zerocode/core/engine/executor/javaapi/JavaMethodExecutorImplTest.java
@@ -1,52 +1,80 @@
-package org.jsmart.zerocode.core.engine.executor;
+package org.jsmart.zerocode.core.engine.executor.javaapi;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.inject.Guice;
 import com.google.inject.Injector;
+import java.lang.reflect.Method;
+import java.util.List;
 import org.jsmart.zerocode.core.di.main.ApplicationMainModule;
+import org.jsmart.zerocode.core.di.provider.ObjectMapperProvider;
 import org.jsmart.zerocode.core.domain.ScenarioSpec;
 import org.jsmart.zerocode.core.utils.SmartUtils;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
-
-import java.util.List;
+import org.junit.rules.ExpectedException;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 
-public class JavaExecutorImplTest {
+public class JavaMethodExecutorImplTest {
 
-    JavaExecutor defaultJavaExecutor;
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    JavaMethodExecutorImpl methodExecutor;
     Injector injector;
     SmartUtils smartUtils;
     ObjectMapper mapper;
 
     @Before
-    public void name() throws Exception {
+    public void setUp() throws Exception {
         injector = Guice.createInjector(new ApplicationMainModule("config_hosts_test.properties"));
-        defaultJavaExecutor = new JavaExecutorImpl(injector);
+        mapper = new ObjectMapperProvider().get();
+
+        methodExecutor = new JavaMethodExecutorImpl(injector, mapper);
         smartUtils = injector.getInstance(SmartUtils.class);
-        mapper = smartUtils.getMapper();
+    }
+
+    @Test
+    public void willFind_matchingMethod() throws Exception {
+        String serviceName = "org.jsmart.zerocode.core.AddService";
+        String methodName = "squareMyNumber";
+
+        Method matchingMethod = methodExecutor.findMatchingMethod(serviceName, methodName);
+
+        assertThat(matchingMethod.getDeclaringClass().getName(), is("org.jsmart.zerocode.core.AddService"));
+        assertThat(matchingMethod.getName(), is("squareMyNumber"));
     }
 
     @Test
     public void willExecuteA_Java_Method() throws Exception {
 
-        final Object result = defaultJavaExecutor.execute("org.jsmart.zerocode.core.AddService", "add", 1, 2);
+        final Object result = methodExecutor.executeWithParams("org.jsmart.zerocode.core.AddService", "add", 1, 2);
         assertThat(result, is(3));
     }
 
     @Test
-    public void willExecuteJsonRequestFor_java_method_basics() throws Exception {
+    public void test_noMatchingMethod_exception() throws Exception {
+        String serviceName = "org.jsmart.zerocode.core.AddService";
+        String methodName = "invalidMethod";
+
+        expectedException.expect(RuntimeException.class);
+        expectedException.expectMessage("Java exec(): No matching method invalidMethod found in class org.jsmart.zerocode.core.AddService");
+        List<Class<?>> argumentTypes = methodExecutor.getParameterTypes(serviceName, methodName);
+    }
+
+    @Test
+    public void willExecuteJsonRequestFor_javaMethod_viaReflection() throws Exception {
         String requestJson = "30";
 
         String serviceName = "org.jsmart.zerocode.core.AddService";
         String methodName = "square";
 
-        List<Class<?>> argumentTypes = defaultJavaExecutor.argumentTypes(serviceName, methodName);
+        List<Class<?>> argumentTypes = methodExecutor.getParameterTypes(serviceName, methodName);
 
         Object request = mapper.readValue(requestJson, argumentTypes.get(0));
-        Object result = defaultJavaExecutor.execute(serviceName, methodName, request);
+        Object result = methodExecutor.executeWithParams(serviceName, methodName, request);
 
         assertThat(result, is(900));
     }
@@ -59,23 +87,23 @@ public class JavaExecutorImplTest {
         String serviceName = scenarioSpec.getSteps().get(0).getUrl();
         String methodName = scenarioSpec.getSteps().get(0).getOperation();
 
-        Object result = defaultJavaExecutor.execute(serviceName, methodName, null);
+        Object result = methodExecutor.executeWithParams(serviceName, methodName, null);
 
         assertThat(result, is(30));
     }
 
     @Test
-    public void willExecuteJsonRequestFor_java_method() throws Exception {
+    public void willExecuteJsonRequestFor_java_method_viaDsl() throws Exception {
         String scenariosJsonAsString = SmartUtils.readJsonAsString("05_test_java_service/01_test_json_java_service_method_Integer.json");
         final ScenarioSpec scenarioSpec = smartUtils.getMapper().readValue(scenariosJsonAsString, ScenarioSpec.class);
 
         String serviceName = scenarioSpec.getSteps().get(0).getUrl();
         String methodName = scenarioSpec.getSteps().get(0).getOperation();
         String requestJson = scenarioSpec.getSteps().get(0).getRequest().toString();
-        List<Class<?>> argumentTypes = defaultJavaExecutor.argumentTypes(serviceName, methodName);
+        List<Class<?>> argumentTypes = methodExecutor.getParameterTypes(serviceName, methodName);
 
         Object request = mapper.readValue(requestJson, argumentTypes.get(0));
-        Object result = defaultJavaExecutor.execute(serviceName, methodName, request);
+        Object result = methodExecutor.executeWithParams(serviceName, methodName, request);
 
         assertThat(result, is(65025));
     }
@@ -88,16 +116,16 @@ public class JavaExecutorImplTest {
         String serviceName = scenarioSpec.getSteps().get(0).getUrl();
         String methodName = scenarioSpec.getSteps().get(0).getOperation();
         String requestJson = scenarioSpec.getSteps().get(0).getRequest().toString();
-        List<Class<?>> argumentTypes = defaultJavaExecutor.argumentTypes(serviceName, methodName);
+        List<Class<?>> argumentTypes = methodExecutor.getParameterTypes(serviceName, methodName);
 
         Object request = mapper.readValue(requestJson, argumentTypes.get(0));
-        Object result = defaultJavaExecutor.execute(serviceName, methodName, request);
+        Object result = methodExecutor.executeWithParams(serviceName, methodName, request);
 
         assertThat(result, is(900));
     }
 
     @Test
-    public void willExecuteJsonRequestFor_CustomObject_back_to_basics() throws Exception {
+    public void willExecuteJsonWithParams_CustomObject_viaJson() throws Exception {
         String requestJson = "{\n" +
                 "          \"number\": 30\n" +
                 "        }";
@@ -105,10 +133,11 @@ public class JavaExecutorImplTest {
         String serviceName = "org.jsmart.zerocode.core.AddService";
         String methodName = "squareMyNumber";
 
-        List<Class<?>> argumentTypes = defaultJavaExecutor.argumentTypes(serviceName, methodName);
+        List<Class<?>> argumentTypes = methodExecutor.getParameterTypes(serviceName, methodName);
 
         Object request = mapper.readValue(requestJson, argumentTypes.get(0));
-        Object result = defaultJavaExecutor.execute(serviceName, methodName, request);
+        Object result = methodExecutor.executeWithParams(serviceName, methodName, request);
         assertThat(result, is(900));
     }
+
 }
\ No newline at end of file
diff --git a/core/src/test/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesorImplTest.java b/core/src/test/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesorImplTest.java
index 3aa308d7..7fd76e76 100644
--- a/core/src/test/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesorImplTest.java
+++ b/core/src/test/java/org/jsmart/zerocode/core/engine/preprocessor/ZeroCodeJsonTestProcesorImplTest.java
@@ -8,9 +8,9 @@ import org.jsmart.simulator.main.SimpleRestJsonSimulatorsMain;
 import org.jsmart.zerocode.core.di.main.ApplicationMainModule;
 import org.jsmart.zerocode.core.di.provider.ObjectMapperProvider;
 import org.jsmart.zerocode.core.domain.ScenarioSpec;
-import org.jsmart.zerocode.core.engine.assertion.AssertionReport;
+import org.jsmart.zerocode.core.engine.assertion.FieldAssertionMatcher;
 import org.jsmart.zerocode.core.engine.assertion.JsonAsserter;
-import org.jsmart.zerocode.core.engine.executor.JsonServiceExecutorImpl;
+import org.jsmart.zerocode.core.engine.executor.ApiServiceExecutorImpl;
 import org.jsmart.zerocode.core.utils.SmartUtils;
 import org.junit.Before;
 import org.junit.Test;
@@ -24,7 +24,7 @@ import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertThat;
 
 public class ZeroCodeJsonTestProcesorImplTest {
-    JsonServiceExecutorImpl jsonServiceExecutor;
+    ApiServiceExecutorImpl jsonServiceExecutor;
     Injector injector;
     SmartUtils smartUtils;
     SimpleRestJsonSimulatorsMain simulator ;
@@ -164,7 +164,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
         List<JsonAsserter> asserters = jsonPreProcessor.createJsonAsserters(resolvedAssertions);
         assertThat(asserters.size(), is(17));
 
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, sapmleExecutionResult);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, sapmleExecutionResult);
 
         System.out.println("###failedReports : " + failedReports);
         assertThat(failedReports.toString(), containsString("did not match the expected value 'NOT NULL'"));
@@ -212,7 +212,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
         assertThat(asserters.size(), is(1));
 
         String sampleExecutionResult = "\"id-generated-0101-XY\"";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, sampleExecutionResult);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, sampleExecutionResult);
 
         System.out.println("###failedReports : " + failedReports);
         assertThat(failedReports.toString(), containsString("'$' with actual value 'id-generated-0101-XY' did not match the expected value 'id-generated-0101'"));
@@ -247,7 +247,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
         assertThat(asserters.size(), is(1));
 
         Integer sampleExecutionResult = 1077;
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, sampleExecutionResult.toString());
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, sampleExecutionResult.toString());
 
         System.out.println("###failedReports : " + failedReports);
         assertThat(failedReports.toString(), containsString("'$' with actual value '1077' did not match the expected value '1099'"));
@@ -324,7 +324,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "    \"name\": \"Hello CreXasy\"\n" +
                 "  }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
         assertThat(failedReports.toString(), containsString("did not match the expected value 'containing sub-string with ignoring case:"));
@@ -349,7 +349,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "    \"name\": \"Hello Creasy\"\n" +
                 "  }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -375,7 +375,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "    \"dob\": \"2018-06-26\"\n" +
                 "  }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -408,7 +408,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -438,7 +438,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
     }
@@ -471,7 +471,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -504,11 +504,11 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
         assertThat(failedReports.get(0).toString(),
-                is("Assertion path '$.body.persons' with actual value '2' did not match the expected value 'Array of size $GT.5'"));
+                is("Assertion jsonPath '$.body.persons' with actual value '2' did not match the expected value 'Array of size $GT.5'"));
     }
 
     @Test
@@ -539,7 +539,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -572,11 +572,11 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
         assertThat(failedReports.get(0).toString(),
-                is("Assertion path '$.body.persons' with actual value '2' did not match the expected value 'Array of size $LT.1'"));
+                is("Assertion jsonPath '$.body.persons' with actual value '2' did not match the expected value 'Array of size $LT.1'"));
     }
 
     @Test
@@ -607,7 +607,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -640,11 +640,11 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
         assertThat(failedReports.get(0).toString(),
-                is("Assertion path '$.body.persons' with actual value '2' did not match the expected value 'Array of size $EQ.3'"));
+                is("Assertion jsonPath '$.body.persons' with actual value '2' did not match the expected value 'Array of size $EQ.3'"));
     }
 
     @Test
@@ -675,7 +675,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -708,11 +708,11 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        ]\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
         assertThat(failedReports.get(0).toString(),
-                is("Assertion path '$.body.persons' with actual value '2' did not match the expected value 'Array of size $NOT.EQ.2'"));
+                is("Assertion jsonPath '$.body.persons' with actual value '2' did not match the expected value 'Array of size $NOT.EQ.2'"));
     }
     
     @Test
@@ -742,7 +742,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "}";
     
         
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
         assertThat(failedReports.size(), is(0));
     }
     
@@ -773,14 +773,14 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "}";
     
         
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(2));
         assertThat(failedReports.get(0).toString(),
-                is("Assertion path '$.body.projectDetails.startDateTime' with actual value '2017-04-14T11:49:56.000Z' "
+                is("Assertion jsonPath '$.body.projectDetails.startDateTime' with actual value '2017-04-14T11:49:56.000Z' "
                 		+ "did not match the expected value 'Date Before:2016-09-14T09:49:34'"));
         assertThat(failedReports.get(1).toString(),
-                is("Assertion path '$.body.projectDetails.endDateTime' with actual value '2018-11-12T09:39:34.000Z' "
+                is("Assertion jsonPath '$.body.projectDetails.endDateTime' with actual value '2018-11-12T09:39:34.000Z' "
                 		+ "did not match the expected value 'Date After:2019-09-14T09:49:34'"));
     }
     
@@ -809,11 +809,11 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "}";
     
         
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
         assertThat(failedReports.get(0).toString(),
-                is("Assertion path '$.body.projectDetails.startDateTime' with actual value '2015-09-14T09:49:34.000Z' "
+                is("Assertion jsonPath '$.body.projectDetails.startDateTime' with actual value '2015-09-14T09:49:34.000Z' "
                 		+ "did not match the expected value 'Date After:2015-09-14T09:49:34'"));
     }
     
@@ -842,11 +842,11 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "}";
     
         
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
         assertThat(failedReports.get(0).toString(),
-                is("Assertion path '$.body.projectDetails.startDateTime' with actual value '2015-09-14T09:49:34.000Z' "
+                is("Assertion jsonPath '$.body.projectDetails.startDateTime' with actual value '2015-09-14T09:49:34.000Z' "
                 		+ "did not match the expected value 'Date Before:2015-09-14T09:49:34'"));
     }
     
@@ -872,7 +872,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        \"currentStatus\": \"Searching\"\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -899,7 +899,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        \"currentStatus\": \"Quit\"\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
     }
@@ -925,7 +925,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "    \"body\": {\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
     }
@@ -952,7 +952,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        \"currentStatus\": \"\"\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -979,7 +979,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        \"currentStatus\": \" \"\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(0));
     }
@@ -1006,7 +1006,7 @@ public class ZeroCodeJsonTestProcesorImplTest {
                 "        \"currentStatus\": \"Searching\"\n" +
                 "    }\n" +
                 "}";
-        List<AssertionReport> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
+        List<FieldAssertionMatcher> failedReports = jsonPreProcessor.assertAllAndReturnFailed(asserters, mockTestResponse);
 
         assertThat(failedReports.size(), is(1));
     }
diff --git a/core/src/test/java/org/jsmart/zerocode/core/runner/ZeroCodeMultiStepsScenarioRunner_FailedAssertionsTest.java b/core/src/test/java/org/jsmart/zerocode/core/runner/ZeroCodeMultiStepsScenarioRunner_FailedAssertionsTest.java
index fdfd59c1..e0d7a943 100644
--- a/core/src/test/java/org/jsmart/zerocode/core/runner/ZeroCodeMultiStepsScenarioRunner_FailedAssertionsTest.java
+++ b/core/src/test/java/org/jsmart/zerocode/core/runner/ZeroCodeMultiStepsScenarioRunner_FailedAssertionsTest.java
@@ -60,7 +60,7 @@ public class ZeroCodeMultiStepsScenarioRunner_FailedAssertionsTest {
             assertThat(rawJsonReport.getResults().get(0).getSteps().get(0).getResult(), is("FAILED"));
             assertThat(rawJsonReport.getResults().get(0).getSteps().get(0).getAssertions(), containsString("Assumed Payload"));
             assertThat(rawJsonReport.getResults().get(0).getSteps().get(0).getAssertions(), containsString("Assertion Errors"));
-            assertThat(rawJsonReport.getResults().get(0).getSteps().get(0).getAssertions(), containsString("Assertion path"));
+            assertThat(rawJsonReport.getResults().get(0).getSteps().get(0).getAssertions(), containsString("Assertion jsonPath"));
 
             assertThat(rawJsonReport.getResults().get(0).getSteps().get(1).getName(), is("PassedStep"));
             assertThat(rawJsonReport.getResults().get(0).getSteps().get(1).getResult(), is("PASSED"));
diff --git a/junit5-testing/src/main/java/org/jsmart/zerocode/jupiter/listener/ZeroCodeTestReportJupiterListener.java b/junit5-testing/src/main/java/org/jsmart/zerocode/jupiter/listener/ZeroCodeTestReportJupiterListener.java
index f65db4e6..46d9881a 100644
--- a/junit5-testing/src/main/java/org/jsmart/zerocode/jupiter/listener/ZeroCodeTestReportJupiterListener.java
+++ b/junit5-testing/src/main/java/org/jsmart/zerocode/jupiter/listener/ZeroCodeTestReportJupiterListener.java
@@ -27,7 +27,6 @@ import static org.slf4j.LoggerFactory.getLogger;
  * Later the logs are written to the target folder as raw JSON files ready for rendering
  * CSV-reports and Html-Chart/Dashboards
  *
- * @author Nirmal Chandra on 25-apr-2019
  */
 public class ZeroCodeTestReportJupiterListener implements TestExecutionListener {
     private static final Logger LOGGER = getLogger(ZeroCodeTestReportJupiterListener.class);