JSONAssertTest.java

/*
 * 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 static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.skyscreamer.jsonassert.JSONCompareMode.LENIENT;
import static org.skyscreamer.jsonassert.JSONCompareMode.NON_EXTENSIBLE;
import static org.skyscreamer.jsonassert.JSONCompareMode.STRICT;
import static org.skyscreamer.jsonassert.JSONCompareMode.STRICT_ORDER;

import java.util.Arrays;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.junit.Assert;
import org.junit.Test;
import org.skyscreamer.jsonassert.comparator.CustomComparator;
import org.skyscreamer.jsonassert.comparator.JSONComparator;

/**
 * Unit tests for {@link JSONAssert}
 */
public class JSONAssertTest {
    @Test
    public void testString() throws JSONException {
        testPass("\"Joe\"", "\"Joe\"", STRICT);
        testPass("\"Joe\"", "\"Joe\"", LENIENT);
        testPass("\"Joe\"", "\"Joe\"", NON_EXTENSIBLE);
        testPass("\"Joe\"", "\"Joe\"", STRICT_ORDER);
        testFail("\"Joe\"", "\"Joe1\"", STRICT);
        testFail("\"Joe\"", "\"Joe2\"", LENIENT);
        testFail("\"Joe\"", "\"Joe3\"", NON_EXTENSIBLE);
        testFail("\"Joe\"", "\"Joe4\"", STRICT_ORDER);
    }

    @Test
    public void testNumber() throws JSONException {
        testPass("123", "123", STRICT);
        testPass("123", "123", LENIENT);
        testPass("123", "123", NON_EXTENSIBLE);
        testPass("123", "123", STRICT_ORDER);
        testFail("123", "1231", STRICT);
        testFail("123", "1232", LENIENT);
        testFail("123", "1233", NON_EXTENSIBLE);
        testFail("123", "1234", STRICT_ORDER);
        testPass("0", "0", STRICT);
        testPass("-1", "-1", STRICT);
        testPass("0.1", "0.1", STRICT);
        testPass("1.2e5", "1.2e5", STRICT);
        testPass("20.4e-1", "20.4e-1", STRICT);
        testFail("310.1e-1", "31.01", STRICT); // should fail though numbers are the same?
    }

    @Test
    public void testSimple() throws JSONException {
        testPass("{id:1}", "{id:1}", STRICT);
        testFail("{id:1}", "{id:2}", STRICT);
        testPass("{id:1}", "{id:1}", LENIENT);
        testFail("{id:1}", "{id:2}", LENIENT);
        testPass("{id:1}", "{id:1}", NON_EXTENSIBLE);
        testFail("{id:1}", "{id:2}", NON_EXTENSIBLE);
        testPass("{id:1}", "{id:1}", STRICT_ORDER);
        testFail("{id:1}", "{id:2}", STRICT_ORDER);
    }

    @Test
    public void testSimpleStrict() throws JSONException {
        testPass("{id:1}", "{id:1,name:\"Joe\"}", LENIENT);
        testFail("{id:1}", "{id:1,name:\"Joe\"}", STRICT);
        testPass("{id:1}", "{id:1,name:\"Joe\"}", STRICT_ORDER);
        testFail("{id:1}", "{id:1,name:\"Joe\"}", NON_EXTENSIBLE);
    }

    @Test
    public void testReversed() throws JSONException {
        testPass("{name:\"Joe\",id:1}", "{id:1,name:\"Joe\"}", LENIENT);
        testPass("{name:\"Joe\",id:1}", "{id:1,name:\"Joe\"}", STRICT);
        testPass("{name:\"Joe\",id:1}", "{id:1,name:\"Joe\"}", NON_EXTENSIBLE);
        testPass("{name:\"Joe\",id:1}", "{id:1,name:\"Joe\"}", STRICT_ORDER);
    }

    @Test // Currently JSONAssert assumes JSONObject.
    public void testArray() throws JSONException {
        testPass("[1,2,3]","[1,2,3]", STRICT);
        testPass("[1,2,3]","[1,3,2]", LENIENT);
        testFail("[1,2,3]","[1,3,2]", STRICT);
        testFail("[1,2,3]","[4,5,6]", LENIENT);
        testPass("[1,2,3]","[1,2,3]", STRICT_ORDER);
        testPass("[1,2,3]","[1,3,2]", NON_EXTENSIBLE);
        testFail("[1,2,3]","[1,3,2]", STRICT_ORDER);
        testFail("[1,2,3]","[4,5,6]", NON_EXTENSIBLE);
    }

