Java Code Examples for com.fasterxml.jackson.databind.JsonNode#equals()

private void generateDiffs(JsonPointer path, JsonNode source, JsonNode target) {
    if (!source.equals(target)) {
        final NodeType sourceType = NodeType.getNodeType(source);
        final NodeType targetType = NodeType.getNodeType(target);

        if (sourceType == NodeType.ARRAY && targetType == NodeType.ARRAY) {
            //both are arrays
            compareArray(path, source, target);
        } else if (sourceType == NodeType.OBJECT && targetType == NodeType.OBJECT) {
            //both are json
            compareObjects(path, source, target);
        } else {
            //can be replaced
            if (flags.contains(DiffFlags.EMIT_TEST_OPERATIONS))
                diffs.add(new Diff(Operation.TEST, path, source));
            diffs.add(Diff.generateDiff(Operation.REPLACE, path, source, target));
        }
    }
}
 

private static void computeUnchangedValues(Map<JsonNode, JsonPointer> unchangedValues, JsonPointer path, JsonNode source, JsonNode target) {
    if (source.equals(target)) {
        if (!unchangedValues.containsKey(target)) {
            unchangedValues.put(target, path);
        }
        return;
    }

    final NodeType firstType = NodeType.getNodeType(source);
    final NodeType secondType = NodeType.getNodeType(target);

    if (firstType == secondType) {
        switch (firstType) {
            case OBJECT:
                computeObject(unchangedValues, path, source, target);
                break;
            case ARRAY:
                computeArray(unchangedValues, path, source, target);
                break;
            default:
                /* nothing */
        }
    }
}
 

static boolean equals(JsonNode v1, JsonNode v2) {
  boolean result;
  if (v1.isNumber() && v2.isNumber()) {
    // unfortunately, comparison of numeric nodes in Jackson is
    // deliberately less helpful than what we need here. so we have
    // to develop our own support for it.
    // https://github.com/FasterXML/jackson-databind/issues/1758

    if (v1.isIntegralNumber() && v2.isIntegralNumber())
      // if both are integers, then compare them as such
      return v1.longValue() == v2.longValue();
    else
      return v1.doubleValue() == v2.doubleValue();
  } else
    return v1.equals(v2);
}
 

/**
 * PATCH /tokens/{appId}
 *
 * <p>Activates or deactivates the token of the specified {@code appId}.
 */
@Patch("/tokens/{appId}")
@Consumes("application/json-patch+json")
public CompletableFuture<Token> updateToken(ServiceRequestContext ctx,
                                            @Param String appId,
                                            JsonNode node, Author author, User loginUser) {
    if (node.equals(activation)) {
        return getTokenOrRespondForbidden(ctx, appId, loginUser).thenCompose(
                token -> mds.activateToken(author, appId)
                            .thenApply(unused -> token.withoutSecret()));
    }
    if (node.equals(deactivation)) {
        return getTokenOrRespondForbidden(ctx, appId, loginUser).thenCompose(
                token -> mds.deactivateToken(author, appId)
                            .thenApply(unused -> token.withoutSecret()));
    }
    throw new IllegalArgumentException("Unsupported JSON patch: " + node +
                                       " (expected: " + activation + " or " + deactivation + ')');
}
 

private static JsonSchema obtainSubSchemaNode(final JsonNode schemaNode, final ValidationContext validationContext) {
    final JsonNode node = schemaNode.get("id");
    if (node == null) return null;
    if (node.equals(schemaNode.get("$schema"))) return null;

    final String text = node.textValue();
    if (text == null) {
        return null;
    } else {
        final URI uri;
        try {
            uri = validationContext.getURIFactory().create(node.textValue());
        } catch (IllegalArgumentException e) {
            return null;
        }
        return validationContext.getJsonSchemaFactory().getSchema(uri, validationContext.getConfig());
    }
}
 

/**
 * PathAny matcher that checks if any element of the final
 * result matches the expected result
 *
 * @param expectedResult Expected result given by the waiter definition
 * @param finalResult    Final result of the resource got by the execution
 *                       of the JmesPath expression given by the waiter
 *                       definition
 * @return True if any single element of the final result matches
 * the expected result, False if none matched
 */
