How to use

failed

method

in

org.skyscreamer.jsonassert.JSONCompareResult

@Override
public boolean matches(Object item) {
 if (!(item instanceof String)) {
  ObjectMapper om = new ObjectMapper();
  try {
   item = om.writeValueAsString(item);
  } catch (JsonProcessingException e) {
   failureMessage = e.getMessage();
   return false;
  }
 }
 JSONCompareResult result;
 try {
  result = JSONCompare.compareJSON(expectedJson, item.toString(), JSONCompareMode.LENIENT);
 } catch (JSONException jex) {
  failureMessage = jex.getMessage();
  return false;
 }
 if (result != null && result.failed()) {
  failureMessage = result.getMessage();
 }
 return result != null && result.passed();
}

/**
 * Asserts that the JSONArray provided matches the expected string.  If it isn't it throws an
 * {@link AssertionError}.
 *
 * @param message Error message to be displayed in case of assertion failure
 * @param expectedStr Expected JSON string
 * @param actualStr String to compare
 * @param compareMode Specifies which comparison mode to use
 * @throws JSONException JSON parsing error
 */
public static void assertEquals(String message, String expectedStr, String actualStr, JSONCompareMode compareMode)
  throws JSONException {
  if (expectedStr==actualStr) return;
  if (expectedStr==null){
    throw new AssertionError("Expected string is null.");
  }else if (actualStr==null){
    throw new AssertionError("Actual string is null.");
  }
  JSONCompareResult result = JSONCompare.compareJSON(expectedStr, actualStr, compareMode);
  if (result.failed()) {
    throw new AssertionError(getCombinedMessage(message, result.getMessage()));
  }
}

/**
 * Asserts that the json string provided matches the expected string.  If it isn't it throws an
 * {@link AssertionError}.
 *
 * @param message Error message to be displayed in case of assertion failure
 * @param expectedStr Expected JSON string
 * @param actualStr String to compare
 * @param comparator Comparator
 * @throws JSONException JSON parsing error
 */
public static void assertEquals(String message, String expectedStr, String actualStr, JSONComparator comparator)
  throws JSONException {
  JSONCompareResult result = JSONCompare.compareJSON(expectedStr, actualStr, comparator);
  if (result.failed()) {
    throw new AssertionError(getCombinedMessage(message, result.getMessage()));
  }
}

/**
 * Asserts that the JSONObject provided matches the expected JSONObject.  If it isn't it throws an
 * {@link AssertionError}.
 *
 * @param message Error message to be displayed in case of assertion failure
 * @param expected Expected JSONObject
 * @param actual JSONObject to compare
 * @param compareMode Specifies which comparison mode to use
 * @throws JSONException JSON parsing error
 */
public static void assertEquals(String message, JSONObject expected, JSONObject actual, JSONCompareMode compareMode)
  throws JSONException {
  JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
  if (result.failed()) {
    throw new AssertionError(getCombinedMessage(message, result.getMessage()));
  }
}

/**
 * Asserts that the JSONArray provided matches the expected JSONArray.  If it isn't it throws an
 * {@link AssertionError}.
 *
 * @param message Error message to be displayed in case of assertion failure
 * @param expected Expected JSONArray
 * @param actual JSONArray to compare
 * @param compareMode Specifies which comparison mode to use
 * @throws JSONException JSON parsing error
 */
public static void assertEquals(String message, JSONArray expected, JSONArray actual, JSONCompareMode compareMode)
  throws JSONException {
  JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
  if (result.failed()) {
    throw new AssertionError(getCombinedMessage(message, result.getMessage()));
  }
}

/**
 * Asserts that the JSONArray provided matches the expected string.  If it isn't it throws an
 * {@link AssertionError}.
 *
 * @param message Error message to be displayed in case of assertion failure
 * @param expectedStr Expected JSON string
 * @param actualStr String to compare
 * @param compareMode Specifies which comparison mode to use
 * @throws JSONException JSON parsing error
 */
public static void assertEquals(String message, String expectedStr, String actualStr, JSONCompareMode compareMode)
  throws JSONException {
  if (expectedStr==actualStr) return;
  if (expectedStr==null){
    throw new AssertionError("Expected string is null.");
  }else if (actualStr==null){
    throw new AssertionError("Actual string is null.");
  }
  JSONCompareResult result = JSONCompare.compareJSON(expectedStr, actualStr, compareMode);
  if (result.failed()) {
    throw new AssertionError(getCombinedMessage(message, result.getMessage()));
  }
}

/**
 * Asserts that the JSONObject provided matches the expected JSONObject.  If it isn't it throws an
 * {@link AssertionError}.
 *
 * @param message Error message to be displayed in case of assertion failure
 * @param expected Expected JSONObject
 * @param actual JSONObject to compare
 * @param compareMode Specifies which comparison mode to use
 * @throws JSONException JSON parsing error
 */
public static void assertEquals(String message, JSONObject expected, JSONObject actual, JSONCompareMode compareMode)
  throws JSONException {
  JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
  if (result.failed()) {
    throw new AssertionError(getCombinedMessage(message, result.getMessage()));
  }
}

/**
 * Asserts that the JSONArray provided matches the expected JSONArray.  If it isn't it throws an
 * {@link AssertionError}.
 *
 * @param message Error message to be displayed in case of assertion failure
 * @param expected Expected JSONArray
 * @param actual JSONArray to compare
 * @param compareMode Specifies which comparison mode to use
 * @throws JSONException JSON parsing error
 */
public static void assertEquals(String message, JSONArray expected, JSONArray actual, JSONCompareMode compareMode)
  throws JSONException {
  JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
  if (result.failed()) {
    throw new AssertionError(getCombinedMessage(message, result.getMessage()));
  }
}

