sign-artifacts
diff --git a/src/main/java/org/skyscreamer/jsonassert/ArrayValueMatcher.java b/src/main/java/org/skyscreamer/jsonassert/ArrayValueMatcher.java
new file mode 100644
index 00000000..2d4dd8ec
--- /dev/null
+++ b/src/main/java/org/skyscreamer/jsonassert/ArrayValueMatcher.java
@@ -0,0 +1,222 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+package org.skyscreamer.jsonassert;
+
+import java.text.MessageFormat;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.skyscreamer.jsonassert.comparator.JSONComparator;
+
+/**
+ * A value matcher for arrays. This operates like STRICT_ORDER array match,
+ * however if expected array has less elements than actual array the matching
+ * process loops through the expected array to get expected elements for the
+ * additional actual elements. In general the expected array will contain a
+ * single element which is matched against each actual array element in turn.
+ * This allows simple verification of constant array element components and
+ * coupled with RegularExpressionValueMatcher can be used to match specific
+ * array element components against a regular expression pattern. As a convenience to reduce syntactic complexity of expected string, if the
+ * expected object is not an array, a one element expected array is created
+ * containing whatever is provided as the expected value.
+ *
+ * Some examples of typical usage idioms listed below.
+ *
+ * Assuming JSON to be verified is held in String variable ARRAY_OF_JSONOBJECTS and contains:
+ *
+ * {@code
+ * {a:[{background:white, id:1, type:row},
+ * {background:grey, id:2, type:row},
+ * {background:white, id:3, type:row},
+ * {background:grey, id:4, type:row}]}
+ * }
+ *
+ * then:
+ *
+ * To verify that the 'id' attribute of first element of array 'a' is '1':
+ *
+ * {@code
+ * JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
+ * Customization customization = new Customization("a", new ArrayValueMatcher(comparator, 0));
+ * JSONAssert.assertEquals("{a:[{id:1}]}", ARRAY_OF_JSONOBJECTS,
+ * new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * }
+ *
+ * To simplify complexity of expected JSON string, the value "a:[{id:1}]}" may be replaced by "a:{id:1}}"
+ *
+ * To verify that the 'type' attribute of second and third elements of array 'a' is 'row':
+ *
+ * {@code
+ * JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
+ * Customization customization = new Customization("a", new ArrayValueMatcher(comparator, 1, 2));
+ * JSONAssert.assertEquals("{a:[{type:row}]}", ARRAY_OF_JSONOBJECTS,
+ * new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * }
+ *
+ * To verify that the 'type' attribute of every element of array 'a' is 'row':
+ *
+ * {@code
+ * JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
+ * Customization customization = new Customization("a", new ArrayValueMatcher(comparator));
+ * JSONAssert.assertEquals("{a:[{type:row}]}", ARRAY_OF_JSONOBJECTS,
+ * new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * }
+ *
+ * To verify that the 'id' attribute of every element of array 'a' matches regular expression '\d+'. This requires a custom comparator to specify regular expression to be used to validate each array element, hence the array of Customization instances:
+ *
+ * {@code
+ * // get length of array we will verify
+ * int aLength = ((JSONArray)((JSONObject)JSONParser.parseJSON(ARRAY_OF_JSONOBJECTS)).get("a")).length();
+ * // create array of customizations one for each array element
+ * RegularExpressionValueMatcher regExValueMatcher =
+ * new RegularExpressionValueMatcher("\\d+"); // matches one or more digits
+ * Customization[] customizations = new Customization[aLength];
+ * for (int i=0; i regExArrayValueMatcher = new ArrayValueMatcher(regExComparator);
+ * Customization regExArrayValueCustomization = new Customization("a", regExArrayValueMatcher);
+ * CustomComparator regExCustomArrayValueComparator =
+ * new CustomComparator(JSONCompareMode.STRICT_ORDER, new Customization[] { regExArrayValueCustomization });
+ * JSONAssert.assertEquals("{a:[{id:X}]}", ARRAY_OF_JSONOBJECTS, regExCustomArrayValueComparator);
+ * }
+ *
+ * To verify that the 'background' attribute of every element of array 'a' alternates between 'white' and 'grey' starting with first element 'background' being 'white':
+ *
+ * {@code
+ * JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);
+ * Customization customization = new Customization("a", new ArrayValueMatcher(comparator));
+ * JSONAssert.assertEquals("{a:[{background:white},{background:grey}]}", ARRAY_OF_JSONOBJECTS,
+ * new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * }
+ *
+ * Assuming JSON to be verified is held in String variable ARRAY_OF_JSONARRAYS and contains:
+ *
+ * {a:[[6,7,8], [9,10,11], [12,13,14], [19,20,21,22]]}
+ *
+ * then:
+ *
+ * To verify that the first three elements of JSON array 'a' are JSON arrays of length 3:
+ *
+ * {@code
+ * JSONComparator comparator = new ArraySizeComparator(JSONCompareMode.STRICT_ORDER);
+ * Customization customization = new Customization("a", new ArrayValueMatcher(comparator, 0, 2));
+ * JSONAssert.assertEquals("{a:[[3]]}", ARRAY_OF_JSONARRAYS, new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * }
+ *
+ * NOTE: simplified expected JSON strings are not possible in this case as ArraySizeComparator does not support them.
+ *
+ * To verify that the second elements of JSON array 'a' is a JSON array whose first element has the value 9:
+ *
+ * {@code
+ * JSONComparator innerComparator = new DefaultComparator(JSONCompareMode.LENIENT);
+ * Customization innerCustomization = new Customization("a[1]", new ArrayValueMatcher(innerComparator, 0));
+ * JSONComparator comparator = new CustomComparator(JSONCompareMode.LENIENT, innerCustomization);
+ * Customization customization = new Customization("a", new ArrayValueMatcher(comparator, 1));
+ * JSONAssert.assertEquals("{a:[[9]]}", ARRAY_OF_JSONARRAYS, new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * }
+ *
+ * To simplify complexity of expected JSON string, the value "{a:[[9]]}" may be replaced by "{a:[9]}" or "{a:9}"
+ *
+ * @author Duncan Mackinder
+ * @param Array Type
+ */
+public class ArrayValueMatcher implements LocationAwareValueMatcher {
+ private final JSONComparator comparator;
+ private final int from;
+ private final int to;
+
+ /**
+ * Create ArrayValueMatcher to match every element in actual array against
+ * elements taken in sequence from expected array, repeating from start of
+ * expected array if necessary.
+ *
+ * @param comparator
+ * comparator to use to compare elements
+ */
+ public ArrayValueMatcher(JSONComparator comparator) {
+ this(comparator, 0, Integer.MAX_VALUE);
+ }
+
+ /**
+ * Create ArrayValueMatcher to match specified element in actual array
+ * against first element of expected array.
+ *
+ * @param comparator
+ * comparator to use to compare elements
+ * @param index
+ * index of the array element to be compared
+ */
+ public ArrayValueMatcher(JSONComparator comparator, int index) {
+ this(comparator, index, index);
+ }
+
+ /**
+ * Create ArrayValueMatcher to match every element in specified range
+ * (inclusive) from actual array against elements taken in sequence from
+ * expected array, repeating from start of expected array if necessary.
+ *
+ * @param comparator
+ * comparator to use to compare elements
+ * @param from first element in actual array to compared
+ * @param to last element in actual array to compared
+ */
+ public ArrayValueMatcher(JSONComparator comparator, int from, int to) {
+ assert comparator != null : "comparator null";
+ assert from >= 0 : MessageFormat.format("from({0}) < 0", from);
+ assert to >= from : MessageFormat.format("to({0}) < from({1})", to,
+ from);
+ this.comparator = comparator;
+ this.from = from;
+ this.to = to;
+ }
+
+ @Override
+ /*
+ * NOTE: method defined as required by ValueMatcher interface but will never
+ * be called so defined simply to indicate match failure
+ */
+ public boolean equal(T o1, T o2) {
+ return false;
+ }
+
+ @Override
+ public boolean equal(String prefix, T actual, T expected, JSONCompareResult result) {
+ if (!(actual instanceof JSONArray)) {
+ throw new IllegalArgumentException("ArrayValueMatcher applied to non-array actual value");
+ }
+ try {
+ JSONArray actualArray = (JSONArray) actual;
+ JSONArray expectedArray = expected instanceof JSONArray ? (JSONArray) expected: new JSONArray(new Object[] { expected });
+ int first = Math.max(0, from);
+ int last = Math.min(actualArray.length() - 1, to);
+ int expectedLen = expectedArray.length();
+ for (int i = first; i <= last; i++) {
+ String elementPrefix = MessageFormat.format("{0}[{1}]", prefix, i);
+ Object actualElement = actualArray.get(i);
+ Object expectedElement = expectedArray.get((i - first) % expectedLen);
+ comparator.compareValues(elementPrefix, expectedElement, actualElement, result);
+ }
+ // any failures have already been passed to result, so return true
+ return true;
+ }
+ catch (JSONException e) {
+ return false;
+ }
+ }
+
+}
diff --git a/src/main/java/org/skyscreamer/jsonassert/Customization.java b/src/main/java/org/skyscreamer/jsonassert/Customization.java
index 71155a0b..c812a447 100644
--- a/src/main/java/org/skyscreamer/jsonassert/Customization.java
+++ b/src/main/java/org/skyscreamer/jsonassert/Customization.java
@@ -1,28 +1,151 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert;
+import java.util.regex.Pattern;
+
/**
* Associates a custom matcher to a specific jsonpath.
*/
public final class Customization {
- private final String path;
+ private final Pattern path;
private final ValueMatcher comparator;
public Customization(String path, ValueMatcher comparator) {
assert path != null;
assert comparator != null;
- this.path = path;
+ this.path = Pattern.compile(buildPattern(path));
this.comparator = comparator;
}
+ private String buildPattern(String path) {
+ return buildPatternLevel1(path);
+ }
+
+ private String buildPatternLevel1(String path) {
+ String regex = "\\*\\*\\.";
+ String replacement = "(?:.+\\.)?";
+
+ return buildPattern(path, regex, replacement, 1);
+ }
+
+ private String buildPatternLevel2(String s) {
+ if (s.isEmpty()) {
+ return "";
+ }
+ String regex = "\\*\\*";
+ String replacement = ".+";
+
+ return buildPattern(s, regex, replacement, 2);
+ }
+
+ private String buildPatternLevel3(String s) {
+ if (s.isEmpty()) {
+ return "";
+ }
+
+ String regex = "\\*";
+ String replacement = "[^\\.]+";
+
+ return buildPattern(s, regex, replacement, 3);
+ }
+
+ private String buildPattern(String path, String regex, String replacement, int level) {
+ StringBuilder sb = new StringBuilder();
+ String[] parts = path.split(regex);
+ for (int i = 0; i < parts.length; i++) {
+ sb.append(buildPatternForLevel(level, parts[i]));
+ if (i < parts.length - 1) {
+ sb.append(replacement);
+ }
+ }
+ return sb.toString();
+ }
+
+ private String buildPatternForLevel(int level, String part) {
+ switch (level) {
+ case 1:
+ return buildPatternLevel2(part);
+ case 2:
+ return buildPatternLevel3(part);
+ case 3:
+ return Pattern.quote(part);
+ default:
+ return "Incorrect level.";
+ }
+ }
+
+ /**
+ * Creates a new {@link Customization} instance for {@code path} and {@code comparator}.
+ *
+ * @param path the json path
+ * @param comparator the comparator
+ * @return a new Customization
+ */
public static Customization customization(String path, ValueMatcher comparator) {
return new Customization(path, comparator);
}
public boolean appliesToPath(String path) {
- return this.path.equals(path);
+ return this.path.matcher(path).matches();
}
+ /**
+ * Return true if actual value matches expected value using this
+ * Customization's comparator. Calls to this method should be replaced by
+ * calls to matches(String prefix, Object actual, Object expected,
+ * JSONCompareResult result).
+ *
+ * @param actual
+ * JSON value being tested
+ * @param expected
+ * expected JSON value
+ * @return true if actual value matches expected value
+ */
+ @Deprecated
public boolean matches(Object actual, Object expected) {
return comparator.equal(actual, expected);
}
+
+ /**
+ * Return true if actual value matches expected value using this
+ * Customization's comparator. The equal method used for comparison depends
+ * on type of comparator.
+ *
+ * @param prefix
+ * JSON path of the JSON item being tested (only used if
+ * comparator is a LocationAwareValueMatcher)
+ * @param actual
+ * JSON value being tested
+ * @param expected
+ * expected JSON value
+ * @param result
+ * JSONCompareResult to which match failure may be passed (only
+ * used if comparator is a LocationAwareValueMatcher)
+ * @return true if expected and actual equal or any difference has already
+ * been passed to specified result instance, false otherwise.
+ * @throws ValueMatcherException
+ * if expected and actual values not equal and ValueMatcher
+ * needs to override default comparison failure message that
+ * would be generated if this method returned false.
+ */
+ public boolean matches(String prefix, Object actual, Object expected,
+ JSONCompareResult result) throws ValueMatcherException {
+ if (comparator instanceof LocationAwareValueMatcher) {
+ return ((LocationAwareValueMatcher)comparator).equal(prefix, actual, expected, result);
+ }
+ return comparator.equal(actual, expected);
+ }
}
diff --git a/src/main/java/org/skyscreamer/jsonassert/FieldComparisonFailure.java b/src/main/java/org/skyscreamer/jsonassert/FieldComparisonFailure.java
index 73d5b4d9..a4746f24 100644
--- a/src/main/java/org/skyscreamer/jsonassert/FieldComparisonFailure.java
+++ b/src/main/java/org/skyscreamer/jsonassert/FieldComparisonFailure.java
@@ -1,3 +1,17 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert;
/**
diff --git a/src/main/java/org/skyscreamer/jsonassert/JSONAssert.java b/src/main/java/org/skyscreamer/jsonassert/JSONAssert.java
index 10ce2c1b..5a2eec18 100644
--- a/src/main/java/org/skyscreamer/jsonassert/JSONAssert.java
+++ b/src/main/java/org/skyscreamer/jsonassert/JSONAssert.java
@@ -1,7 +1,20 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert;
import org.json.JSONArray;
-import org.json.JSONException;
import org.json.JSONObject;
import org.skyscreamer.jsonassert.comparator.JSONComparator;
@@ -45,28 +58,52 @@ private JSONAssert() {}
* @param expectedStr Expected JSON string
* @param actual JSONObject to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertEquals(String expectedStr, JSONObject actual, boolean strict)
- throws JSONException {
+ public static void assertEquals(String expectedStr, JSONObject actual, boolean strict) {
assertEquals(expectedStr, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
+
+ /**
+ * Asserts that the JSONObject 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 actual JSONObject to compare
+ * @param strict Enables strict checking
+ */
+ public static void assertEquals(String message, String expectedStr, JSONObject actual, boolean strict) {
+ assertEquals(message, expectedStr, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
/**
* Asserts that the JSONObject provided does not match the expected string. If it is it throws an
* {@link AssertionError}.
*
- * @see #assertEquals(String JSONObject, boolean)
+ * @see #assertEquals(String, JSONObject, boolean)
*
* @param expectedStr Expected JSON string
* @param actual JSONObject to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertNotEquals(String expectedStr, JSONObject actual, boolean strict)
- throws JSONException {
+ public static void assertNotEquals(String expectedStr, JSONObject actual, boolean strict) {
assertNotEquals(expectedStr, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
+
+ /**
+ * Asserts that the JSONObject provided does not match the expected string. If it is it throws an
+ * {@link AssertionError}.
+ *
+ * @see #assertEquals(String, JSONObject, boolean)
+ *
+ * @param message Error message to be displayed in case of assertion failure
+ * @param expectedStr Expected JSON string
+ * @param actual JSONObject to compare
+ * @param strict Enables strict checking
+ */
+ public static void assertNotEquals(String message, String expectedStr, JSONObject actual, boolean strict) {
+ assertNotEquals(message, expectedStr, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
/**
* Asserts that the JSONObject provided matches the expected string. If it isn't it throws an
@@ -75,13 +112,25 @@ public static void assertNotEquals(String expectedStr, JSONObject actual, boolea
* @param expectedStr Expected JSON string
* @param actual JSONObject to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertEquals(String expectedStr, JSONObject actual, JSONCompareMode compareMode)
- throws JSONException {
+ public static void assertEquals(String expectedStr, JSONObject actual, JSONCompareMode compareMode) {
+ assertEquals("", expectedStr, actual, compareMode);
+ }
+
+ /**
+ * Asserts that the JSONObject 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 actual JSONObject to compare
+ * @param compareMode Specifies which comparison mode to use
+ */
+ public static void assertEquals(String message, String expectedStr, JSONObject actual, JSONCompareMode compareMode)
+ {
Object expected = JSONParser.parseJSON(expectedStr);
if (expected instanceof JSONObject) {
- assertEquals((JSONObject)expected, actual, compareMode);
+ assertEquals(message, (JSONObject)expected, actual, compareMode);
}
else {
throw new AssertionError("Expecting a JSON array, but passing in a JSON object");
@@ -97,13 +146,27 @@ public static void assertEquals(String expectedStr, JSONObject actual, JSONCompa
* @param expectedStr Expected JSON string
* @param actual JSONObject to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertNotEquals(String expectedStr, JSONObject actual, JSONCompareMode compareMode)
- throws JSONException {
+ public static void assertNotEquals(String expectedStr, JSONObject actual, JSONCompareMode compareMode) {
+ assertNotEquals("", expectedStr, actual, compareMode);
+ }
+
+ /**
+ * Asserts that the JSONObject provided does not match the expected string. If it is it throws an
+ * {@link AssertionError}.
+ *
+ * @see #assertEquals(String, JSONObject, JSONCompareMode)
+ *
+ * @param message Error message to be displayed in case of assertion failure
+ * @param expectedStr Expected JSON string
+ * @param actual JSONObject to compare
+ * @param compareMode Specifies which comparison mode to use
+ */
+ public static void assertNotEquals(String message, String expectedStr, JSONObject actual,
+ JSONCompareMode compareMode) {
Object expected = JSONParser.parseJSON(expectedStr);
if (expected instanceof JSONObject) {
- assertNotEquals((JSONObject) expected, actual, compareMode);
+ assertNotEquals(message, (JSONObject) expected, actual, compareMode);
}
else {
throw new AssertionError("Expecting a JSON array, but passing in a JSON object");
@@ -117,12 +180,23 @@ public static void assertNotEquals(String expectedStr, JSONObject actual, JSONCo
* @param expectedStr Expected JSON string
* @param actual JSONArray to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertEquals(String expectedStr, JSONArray actual, boolean strict)
- throws JSONException {
+ public static void assertEquals(String expectedStr, JSONArray actual, boolean strict) {
assertEquals(expectedStr, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
+
+ /**
+ * 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 actual JSONArray to compare
+ * @param strict Enables strict checking
+ */
+ public static void assertEquals(String message, String expectedStr, JSONArray actual, boolean strict) {
+ assertEquals(message, expectedStr, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
/**
* Asserts that the JSONArray provided does not match the expected string. If it is it throws an
@@ -131,12 +205,23 @@ public static void assertEquals(String expectedStr, JSONArray actual, boolean st
* @param expectedStr Expected JSON string
* @param actual JSONArray to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertNotEquals(String expectedStr, JSONArray actual, boolean strict)
- throws JSONException {
+ public static void assertNotEquals(String expectedStr, JSONArray actual, boolean strict) {
assertNotEquals(expectedStr, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
+
+ /**
+ * Asserts that the JSONArray provided does not match the expected string. If it is it throws an
+ * {@link AssertionError}.
+ *
+ * @param message Error message to be displayed in case of assertion failure
+ * @param expectedStr Expected JSON string
+ * @param actual JSONArray to compare
+ * @param strict Enables strict checking
+ */
+ public static void assertNotEquals(String message, String expectedStr, JSONArray actual, boolean strict) {
+ assertNotEquals(message, expectedStr, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
/**
* Asserts that the JSONArray provided matches the expected string. If it isn't it throws an
@@ -145,13 +230,24 @@ public static void assertNotEquals(String expectedStr, JSONArray actual, boolean
* @param expectedStr Expected JSON string
* @param actual JSONArray to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertEquals(String expectedStr, JSONArray actual, JSONCompareMode compareMode)
- throws JSONException {
+ public static void assertEquals(String expectedStr, JSONArray actual, JSONCompareMode compareMode) {
+ assertEquals("", expectedStr, actual, compareMode);
+ }
+
+ /**
+ * 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 actual JSONArray to compare
+ * @param compareMode Specifies which comparison mode to use
+ */
+ public static void assertEquals(String message, String expectedStr, JSONArray actual, JSONCompareMode compareMode) {
Object expected = JSONParser.parseJSON(expectedStr);
if (expected instanceof JSONArray) {
- assertEquals((JSONArray) expected, actual, compareMode);
+ assertEquals(message, (JSONArray) expected, actual, compareMode);
}
else {
throw new AssertionError("Expecting a JSON object, but passing in a JSON array");
@@ -165,10 +261,8 @@ public static void assertEquals(String expectedStr, JSONArray actual, JSONCompar
* @param expectedStr Expected JSON string
* @param actual JSONArray to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertNotEquals(String expectedStr, JSONArray actual, JSONCompareMode compareMode)
- throws JSONException {
+ public static void assertNotEquals(String expectedStr, JSONArray actual, JSONCompareMode compareMode) {
Object expected = JSONParser.parseJSON(expectedStr);
if (expected instanceof JSONArray) {
assertNotEquals((JSONArray) expected, actual, compareMode);
@@ -177,6 +271,26 @@ public static void assertNotEquals(String expectedStr, JSONArray actual, JSONCom
throw new AssertionError("Expecting a JSON object, but passing in a JSON array");
}
}
+
+ /**
+ * Asserts that the JSONArray provided does not match the expected string. If it is it throws an
+ * {@link AssertionError}.
+ *
+ * @param message Error message to be displayed in case of assertion failure
+ * @param expectedStr Expected JSON string
+ * @param actual JSONArray to compare
+ * @param compareMode Specifies which comparison mode to use
+ */
+ public static void assertNotEquals(String message, String expectedStr, JSONArray actual,
+ JSONCompareMode compareMode) {
+ Object expected = JSONParser.parseJSON(expectedStr);
+ if (expected instanceof JSONArray) {
+ assertNotEquals(message, (JSONArray) expected, actual, compareMode);
+ }
+ else {
+ throw new AssertionError("Expecting a JSON object, but passing in a JSON array");
+ }
+ }
/**
* Asserts that the JSONArray provided matches the expected string. If it isn't it throws an
@@ -185,12 +299,23 @@ public static void assertNotEquals(String expectedStr, JSONArray actual, JSONCom
* @param expectedStr Expected JSON string
* @param actualStr String to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertEquals(String expectedStr, String actualStr, boolean strict)
- throws JSONException {
+ public static void assertEquals(String expectedStr, String actualStr, boolean strict) {
assertEquals(expectedStr, actualStr, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
+
+ /**
+ * 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 strict Enables strict checking
+ */
+ public static void assertEquals(String message, String expectedStr, String actualStr, boolean strict) {
+ assertEquals(message, expectedStr, actualStr, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
/**
* Asserts that the JSONArray provided does not match the expected string. If it is it throws an
@@ -199,12 +324,23 @@ public static void assertEquals(String expectedStr, String actualStr, boolean st
* @param expectedStr Expected JSON string
* @param actualStr String to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertNotEquals(String expectedStr, String actualStr, boolean strict)
- throws JSONException {
+ public static void assertNotEquals(String expectedStr, String actualStr, boolean strict) {
assertNotEquals(expectedStr, actualStr, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
+
+ /**
+ * Asserts that the JSONArray provided does not match the expected string. If it is 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 strict Enables strict checking
+ */
+ public static void assertNotEquals(String message, String expectedStr, String actualStr, boolean strict) {
+ assertNotEquals(message, expectedStr, actualStr, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
/**
* Asserts that the JSONArray provided matches the expected string. If it isn't it throws an
@@ -213,13 +349,30 @@ public static void assertNotEquals(String expectedStr, String actualStr, boolean
* @param expectedStr Expected JSON string
* @param actualStr String to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertEquals(String expectedStr, String actualStr, JSONCompareMode compareMode)
- throws JSONException {
+ public static void assertEquals(String expectedStr, String actualStr, JSONCompareMode compareMode) {
+ assertEquals("", expectedStr, actualStr, compareMode);
+ }
+
+ /**
+ * 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
+ */
+ public static void assertEquals(String message, String expectedStr, String actualStr, JSONCompareMode compareMode) {
+ 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(result.getMessage());
+ throw new AssertionError(getCombinedMessage(message, result.getMessage()));
}
}
@@ -230,13 +383,25 @@ public static void assertEquals(String expectedStr, String actualStr, JSONCompar
* @param expectedStr Expected JSON string
* @param actualStr String to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertNotEquals(String expectedStr, String actualStr, JSONCompareMode compareMode)
- throws JSONException {
+ public static void assertNotEquals(String expectedStr, String actualStr, JSONCompareMode compareMode) {
+ assertNotEquals("", expectedStr, actualStr, compareMode);
+ }
+
+ /**
+ * Asserts that the JSONArray provided does not match the expected string. If it is 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
+ */
+ public static void assertNotEquals(String message, String expectedStr, String actualStr,
+ JSONCompareMode compareMode) {
JSONCompareResult result = JSONCompare.compareJSON(expectedStr, actualStr, compareMode);
if (result.passed()) {
- throw new AssertionError(result.getMessage());
+ throw new AssertionError(getCombinedMessage(message, result.getMessage()));
}
}
@@ -247,13 +412,25 @@ public static void assertNotEquals(String expectedStr, String actualStr, JSONCom
* @param expectedStr Expected JSON string
* @param actualStr String to compare
* @param comparator Comparator
- * @throws JSONException
*/
- public static void assertEquals(String expectedStr, String actualStr, JSONComparator comparator)
- throws JSONException {
+ public static void assertEquals(String expectedStr, String actualStr, JSONComparator comparator) {
+ assertEquals("", expectedStr, actualStr, comparator);
+
+ }
+
+ /**
+ * 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
+ */
+ public static void assertEquals(String message, String expectedStr, String actualStr, JSONComparator comparator) {
JSONCompareResult result = JSONCompare.compareJSON(expectedStr, actualStr, comparator);
if (result.failed()) {
- throw new AssertionError(result.getMessage());
+ throw new AssertionError(getCombinedMessage(message, result.getMessage()));
}
}
@@ -264,16 +441,85 @@ public static void assertEquals(String expectedStr, String actualStr, JSONCompar
* @param expectedStr Expected JSON string
* @param actualStr String to compare
* @param comparator Comparator
- * @throws JSONException
*/
- public static void assertNotEquals(String expectedStr, String actualStr, JSONComparator comparator)
- throws JSONException {
+ public static void assertNotEquals(String expectedStr, String actualStr, JSONComparator comparator) {
+ assertNotEquals("", expectedStr, actualStr, comparator);
+ }
+
+ /**
+ * Asserts that the json string provided does not match the expected string. If it is 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
+ */
+ public static void assertNotEquals(String message, String expectedStr, String actualStr,
+ JSONComparator comparator) {
JSONCompareResult result = JSONCompare.compareJSON(expectedStr, actualStr, comparator);
if (result.passed()) {
- throw new AssertionError(result.getMessage());
+ 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 expected Expected JSONObject
+ * @param actual JSONObject to compare
+ * @param comparator Comparator
+ */
+ public static void assertEquals(JSONObject expected, JSONObject actual, JSONComparator comparator) {
+ assertEquals("", expected, actual, comparator);
+ }
+
+ /**
+ * 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 comparator Comparator
+ */
+ public static void assertEquals(String message, JSONObject expected, JSONObject actual, JSONComparator comparator) {
+ JSONCompareResult result = JSONCompare.compareJSON(expected, actual, comparator);
+ if (result.failed()) {
+ throw new AssertionError(getCombinedMessage(message, result.getMessage()));
+ }
+ }
+
+ /**
+ * Asserts that the JSONObject provided does not match the expected JSONObject. If it is it throws an
+ * {@link AssertionError}.
+ *
+ * @param expected Expected JSONObject
+ * @param actual JSONObject to compare
+ * @param comparator Comparator
+ */
+ public static void assertNotEquals(JSONObject expected, JSONObject actual, JSONComparator comparator) {
+ assertNotEquals("", expected, actual, comparator);
+ }
+
+ /**
+ * Asserts that the JSONObject provided does not match the expected JSONObject. If it is 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 comparator Comparator
+ */
+ public static void assertNotEquals(String message, JSONObject expected, JSONObject actual,
+ JSONComparator comparator) {
+ JSONCompareResult result = JSONCompare.compareJSON(expected, actual, comparator);
+ if (result.passed()) {
+ 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}.
@@ -281,12 +527,23 @@ public static void assertNotEquals(String expectedStr, String actualStr, JSONCom
* @param expected Expected JSONObject
* @param actual JSONObject to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertEquals(JSONObject expected, JSONObject actual, boolean strict)
- throws JSONException {
+ public static void assertEquals(JSONObject expected, JSONObject actual, boolean strict) {
assertEquals(expected, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
+
+ /**
+ * 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 strict Enables strict checking
+ */
+ public static void assertEquals(String message, JSONObject expected, JSONObject actual, boolean strict) {
+ assertEquals(message, expected, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
/**
* Asserts that the JSONObject provided does not match the expected JSONObject. If it is it throws an
@@ -295,12 +552,23 @@ public static void assertEquals(JSONObject expected, JSONObject actual, boolean
* @param expected Expected JSONObject
* @param actual JSONObject to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertNotEquals(JSONObject expected, JSONObject actual, boolean strict)
- throws JSONException {
+ public static void assertNotEquals(JSONObject expected, JSONObject actual, boolean strict) {
assertNotEquals(expected, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
+
+ /**
+ * Asserts that the JSONObject provided does not match the expected JSONObject. If it is 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 strict Enables strict checking
+ */
+ public static void assertNotEquals(String message, JSONObject expected, JSONObject actual, boolean strict) {
+ assertNotEquals(message, expected, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
/**
* Asserts that the JSONObject provided matches the expected JSONObject. If it isn't it throws an
@@ -309,14 +577,25 @@ public static void assertNotEquals(JSONObject expected, JSONObject actual, boole
* @param expected Expected JSONObject
* @param actual JSONObject to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertEquals(JSONObject expected, JSONObject actual, JSONCompareMode compareMode)
- throws JSONException
- {
+ public static void assertEquals(JSONObject expected, JSONObject actual, JSONCompareMode compareMode) {
+ assertEquals("", expected, actual, compareMode);
+ }
+
+ /**
+ * 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
+ */
+ public static void assertEquals(String message, JSONObject expected, JSONObject actual,
+ JSONCompareMode compareMode) {
JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
if (result.failed()) {
- throw new AssertionError(result.getMessage());
+ throw new AssertionError(getCombinedMessage(message, result.getMessage()));
}
}
@@ -327,14 +606,25 @@ public static void assertEquals(JSONObject expected, JSONObject actual, JSONComp
* @param expected Expected JSONObject
* @param actual JSONObject to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertNotEquals(JSONObject expected, JSONObject actual, JSONCompareMode compareMode)
- throws JSONException
- {
+ public static void assertNotEquals(JSONObject expected, JSONObject actual, JSONCompareMode compareMode) {
+ assertNotEquals("", expected, actual, compareMode);
+ }
+
+ /**
+ * Asserts that the JSONObject provided does not match the expected JSONObject. If it is 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
+ */
+ public static void assertNotEquals(String message, JSONObject expected, JSONObject actual,
+ JSONCompareMode compareMode) {
JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
if (result.passed()) {
- throw new AssertionError(result.getMessage());
+ throw new AssertionError(getCombinedMessage(message, result.getMessage()));
}
}
@@ -345,11 +635,22 @@ public static void assertNotEquals(JSONObject expected, JSONObject actual, JSONC
* @param expected Expected JSONArray
* @param actual JSONArray to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertEquals(JSONArray expected, JSONArray actual, boolean strict)
- throws JSONException {
- assertEquals(expected, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ public static void assertEquals(JSONArray expected, JSONArray actual, boolean strict) {
+ assertEquals("", expected, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
+
+ /**
+ * 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 strict Enables strict checking
+ */
+ public static void assertEquals(String message, JSONArray expected, JSONArray actual, boolean strict) {
+ assertEquals(message, expected, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
/**
@@ -359,12 +660,23 @@ public static void assertEquals(JSONArray expected, JSONArray actual, boolean st
* @param expected Expected JSONArray
* @param actual JSONArray to compare
* @param strict Enables strict checking
- * @throws JSONException
*/
- public static void assertNotEquals(JSONArray expected, JSONArray actual, boolean strict)
- throws JSONException {
+ public static void assertNotEquals(JSONArray expected, JSONArray actual, boolean strict) {
assertNotEquals(expected, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
}
+
+ /**
+ * Asserts that the JSONArray provided does not match the expected JSONArray. If it is 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 strict Enables strict checking
+ */
+ public static void assertNotEquals(String message, JSONArray expected, JSONArray actual, boolean strict) {
+ assertNotEquals(message, expected, actual, strict ? JSONCompareMode.STRICT : JSONCompareMode.LENIENT);
+ }
/**
* Asserts that the JSONArray provided matches the expected JSONArray. If it isn't it throws an
@@ -373,13 +685,24 @@ public static void assertNotEquals(JSONArray expected, JSONArray actual, boolean
* @param expected Expected JSONArray
* @param actual JSONArray to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertEquals(JSONArray expected, JSONArray actual, JSONCompareMode compareMode)
- throws JSONException {
+ public static void assertEquals(JSONArray expected, JSONArray actual, JSONCompareMode compareMode) {
+ assertEquals("", expected, actual, compareMode);
+ }
+
+ /**
+ * 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
+ */
+ public static void assertEquals(String message, JSONArray expected, JSONArray actual, JSONCompareMode compareMode) {
JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
if (result.failed()) {
- throw new AssertionError(result.getMessage());
+ throw new AssertionError(getCombinedMessage(message, result.getMessage()));
}
}
@@ -390,13 +713,36 @@ public static void assertEquals(JSONArray expected, JSONArray actual, JSONCompar
* @param expected Expected JSONArray
* @param actual JSONArray to compare
* @param compareMode Specifies which comparison mode to use
- * @throws JSONException
*/
- public static void assertNotEquals(JSONArray expected, JSONArray actual, JSONCompareMode compareMode)
- throws JSONException {
+ public static void assertNotEquals(JSONArray expected, JSONArray actual, JSONCompareMode compareMode) {
+ assertNotEquals("", expected, actual, compareMode);
+ }
+
+ /**
+ * Asserts that the JSONArray provided does not match the expected JSONArray. If it is 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
+ */
+ public static void assertNotEquals(String message, JSONArray expected, JSONArray actual,
+ JSONCompareMode compareMode) {
JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
if (result.passed()) {
- throw new AssertionError(result.getMessage());
+ throw new AssertionError(getCombinedMessage(message, result.getMessage()));
+ }
+ }
+
+ private static String getCombinedMessage(String message1, String message2) {
+ String combinedMessage = "";
+
+ if(message1 == null || "".equals(message1)) {
+ combinedMessage = message2;
+ } else {
+ combinedMessage = message1 + " " + message2;
}
+ return combinedMessage;
}
}
diff --git a/src/main/java/org/skyscreamer/jsonassert/JSONCompare.java b/src/main/java/org/skyscreamer/jsonassert/JSONCompare.java
index fc41bf4f..c17115df 100644
--- a/src/main/java/org/skyscreamer/jsonassert/JSONCompare.java
+++ b/src/main/java/org/skyscreamer/jsonassert/JSONCompare.java
@@ -1,7 +1,20 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert;
import org.json.JSONArray;
-import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONString;
import org.skyscreamer.jsonassert.comparator.DefaultComparator;
@@ -27,11 +40,9 @@ private static JSONComparator getComparatorForMode(JSONCompareMode mode) {
* @param actualStr JSON string to compare
* @param comparator Comparator to use
* @return result of the comparison
- * @throws JSONException
* @throws IllegalArgumentException when type of expectedStr doesn't match the type of actualStr
*/
- public static JSONCompareResult compareJSON(String expectedStr, String actualStr, JSONComparator comparator)
- throws JSONException {
+ public static JSONCompareResult compareJSON(String expectedStr, String actualStr, JSONComparator comparator) {
Object expected = JSONParser.parseJSON(expectedStr);
Object actual = JSONParser.parseJSON(actualStr);
if ((expected instanceof JSONObject) && (actual instanceof JSONObject)) {
@@ -58,10 +69,8 @@ else if (expected instanceof JSONObject) {
* @param actual actual json object
* @param comparator comparator to use
* @return result of the comparison
- * @throws JSONException
*/
- public static JSONCompareResult compareJSON(JSONObject expected, JSONObject actual, JSONComparator comparator)
- throws JSONException {
+ public static JSONCompareResult compareJSON(JSONObject expected, JSONObject actual, JSONComparator comparator) {
return comparator.compareJSON(expected, actual);
}
@@ -72,10 +81,8 @@ public static JSONCompareResult compareJSON(JSONObject expected, JSONObject actu
* @param actual actual json array
* @param comparator comparator to use
* @return result of the comparison
- * @throws JSONException
*/
- public static JSONCompareResult compareJSON(JSONArray expected, JSONArray actual, JSONComparator comparator)
- throws JSONException {
+ public static JSONCompareResult compareJSON(JSONArray expected, JSONArray actual, JSONComparator comparator) {
return comparator.compareJSON(expected, actual);
}
@@ -85,6 +92,7 @@ public static JSONCompareResult compareJSON(JSONArray expected, JSONArray actual
*
* @param expected Expected {@code JSONstring}
* @param actual {@code JSONstring} to compare
+ * @return result of the comparison
*/
public static JSONCompareResult compareJson(final JSONString expected, final JSONString actual) {
final JSONCompareResult result = new JSONCompareResult();
@@ -102,10 +110,9 @@ public static JSONCompareResult compareJson(final JSONString expected, final JSO
* @param expectedStr Expected JSON string
* @param actualStr JSON string to compare
* @param mode Defines comparison behavior
- * @throws JSONException
+ * @return result of the comparison
*/
- public static JSONCompareResult compareJSON(String expectedStr, String actualStr, JSONCompareMode mode)
- throws JSONException {
+ public static JSONCompareResult compareJSON(String expectedStr, String actualStr, JSONCompareMode mode) {
return compareJSON(expectedStr, actualStr, getComparatorForMode(mode));
}
@@ -115,10 +122,9 @@ public static JSONCompareResult compareJSON(String expectedStr, String actualStr
* @param expected Expected JSONObject
* @param actual JSONObject to compare
* @param mode Defines comparison behavior
- * @throws JSONException
+ * @return result of the comparison
*/
- public static JSONCompareResult compareJSON(JSONObject expected, JSONObject actual, JSONCompareMode mode)
- throws JSONException {
+ public static JSONCompareResult compareJSON(JSONObject expected, JSONObject actual, JSONCompareMode mode) {
return compareJSON(expected, actual, getComparatorForMode(mode));
}
@@ -129,10 +135,9 @@ public static JSONCompareResult compareJSON(JSONObject expected, JSONObject actu
* @param expected Expected JSONArray
* @param actual JSONArray to compare
* @param mode Defines comparison behavior
- * @throws JSONException
+ * @return result of the comparison
*/
- public static JSONCompareResult compareJSON(JSONArray expected, JSONArray actual, JSONCompareMode mode)
- throws JSONException {
+ public static JSONCompareResult compareJSON(JSONArray expected, JSONArray actual, JSONCompareMode mode) {
return compareJSON(expected, actual, getComparatorForMode(mode));
}
diff --git a/src/main/java/org/skyscreamer/jsonassert/JSONCompareMode.java b/src/main/java/org/skyscreamer/jsonassert/JSONCompareMode.java
index a4df7e07..8185b065 100644
--- a/src/main/java/org/skyscreamer/jsonassert/JSONCompareMode.java
+++ b/src/main/java/org/skyscreamer/jsonassert/JSONCompareMode.java
@@ -1,3 +1,17 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert;
/**
@@ -5,6 +19,9 @@
* Each mode encapsulates two underlying behaviors: extensibility and strict ordering.
*
*
+ *
+ * Behavior of JSONCompareMode
+ *
* Extensible Strict Ordering STRICT no yes LENIENT yes no _fieldFailures = new ArrayList();
+ private final List _fieldMissing = new ArrayList();
+ private final List _fieldUnexpected = new ArrayList();
/**
* Default constructor.
@@ -56,10 +72,27 @@ public String getMessage() {
/**
* Get the list of failures on field comparisons
+ * @return list of comparsion failures
*/
public List getFieldFailures() {
return Collections.unmodifiableList(_fieldFailures);
}
+
+ /**
+ * Get the list of missed on field comparisons
+ * @return list of comparsion failures
+ */
+ public List getFieldMissing() {
+ return Collections.unmodifiableList(_fieldMissing);
+ }
+
+ /**
+ * Get the list of failures on field comparisons
+ * @return list of comparsion failures
+ */
+ public List getFieldUnexpected() {
+ return Collections.unmodifiableList(_fieldUnexpected);
+ }
/**
* Actual field value
@@ -69,6 +102,7 @@ public List getFieldFailures() {
* particular field
* @deprecated Superseded by {@link #getFieldFailures()}
*/
+ @Deprecated
public Object getActual() {
return _actual;
}
@@ -81,16 +115,34 @@ public Object getActual() {
* particular field
* @deprecated Superseded by {@link #getFieldFailures()}
*/
+ @Deprecated
public Object getExpected() {
return _expected;
}
/**
* Check if comparison failed on any particular fields
+ * @return true if there are field failures
*/
public boolean isFailureOnField() {
return !_fieldFailures.isEmpty();
}
+
+ /**
+ * Check if comparison failed with missing on any particular fields
+ * @return true if an expected field is missing
+ */
+ public boolean isMissingOnField() {
+ return !_fieldMissing.isEmpty();
+ }
+
+ /**
+ * Check if comparison failed with unexpected on any particular fields
+ * @return true if an unexpected field is in the result
+ */
+ public boolean isUnexpectedOnField() {
+ return !_fieldUnexpected.isEmpty();
+ }
/**
* Dot-separated path the the field that failed comparison
@@ -99,6 +151,7 @@ public boolean isFailureOnField() {
* not fail on a particular field
* @deprecated Superseded by {@link #getFieldFailures()}
*/
+ @Deprecated
public String getField() {
return _field;
}
@@ -117,6 +170,7 @@ public void fail(String message) {
* @param field Which field failed
* @param expected Expected result
* @param actual Actual result
+ * @return result of comparision
*/
public JSONCompareResult fail(String field, Object expected, Object actual) {
_fieldFailures.add(new FieldComparisonFailure(field, expected, actual));
@@ -127,6 +181,17 @@ public JSONCompareResult fail(String field, Object expected, Object actual) {
return this;
}
+ /**
+ * Identify that the comparison failed
+ * @param field Which field failed
+ * @param exception exception containing details of match failure
+ * @return result of comparision
+ */
+ public JSONCompareResult fail(String field, ValueMatcherException exception) {
+ fail(field + ": " + exception.getMessage(), exception.getExpected(), exception.getActual());
+ return this;
+ }
+
private String formatFailureMessage(String field, Object expected, Object actual) {
return field
+ "\nExpected: "
@@ -136,7 +201,14 @@ private String formatFailureMessage(String field, Object expected, Object actual
+ "\n";
}
+ /**
+ * Identify the missing field
+ * @param field missing field
+ * @param expected expected result
+ * @return result of comparison
+ */
public JSONCompareResult missing(String field, Object expected) {
+ _fieldMissing.add(new FieldComparisonFailure(field, expected, null));
fail(formatMissing(field, expected));
return this;
}
@@ -148,15 +220,22 @@ private String formatMissing(String field, Object expected) {
+ "\n but none found\n";
}
- public JSONCompareResult unexpected(String field, Object value) {
- fail(formatUnexpected(field, value));
+ /**
+ * Identify unexpected field
+ * @param field unexpected field
+ * @param actual actual result
+ * @return result of comparison
+ */
+ public JSONCompareResult unexpected(String field, Object actual) {
+ _fieldUnexpected.add(new FieldComparisonFailure(field, null, actual));
+ fail(formatUnexpected(field, actual));
return this;
}
- private String formatUnexpected(String field, Object value) {
+ private String formatUnexpected(String field, Object actual) {
return field
+ "\nUnexpected: "
- + describe(value)
+ + describe(actual)
+ "\n";
}
@@ -166,7 +245,7 @@ private static String describe(Object value) {
} else if (value instanceof JSONObject) {
return "a JSON object";
} else {
- return value.toString();
+ return String.valueOf(value);
}
}
diff --git a/src/main/java/org/skyscreamer/jsonassert/JSONParser.java b/src/main/java/org/skyscreamer/jsonassert/JSONParser.java
index 45df77c1..a70af96c 100644
--- a/src/main/java/org/skyscreamer/jsonassert/JSONParser.java
+++ b/src/main/java/org/skyscreamer/jsonassert/JSONParser.java
@@ -1,3 +1,17 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert;
import org.json.JSONArray;
@@ -22,9 +36,8 @@ private JSONParser() {}
*
* @param s Raw JSON string to be parsed
* @return JSONObject or JSONArray
- * @throws JSONException
*/
- public static Object parseJSON(final String s) throws JSONException {
+ public static Object parseJSON(final String s) {
if (s.trim().startsWith("{")) {
return new JSONObject(s);
}
diff --git a/src/main/java/org/skyscreamer/jsonassert/LocationAwareValueMatcher.java b/src/main/java/org/skyscreamer/jsonassert/LocationAwareValueMatcher.java
new file mode 100644
index 00000000..cc2b7449
--- /dev/null
+++ b/src/main/java/org/skyscreamer/jsonassert/LocationAwareValueMatcher.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+/**
+ *
+ */
+package org.skyscreamer.jsonassert;
+
+/**
+ * A ValueMatcher extension that provides location in form of prefix to the equals method.
+ *
+ * @author Duncan Mackinder
+ * @param Generic Type
+ */
+public interface LocationAwareValueMatcher extends ValueMatcher {
+
+ /**
+ * Match actual value with expected value. If match fails any of the
+ * following may occur, return false, pass failure details to specified
+ * JSONCompareResult and return true, or throw ValueMatcherException
+ * containing failure details. Passing failure details to JSONCompareResult
+ * or returning via ValueMatcherException enables more useful failure
+ * description for cases where expected value depends entirely or in part on
+ * configuration of the ValueMatcher and therefore expected value passed to
+ * this method will not give a useful indication of expected value.
+ *
+ * @param prefix
+ * JSON path of the JSON item being tested
+ * @param actual
+ * JSON value being tested
+ * @param expected
+ * expected JSON value
+ * @param result
+ * JSONCompareResult to which match failure may be passed
+ * @return true if expected and actual equal or any difference has already
+ * been passed to specified result instance, false otherwise.
+ * @throws ValueMatcherException
+ * if expected and actual values not equal and ValueMatcher
+ * needs to override default comparison failure message that
+ * would be generated if this method returned false.
+ */
+ boolean equal(String prefix, T actual, T expected, JSONCompareResult result) throws ValueMatcherException;
+}
diff --git a/src/main/java/org/skyscreamer/jsonassert/RegularExpressionValueMatcher.java b/src/main/java/org/skyscreamer/jsonassert/RegularExpressionValueMatcher.java
new file mode 100644
index 00000000..19a4ef1d
--- /dev/null
+++ b/src/main/java/org/skyscreamer/jsonassert/RegularExpressionValueMatcher.java
@@ -0,0 +1,96 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+package org.skyscreamer.jsonassert;
+
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+import org.skyscreamer.jsonassert.ValueMatcher;
+
+/**
+ * A JSONassert value matcher that matches actual value to regular expression.
+ * If non-null regular expression passed to constructor, then all actual values
+ * will be compared against this constant pattern, ignoring any expected value
+ * passed to equal method. If null regular expression passed to constructor,
+ * then expected value passed to equals method will be used to dynamically
+ * specify regular expression pattern that actual value must match.
+ *
+ * @author Duncan Mackinder
+ * @param Generic Type
+ */
+public class RegularExpressionValueMatcher implements ValueMatcher {
+
+ private final Pattern expectedPattern;
+
+ /**
+ * Create RegularExpressionValueMatcher in which the pattern the actual
+ * value must match with be specified dynamically from the expected string
+ * passed to this matcher in the equals method.
+ */
+ public RegularExpressionValueMatcher() {
+ this(null);
+ }
+
+ /**
+ * Create RegularExpressionValueMatcher with specified pattern. If pattern
+ * is not null, it must be a valid regular expression that defines a
+ * constant expected pattern that every actual value must match (in this
+ * case the expected value passed to equal method will be ignored). If
+ * pattern is null, the pattern the actual value must match with be
+ * specified dynamically from the expected string passed to this matcher in
+ * the equals method.
+ *
+ * @param pattern
+ * if non null, regular expression pattern which all actual
+ * values this matcher is applied to must match. If null, this
+ * matcher will apply pattern specified dynamically via the
+ * expected parameter to the equal method.
+ * @throws IllegalArgumentException
+ * if pattern is non-null and not a valid regular expression.
+ */
+ public RegularExpressionValueMatcher(String pattern) throws IllegalArgumentException {
+ try {
+ expectedPattern = pattern == null ? null : Pattern.compile(pattern);
+ }
+ catch (PatternSyntaxException e) {
+ throw new IllegalArgumentException("Constant expected pattern invalid: " + e.getMessage(), e);
+ }
+ }
+
+ @Override
+ public boolean equal(T actual, T expected) {
+ String actualString = actual.toString();
+ String expectedString = expected.toString();
+ try {
+ Pattern pattern = isStaticPattern() ? expectedPattern : Pattern
+ .compile(expectedString);
+ if (!pattern.matcher(actualString).matches()) {
+ throw new ValueMatcherException(getPatternType() + " expected pattern did not match value", pattern.toString(), actualString);
+ }
+ }
+ catch (PatternSyntaxException e) {
+ throw new ValueMatcherException(getPatternType() + " expected pattern invalid: " + e.getMessage(), e, expectedString, actualString);
+ }
+ return true;
+ }
+
+ private boolean isStaticPattern() {
+ return expectedPattern != null;
+ }
+
+ private String getPatternType() {
+ return isStaticPattern()? "Constant": "Dynamic";
+ }
+}
diff --git a/src/main/java/org/skyscreamer/jsonassert/ValueMatcher.java b/src/main/java/org/skyscreamer/jsonassert/ValueMatcher.java
index 58a86cf9..a05691a1 100644
--- a/src/main/java/org/skyscreamer/jsonassert/ValueMatcher.java
+++ b/src/main/java/org/skyscreamer/jsonassert/ValueMatcher.java
@@ -1,7 +1,33 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert;
+/**
+ * Represents a value matcher that can compare two objects for equality.
+ *
+ * @param the object type to compare
+ */
public interface ValueMatcher {
+ /**
+ * Compares the two provided objects whether they are equal.
+ *
+ * @param o1 the first object to check
+ * @param o2 the object to check the first against
+ * @return true if the objects are equal, false otherwise
+ */
boolean equal(T o1, T o2);
}
diff --git a/src/main/java/org/skyscreamer/jsonassert/ValueMatcherException.java b/src/main/java/org/skyscreamer/jsonassert/ValueMatcherException.java
new file mode 100644
index 00000000..19807722
--- /dev/null
+++ b/src/main/java/org/skyscreamer/jsonassert/ValueMatcherException.java
@@ -0,0 +1,78 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+package org.skyscreamer.jsonassert;
+
+/**
+ * Exception that may be thrown by ValueMatcher subclasses to provide more detail on why matches method failed.
+ *
+ * @author Duncan Mackinder
+ *
+ */
+public class ValueMatcherException extends RuntimeException {
+ private static final long serialVersionUID = 1L;
+
+ private final String expected;
+
+ private final String actual;
+
+ /**
+ * Create new ValueMatcherException
+ *
+ * @param message
+ * description of exception
+ * @param expected
+ * value expected by ValueMatcher
+ * @param actual
+ * value being tested by ValueMatcher
+ */
+ public ValueMatcherException(String message, String expected, String actual) {
+ super(message);
+ this.expected = expected;
+ this.actual = actual;
+ }
+
+ /**
+ * Create new ValueMatcherException
+ *
+ * @param message
+ * description of exception
+ * @param cause
+ * cause of ValueMatcherException
+ * @param expected
+ * value expected by ValueMatcher
+ * @param actual
+ * value being tested by ValueMatcher
+ */
+ public ValueMatcherException(String message, Throwable cause, String expected, String actual) {
+ super(message, cause);
+ this.expected = expected;
+ this.actual = actual;
+ }
+
+ /**
+ * @return the expected value
+ */
+ public String getExpected() {
+ return expected;
+ }
+
+ /**
+ * @return the actual value
+ */
+ public String getActual() {
+ return actual;
+ }
+
+}
diff --git a/src/main/java/org/skyscreamer/jsonassert/comparator/AbstractComparator.java b/src/main/java/org/skyscreamer/jsonassert/comparator/AbstractComparator.java
index 037bb6af..190e47ea 100644
--- a/src/main/java/org/skyscreamer/jsonassert/comparator/AbstractComparator.java
+++ b/src/main/java/org/skyscreamer/jsonassert/comparator/AbstractComparator.java
@@ -1,7 +1,20 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert.comparator;
import org.json.JSONArray;
-import org.json.JSONException;
import org.json.JSONObject;
import org.skyscreamer.jsonassert.JSONCompareResult;
@@ -11,19 +24,26 @@
/**
* This class provides a skeletal implementation of the {@link JSONComparator}
- * interface, to minimize the effort required to implement this interface.
+ * interface, to minimize the effort required to implement this interface.
+ *
+ *
*/
public abstract class AbstractComparator implements JSONComparator {
+ /**
+ * Default constructor
+ */
+ public AbstractComparator() {
+ }
+
/**
* Compares JSONObject provided to the expected JSONObject, and returns the results of the comparison.
*
* @param expected Expected JSONObject
* @param actual JSONObject to compare
- * @throws JSONException
*/
@Override
- public final JSONCompareResult compareJSON(JSONObject expected, JSONObject actual) throws JSONException {
+ public final JSONCompareResult compareJSON(JSONObject expected, JSONObject actual) {
JSONCompareResult result = new JSONCompareResult();
compareJSON("", expected, actual, result);
return result;
@@ -34,15 +54,20 @@ public final JSONCompareResult compareJSON(JSONObject expected, JSONObject actua
*
* @param expected Expected JSONArray
* @param actual JSONArray to compare
- * @throws JSONException
*/
@Override
- public final JSONCompareResult compareJSON(JSONArray expected, JSONArray actual) throws JSONException {
+ public final JSONCompareResult compareJSON(JSONArray expected, JSONArray actual) {
JSONCompareResult result = new JSONCompareResult();
compareJSONArray("", expected, actual, result);
return result;
}
+ /**
+ * @param prefix
+ * @param expected
+ * @param actual
+ * @param result
+ */
protected void checkJsonObjectKeysActualInExpected(String prefix, JSONObject expected, JSONObject actual, JSONCompareResult result) {
Set actualKeys = getKeys(actual);
for (String key : actualKeys) {
@@ -52,7 +77,14 @@ protected void checkJsonObjectKeysActualInExpected(String prefix, JSONObject exp
}
}
- protected void checkJsonObjectKeysExpectedInActual(String prefix, JSONObject expected, JSONObject actual, JSONCompareResult result) throws JSONException {
+ /**
+ *
+ * @param prefix
+ * @param expected
+ * @param actual
+ * @param result
+ */
+ protected void checkJsonObjectKeysExpectedInActual(String prefix, JSONObject expected, JSONObject actual, JSONCompareResult result) {
Set expectedKeys = getKeys(expected);
for (String key : expectedKeys) {
Object expectedValue = expected.get(key);
@@ -65,7 +97,7 @@ protected void checkJsonObjectKeysExpectedInActual(String prefix, JSONObject exp
}
}
- protected void compareJSONArrayOfJsonObjects(String key, JSONArray expected, JSONArray actual, JSONCompareResult result) throws JSONException {
+ protected void compareJSONArrayOfJsonObjects(String key, JSONArray expected, JSONArray actual, JSONCompareResult result) {
String uniqueKey = findUniqueKey(expected);
if (uniqueKey == null || !isUsableAsUniqueKey(uniqueKey, actual)) {
// An expensive last resort
@@ -90,7 +122,7 @@ protected void compareJSONArrayOfJsonObjects(String key, JSONArray expected, JSO
}
}
- protected void compareJSONArrayOfSimpleValues(String key, JSONArray expected, JSONArray actual, JSONCompareResult result) throws JSONException {
+ protected void compareJSONArrayOfSimpleValues(String key, JSONArray expected, JSONArray actual, JSONCompareResult result) {
Map expectedCount = JSONCompareUtil.getCardinalityMap(jsonArrayToList(expected));
Map actualCount = JSONCompareUtil.getCardinalityMap(jsonArrayToList(actual));
for (Object o : expectedCount.keySet()) {
@@ -108,10 +140,10 @@ protected void compareJSONArrayOfSimpleValues(String key, JSONArray expected, JS
}
}
- protected void compareJSONArrayWithStrictOrder(String key, JSONArray expected, JSONArray actual, JSONCompareResult result) throws JSONException {
+ protected void compareJSONArrayWithStrictOrder(String key, JSONArray expected, JSONArray actual, JSONCompareResult result) {
for (int i = 0; i < expected.length(); ++i) {
- Object expectedValue = expected.get(i);
- Object actualValue = actual.get(i);
+ Object expectedValue = JSONCompareUtil.getObjectOrNull(expected, i);
+ Object actualValue = JSONCompareUtil.getObjectOrNull(actual, i);
compareValues(key + "[" + i + "]", expectedValue, actualValue, result);
}
}
@@ -121,13 +153,20 @@ protected void compareJSONArrayWithStrictOrder(String key, JSONArray expected, J
// This is expensive (O(n^2) -- yuck), but may be the only resort for some cases with loose array ordering, and no
// easy way to uniquely identify each element.
protected void recursivelyCompareJSONArray(String key, JSONArray expected, JSONArray actual,
- JSONCompareResult result) throws JSONException {
+ JSONCompareResult result) {
Set matched = new HashSet();
for (int i = 0; i < expected.length(); ++i) {
- Object expectedElement = expected.get(i);
+ Object expectedElement = JSONCompareUtil.getObjectOrNull(expected, i);
boolean matchFound = false;
for (int j = 0; j < actual.length(); ++j) {
- Object actualElement = actual.get(j);
+ Object actualElement = JSONCompareUtil.getObjectOrNull(actual, j);
+ if (expectedElement == actualElement) {
+ matchFound = true;
+ break;
+ }
+ if ((expectedElement == null && actualElement != null) || (expectedElement != null && actualElement == null)) {
+ continue;
+ }
if (matched.contains(j) || !actualElement.getClass().equals(expectedElement.getClass())) {
continue;
}
diff --git a/src/main/java/org/skyscreamer/jsonassert/comparator/ArraySizeComparator.java b/src/main/java/org/skyscreamer/jsonassert/comparator/ArraySizeComparator.java
new file mode 100644
index 00000000..7e348b82
--- /dev/null
+++ b/src/main/java/org/skyscreamer/jsonassert/comparator/ArraySizeComparator.java
@@ -0,0 +1,120 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+package org.skyscreamer.jsonassert.comparator;
+
+import java.text.MessageFormat;
+
+import org.json.JSONArray;
+import org.skyscreamer.jsonassert.JSONCompareMode;
+import org.skyscreamer.jsonassert.JSONCompareResult;
+
+/**
+ * A JSONAssert array size comparator.
+ *
+ * Some typical usage idioms are listed below.
+ *
+ * Assuming JSON to be verified is held in String variable ARRAY_OF_JSONOBJECTS and contains:
+ *
+ * {a:[7, 8, 9]}
+ *
+ * then:
+ *
+ * To verify that array 'a' contains 3 elements:
+ *
+ *
+ * JSONAssert.assertEquals("{a:[3]}", ARRAY_OF_JSONOBJECTS, new ArraySizeComparator(JSONCompareMode.LENIENT));
+ *
+ *
+ * To verify that array 'a' contains between 2 and 6 elements:
+ *
+ *
+ * JSONAssert.assertEquals("{a:[2,6]}", ARRAY_OF_JSONOBJECTS, new ArraySizeComparator(JSONCompareMode.LENIENT));
+ *
+ *
+ * @author Duncan Mackinder
+ *
+ */
+public class ArraySizeComparator extends DefaultComparator {
+
+ /**
+ * Create new ArraySizeComparator.
+ *
+ * @param mode
+ * comparison mode, has no impact on ArraySizeComparator but is
+ * used by instance of superclass DefaultComparator to control
+ * comparison of JSON items other than arrays.
+ */
+ public ArraySizeComparator(JSONCompareMode mode) {
+ super(mode);
+ }
+
+ /**
+ * Expected array should consist of either 1 or 2 integer values that define
+ * maximum and minimum valid lengths of the actual array. If expected array
+ * contains a single integer value, then the actual array must contain
+ * exactly that number of elements.
+ */
+ @Override
+ public void compareJSONArray(String prefix, JSONArray expected,
+ JSONArray actual, JSONCompareResult result) {
+ String arrayPrefix = prefix + "[]";
+ if (expected.length() < 1 || expected.length() > 2) {
+ result.fail(MessageFormat
+ .format("{0}: invalid expectation: expected array should contain either 1 or 2 elements but contains {1} elements",
+ arrayPrefix, expected.length()));
+ return;
+ }
+ if (!(expected.get(0) instanceof Number)) {
+ result.fail(MessageFormat
+ .format("{0}: invalid expectation: {1}expected array size ''{2}'' not a number",
+ arrayPrefix, (expected.length() == 1? "": "minimum "), expected.get(0)));
+ return;
+ }
+ if ((expected.length() == 2 && !(expected.get(1) instanceof Number))) {
+ result.fail(MessageFormat
+ .format("{0}: invalid expectation: maximum expected array size ''{1}'' not a number",
+ arrayPrefix, expected.get(1)));
+ return;
+ }
+ int minExpectedLength = expected.getInt(0);
+ if (minExpectedLength < 0) {
+ result.fail(MessageFormat
+ .format("{0}: invalid expectation: minimum expected array size ''{1}'' negative",
+ arrayPrefix, minExpectedLength));
+ return;
+ }
+ int maxExpectedLength = expected.length() == 2 ? expected.getInt(1)
+ : minExpectedLength;
+ if (maxExpectedLength < minExpectedLength) {
+ result.fail(MessageFormat
+ .format("{0}: invalid expectation: maximum expected array size ''{1}'' less than minimum expected array size ''{2}''",
+ arrayPrefix, maxExpectedLength, minExpectedLength));
+ return;
+ }
+ if (actual.length() < minExpectedLength
+ || actual.length() > maxExpectedLength) {
+ result.fail(
+ arrayPrefix,
+ MessageFormat.format(
+ "array size of {0}{1} elements",
+ minExpectedLength,
+ (expected.length() == 2 ? (" to " + maxExpectedLength)
+ : "")),
+ MessageFormat.format("{0} elements",
+ actual.length()));
+ }
+ }
+
+}
diff --git a/src/main/java/org/skyscreamer/jsonassert/comparator/CustomComparator.java b/src/main/java/org/skyscreamer/jsonassert/comparator/CustomComparator.java
index 7a9565ea..73337bdf 100644
--- a/src/main/java/org/skyscreamer/jsonassert/comparator/CustomComparator.java
+++ b/src/main/java/org/skyscreamer/jsonassert/comparator/CustomComparator.java
@@ -1,9 +1,23 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert.comparator;
-import org.json.JSONException;
import org.skyscreamer.jsonassert.Customization;
import org.skyscreamer.jsonassert.JSONCompareMode;
import org.skyscreamer.jsonassert.JSONCompareResult;
+import org.skyscreamer.jsonassert.ValueMatcherException;
import java.util.Arrays;
import java.util.Collection;
@@ -18,11 +32,16 @@ public CustomComparator(JSONCompareMode mode, Customization... customizations)
}
@Override
- public void compareValues(String prefix, Object expectedValue, Object actualValue, JSONCompareResult result) throws JSONException {
+ public void compareValues(String prefix, Object expectedValue, Object actualValue, JSONCompareResult result) {
Customization customization = getCustomization(prefix);
if (customization != null) {
- if (!customization.matches(actualValue, expectedValue)) {
- result.fail(prefix, expectedValue, actualValue);
+ try {
+ if (!customization.matches(prefix, actualValue, expectedValue, result)) {
+ result.fail(prefix, expectedValue, actualValue);
+ }
+ }
+ catch (ValueMatcherException e) {
+ result.fail(prefix, e);
}
} else {
super.compareValues(prefix, expectedValue, actualValue, result);
diff --git a/src/main/java/org/skyscreamer/jsonassert/comparator/DefaultComparator.java b/src/main/java/org/skyscreamer/jsonassert/comparator/DefaultComparator.java
index d7ab30be..1e8efc01 100644
--- a/src/main/java/org/skyscreamer/jsonassert/comparator/DefaultComparator.java
+++ b/src/main/java/org/skyscreamer/jsonassert/comparator/DefaultComparator.java
@@ -1,23 +1,30 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert.comparator;
import org.json.JSONArray;
-import org.json.JSONException;
import org.json.JSONObject;
-import org.skyscreamer.jsonassert.Customization;
import org.skyscreamer.jsonassert.JSONCompareMode;
import org.skyscreamer.jsonassert.JSONCompareResult;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-
import static org.skyscreamer.jsonassert.comparator.JSONCompareUtil.allJSONObjects;
import static org.skyscreamer.jsonassert.comparator.JSONCompareUtil.allSimpleValues;
/**
- * This class is the default json comparator implementation.
- * Comparison is performed according to {@link JSONCompareMode} that is passed as constructor's argument.
+ * This class is the default json comparator implementation.
+ * Comparison is performed according to {@link JSONCompareMode} that is passed as constructor's argument.
*/
public class DefaultComparator extends AbstractComparator {
@@ -28,8 +35,7 @@ public DefaultComparator(JSONCompareMode mode) {
}
@Override
- public void compareJSON(String prefix, JSONObject expected, JSONObject actual, JSONCompareResult result)
- throws JSONException {
+ public void compareJSON(String prefix, JSONObject expected, JSONObject actual, JSONCompareResult result) {
// Check that actual contains all the expected values
checkJsonObjectKeysExpectedInActual(prefix, expected, actual, result);
@@ -40,10 +46,14 @@ public void compareJSON(String prefix, JSONObject expected, JSONObject actual, J
}
@Override
- public void compareValues(String prefix, Object expectedValue, Object actualValue, JSONCompareResult result)
- throws JSONException {
- if (expectedValue instanceof Number && actualValue instanceof Number) {
- if (((Number)expectedValue).doubleValue() != ((Number)actualValue).doubleValue()) {
+ public void compareValues(String prefix, Object expectedValue, Object actualValue, JSONCompareResult result) {
+ if (expectedValue == actualValue) {
+ return;
+ }
+ if (expectedValue == null || actualValue == null) {
+ result.fail(prefix, expectedValue, actualValue);
+ } else if (areNumbers(expectedValue, actualValue)) {
+ if (areNotSameDoubles(expectedValue, actualValue)) {
result.fail(prefix, expectedValue, actualValue);
}
} else if (expectedValue.getClass().isAssignableFrom(actualValue.getClass())) {
@@ -60,8 +70,7 @@ public void compareValues(String prefix, Object expectedValue, Object actualValu
}
@Override
- public void compareJSONArray(String prefix, JSONArray expected, JSONArray actual, JSONCompareResult result)
- throws JSONException {
+ public void compareJSONArray(String prefix, JSONArray expected, JSONArray actual, JSONCompareResult result) {
if (expected.length() != actual.length()) {
result.fail(prefix + "[]: Expected " + expected.length() + " values but got " + actual.length());
return;
@@ -80,4 +89,12 @@ public void compareJSONArray(String prefix, JSONArray expected, JSONArray actual
recursivelyCompareJSONArray(prefix, expected, actual, result);
}
}
+
+ protected boolean areNumbers(Object expectedValue, Object actualValue) {
+ return expectedValue instanceof Number && actualValue instanceof Number;
+ }
+
+ protected boolean areNotSameDoubles(Object expectedValue, Object actualValue) {
+ return ((Number) expectedValue).doubleValue() != ((Number) actualValue).doubleValue();
+ }
}
diff --git a/src/main/java/org/skyscreamer/jsonassert/comparator/JSONComparator.java b/src/main/java/org/skyscreamer/jsonassert/comparator/JSONComparator.java
index b5b950fb..9a78d493 100644
--- a/src/main/java/org/skyscreamer/jsonassert/comparator/JSONComparator.java
+++ b/src/main/java/org/skyscreamer/jsonassert/comparator/JSONComparator.java
@@ -1,7 +1,20 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert.comparator;
import org.json.JSONArray;
-import org.json.JSONException;
import org.json.JSONObject;
import org.skyscreamer.jsonassert.JSONCompareResult;
@@ -13,13 +26,54 @@
*/
public interface JSONComparator {
- JSONCompareResult compareJSON(JSONObject expected, JSONObject actual) throws JSONException;
+ /**
+ * Compares two {@link JSONObject}s and returns the result of the comparison in a {@link JSONCompareResult} object.
+ *
+ * @param expected the expected JSON object
+ * @param actual the actual JSON object
+ * @return the result of the comparison
+ */
+ JSONCompareResult compareJSON(JSONObject expected, JSONObject actual);
- JSONCompareResult compareJSON(JSONArray expected, JSONArray actual) throws JSONException;
+ /**
+ * Compares two {@link JSONArray}s and returns the result of the comparison in a {@link JSONCompareResult} object.
+ *
+ * @param expected the expected JSON array
+ * @param actual the actual JSON array
+ * @return the result of the comparison
+ */
+ JSONCompareResult compareJSON(JSONArray expected, JSONArray actual);
- void compareJSON(String prefix, JSONObject expected, JSONObject actual, JSONCompareResult result) throws JSONException;
+ /**
+ * Compares two {@link JSONObject}s on the provided path represented by {@code prefix} and
+ * updates the result of the comparison in the {@code result} {@link JSONCompareResult} object.
+ *
+ * @param prefix the path in the json where the comparison happens
+ * @param expected the expected JSON object
+ * @param actual the actual JSON object
+ * @param result stores the actual state of the comparison result
+ */
+ void compareJSON(String prefix, JSONObject expected, JSONObject actual, JSONCompareResult result);
- void compareValues(String prefix, Object expectedValue, Object actualValue, JSONCompareResult result) throws JSONException;
+ /**
+ * Compares two {@link Object}s on the provided path represented by {@code prefix} and
+ * updates the result of the comparison in the {@code result} {@link JSONCompareResult} object.
+ *
+ * @param prefix the path in the json where the comparison happens
+ * @param expectedValue the expected value
+ * @param actualValue the actual value
+ * @param result stores the actual state of the comparison result
+ */
+ void compareValues(String prefix, Object expectedValue, Object actualValue, JSONCompareResult result);
- void compareJSONArray(String prefix, JSONArray expected, JSONArray actual, JSONCompareResult result) throws JSONException;
+ /**
+ * Compares two {@link JSONArray}s on the provided path represented by {@code prefix} and
+ * updates the result of the comparison in the {@code result} {@link JSONCompareResult} object.
+ *
+ * @param prefix the path in the json where the comparison happens
+ * @param expected the expected JSON array
+ * @param actual the actual JSON array
+ * @param result stores the actual state of the comparison result
+ */
+ void compareJSONArray(String prefix, JSONArray expected, JSONArray actual, JSONCompareResult result);
}
diff --git a/src/main/java/org/skyscreamer/jsonassert/comparator/JSONCompareUtil.java b/src/main/java/org/skyscreamer/jsonassert/comparator/JSONCompareUtil.java
index 6d28dd97..8a7fe18d 100644
--- a/src/main/java/org/skyscreamer/jsonassert/comparator/JSONCompareUtil.java
+++ b/src/main/java/org/skyscreamer/jsonassert/comparator/JSONCompareUtil.java
@@ -1,34 +1,69 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
package org.skyscreamer.jsonassert.comparator;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
import org.json.JSONArray;
-import org.json.JSONException;
import org.json.JSONObject;
-import java.util.*;
-
/**
- * Utility class that contains Json manipulation methods
+ * Utility class that contains Json manipulation methods.
*/
public final class JSONCompareUtil {
private static Integer INTEGER_ONE = new Integer(1);
- private JSONCompareUtil() {}
+ private JSONCompareUtil() {
+ }
- public static Map arrayOfJsonObjectToMap(JSONArray array, String uniqueKey) throws JSONException {
+ /**
+ * Converts the provided {@link JSONArray} to a Map of {@link JSONObject}s where the key of each object
+ * is the value at {@code uniqueKey} in each object.
+ *
+ * @param array the JSON array to convert
+ * @param uniqueKey the key to map the JSON objects to
+ * @return the map of {@link JSONObject}s from {@code array}
+ */
+ public static Map arrayOfJsonObjectToMap(JSONArray array, String uniqueKey) {
Map valueMap = new HashMap();
- for(int i = 0 ; i < array.length() ; ++i) {
- JSONObject jsonObject = (JSONObject)array.get(i);
+ for (int i = 0; i < array.length(); ++i) {
+ JSONObject jsonObject = (JSONObject) array.get(i);
Object id = jsonObject.get(uniqueKey);
valueMap.put(id, jsonObject);
}
return valueMap;
}
-
- public static String findUniqueKey(JSONArray expected) throws JSONException {
+ /**
+ * Searches for the unique key of the {@code expected} JSON array.
+ *
+ * @param expected the array to find the unique key of
+ * @return the unique key if there's any, otherwise null
+ */
+ public static String findUniqueKey(JSONArray expected) {
// Find a unique key for the object (id, name, whatever)
- JSONObject o = (JSONObject)expected.get(0); // There's at least one at this point
- for(String candidate : getKeys(o)) {
+ JSONObject o = (JSONObject) expected.get(0); // There's at least one at this point
+ for (String candidate : getKeys(o)) {
if (isUsableAsUniqueKey(candidate, expected)) return candidate;
}
// No usable unique key :-(
@@ -36,12 +71,22 @@ public static String findUniqueKey(JSONArray expected) throws JSONException {
}
/**
- * {@code candidate} is usable as a unique key if every element in the
- * {@code array} is a JSONObject having that key, and no two values are the same.
+ * Looks to see if candidate field is a possible unique key across a array of objects.
+ * Returns true IFF:
+ *
+ * array is an array of JSONObject
+ * candidate is a top-level field in each of of the objects in the array
+ * candidate is a simple value (not JSONObject or JSONArray)
+ * candidate is unique across all elements in the array
+ *
+ *
+ * @param candidate is usable as a unique key if every element in the
+ * @param array is a JSONObject having that key, and no two values are the same.
+ * @return true if the candidate can work as a unique id across array
*/
- public static boolean isUsableAsUniqueKey(String candidate, JSONArray array) throws JSONException {
+ public static boolean isUsableAsUniqueKey(String candidate, JSONArray array) {
Set seenValues = new HashSet();
- for (int i = 0 ; i < array.length() ; i++) {
+ for (int i = 0; i < array.length(); i++) {
Object item = array.get(i);
if (item instanceof JSONObject) {
JSONObject o = (JSONObject) item;
@@ -62,29 +107,65 @@ public static boolean isUsableAsUniqueKey(String candidate, JSONArray array) thr
return true;
}
- public static List jsonArrayToList(JSONArray expected) throws JSONException {
+ /**
+ * Converts the given {@link JSONArray} to a list of {@link Object}s.
+ *
+ * @param expected the JSON array to convert
+ * @return the list of objects from the {@code expected} array
+ */
+ public static List jsonArrayToList(JSONArray expected) {
List jsonObjects = new ArrayList(expected.length());
- for(int i = 0 ; i < expected.length() ; ++i) {
- jsonObjects.add(expected.get(i));
+ for (int i = 0; i < expected.length(); ++i) {
+ jsonObjects.add(getObjectOrNull(expected, i));
}
return jsonObjects;
}
- public static boolean allSimpleValues(JSONArray array) throws JSONException {
- for(int i = 0 ; i < array.length() ; ++i) {
- if (!isSimpleValue(array.get(i))) {
+ /**
+ * Returns the value present in the given index position. If null value is present, it will return null
+ *
+ * @param jsonArray the JSON array to get value from
+ * @param index index of object to retrieve
+ * @return value at the given index position
+ */
+ public static Object getObjectOrNull(JSONArray jsonArray, int index) {
+ return jsonArray.isNull(index) ? null : jsonArray.get(index);
+ }
+
+ /**
+ * Returns whether all of the elements in the given array are simple values.
+ *
+ * @param array the JSON array to iterate through on
+ * @return true if all the elements in {@code array} are simple values
+ * @see #isSimpleValue(Object)
+ */
+ public static boolean allSimpleValues(JSONArray array) {
+ for (int i = 0; i < array.length(); ++i) {
+ if (!array.isNull(i) && !isSimpleValue(array.get(i))) {
return false;
}
}
return true;
}
+ /**
+ * Returns whether the given object is a simple value: not {@link JSONObject} and not {@link JSONArray}.
+ *
+ * @param o the object to inspect
+ * @return true if {@code o} is a simple value
+ */
public static boolean isSimpleValue(Object o) {
return !(o instanceof JSONObject) && !(o instanceof JSONArray);
}
- public static boolean allJSONObjects(JSONArray array) throws JSONException {
- for(int i = 0 ; i < array.length() ; ++i) {
+ /**
+ * Returns whether all elements in {@code array} are {@link JSONObject} instances.
+ *
+ * @param array the array to inspect
+ * @return true if all the elements in the given array are JSONObjects
+ */
+ public static boolean allJSONObjects(JSONArray array) {
+ for (int i = 0; i < array.length(); ++i) {
if (!(array.get(i) instanceof JSONObject)) {
return false;
}
@@ -92,8 +173,14 @@ public static boolean allJSONObjects(JSONArray array) throws JSONException {
return true;
}
- public static boolean allJSONArrays(JSONArray array) throws JSONException {
- for(int i = 0 ; i < array.length() ; ++i) {
+ /**
+ * Returns whether all elements in {@code array} are {@link JSONArray} instances.
+ *
+ * @param array the array to inspect
+ * @return true if all the elements in the given array are JSONArrays
+ */
+ public static boolean allJSONArrays(JSONArray array) {
+ for (int i = 0; i < array.length(); ++i) {
if (!(array.get(i) instanceof JSONArray)) {
return false;
}
@@ -101,11 +188,17 @@ public static boolean allJSONArrays(JSONArray array) throws JSONException {
return true;
}
+ /**
+ * Collects all keys in {@code jsonObject}.
+ *
+ * @param jsonObject the {@link JSONObject} to get the keys of
+ * @return the set of keys
+ */
public static Set getKeys(JSONObject jsonObject) {
Set keys = new TreeSet();
Iterator iter = jsonObject.keys();
- while(iter.hasNext()) {
- keys.add((String)iter.next());
+ while (iter.hasNext()) {
+ keys.add((String) iter.next());
}
return keys;
}
@@ -118,6 +211,13 @@ public static String formatUniqueKey(String key, String uniqueKey, Object value)
return key + "[" + uniqueKey + "=" + value + "]";
}
+ /**
+ * Creates a cardinality map from {@code coll}.
+ *
+ * @param coll the collection of items to convert
+ * @param the type of elements in the input collection
+ * @return the cardinality map
+ */
public static Map getCardinalityMap(final Collection coll) {
Map count = new HashMap();
for (T item : coll) {
diff --git a/src/site/resources/cookbook.html b/src/site/resources/cookbook.html
index 0ca0eb7a..2e271348 100644
--- a/src/site/resources/cookbook.html
+++ b/src/site/resources/cookbook.html
@@ -132,6 +132,6 @@ Cookbook
result, true); // Pass