public static boolean pathAny(JsonNode expectedResult, JsonNode finalResult) {
    if (finalResult.isNull()) {
        return false;
    }
    if (!finalResult.isArray()) {
        throw new RuntimeException("Expected an array");
    }
    for (JsonNode element : finalResult) {
        if (element.equals(expectedResult)) {
            return true;
        }
    }
    return false;

}
 

/**
 * Compare two JsonNode objects and return an integer.
 *
 * @return  a negative integer, zero, or a positive integer as this object
 *          is less than, equal to, or greater than the specified object.
 */
public static int compare(JsonNode left, JsonNode right) {
  if (left.isLong() || left.isInt()) {
    return Long.compare(left.asLong(), right.asLong());

  } else if (left.isDouble() || left.isFloat()) {
    return Double.compare(left.asDouble(), right.asDouble());

  } else if (left.isTextual()) {
    return left.asText().compareTo(right.asText());

  } else if (left.isBoolean()) {
    return Boolean.compare(left.asBoolean(), right.asBoolean());
  }

  // Not comparable in a relative sense, default to equals.
  return left.equals(right) ? 0 : -1;
}
 

public static void compareJson(String expected, String actual) throws IOException {
  if(ElasticsearchCluster.USE_EXTERNAL_ES5){
    // ignore json comparison for now
    return;
  }

  ObjectMapper m = new ObjectMapper();
  JsonNode expectedRootNode = m.readTree(expected);
  JsonNode actualRootNode = m.readTree(actual);
  if (!expectedRootNode.equals(actualRootNode)) {
    ObjectWriter writer = m.writerWithDefaultPrettyPrinter();
    String message = String.format("Comparison between JSON values failed.\nExpected:\n%s\nActual:\n%s", expected, actual);
    // assertEquals gives a better diff
    assertEquals(message, writer.writeValueAsString(expectedRootNode), writer.writeValueAsString(actualRootNode));
    throw new RuntimeException(message);
  }
}
 

@Override
public boolean apply(Context ctx, Arguments args) throws CodeExecuteException {
  JsonNode arg0 = resolve(ctx, args, 0);
  if (args.count() == 1) {
    return !ctx.node().equals(arg0);
  } else {
    return !arg0.equals(resolve(ctx, args, 1));
  }
}
 

public static boolean jsonEquals(JsonObject first, JsonObject second) {
    final ObjectMapper mapper = new ObjectMapper();

    try {
        final JsonNode tree1 = mapper.readTree(first.toString());
        final JsonNode tree2 = mapper.readTree(second.toString());
        return tree1.equals(tree2);
    } catch (IOException e) {
        return false;
    }
}
 

/**
 * Safely merge two nodes. This will appropriately merge objects or lists, as
 * well as verifying that values are compatible if both nodes are values. If
 * {@code throwOnConflict} is set, an exception will be thrown if there is a merge conflict.
 * Otherwise, node1 will be returned as the conflict resolution.
 */
public static JsonNode mergeNode(JsonNode node1, JsonNode node2, boolean throwOnConflict) {
  if (node1.isArray()) {
    if (!node2.isArray()) {
      if (throwOnConflict) {
        throw new IllegalArgumentException("Cannot merge array and non-array: "
            + node1 + ", " + node2);
      }
      return node1;
    }
    return mergeArray((ArrayNode) node1, (ArrayNode) node2);
  } else if (node1.isObject()) {
    if (!node2.isObject()) {
      if (throwOnConflict) {
        throw new IllegalArgumentException("Cannot merge object and non-object: "
            + node1 + ", " + node2);
      }
      return node1;
    }
    return mergeObject((ObjectNode) node1, (ObjectNode) node2, throwOnConflict);
  } else {
    // Value node, verify equivalence.
    if (throwOnConflict && !node1.equals(node2)) {
      throw new IllegalArgumentException("Cannot merge different values: "
          + node1 + ", " + node2);
    }
    return node1;
  }
}
 

private boolean jsonEqual(String string1, String string2) {
    ObjectMapper mapper = SimpleJsonMapper.getSimpleObjectMapper();
    try {
        JsonNode json1 = mapper.readTree(string1);
        JsonNode json2 = mapper.readTree(string2);
        return json1.equals(json2);
    } catch (IOException ex) {
        Logger.getLogger(EntityFormatterTest.class.getName()).log(Level.SEVERE, null, ex);
    }
    return false;
}
 