/**
 * Asserts that the json string provided matches the expected string.  If it isn't it throws an
 * {@link AssertionError}.
 *
 * @param message Error message to be displayed in case of assertion failure
 * @param expectedStr Expected JSON string
 * @param actualStr String to compare
 * @param comparator Comparator
 * @throws JSONException JSON parsing error
 */
public static void assertEquals(String message, String expectedStr, String actualStr, JSONComparator comparator)
  throws JSONException {
  JSONCompareResult result = JSONCompare.compareJSON(expectedStr, actualStr, comparator);
  if (result.failed()) {
    throw new AssertionError(getCombinedMessage(message, result.getMessage()));
  }
}

private JsonContentAssert assertNotFailed(JSONCompareResult result) {
  if (result.failed()) {
    throw new AssertionError("JSON Comparison failure: " + result.getMessage());
  }
  return this;
}

static JSONComparisonResult resultOf(JSONCompareResult result) {
  if (result.failed()) {
    return diagnose(result);
  } else {
    return comparisonPassed();
  }
}

  private static void assertJsonEquals(String expectedJson, String actualJson, JSONCompareMode mode) {
    try {
      JSONCompareResult result = JSONCompare.compareJSON( expectedJson, actualJson, mode );

      if ( result.failed() ) {
        throw new AssertionFailure( result.getMessage() + "; Actual: " + actualJson );
      }
    }
    catch (JSONException e) {
      throw new RuntimeException( e );
    }
  }
}

@Test
public void arrayCompare() throws JSONException
{
  final JSONCompareResult results = JSONCompare.compareJSON("[\"abc\"]", "[\"abc\"]",
      new RegularExpressionJSONComparator(JSONCompareMode.STRICT));
  Assert.assertFalse(results.failed());
}

@Test
public void structMissingItemsInArray() throws JSONException
{
  final JSONObject object1 = (JSONObject) JSONParser.parseJSON("{ \"a\": [ 1, 2 ] }");
  final JSONObject object2 = (JSONObject) JSONParser.parseJSON("{ \"a\": [ 1 ] }");
  final JSONCompareResult results = JSONCompare.compareJSON(object1, object2,
      new RegularExpressionJSONComparator(JSONCompareMode.STRICT));
  Assert.assertTrue(results.failed());
  Assert.assertEquals(1, results.getFieldMissing().size());
  Assert.assertEquals(0, results.getFieldUnexpected().size());
}

@Test
public void lenientOutOfOrderArraysContainingObjects() throws JSONException
{
  final JSONArray array1 = (JSONArray) JSONParser
      .parseJSON("[ { foo:\"123\" }, { foo:\"456\" } ]");
  final JSONArray array2 = (JSONArray) JSONParser
      .parseJSON("[ { foo:\"456\" }, { foo:\"123\" } ]");
  final JSONCompareResult results = JSONCompare.compareJSON(array1, array2,
      new RegularExpressionJSONComparator(JSONCompareMode.LENIENT));
  Assert.assertFalse(results.failed());
}

@Test
public void lenientOutOfOrderArraysMissingItems() throws JSONException
{
  final JSONArray array1 = (JSONArray) JSONParser.parseJSON("[\"123\", \"456\"]");
  final JSONArray array2 = (JSONArray) JSONParser.parseJSON("[\"789\", \"123\"]");
  final JSONCompareResult results = JSONCompare.compareJSON(array1, array2,
      new RegularExpressionJSONComparator(JSONCompareMode.LENIENT));
  Assert.assertTrue(results.failed());
}

@Test
public void nonExtensibleObjectTest() throws JSONException
{
  final JSONObject obj1 = (JSONObject) JSONParser.parseJSON("{ foo:\"abc\" }");
  final JSONObject obj2 = (JSONObject) JSONParser.parseJSON("{ foo:\"abc\", bar: \"def\" }");
  final JSONCompareResult results = JSONCompare.compareJSON(obj1, obj2,
      new RegularExpressionJSONComparator(JSONCompareMode.STRICT));
  Assert.assertTrue(results.failed());
}

@Test
public void lenientOutOfOrderArraysMixedAndMissingItems() throws JSONException
{
  final JSONArray array1 = (JSONArray) JSONParser.parseJSON("[ { foo:\"123\" }, 789 ]");
  final JSONArray array2 = (JSONArray) JSONParser.parseJSON("[ 456, { foo:\"123\" } ]");
  final JSONCompareResult results = JSONCompare.compareJSON(array1, array2,
      new RegularExpressionJSONComparator(JSONCompareMode.LENIENT));
  Assert.assertTrue(results.failed());
}

@Test
public void strictOutOfOrderArraysContainingArrays() throws JSONException
{
  final JSONArray array1 = (JSONArray) JSONParser.parseJSON("[ [\"123\" ], [\"456\" ] ]");
  final JSONArray array2 = (JSONArray) JSONParser.parseJSON("[ [\"456\" ], [\"123\" ] ]");
  final JSONCompareResult results = JSONCompare.compareJSON(array1, array2,
      new RegularExpressionJSONComparator(JSONCompareMode.STRICT_ORDER));
  Assert.assertTrue(results.failed());
}

@Test
public void strictOutOfOrderArraysContainingObjects() throws JSONException
{
  final JSONArray array1 = (JSONArray) JSONParser
      .parseJSON("[ { foo:\"123\" }, { bar:\"456\" } ]");
  final JSONArray array2 = (JSONArray) JSONParser
      .parseJSON("[ { bar:\"456\" }, { foo:\"123\" } ]");
  final JSONCompareResult results = JSONCompare.compareJSON(array1, array2,
      new RegularExpressionJSONComparator(JSONCompareMode.STRICT_ORDER));
  Assert.assertTrue(results.failed());
}