Java JsonNode.equals方法代码示例

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
/**
 * 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;

}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
/**
 * 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;

}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
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);
  }
}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
@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();
        return Double.compare(d1, d2);
    }
    int comp = o1.asText().compareTo(o2.asText());
    if (comp == 0) {
        return Integer.compare(o1.hashCode(), o2.hashCode());
    }
    return comp;
}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
@Override
protected boolean doEquivalent(final JsonNode a, final JsonNode b) {
    /*
     * If both are numbers, delegate to the helper method
     */
    if (a.isNumber() && b.isNumber()) {
        return numEquals(a, b);
    }

    final JsonNodeType typeA = a.getNodeType();
    final JsonNodeType typeB = b.getNodeType();

    /*
     * If they are of different types, no dice
     */
    if (typeA != typeB) {
        return false;
    }

    /*
     * For all other primitive types than numbers, trust JsonNode
     */
    if (!a.isContainerNode()) {
        return a.equals(b);
    }

    /*
     * OK, so they are containers (either both arrays or objects due to the
     * test on types above). They are obviously not equal if they do not
     * have the same number of elements/members.
     */
    if (a.size() != b.size()) {
        return false;
    }

    /*
     * Delegate to the appropriate method according to their type.
     */
    return typeA == JsonNodeType.ARRAY ? arrayEquals(a, b) : objectEquals(a, b);
}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
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;
}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
/**
 * 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;
}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
private boolean sameJson(String s1, String s2) {
    try {
        JsonNode tree1 = MAPPER.readTree(s1);
        JsonNode tree2 = MAPPER.readTree(s2);
        return tree1.equals(tree2);
    } catch (IOException e) {
        System.out.println("Exception: " + e);
    }
    return false;
}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
/**
 * 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;
}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
/**
 * Path matcher that checks if 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 the final result matches the expected result,
 *         False otherwise
 */
public static boolean path(JsonNode expectedResult, JsonNode finalResult) {
    return finalResult.equals(expectedResult);
}
 

import com.fasterxml.jackson.databind.JsonNode; //导入方法依赖的package包/类
/**
 * Path matcher that checks if 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 the final result matches the expected result,
 * False otherwise
 */
public static boolean path(JsonNode expectedResult, JsonNode finalResult) {
    return finalResult.equals(expectedResult);
}