    @Test
    public void testNested() throws JSONException {
        testPass("{id:1,address:{addr1:\"123 Main\", addr2:null, city:\"Houston\", state:\"TX\"}}",
                "{id:1,address:{addr1:\"123 Main\", addr2:null, city:\"Houston\", state:\"TX\"}}", STRICT);
        testFail("{id:1,address:{addr1:\"123 Main\", addr2:null, city:\"Houston\", state:\"TX\"}}",
                "{id:1,address:{addr1:\"123 Main\", addr2:null, city:\"Austin\", state:\"TX\"}}", STRICT);
    }

    @Test
    public void testVeryNested() throws JSONException {
        testPass("{a:{b:{c:{d:{e:{f:{g:{h:{i:{j:{k:{l:{m:{n:{o:{p:\"blah\"}}}}}}}}}}}}}}}}",
                "{a:{b:{c:{d:{e:{f:{g:{h:{i:{j:{k:{l:{m:{n:{o:{p:\"blah\"}}}}}}}}}}}}}}}}", STRICT);
        testFail("{a:{b:{c:{d:{e:{f:{g:{h:{i:{j:{k:{l:{m:{n:{o:{p:\"blah\"}}}}}}}}}}}}}}}}",
                "{a:{b:{c:{d:{e:{f:{g:{h:{i:{j:{k:{l:{m:{n:{o:{z:\"blah\"}}}}}}}}}}}}}}}}", STRICT);
    }

    @Test
    public void testSimpleArray() throws JSONException {
        testPass("{id:1,pets:[\"dog\",\"cat\",\"fish\"]}", // Exact to exact (strict)
                "{id:1,pets:[\"dog\",\"cat\",\"fish\"]}",
                STRICT);
        testFail("{id:1,pets:[\"dog\",\"cat\",\"fish\"]}", // Out-of-order fails (strict)
                "{id:1,pets:[\"dog\",\"fish\",\"cat\"]}",
                STRICT);
        testPass("{id:1,pets:[\"dog\",\"cat\",\"fish\"]}", // Out-of-order ok
                "{id:1,pets:[\"dog\",\"fish\",\"cat\"]}",
                LENIENT);
        testPass("{id:1,pets:[\"dog\",\"cat\",\"fish\"]}", // Out-of-order ok
                "{id:1,pets:[\"dog\",\"fish\",\"cat\"]}",
                NON_EXTENSIBLE);
        testFail("{id:1,pets:[\"dog\",\"cat\",\"fish\"]}", // Out-of-order fails (strict order)
                "{id:1,pets:[\"dog\",\"fish\",\"cat\"]}",
                STRICT_ORDER);
        testFail("{id:1,pets:[\"dog\",\"cat\",\"fish\"]}", // Mismatch
                "{id:1,pets:[\"dog\",\"cat\",\"bird\"]}",
                STRICT);
        testFail("{id:1,pets:[\"dog\",\"cat\",\"fish\"]}", // Mismatch
                "{id:1,pets:[\"dog\",\"cat\",\"bird\"]}",
                LENIENT);
        testFail("{id:1,pets:[\"dog\",\"cat\",\"fish\"]}", // Mismatch
                "{id:1,pets:[\"dog\",\"cat\",\"bird\"]}",
                STRICT_ORDER);
        testFail("{id:1,pets:[\"dog\",\"cat\",\"fish\"]}", // Mismatch
                "{id:1,pets:[\"dog\",\"cat\",\"bird\"]}",
                NON_EXTENSIBLE);
    }

    @Test
    public void testSimpleMixedArray() throws JSONException {
        testPass("{stuff:[321, \"abc\"]}", "{stuff:[\"abc\", 321]}", LENIENT);
        testFail("{stuff:[321, \"abc\"]}", "{stuff:[\"abc\", 789]}", LENIENT);
    }

    @Test
    public void testComplexMixedStrictArray() throws JSONException {
        testPass("{stuff:[{pet:\"cat\"},{car:\"Ford\"}]}", "{stuff:[{pet:\"cat\"},{car:\"Ford\"}]}", STRICT);
    }

    @Test
    public void testComplexMixedArray() throws JSONException {
        testPass("{stuff:[{pet:\"cat\"},{car:\"Ford\"}]}", "{stuff:[{pet:\"cat\"},{car:\"Ford\"}]}", LENIENT);
    }

