Best JSONassert code snippet using org.skyscreamer.jsonassert.JSONCompareResult.JSONCompareResult
Source:FuzzyComparator.java  
2import org.json.JSONArray;3import org.json.JSONException;4import org.json.JSONObject;5import org.skyscreamer.jsonassert.JSONCompareMode;6import org.skyscreamer.jsonassert.JSONCompareResult;7import org.skyscreamer.jsonassert.comparator.AbstractComparator;8import org.skyscreamer.jsonassert.comparator.JSONCompareUtil;9import java.util.HashSet;10import java.util.Map;11import java.util.Set;12import java.util.regex.Matcher;13import java.util.regex.Pattern;14import static org.skyscreamer.jsonassert.comparator.JSONCompareUtil.*;15import static org.skyscreamer.jsonassert.comparator.JSONCompareUtil.formatUniqueKey;16public class FuzzyComparator extends AbstractComparator {17    JSONCompareMode mode;18    protected Pattern replaceParamPattern = Pattern.compile("\\$\\{(.*)\\}");19    public FuzzyComparator(JSONCompareMode mode) {20        this.mode = mode;21    }22    @Override23    public void compareJSON(String prefix, JSONObject expected, JSONObject actual, JSONCompareResult result)24            throws JSONException {25        checkJsonObjectKeysExpectedInActual(prefix, expected, actual, result);26        if (!mode.isExtensible()) {27            checkJsonObjectKeysActualInExpected(prefix, expected, actual, result);28        }29    }30    protected void checkJsonObjectKeysExpectedInActual(String prefix, JSONObject expected, JSONObject actual,31                                                       JSONCompareResult result) throws JSONException {32        Set<String> expectedKeys = getKeys(expected);33        for (String key : expectedKeys) {34            Object expectedValue = expected.get(key);35            if (actual.has(key)) {36                Object actualValue = actual.get(key);37                compareValues(qualify(prefix, key), expectedValue, actualValue, result);38            } else {39                result.missing(prefix, key);40            }41        }42    }43    protected void checkJsonObjectKeysActualInExpected(String prefix, JSONObject expected, JSONObject actual,44                                                       JSONCompareResult result) {45        Set<String> actualKeys = getKeys(actual);46        for (String key : actualKeys) {47            if (!expected.has(key)) {48                result.unexpected(prefix, key);49            }50        }51    }52    @Override53    public void compareValues(String prefix, Object expectedValue, Object actualValue, JSONCompareResult result)54            throws JSONException {55        if (isSimpleValue(actualValue) && isSimpleValue(expectedValue)) {56            Matcher m = replaceParamPattern.matcher(String.valueOf(expectedValue));57            if (m.find()) {58                String replaceKey = m.group(1);59                if (!Pattern.compile(replaceKey).matcher(String.valueOf(actualValue)).matches()) {60                    result.fail(prefix + " Expected " + replaceKey + " matched with " + actualValue);61                }62                return;63            }64        }65        if (areNumbers(expectedValue, actualValue)) {66            if (areNotSameDoubles(expectedValue, actualValue)) {67                result.fail(prefix, expectedValue, actualValue);68            }69        } else if (expectedValue.getClass().isAssignableFrom(actualValue.getClass())) {70            if (expectedValue instanceof JSONArray) {71                compareJSONArray(prefix, (JSONArray) expectedValue, (JSONArray) actualValue, result);72            } else if (expectedValue instanceof JSONObject) {73                compareJSON(prefix, (JSONObject) expectedValue, (JSONObject) actualValue, result);74            } else if (!expectedValue.equals(actualValue)) {75                result.fail(prefix, expectedValue, actualValue);76            }77        } else {78            result.fail(prefix, expectedValue, actualValue);79        }80    }81    @Override82    public void compareJSONArray(String prefix, JSONArray expected, JSONArray actual, JSONCompareResult result)83            throws JSONException {84        if (mode == JSONCompareMode.STRICT || mode == JSONCompareMode.NON_EXTENSIBLE) {85            if (expected.length() != actual.length()) {86                result.fail(prefix + "[]: Expected " + expected.length() + " values but got " + actual.length());87                return;88            } else if (expected.length() == 0) {89                return; // Nothing to compare90            }91        }92        if (mode.hasStrictOrder()) {93            compareJSONArrayWithStrictOrder(prefix, expected, actual, result);94        } else if (allSimpleValues(expected)) {95            compareJSONArrayOfSimpleValues(prefix, expected, actual, result);96        } else if (allJSONObjects(expected)) {97            compareJSONArrayOfJsonObjects(prefix, expected, actual, result);98        } else {99            recursivelyCompareJSONArray(prefix, expected, actual, result);100        }101    }102    protected void compareJSONArrayOfSimpleValues(String key, JSONArray expected, JSONArray actual,103                                                  JSONCompareResult result) throws JSONException {104        Map<Object, Integer> expectedCount = JSONCompareUtil.getCardinalityMap(jsonArrayToList(expected));105        Map<Object, Integer> actualCount = JSONCompareUtil.getCardinalityMap(jsonArrayToList(actual));106        if (expectedCount.size() == 1 && isCountFun(String.valueOf(expectedCount.entrySet().iterator().next().getKey()))) {107            int count = 0;108            Matcher m = Pattern.compile("\\$\\{count\\((\\d+)\\)\\}").matcher(String.valueOf(expectedCount.entrySet().iterator().next().getKey()));109            if (m.find()) {110                count = Integer.valueOf(m.group(1));111            }112            if (count != actual.length()) {113                result.fail(key + "[]: Expected " + actual.toString() + " has " + count + " elements, but fount " + actual.length());114            }115            return;116        }117        if (expectedCount.size() == 1 && isRegex(String.valueOf(expectedCount.entrySet().iterator().next().getKey()))118                && mode.isExtensible()) {119            String replaceKey = null;120            for (Object o : actualCount.keySet()) {121                Matcher m = replaceParamPattern122                        .matcher(String.valueOf(expectedCount.entrySet().iterator().next().getKey()));123                if (m.find()) {124                    replaceKey = m.group(1);125                }126                if ("".equals(replaceKey) || replaceKey == null127                        || !Pattern.compile(replaceKey).matcher(String.valueOf(o)).find()) {128                    result.fail(key + "[]: Expected " + replaceKey + " matched with " + o);129                }130            }131            return;132        }133        for (Object o : expectedCount.keySet()) {134            if (!actualCount.containsKey(o)) {135                result.missing(key + "[]", o);136            } else if (!actualCount.get(o).equals(expectedCount.get(o))) {137                result.fail(key + "[]: Expected " + expectedCount.get(o) + " occurrence(s) of " + o + " but got "138                        + actualCount.get(o) + " occurrence(s)");139            }140        }141        for (Object o : actualCount.keySet()) {142            if (!expectedCount.containsKey(o)) {143                result.unexpected(key + "[]", o);144            }145        }146    }147    private boolean isCountFun(String valueOf) {148        Pattern countPatten = Pattern.compile("\\$\\{count\\((\\d+)\\)\\}");149        return countPatten.matcher(valueOf).find();150    }151    protected void compareJSONArrayOfJsonObjects(String key, JSONArray expected, JSONArray actual,152                                                 JSONCompareResult result) throws JSONException {153        String uniqueKey = findUniqueKey(expected);154        if (uniqueKey == null || !isUsableAsUniqueKey(uniqueKey, actual) || isRegex(expected.toString())) {155            recursivelyCompareJSONArray(key, expected, actual, result);156            return;157        }158        Map<Object, JSONObject> expectedValueMap = arrayOfJsonObjectToMap(expected, uniqueKey);159        Map<Object, JSONObject> actualValueMap = arrayOfJsonObjectToMap(actual, uniqueKey);160        for (Object id : expectedValueMap.keySet()) {161            if (!actualValueMap.containsKey(id)) {162                result.missing(formatUniqueKey(key, uniqueKey, id), expectedValueMap.get(id));163                continue;164            }165            JSONObject expectedValue = expectedValueMap.get(id);166            JSONObject actualValue = actualValueMap.get(id);167            compareValues(formatUniqueKey(key, uniqueKey, id), expectedValue, actualValue, result);168        }169        for (Object id : actualValueMap.keySet()) {170            if (!expectedValueMap.containsKey(id)) {171                result.unexpected(formatUniqueKey(key, uniqueKey, id), actualValueMap.get(id));172            }173        }174    }175    protected void recursivelyCompareJSONArray(String key, JSONArray expected, JSONArray actual, JSONCompareResult result) throws JSONException {176        Set<Integer> matched = new HashSet();177        for (int i = 0; i < expected.length(); ++i) {178            Object expectedElement = expected.get(i);179            boolean matchFound = false;180            StringBuilder build = new StringBuilder();181            for (int j = 0; j < actual.length(); ++j) {182                Object actualElement = actual.get(j);183                if (!matched.contains(j) && actualElement.getClass().equals(expectedElement.getClass())) {184                    if (expectedElement instanceof JSONObject) {185                        JSONCompareResult tmp = compareJSON((JSONObject) expectedElement, (JSONObject) actualElement);186                        if (tmp.passed()) {187                            matched.add(j);188                            matchFound = true;189                            break;190                        }191                        build.append(tmp.getMessage());192                    } else if (expectedElement instanceof JSONArray) {193                        JSONCompareResult tmp = compareJSON((JSONObject) expectedElement, (JSONObject) actualElement);194                        if (tmp.passed()) {195                            matched.add(j);196                            matchFound = true;197                            break;198                        }199                        build.append(tmp.getMessage());200                    } else if (expectedElement.equals(actualElement)) {201                        matched.add(j);202                        matchFound = true;203                        break;204                    }205                    else {206                        build.append("Expect " + expectedElement + " equals to " + actualElement);207                    }...Source:DataAsserter.java  
...3import org.json.JSONException;4import org.skyscreamer.jsonassert.FieldComparisonFailure;5import org.skyscreamer.jsonassert.JSONCompare;6import org.skyscreamer.jsonassert.JSONCompareMode;7import org.skyscreamer.jsonassert.JSONCompareResult;8import java.util.ArrayList;9import java.util.Collection;10import java.util.Collections;11import java.util.List;12import java.util.function.Predicate;13import java.util.stream.Collectors;14public class DataAsserter {15    private StringBuilder errorStringBuilder;16    private boolean isNotEmpty(Collection collection) {17        return null != collection && collection.size() > 0;18    }19    public void assertData(String expected, String actual, List<String> dynamicFieldsToExclude) throws JSONException, DataAssertionFailed {20        JSONCompareResult jsonCompareResult = JSONCompare.compareJSON(expected, actual, JSONCompareMode.STRICT);21        List<FieldComparisonFailure> fieldComparisonFailures = new ArrayList<>();22        fieldComparisonFailures.addAll(jsonCompareResult.getFieldFailures());23        fieldComparisonFailures.addAll(jsonCompareResult.getFieldMissing());24        fieldComparisonFailures.addAll(jsonCompareResult.getFieldUnexpected());25        Predicate<FieldComparisonFailure> dynamicFieldsPredicate = isNotEmpty(dynamicFieldsToExclude) ?26                $ -> dynamicFieldsToExclude.indexOf($.getActual()) == -1 : $ -> true;27        List<FieldComparisonFailure> anyAdditionalFieldMismatched = fieldComparisonFailures.stream()28                .filter(dynamicFieldsPredicate).collect(Collectors.toList());29        if (isNotEmpty(fieldComparisonFailures) && isNotEmpty(anyAdditionalFieldMismatched)) {30            errorStringBuilder = new StringBuilder("Data Mismatched !\n");31            displayResults(jsonCompareResult);32            throw new DataAssertionFailed(errorStringBuilder.toString());33        }34        if (isNotEmpty(anyAdditionalFieldMismatched)) {35            String mismatchedFieldPaths = anyAdditionalFieldMismatched.stream().map(FieldComparisonFailure::getField)36                    .collect(Collectors.joining("\n"));37            throw new DataAssertionFailed("There are additional fields mismatch. They are :\n" + mismatchedFieldPaths + "\n");38        }39    }40    private void displayResults(JSONCompareResult compareResult) {41        if (isNotEmpty(compareResult.getFieldFailures())) {42            errorStringBuilder.append("Field Failures");43            compareResult.getFieldFailures().forEach(this::displayResults);44        } else if (isNotEmpty(compareResult.getFieldMissing())) {45            errorStringBuilder.append("Missing Fields");46            compareResult.getFieldMissing().forEach(this::displayResults);47        } else if (isNotEmpty(compareResult.getFieldUnexpected())) {48            errorStringBuilder.append("UnExpected Fields");49            compareResult.getFieldUnexpected().forEach(this::displayResults);50        }51    }52    private void displayResults(FieldComparisonFailure fieldComparisonFailure) {53        errorStringBuilder.append("\n\t\tField Path : ").append(fieldComparisonFailure.getField());54        errorStringBuilder.append("\n\t\t[ Expected - ")...Source:JsonStringMatcher.java  
...3import com.google.common.base.Strings;4import org.mockserver.logging.MockServerLogger;5import org.mockserver.model.HttpRequest;6import org.skyscreamer.jsonassert.JSONCompareMode;7import org.skyscreamer.jsonassert.JSONCompareResult;8import static org.skyscreamer.jsonassert.JSONCompare.compareJSON;9/**10 * @author jamesdbloom11 */12public class JsonStringMatcher extends BodyMatcher<String> {13    private static final String[] excludedFields = {"mockServerLogger"};14    private final MockServerLogger mockServerLogger;15    private final String matcher;16    private final MatchType matchType;17    public JsonStringMatcher(MockServerLogger mockServerLogger, String matcher, MatchType matchType) {18        this.mockServerLogger = mockServerLogger;19        this.matcher = matcher;20        this.matchType = matchType;21    }22    public boolean matches(final HttpRequest context, String matched) {23        boolean result = false;24        JSONCompareResult jsonCompareResult;25        try {26            if (Strings.isNullOrEmpty(matcher)) {27                result = true;28            } else {29                JSONCompareMode jsonCompareMode = JSONCompareMode.LENIENT;30                if (matchType == MatchType.STRICT) {31                    jsonCompareMode = JSONCompareMode.STRICT;32                }33                jsonCompareResult = compareJSON(matcher, matched, jsonCompareMode);34                if (jsonCompareResult.passed()) {35                    result = true;36                }37                if (!result) {38                    mockServerLogger.trace(context, "Failed to perform JSON match \"{}\" with \"{}\" because {}", matched, this.matcher, jsonCompareResult.getMessage());...JSONCompareResult
Using AI Code Generation
1import org.skyscreamer.jsonassert.JSONCompareResult;2import org.skyscreamer.jsonassert.JSONCompareMode;3import org.skyscreamer.jsonassert.JSONParser;4import org.skyscreamer.jsonassert.JSONCompare;5public class JSONCompareResultExample {6   public static void main(String[] args) {7      try {8         String str1 = "{'name':'sonoo','salary':600000,'age':27}";9         String str2 = "{'name':'sonoo','salary':600000,'age':28}";10         Object obj1 = JSONParser.parseJSON(str1);11         Object obj2 = JSONParser.parseJSON(str2);12         JSONCompareResult result = JSONCompare.compareJSON(obj1, obj2, JSONCompareMode.NON_EXTENSIBLE);13         if (result.failed()) {14            System.out.println("The JSON object are not equal");15         } else {16            System.out.println("The JSON object are equal");17         }18      } catch (Exception e) {19         e.printStackTrace();20      }21   }22}JSONCompareResult
Using AI Code Generation
1import org.skyscreamer.jsonassert.JSONCompareResult;2import org.skyscreamer.jsonassert.JSONCompareMode;3import org.skyscreamer.jsonassert.JSONCompare;4import org.json.JSONObject;5import org.json.JSONArray;6import org.json.JSONException;7import org.json.JSONTokener;8import org.json.JSONStringer;9import org.json.JSONWriter;10import org.json.JSONString;11import org.json.JSONML;12import org.json.JSONPointer;13import org.json.JSONPointerException;14public class JSONCompareResultExample {15    public static void main(String[] args) {16        try {17            String json1 = "{18            }";19            String json2 = "{20            }";21            JSONObject jsonObject1 = new JSONObject(json1);22            JSONObject jsonObject2 = new JSONObject(json2);23            JSONCompareResult result = JSONCompare.compareJSON(jsonObject1, jsonObject2, JSONCompareMode.STRICT);24            System.out.println("isEquals: " + result.isEquals());25        } catch (JSONException e) {26            System.out.println(e);27        }28    }29}JSONCompareResult
Using AI Code Generation
1import org.skyscreamer.jsonassert.JSONCompareResult;2import org.skyscreamer.jsonassert.JSONCompareMode;3import org.skyscreamer.jsonassert.JSONCompare;4import org.json.JSONObject;5import org.json.JSONException;6import org.json.JSONArray;7public class JSONCompareResultExample {8   public static void main(String[] args) {9      try {10         JSONObject json1 = new JSONObject();11         json1.put("name", "john");12         json1.put("age", 25);13         json1.put("city", "newyork");14         JSONObject json2 = new JSONObject();15         json2.put("name", "john");16         json2.put("age", 25);17         json2.put("city", "newyork");18         JSONCompareResult result = JSONCompare.compareJSON(json1, json2, JSONCompareMode.STRICT);19         if (result.passed()) {20            System.out.println("JSON objects are equal");21         } else {22            System.out.println("JSON objects are not equal");23         }24      } catch (JSONException e) {25         e.printStackTrace();26      }27   }28}JSONCompareResult
Using AI Code Generation
1package org.skyscreamer.jsonassert;2import org.json.JSONException;3import org.json.JSONObject;4import org.skyscreamer.jsonassert.comparator.CustomComparator;5import org.skyscreamer.jsonassert.comparator.JSONComparator;6public class JSONCompareResult {7    public static void main(String[] args) throws JSONException {8        JSONObject obj1 = new JSONObject("{\"name\":\"John Doe\",\"age\":33}");9        JSONObject obj2 = new JSONObject("{\"name\":\"John Doe\",\"age\":33}");10        JSONComparator customComparator = new CustomComparator(JSONCompareMode.LENIENT,11                new Customization("name", (o1, o2) -> true));12        JSONCompareResult result = JSONCompare.compareJSON(obj1, obj2, customComparator);13        System.out.println(result.failed());14        System.out.println(result.getMessage());15    }16}JSONCompareResult
Using AI Code Generation
1import org.skyscreamer.jsonassert.JSONCompareResult;2import org.skyscreamer.jsonassert.JSONCompareMode;3import org.json.JSONException;4import org.json.JSONObject;5import org.skyscreamer.jsonassert.JSONCompare;6public class JSONCompareResultExample {7   public static void main(String[] args) throws JSONException {8      String json1 = "{'name':'John','age':13}";9      String json2 = "{'name':'John','age':13}";10      JSONObject jsonObject1 = new JSONObject(json1);11      JSONObject jsonObject2 = new JSONObject(json2);12      JSONCompareResult result = JSONCompare.compareJSON(jsonObject1, jsonObject2, JSONCompareMode.LENIENT);13      System.out.println("Passed: " + result.passed());14   }15}JSONCompareResult
Using AI Code Generation
1import org.json.JSONException;2import org.skyscreamer.jsonassert.JSONCompareResult;3public class JSONCompareResultExample {4   public static void main(String[] args) {5      JSONCompareResult result = new JSONCompareResult();6      result.fail("Failure message");7      result.error(new JSONException("Error message"));8      System.out.println(result);9   }10}11{"errors":[{"message":"Error message","type":"org.json.JSONException"}],"failures":["Failure message"],"passed":false}JSONCompareResult
Using AI Code Generation
1import org.json.JSONException;2import org.json.JSONObject;3import org.skyscreamer.jsonassert.JSONCompareResult;4public class JSONCompareResultMethod {5    public static void main(String[] args) throws JSONException {6        String actual = "{\"name\":\"John\",\"age\":30}";7        String expected = "{\"name\":\"John\",\"age\":30}";8        JSONCompareResult compareResult = JSONCompareResult.compareJSON(expected, actual, true);9        System.out.println("Result: " + compareResult.passed());10    }11}Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Get 100 minutes of automation test minutes FREE!!
