Version 2.6.2.3

Author: kpgalligan

README.md

@@ -12,7 +12,7 @@ iOS development with J2objc using the [Doppl build framework](http://doppl.co/).
 ```groovy
 dependencies {
     compile 'com.google.code.gson:gson:2.6.2'
-    doppl 'co.doppl.com.google.code.gson:gson:2.6.2.2'
+    doppl 'co.doppl.com.google.code.gson:gson:2.6.2.3'
 }
 ```
 

gson/build.gradle

@@ -7,8 +7,8 @@ apply plugin: 'ivy-publish'
 sourceCompatibility = 1.7
 targetCompatibility = 1.7
 
-def javaCoreVersion = '0.7.5'
-def dopplCoreVersion = '0.7.5.0'
+def javaCoreVersion = '0.8.0'
+def dopplCoreVersion = '0.8.0.0'
 
 dependencies {
     testCompile 'junit:junit:4.11'
@@ -18,7 +18,7 @@ dependencies {
 }
 
 group = 'co.doppl.com.google.code.gson'
-version = '2.6.2.3-SNAPSHOT'
+version = '2.6.2.3'
 
 ext.bintrayGitUrl = 'https://github.com/doppllib/gson.git'
 
@@ -42,5 +42,5 @@ task runIOSTests(type:Exec, dependsOn: 'dopplDeploy') {
     workingDir '../iostest'
 
     //on windows:
-    commandLine 'xcodebuild', 'test', '-project', 'iostest.xcodeproj', '-scheme', 'iostest', '-destination', 'platform=iOS Simulator,name=iPhone 7,OS=10.3'
+    commandLine 'xcodebuild', 'test', '-project', 'iostest.xcodeproj', '-scheme', 'iostest', '-destination', 'platform=iOS Simulator,name=iPhone 7,OS=10.3.1'
 }

gson/src/test/java/org/skyscreamer/jsonassert/ArrayValueMatcher.java

@@ -0,0 +1,197 @@
+package org.skyscreamer.jsonassert;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.skyscreamer.jsonassert.comparator.JSONComparator;
+
+import java.text.MessageFormat;
+
+/**
+ * <p>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.</p>
+ * 
+ * <p>Some examples of typical usage idioms listed below.</p>
+ * 
+ * <p>Assuming JSON to be verified is held in String variable ARRAY_OF_JSONOBJECTS and contains:</p>
+ * 
+ * <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}]}</code>
+ * 
+ * <p>then:</p>
+ * 
+ * <p>To verify that the 'id' attribute of first element of array 'a' is '1':</p>
+ * 
+ * <code>
+ * JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);<br/>
+ * Customization customization = new Customization("a", new ArrayValueMatcher&lt;Object&gt;(comparator, 0));<br/>
+ * JSONAssert.assertEquals("{a:[{id:1}]}", ARRAY_OF_JSONOBJECTS, new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * </code>
+ *
+ * <p>To simplify complexity of expected JSON string, the value <code>"a:[{id:1}]}"</code> may be replaced by <code>"a:{id:1}}"</code></p>
+ * 
+ * <p>To verify that the 'type' attribute of second and third elements of array 'a' is 'row':</p>
+ * 
+ * <code>
+ * JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);<br/>
+ * Customization customization = new Customization("a", new ArrayValueMatcher&lt;Object&gt;(comparator, 1, 2));<br/>
+ * JSONAssert.assertEquals("{a:[{type:row}]}", ARRAY_OF_JSONOBJECTS, new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * </code>
+ * 
+ * <p>To verify that the 'type' attribute of every element of array 'a' is 'row':</p>
+ * 
+ * <code>
+ * JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);<br/>
+ * Customization customization = new Customization("a", new ArrayValueMatcher&lt;Object&gt;(comparator));<br/>
+ * JSONAssert.assertEquals("{a:[{type:row}]}", ARRAY_OF_JSONOBJECTS, new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * </code>
+ * 
+ * <p>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:</p>
+ * 
+ * <code>
+ * // get length of array we will verify<br/>
+ * int aLength = ((JSONArray)((JSONObject)JSONParser.parseJSON(ARRAY_OF_JSONOBJECTS)).get("a")).length();<br/>
+ * // create array of customizations one for each array element<br/>
+ * RegularExpressionValueMatcher&lt;Object&gt; regExValueMatcher = new RegularExpressionValueMatcher&lt;Object&gt;("\\d+");  // matches one or more digits<br/>
+ * Customization[] customizations = new Customization[aLength];<br/>
+ * for (int i=0; i&lt;aLength; i++) {<br/>
+ * &nbsp;&nbsp;String contextPath = "a["+i+"].id";<br/>
+ * &nbsp;&nbsp;customizations[i] = new Customization(contextPath, regExValueMatcher);<br/>
+ * }<br/>
+ * CustomComparator regExComparator = new CustomComparator(JSONCompareMode.STRICT_ORDER, customizations);<br/>
+ * ArrayValueMatcher&lt;Object&gt; regExArrayValueMatcher = new ArrayValueMatcher&lt;Object&gt;(regExComparator);<br/>
+ * Customization regExArrayValueCustomization = new Customization("a", regExArrayValueMatcher);<br/>
+ * CustomComparator regExCustomArrayValueComparator = new CustomComparator(JSONCompareMode.STRICT_ORDER, new Customization[] { regExArrayValueCustomization });<br/>
+ * JSONAssert.assertEquals("{a:[{id:X}]}", ARRAY_OF_JSONOBJECTS, regExCustomArrayValueComparator);<br/>
+ * </code>
+ * 
+ * <p>To verify that the 'background' attribute of every element of array 'a' alternates between 'white' and 'grey' starting with first element 'background' being 'white':</p>
+ * 
+ * <code>
+ * JSONComparator comparator = new DefaultComparator(JSONCompareMode.LENIENT);<br/>
+ * Customization customization = new Customization("a", new ArrayValueMatcher&lt;Object&gt;(comparator));<br/>
+ * JSONAssert.assertEquals("{a:[{background:white},{background:grey}]}", ARRAY_OF_JSONOBJECTS, new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * </code>
+ * 
+ * <p>Assuming JSON to be verified is held in String variable ARRAY_OF_JSONARRAYS and contains:</p>
+ * 
+ * <code>{a:[[6,7,8], [9,10,11], [12,13,14], [19,20,21,22]]}</code>
+ * 
+ * <p>then:</p>
+ * 
+ * <p>To verify that the first three elements of JSON array 'a' are JSON arrays of length 3:</p>
+ * 
+ * <code>
+ * JSONComparator comparator = new ArraySizeComparator(JSONCompareMode.STRICT_ORDER);<br/>
+ * Customization customization = new Customization("a", new ArrayValueMatcher&lt;Object&gt;(comparator, 0, 2));<br/>
+ * JSONAssert.assertEquals("{a:[[3]]}", ARRAY_OF_JSONARRAYS, new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * </code>
+ *
+ * <p>NOTE: simplified expected JSON strings are not possible in this case as ArraySizeComparator does not support them.</p>
+ * 
+ * <p>To verify that the second elements of JSON array 'a' is a JSON array whose first element has the value 9:</p>
+ * 
+ * <code>
+ * JSONComparator innerComparator = new DefaultComparator(JSONCompareMode.LENIENT);<br/>
+ * Customization innerCustomization = new Customization("a[1]", new ArrayValueMatcher&lt;Object&gt;(innerComparator, 0));<br/>
+ * JSONComparator comparator = new CustomComparator(JSONCompareMode.LENIENT, innerCustomization);<br/>
+ * Customization customization = new Customization("a", new ArrayValueMatcher&lt;Object&gt;(comparator, 1));<br/>
+ * JSONAssert.assertEquals("{a:[[9]]}", ARRAY_OF_JSONARRAYS, new CustomComparator(JSONCompareMode.LENIENT, customization));
+ * </code>
+ *
+ * <p>To simplify complexity of expected JSON string, the value <code>"{a:[[9]]}"</code> may be replaced by <code>"{a:[9]}"</code> or <code>"{a:9}"</code></p>
+ * 
+ * @author Duncan Mackinder
+ * 
+ */
+public class ArrayValueMatcher<T> implements LocationAwareValueMatcher<T> {
+	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
+	 * @from first element in actual array to compared
+	 * @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;
+		}
+	}
+
+}