    @Test
    public void testComplexArrayNoUniqueID() throws JSONException {
        testPass("{stuff:[{address:{addr1:\"123 Main\"}}, {address:{addr1:\"234 Broad\"}}]}",
                "{stuff:[{address:{addr1:\"123 Main\"}}, {address:{addr1:\"234 Broad\"}}]}",
                LENIENT);
    }

    @Test
    public void testSimpleAndComplexStrictArray() throws JSONException {
        testPass("{stuff:[123,{a:\"b\"}]}", "{stuff:[123,{a:\"b\"}]}", STRICT);
    }

    @Test
    public void testSimpleAndComplexArray() throws JSONException {
        testPass("{stuff:[123,{a:\"b\"}]}", "{stuff:[123,{a:\"b\"}]}", LENIENT);
    }

    @Test
    public void testComplexArray() throws JSONException {
        testPass("{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                 "{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                 STRICT); // Exact to exact (strict)
        testFail("{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                "{id:1,name:\"Joe\",friends:[{id:3,name:\"Sue\",pets:[\"fish\",\"bird\"]},{id:2,name:\"Pat\",pets:[\"dog\"]}],pets:[]}",
                STRICT); // Out-of-order fails (strict)
        testFail("{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                "{id:1,name:\"Joe\",friends:[{id:3,name:\"Sue\",pets:[\"fish\",\"bird\"]},{id:2,name:\"Pat\",pets:[\"dog\"]}],pets:[]}",
                STRICT_ORDER); // Out-of-order fails (strict order)
        testPass("{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                "{id:1,name:\"Joe\",friends:[{id:3,name:\"Sue\",pets:[\"fish\",\"bird\"]},{id:2,name:\"Pat\",pets:[\"dog\"]}],pets:[]}",
                LENIENT); // Out-of-order ok
        testPass("{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                "{id:1,name:\"Joe\",friends:[{id:3,name:\"Sue\",pets:[\"fish\",\"bird\"]},{id:2,name:\"Pat\",pets:[\"dog\"]}],pets:[]}",
                NON_EXTENSIBLE); // Out-of-order ok
        testFail("{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                "{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"cat\",\"fish\"]}],pets:[]}",
                STRICT); // Mismatch (strict)
        testFail("{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                "{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"cat\",\"fish\"]}],pets:[]}",
                LENIENT); // Mismatch
        testFail("{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                "{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"cat\",\"fish\"]}],pets:[]}",
                STRICT_ORDER); // Mismatch
        testFail("{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"bird\",\"fish\"]}],pets:[]}",
                "{id:1,name:\"Joe\",friends:[{id:2,name:\"Pat\",pets:[\"dog\"]},{id:3,name:\"Sue\",pets:[\"cat\",\"fish\"]}],pets:[]}",
                NON_EXTENSIBLE); // Mismatch
    }

    @Test
    public void testArrayOfArraysStrict() throws JSONException {
        testPass("{id:1,stuff:[[1,2],[2,3],[],[3,4]]}", "{id:1,stuff:[[1,2],[2,3],[],[3,4]]}", STRICT);
        testFail("{id:1,stuff:[[1,2],[2,3],[3,4],[]]}", "{id:1,stuff:[[1,2],[2,3],[],[3,4]]}", STRICT);
    }

    @Test
    public void testArrayOfArrays() throws JSONException {
        testPass("{id:1,stuff:[[4,3],[3,2],[],[1,2]]}", "{id:1,stuff:[[1,2],[2,3],[],[3,4]]}", LENIENT);
    }
    
    @Test
    public void testLenientArrayRecursion() throws JSONException {
        testPass("[{\"arr\":[5, 2, 1]}]", "[{\"b\":3, \"arr\":[1, 5, 2]}]", LENIENT);
    }
   
    @Test 
    public void testFieldMismatch() throws JSONException {
        JSONCompareResult result = JSONCompare.compareJSON("{name:\"Pat\"}", "{name:\"Sue\"}", STRICT);
        FieldComparisonFailure comparisonFailure = result.getFieldFailures().iterator().next();
        Assert.assertEquals("Pat", comparisonFailure.getExpected());
        Assert.assertEquals("Sue", comparisonFailure.getActual());
        Assert.assertEquals("name", comparisonFailure.getField());
    }

    @Test
    public void testBooleanArray() throws JSONException {
        testPass("[true, false, true, true, false]", "[true, false, true, true, false]", STRICT);
        testPass("[false, true, true, false, true]", "[true, false, true, true, false]", LENIENT);
        testFail("[false, true, true, false, true]", "[true, false, true, true, false]", STRICT);
        testPass("[false, true, true, false, true]", "[true, false, true, true, false]", NON_EXTENSIBLE);
        testFail("[false, true, true, false, true]", "[true, false, true, true, false]", STRICT_ORDER);
    }

    @Test
    public void testNullProperty() throws JSONException {
        testFail("{id:1,name:\"Joe\"}", "{id:1,name:null}", STRICT);
        testFail("{id:1,name:null}", "{id:1,name:\"Joe\"}", STRICT);
    }

    @Test
    public void testIncorrectTypes() throws JSONException {
        testFail("{id:1,name:\"Joe\"}", "{id:1,name:[]}", STRICT);
        testFail("{id:1,name:[]}", "{id:1,name:\"Joe\"}", STRICT);
    }

    @Test
    public void testNullEquality() throws JSONException {
        testPass("{id:1,name:null}", "{id:1,name:null}", STRICT);
    }

    @Test
    public void testExpectedArrayButActualObject() throws JSONException {
        testFail("[1]", "{id:1}", LENIENT);
    }

    @Test
    public void testExpectedObjectButActualArray() throws JSONException {
        testFail("{id:1}", "[1]", LENIENT);
    }

    @Test
    public void testEquivalentIntAndLong() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Long.valueOf(12345));
        JSONAssert.assertEquals(expected, actual, true);
        JSONAssert.assertEquals(actual, expected, true);
    }

    @Test
    public void testEquivalentIntAndDouble() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Double.valueOf(12345.0));
        JSONAssert.assertEquals(expected, actual, true);
        JSONAssert.assertEquals(actual, expected, true);
    }

    @Test(expected = AssertionError.class)
    public void testAssertNotEqualsWhenEqualStrict() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Double.valueOf(12345));
        JSONAssert.assertNotEquals(expected, actual, true);
    }

    @Test(expected = AssertionError.class)
    public void testAssertNotEqualsWhenEqualLenient() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Double.valueOf(12345));
        JSONAssert.assertNotEquals(expected, actual, false);
    }