/**
 * Static method which tries to match 2 JsonNode objects recursively.
 *
 * @param path: Path to start matching the objects from.
 * @param expected: First JsonNode.
 * @param actual: Second JsonNode.
 * @param description: The Description to be appended to.
 * @return true if the 2 objects match, false otherwise.
 */
private static boolean matchJsonObjects(
    String path, JsonNode expected, JsonNode actual, Description description) {
  if (expected != null && actual != null && expected.isObject()) {
    if (!actual.isObject()) {
      description.appendText(String.format("the JsonNodeType is not OBJECT at path [%s]", path));
      return false;
    }
    HashSet<String> expectedFields = Sets.newHashSet(expected.fieldNames());
    HashSet<String> actualFields = Sets.newHashSet(actual.fieldNames());

    for (String field : expectedFields) {
      if (!actualFields.contains(field)) {
        description.appendText(String.format("expecting field [%s] at path [%s]", field, path));
        return false;
      }
      if (!matchJsonObjects(
          path + "/" + field, expected.get(field), actual.get(field), description)) {
        return false;
      }
    }
    if (!new HashSet<>().equals(Sets.difference(actualFields, expectedFields))) {
      description.appendText(
          String.format(
              "found unexpected fields %s at path [%s]",
              Sets.difference(actualFields, expectedFields).toString(), path));
      return false;
    }
  }
  if (!expected.equals(actual)) {
    description.appendText(String.format("mismatch at path [%s]", path));
    return false;
  }
  return true;
}
 

/**
 * PathAll matcher that checks if each element of the final
 * result matches the expected result
 *
 * @param expectedResult Expected result given by the waiter definition
 * @param finalResult    Final result of the resource got by the execution
 *                       of the JmesPath expression given by the waiter
 *                       definition
 * @return True if all elements of the final result matches
 * the expected result, False otherwise
 */
public static boolean pathAll(JsonNode expectedResult, JsonNode finalResult) {
    if (finalResult.isNull()) {
        return false;
    }
    if (!finalResult.isArray()) {
        throw new RuntimeException("Expected an array");
    }
    for (JsonNode element : finalResult) {
        if (!element.equals(expectedResult)) {
            return false;
        }
    }
    return true;
}
 

private static boolean numEquals(final JsonNode a, final JsonNode b) {
    /*
     * If both numbers are integers, delegate to JsonNode.
     */
    if (a.isIntegralNumber() && b.isIntegralNumber()) {
        return a.equals(b);
    }

    /*
     * Otherwise, compare decimal values.
     */
    return a.decimalValue().compareTo(b.decimalValue()) == 0;
}
 

/**
 * compare json (deep equals ignoring order)
 */
protected boolean jsonEquals( String json1, String json2 ) throws Exception {
  ObjectMapper om = new ObjectMapper();
  JsonNode parsedJson1 = om.readTree( json1 );
  JsonNode parsedJson2 = om.readTree( json2 );
  return parsedJson1.equals( parsedJson2 );
}
 

/**
 * compare json (deep equals ignoring order)
 */
protected static final boolean jsonEquals( String json1, String json2 ) throws Exception {
  ObjectMapper om = new ObjectMapper();
  JsonNode parsedJson1 = om.readTree( json1 );
  JsonNode parsedJson2 = om.readTree( json2 );
  return parsedJson1.equals( parsedJson2 );
}
 

@Override
public int compare(JsonNode o1, JsonNode o2) {
    if (o1.equals(o2)) {
        return 0;
    }
    if ((o1 instanceof NumericNode) && (o2 instanceof NumericNode)) {
        Double d1 = ((NumericNode) o1).asDouble();
        Double d2 = ((NumericNode) o2).asDouble();
        if (d1.compareTo(d2) == 0) {
            return 0;
        }
    }
    return 1;
}
 

public static boolean isJsonEqual(String json1, String json2) throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    JsonNode tree1 = mapper.readTree(json1);
    JsonNode tree2 = mapper.readTree(json2);
    return tree1.equals(tree2);
}
 

private static boolean jsonCompare(Object o1, Object o2) {
  ObjectMapper mapper = new ObjectMapper();
  JsonNode tree1 = mapper.convertValue(o1, JsonNode.class);
  JsonNode tree2 = mapper.convertValue(o2, JsonNode.class);
  return tree1.equals(tree2);
}