gson/src/test/java/org/skyscreamer/jsonassert/Customization.java

@@ -0,0 +1,71 @@
+package org.skyscreamer.jsonassert;
+
+/**
+ * Associates a custom matcher to a specific jsonpath.
+ */
+public final class Customization {
+	private final String path;
+	private final ValueMatcher<Object> comparator;
+
+	public Customization(String path, ValueMatcher<Object> comparator) {
+        assert path != null;
+        assert comparator != null;
+		this.path = path;
+		this.comparator = comparator;
+	}
+
+	public static Customization customization(String path, ValueMatcher<Object> comparator) {
+		return new Customization(path, comparator);
+	}
+
+    public boolean appliesToPath(String path) {
+        return this.path.equals(path);
+    }
+
+	/**
+	 * 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<Object>)comparator).equal(prefix, actual, expected, result);
+		}
+		return comparator.equal(actual, expected);
+	}
+}

gson/src/test/java/org/skyscreamer/jsonassert/FieldComparisonFailure.java

@@ -0,0 +1,28 @@
+package org.skyscreamer.jsonassert;
+
+/**
+ * Models a failure when comparing two fields.
+ */
+public class FieldComparisonFailure {
+    private final String _field;
+    private final Object _expected;
+    private final Object _actual;
+
+    public FieldComparisonFailure(String field, Object expected, Object actual) {
+        this._field = field;
+        this._expected = expected;
+        this._actual = actual;
+    }
+
+    public String getField() {
+        return _field;
+    }
+
+    public Object getExpected() {
+        return _expected;
+    }
+
+    public Object getActual() {
+        return _actual;
+    }
+}