    @Test()
    public void testAssertNotEqualsWhenEqualDiffObjectsStrict() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        expected.put("name", "Joe");
        actual.put("id", Double.valueOf(12345));
        JSONAssert.assertNotEquals(expected, actual, true);
    }

    @Test(expected = AssertionError.class)
    public void testAssertNotEqualsWhenEqualDiffObjectsLenient() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        expected.put("name", "Joe");
        actual.put("name", "Joe");
        actual.put("id", Double.valueOf(12345));
        JSONAssert.assertNotEquals(expected, actual, false);
    }

    @Test()
    public void testAssertNotEqualsWhenDifferentStrict() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Double.valueOf(12346));
        JSONAssert.assertNotEquals(expected, actual, true);
    }

    @Test()
    public void testAssertNotEqualsWhenDifferentLenient() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Double.valueOf(12346));
        JSONAssert.assertNotEquals(expected, actual, false);
    }

    @Test()
    public void testAssertNotEqualsString() throws JSONException {
        JSONAssert.assertNotEquals("[1,2,3]", "[1,3,2]", STRICT);
        JSONAssert.assertNotEquals("[1,2,3]", "[1,2,4]", LENIENT);
        JSONAssert.assertNotEquals("[1,2,3]", "[1,3,2]", true);
        JSONAssert.assertNotEquals("[1,2,3]", "[1,2,4]", false);
    }
    
    @Test()
    public void testAssertEqualsString() throws JSONException {
        JSONAssert.assertEquals("[1,2,3]", "[1,2,3]", true);
        JSONAssert.assertEquals("{id:12345}", "{id:12345}", false);
        JSONAssert.assertEquals("{id:12345}", "{id:12345, name:\"john\"}", LENIENT);
        JSONAssert.assertEquals("{id:12345}", "{id:12345}", LENIENT);
        JSONAssert.assertEquals("{id:12345}", "{id:12345, name:\"john\"}", LENIENT);
    }

    @Test()
    public void testAssertNotEqualsStringAndJSONObject() throws JSONException {
        JSONObject actual = new JSONObject();
        actual.put("id", Double.valueOf(12345));
        JSONAssert.assertEquals("{id:12345}", actual, false);
        JSONAssert.assertNotEquals("{id:12346}", actual, false);
    }

    @Test()
    public void testAssertNotEqualsJSONArray() throws JSONException {
        JSONArray actual = new JSONArray(Arrays.asList(1, 2, 3));
        JSONAssert.assertEquals("[1,2,3]", actual, false);
        JSONAssert.assertNotEquals("[1,2,4]", actual, false);
        JSONAssert.assertNotEquals("[1,3,2]", actual, true);
        JSONAssert.assertNotEquals(new JSONArray(Arrays.asList(1, 2, 4)), actual, false);
        JSONAssert.assertNotEquals(new JSONArray(Arrays.asList(1, 3, 2)), actual, true);
    }
    
    @Test
    public void testAssertEqualsStringJSONArrayBooleanWithMessage() throws JSONException {
        JSONArray actual = new JSONArray(Arrays.asList(1, 2, 3));
        JSONAssert.assertEquals("Message", "[1,2,3]", actual, false);
        performAssertEqualsTestForMessageVerification("[1,2,4]", actual, false);
        performAssertEqualsTestForMessageVerification("[1,3,2]", actual, true);
    }
    
    @Test
    public void testAssertEqualsStringJSONArrayCompareModeWithMessage() throws JSONException {
        JSONArray actual = new JSONArray(Arrays.asList(1, 2, 3));
        JSONAssert.assertEquals("Message", "[1,2,3]", actual, LENIENT);
        performAssertEqualsTestForMessageVerification("[1,2,4]", actual, LENIENT);
        performAssertEqualsTestForMessageVerification("[1,3,2]", actual, STRICT);
    }

    @Test
    public void testAssertEqualsJSONArray2BooleanWithMessage() throws JSONException {
        JSONArray actual = new JSONArray(Arrays.asList(1, 2, 3));
        JSONAssert.assertEquals("Message", new JSONArray(Arrays.asList(1, 2, 3)), actual, false);
        performAssertEqualsTestForMessageVerification(new JSONArray(Arrays.asList(1, 2, 4)), actual, false);
        performAssertEqualsTestForMessageVerification(new JSONArray(Arrays.asList(1, 3, 2)), actual, true);
    }
    
    @Test
    public void testAssertEqualsJSONArray2JSONCompareWithMessage() throws JSONException {
        JSONArray actual = new JSONArray(Arrays.asList(1, 2, 3));
        
        JSONAssert.assertEquals("Message", new JSONArray(Arrays.asList(1, 2, 3)), actual, LENIENT);
        performAssertEqualsTestForMessageVerification(new JSONArray(Arrays.asList(1, 2, 4)), actual, LENIENT);
        performAssertEqualsTestForMessageVerification(new JSONArray(Arrays.asList(1, 3, 2)), actual, STRICT);
    }
    
    @Test
    public void testAssertEqualsString2Boolean() throws JSONException {
        JSONAssert.assertEquals("Message", "{id:12345}", "{id:12345}", false);
        JSONAssert.assertEquals("Message", "{id:12345}", "{id:12345, name:\"john\"}", false);
        
        performAssertEqualsTestForMessageVerification("{id:12345}", "{id:12345, name:\"john\"}", true);
        performAssertEqualsTestForMessageVerification("{id:12345}", "{id:123456}", false);
    }
    
    @Test
    public void testAssertEqualsString2JSONCompare() throws JSONException {
        JSONAssert.assertEquals("Message", "{id:12345}", "{id:12345}", LENIENT);
        JSONAssert.assertEquals("Message", "{id:12345}", "{id:12345, name:\"john\"}", LENIENT);
        
        performAssertEqualsTestForMessageVerification("{id:12345}", "{id:12345, name:\"john\"}", STRICT);
        performAssertEqualsTestForMessageVerification("{id:12345}", "{id:123456}", LENIENT);
    }
    
    @Test
    public void testAssertEqualsStringJSONObjectBoolean() throws JSONException {
        JSONObject actual = new JSONObject();
        actual.put("id", Double.valueOf(12345));
        JSONAssert.assertEquals("Message", "{id:12345}", actual, false);
        performAssertEqualsTestForMessageVerification("{id:12346}", actual, false);
        performAssertEqualsTestForMessageVerification("[1,2,3]", "[1,3,2]", true);
    }
    
    @Test
    public void testAssertEqualsStringJSONObjectJSONCompare() throws JSONException {
        JSONObject actual = new JSONObject();
        actual.put("id", Double.valueOf(12345));
        JSONAssert.assertEquals("Message", "{id:12345}", actual, LENIENT);
        performAssertEqualsTestForMessageVerification("{id:12346}", actual, LENIENT);
        performAssertEqualsTestForMessageVerification("[1,2,3]", "[1,3,2]", STRICT);
    }
    
    @Test
    public void testAssertEqualsJSONObject2JSONCompare() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("name", "Joe");
        actual.put("id", Integer.valueOf(12345));
        JSONAssert.assertEquals("Message", expected, actual, LENIENT);
        
        expected.put("street", "St. Paul");
        performAssertEqualsTestForMessageVerification(expected, actual, LENIENT);
        
        expected = new JSONObject();
        actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Double.valueOf(12346));
        performAssertEqualsTestForMessageVerification(expected, actual, STRICT);
    }
    
    @Test
    public void testAssertEqualsJSONObject2Boolean() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("name", "Joe");
        actual.put("id", Integer.valueOf(12345));
        JSONAssert.assertEquals("Message", expected, actual, false);
        
        expected.put("street", "St. Paul");
        performAssertEqualsTestForMessageVerification(expected, actual, false);
        
        expected = new JSONObject();
        actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Double.valueOf(12346));
        performAssertEqualsTestForMessageVerification(expected, actual, true);
    }
    
    @Test
    public void testAssertEqualsString2JsonComparator() throws IllegalArgumentException, JSONException {
        JSONAssert.assertEquals("Message", "{\"entry\":{\"id\":x}}", "{\"entry\":{\"id\":1, \"id\":2}}", 
            new CustomComparator(
                JSONCompareMode.STRICT, 
                new Customization("entry.id", 
                new RegularExpressionValueMatcher<Object>("\\d"))
         ));
        
        performAssertEqualsTestForMessageVerification("{\"entry\":{\"id\":x}}", "{\"entry\":{\"id\":1, \"id\":as}}", 
            new CustomComparator(
                JSONCompareMode.STRICT, 
                new Customization("entry.id", 
                new RegularExpressionValueMatcher<Object>("\\d"))
        ));
    }
    
    @Test
    public void testAssertNotEqualsStringJSONArrayBooleanWithMessage() throws JSONException {
        JSONArray actual = new JSONArray(Arrays.asList(1, 2, 3));
        JSONAssert.assertNotEquals("Message", "[1,4,3]", actual, false);
        JSONAssert.assertNotEquals("Message", "[1,4,3]", actual, true);
        performAssertNotEqualsTestForMessageVerification("[1,3,2]", actual, false);
        performAssertNotEqualsTestForMessageVerification("[1,2,3]", actual, true);
    }
    
    @Test
    public void testAssertNotEqualsStringJSONArrayCompareModeWithMessage() throws JSONException {
        JSONArray actual = new JSONArray(Arrays.asList(1, 2, 3));
        JSONAssert.assertNotEquals("Message", "[1,2,4]", actual, LENIENT);
        JSONAssert.assertNotEquals("Message", "[1,2,4]", actual, STRICT);
        performAssertNotEqualsTestForMessageVerification("[1,3,2]", actual, LENIENT);
        performAssertNotEqualsTestForMessageVerification("[1,2,3]", actual, STRICT);
    }
    
    @Test
    public void testAssertNotEqualsJSONArray2BooleanWithMessage() throws JSONException {
        JSONArray actual = new JSONArray(Arrays.asList(1, 2, 3));
        JSONAssert.assertNotEquals("Message", new JSONArray(Arrays.asList(1, 4, 3)), actual, false);
        performAssertNotEqualsTestForMessageVerification(new JSONArray(Arrays.asList(1, 3, 2)), actual, false);
        performAssertNotEqualsTestForMessageVerification(new JSONArray(Arrays.asList(1, 2, 3)), actual, true);
    }
    
    @Test
    public void testAssertNotEqualsJSONArray2JSONCompareWithMessage() throws JSONException {
        JSONArray actual = new JSONArray(Arrays.asList(1, 2, 3));
        
        JSONAssert.assertNotEquals("Message", new JSONArray(Arrays.asList(1, 4, 3)), actual, LENIENT);
        performAssertNotEqualsTestForMessageVerification(new JSONArray(Arrays.asList(1, 3, 2)), actual, LENIENT);
        performAssertNotEqualsTestForMessageVerification(new JSONArray(Arrays.asList(1, 2, 3)), actual, STRICT);
    }
    
    @Test
    public void testAssertNotEqualsString2Boolean() throws JSONException {
        JSONAssert.assertNotEquals("Message", "{id:12345}", "{id:45}", false);
        JSONAssert.assertNotEquals("Message", "{id:12345}", "{id:345, name:\"john\"}", false);
        
        performAssertNotEqualsTestForMessageVerification("{id:12345}", "{id:12345}", true);
        performAssertNotEqualsTestForMessageVerification("{id:12345}", "{id:12345, name:\"John\"}", false);
    }
    
    @Test
    public void testAssertNotEqualsString2JSONCompare() throws JSONException {
        JSONAssert.assertNotEquals("Message", "{id:12345}", "{id:123}", LENIENT);
        JSONAssert.assertNotEquals("Message", "{id:12345, name:\"John\"}", "{id:12345}", LENIENT);
        
        performAssertNotEqualsTestForMessageVerification("{id:12345}", "{id:12345, name:\"john\"}", LENIENT);
        performAssertNotEqualsTestForMessageVerification("{id:12345}", "{id:12345}", STRICT);
    }
    
    @Test
    public void testAssertNotEqualsStringJSONObjectBoolean() throws JSONException {
        JSONObject actual = new JSONObject();
        actual.put("id", Double.valueOf(12345));
        JSONAssert.assertNotEquals("Message", "{id:1234}", actual, false);
        performAssertNotEqualsTestForMessageVerification("{id:12345}", actual, false);
        performAssertNotEqualsTestForMessageVerification("[1,2,3]", "[1,2,3]", true);
    }
    
    @Test
    public void testAssertNotEqualsStringJSONObjectJSONCompare() throws JSONException {
        JSONObject actual = new JSONObject();
        actual.put("id", Double.valueOf(12345));
        JSONAssert.assertNotEquals("Message", "{id:1234}", actual, LENIENT);
        performAssertNotEqualsTestForMessageVerification("{id:12345}", actual, LENIENT);
        performAssertNotEqualsTestForMessageVerification("[1,2,3]", "[1,2,3]", STRICT);
    }
    
    @Test
    public void testAssertNtEqualsJSONObject2JSONCompare() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("name", "Joe");
        actual.put("id", Integer.valueOf(123));
        JSONAssert.assertNotEquals("Message", expected, actual, LENIENT);
        
        actual.remove("id");
        actual.put("id", Integer.valueOf(12345));
        performAssertNotEqualsTestForMessageVerification(expected, actual, LENIENT);
        
        expected = new JSONObject();
        actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Double.valueOf(12345));
        performAssertNotEqualsTestForMessageVerification(expected, actual, STRICT);
    }
    
    @Test
    public void testAssertNotEqualsJSONObject2Boolean() throws JSONException {
        JSONObject expected = new JSONObject();
        JSONObject actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("name", "Joe");
        actual.put("id", Integer.valueOf(123));
        JSONAssert.assertNotEquals("Message", expected, actual, false);
        
        actual.remove("id");
        actual.put("id", Integer.valueOf(12345));
        performAssertNotEqualsTestForMessageVerification(expected, actual, false);
        
        expected = new JSONObject();
        actual = new JSONObject();
        expected.put("id", Integer.valueOf(12345));
        actual.put("id", Double.valueOf(12345));
        performAssertNotEqualsTestForMessageVerification(expected, actual, true);
    }
    
    @Test
    public void testAssertNotEqualsString2JsonComparator() throws IllegalArgumentException, JSONException {
        JSONAssert.assertNotEquals("Message", "{\"entry\":{\"id\":x}}", "{\"entry\":{\"id\":1, \"id\":hh}}", 
            new CustomComparator(
                JSONCompareMode.STRICT, 
                new Customization("entry.id", 
                new RegularExpressionValueMatcher<Object>("\\d"))
         ));
        
        performAssertNotEqualsTestForMessageVerification("{\"entry\":{\"id\":x}}", "{\"entry\":{\"id\":1, \"id\":2}}", 
            new CustomComparator(
                JSONCompareMode.STRICT, 
                new Customization("entry.id", 
                new RegularExpressionValueMatcher<Object>("\\d"))
        ));
    }
    
    private void testPass(String expected, String actual, JSONCompareMode compareMode)
            throws JSONException
    {
        String message = expected + " == " + actual + " (" + compareMode + ")";
        JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
        Assert.assertTrue(message + "\n  " + result.getMessage(), result.passed());
    }

    private void testFail(String expected, String actual, JSONCompareMode compareMode)
            throws JSONException
    {
        String message = expected + " != " + actual + " (" + compareMode + ")";
        JSONCompareResult result = JSONCompare.compareJSON(expected, actual, compareMode);
        Assert.assertTrue(message, result.failed());
    }
    
    private void performAssertEqualsTestForMessageVerification(
        Object expected, 
        Object actual, 
        Object strictMode) throws JSONException {
        
        String message = "Message";
        String testShouldFailMessage = "The test should fail so that the message in AssertionError could be verified.";
        String strictModeMessage = "strictMode must be an instance of JSONCompareMode or Boolean";
        boolean assertEqualsFailed = true;
        if(expected instanceof String && actual instanceof String && strictMode instanceof JSONComparator) {
            try {
                JSONAssert.assertEquals(message, (String) expected, (String) actual, (JSONComparator) strictMode);
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        }
        else if(expected instanceof String && actual instanceof JSONArray) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertEquals(message, (String) expected, (JSONArray) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertEquals(message, (String) expected, (JSONArray) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else if(expected instanceof JSONArray && actual instanceof JSONArray) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertEquals(message, (JSONArray) expected, (JSONArray) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertEquals(message, (JSONArray) expected, (JSONArray) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else if(expected instanceof String && actual instanceof String) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertEquals(message, (String) expected, (String) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertEquals(message, (String) expected, (String) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else if(expected instanceof String && actual instanceof JSONObject) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertEquals(message, (String) expected, (JSONObject) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertEquals(message, (String) expected, (JSONObject) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else if(expected instanceof JSONObject && actual instanceof JSONObject) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertEquals(message, (JSONObject) expected, (JSONObject) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertEquals(message, (JSONObject) expected, (JSONObject) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else {
            fail("No overloaded method found to call");
        }
    }
    
    private void performAssertNotEqualsTestForMessageVerification(
        Object expected, 
        Object actual, 
        Object strictMode) 
        throws JSONException {
        
        String message = "Message";
        String testShouldFailMessage = "The test should fail so that the message in AssertionError could be verified.";
        String strictModeMessage = "strictMode must be an instance of JSONCompareMode or Boolean";
        boolean assertEqualsFailed = true;
        if(expected instanceof String && actual instanceof String && strictMode instanceof JSONComparator) {
            try {
                JSONAssert.assertNotEquals(message, (String) expected, (String) actual, (JSONComparator) strictMode);
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        }
        else if(expected instanceof String && actual instanceof JSONArray) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertNotEquals(message, (String) expected, (JSONArray) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertNotEquals(message, (String) expected, (JSONArray) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else if(expected instanceof JSONArray && actual instanceof JSONArray) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertNotEquals(message, (JSONArray) expected, (JSONArray) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertNotEquals(message, (JSONArray) expected, (JSONArray) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else if(expected instanceof String && actual instanceof String) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertNotEquals(message, (String) expected, (String) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertNotEquals(message, (String) expected, (String) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else if(expected instanceof String && actual instanceof JSONObject) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertNotEquals(message, (String) expected, (JSONObject) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertNotEquals(message, (String) expected, (JSONObject) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else if(expected instanceof JSONObject && actual instanceof JSONObject) {
            try {
                if(strictMode instanceof JSONCompareMode) {
                    JSONAssert.assertNotEquals(message, (JSONObject) expected, (JSONObject) actual, (JSONCompareMode) strictMode);
                } else if(strictMode instanceof Boolean) {
                    JSONAssert.assertNotEquals(message, (JSONObject) expected, (JSONObject) actual, (Boolean) strictMode);
                } else {
                    fail(strictModeMessage);
                }
                assertEqualsFailed = false;
                fail(testShouldFailMessage); //will throw AssertionError
            } catch (AssertionError ae) {
                handleAssertionError(message, assertEqualsFailed, ae);
            }
        } else {
            fail("No overloaded method found to call");
        }
    }

    private void handleAssertionError(String message, boolean assertEqualsFailed, AssertionError ae) throws AssertionError {
        if(assertEqualsFailed) {
            verifyErrorMessage(message, ae);
        } else {
            throw ae;
        }
    }
    
    private void verifyErrorMessage(String message, AssertionError ae) {
        assertTrue(ae.getMessage().contains(message));
        assertTrue(ae.getMessage().startsWith(message));
    }
}