json/src/test/java/org/json/JSONArrayTest.java - platform/libcore-snapshot - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * 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.json;

 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import junit.framework.TestCase;

 /**
  * This black box test was written without inspecting the non-free org.json sourcecode.
  */
 public class JSONArrayTest extends TestCase {

     public void testEmptyArray() throws JSONException {
         JSONArray array = new JSONArray();
         assertEquals(0, array.length());
         assertEquals("", array.join(" AND "));
         try {
             array.get(0);
             fail();
         } catch (JSONException e) {
         }
         try {
             array.getBoolean(0);
             fail();
         } catch (JSONException e) {
         }

         assertEquals("[]", array.toString());
         assertEquals("[]", array.toString(4));

         // out of bounds is co-opted with defaulting
         assertTrue(array.isNull(0));
         assertNull(array.opt(0));
         assertFalse(array.optBoolean(0));
         assertTrue(array.optBoolean(0, true));

         // bogus (but documented) behaviour: returns null rather than an empty object!
         assertNull(array.toJSONObject(new JSONArray()));
     }

     public void testEqualsAndHashCode() throws JSONException {
         JSONArray a = new JSONArray();
         JSONArray b = new JSONArray();
         assertTrue(a.equals(b));
         assertEquals("equals() not consistent with hashCode()", a.hashCode(), b.hashCode());

         a.put(true);
         a.put(false);
         b.put(true);
         b.put(false);
         assertTrue(a.equals(b));
         assertEquals(a.hashCode(), b.hashCode());

         b.put(true);
         assertFalse(a.equals(b));
         assertTrue(a.hashCode() != b.hashCode());
     }

     public void testBooleans() throws JSONException {
         JSONArray array = new JSONArray();
         array.put(true);
         array.put(false);
         array.put(2, false);
         array.put(3, false);
         array.put(2, true);
         assertEquals("[true,false,true,false]", array.toString());
         assertEquals(4, array.length());
         assertEquals(Boolean.TRUE, array.get(0));
         assertEquals(Boolean.FALSE, array.get(1));
         assertEquals(Boolean.TRUE, array.get(2));
         assertEquals(Boolean.FALSE, array.get(3));
         assertFalse(array.isNull(0));
         assertFalse(array.isNull(1));
         assertFalse(array.isNull(2));
         assertFalse(array.isNull(3));
         assertEquals(true, array.optBoolean(0));
         assertEquals(false, array.optBoolean(1, true));
         assertEquals(true, array.optBoolean(2, false));
         assertEquals(false, array.optBoolean(3));
         assertEquals("true", array.getString(0));
         assertEquals("false", array.getString(1));
         assertEquals("true", array.optString(2));
         assertEquals("false", array.optString(3, "x"));
         assertEquals("[\n     true,\n     false,\n     true,\n     false\n]", array.toString(5));

         JSONArray other = new JSONArray();
         other.put(true);
         other.put(false);
         other.put(true);
         other.put(false);
         assertTrue(array.equals(other));
         other.put(true);
         assertFalse(array.equals(other));

         other = new JSONArray();
         other.put("true");
         other.put("false");
         other.put("truE");
         other.put("FALSE");
         assertFalse(array.equals(other));
         assertFalse(other.equals(array));
         assertEquals(true, other.getBoolean(0));
         assertEquals(false, other.optBoolean(1, true));
         assertEquals(true, other.optBoolean(2));
         assertEquals(false, other.getBoolean(3));
     }

     // http://code.google.com/p/android/issues/detail?id=16411
     public void testCoerceStringToBoolean() throws JSONException {
         JSONArray array = new JSONArray();
         array.put("maybe");
         try {
             array.getBoolean(0);
             fail();
         } catch (JSONException expected) {
         }
         assertEquals(false, array.optBoolean(0));
         assertEquals(true, array.optBoolean(0, true));
     }

     public void testNulls() throws JSONException {
         JSONArray array = new JSONArray();
         array.put(3, null);
         array.put(0, JSONObject.NULL);
         assertEquals(4, array.length());
         assertEquals("[null,null,null,null]", array.toString());

         // there's 2 ways to represent null; each behaves differently!
         assertEquals(JSONObject.NULL, array.get(0));
         try {
             array.get(1);
             fail();
         } catch (JSONException e) {
         }
         try {
             array.get(2);
             fail();
         } catch (JSONException e) {
         }
         try {
             array.get(3);
             fail();
         } catch (JSONException e) {
         }
         assertEquals(JSONObject.NULL, array.opt(0));
         assertEquals(null, array.opt(1));
         assertEquals(null, array.opt(2));
         assertEquals(null, array.opt(3));
         assertTrue(array.isNull(0));
         assertTrue(array.isNull(1));
         assertTrue(array.isNull(2));
         assertTrue(array.isNull(3));
         assertEquals("null", array.optString(0));
         assertEquals("", array.optString(1));
         assertEquals("", array.optString(2));
         assertEquals("", array.optString(3));
     }

     /**
      * Our behaviour is questioned by this bug:
      * http://code.google.com/p/android/issues/detail?id=7257
      */
     public void testParseNullYieldsJSONObjectNull() throws JSONException {
         JSONArray array = new JSONArray("[\"null\",null]");
         array.put(null);
         assertEquals("null", array.get(0));
         assertEquals(JSONObject.NULL, array.get(1));
         try {
             array.get(2);
             fail();
         } catch (JSONException e) {
         }
         assertEquals("null", array.getString(0));
         assertEquals("null", array.getString(1));
         try {
             array.getString(2);
             fail();
         } catch (JSONException e) {
         }
     }

     public void testNumbers() throws JSONException {
         JSONArray array = new JSONArray();
         array.put(Double.MIN_VALUE);
         array.put(9223372036854775806L);
         array.put(Double.MAX_VALUE);
         array.put(-0d);
         assertEquals(4, array.length());

         // toString() and getString(int) return different values for -0d
         assertEquals("[4.9E-324,9223372036854775806,1.7976931348623157E308,-0]", array.toString());

         assertEquals(Double.MIN_VALUE, array.get(0));
         assertEquals(9223372036854775806L, array.get(1));
         assertEquals(Double.MAX_VALUE, array.get(2));
         assertEquals(-0d, array.get(3));
         assertEquals(Double.MIN_VALUE, array.getDouble(0));
         assertEquals(9.223372036854776E18, array.getDouble(1));
         assertEquals(Double.MAX_VALUE, array.getDouble(2));
         assertEquals(-0d, array.getDouble(3));
         assertEquals(0, array.getLong(0));
         assertEquals(9223372036854775806L, array.getLong(1));
         assertEquals(Long.MAX_VALUE, array.getLong(2));
         assertEquals(0, array.getLong(3));
         assertEquals(0, array.getInt(0));
         assertEquals(-2, array.getInt(1));
         assertEquals(Integer.MAX_VALUE, array.getInt(2));
         assertEquals(0, array.getInt(3));
         assertEquals(Double.MIN_VALUE, array.opt(0));
         assertEquals(Double.MIN_VALUE, array.optDouble(0));
         assertEquals(0, array.optLong(0, 1L));
         assertEquals(0, array.optInt(0, 1));
         assertEquals("4.9E-324", array.getString(0));
         assertEquals("9223372036854775806", array.getString(1));
         assertEquals("1.7976931348623157E308", array.getString(2));
         assertEquals("-0.0", array.getString(3));

         JSONArray other = new JSONArray();
         other.put(Double.MIN_VALUE);
         other.put(9223372036854775806L);
         other.put(Double.MAX_VALUE);
         other.put(-0d);
         assertTrue(array.equals(other));
         other.put(0, 0L);
         assertFalse(array.equals(other));
     }

     public void testStrings() throws JSONException {
         JSONArray array = new JSONArray();
         array.put("true");
         array.put("5.5");
         array.put("9223372036854775806");
         array.put("null");
         array.put("5\"8' tall");
         assertEquals(5, array.length());
         assertEquals("[\"true\",\"5.5\",\"9223372036854775806\",\"null\",\"5\\\"8' tall\"]",
                 array.toString());

         // although the documentation doesn't mention it, join() escapes text and wraps
         // strings in quotes
         assertEquals("\"true\" \"5.5\" \"9223372036854775806\" \"null\" \"5\\\"8' tall\"",
                 array.join(" "));

         assertEquals("true", array.get(0));
         assertEquals("null", array.getString(3));
         assertEquals("5\"8' tall", array.getString(4));
         assertEquals("true", array.opt(0));
         assertEquals("5.5", array.optString(1));
         assertEquals("9223372036854775806", array.optString(2, null));
         assertEquals("null", array.optString(3, "-1"));
         assertFalse(array.isNull(0));
         assertFalse(array.isNull(3));

         assertEquals(true, array.getBoolean(0));
         assertEquals(true, array.optBoolean(0));
         assertEquals(true, array.optBoolean(0, false));
         assertEquals(0, array.optInt(0));
         assertEquals(-2, array.optInt(0, -2));

         assertEquals(5.5d, array.getDouble(1));
         assertEquals(5L, array.getLong(1));
         assertEquals(5, array.getInt(1));
         assertEquals(5, array.optInt(1, 3));

         // The last digit of the string is a 6 but getLong returns a 7. It's probably parsing as a
         // double and then converting that to a long. This is consistent with JavaScript.
         assertEquals(9223372036854775807L, array.getLong(2));
         assertEquals(9.223372036854776E18, array.getDouble(2));
         assertEquals(Integer.MAX_VALUE, array.getInt(2));

         assertFalse(array.isNull(3));
         try {
             array.getDouble(3);
             fail();
         } catch (JSONException e) {
         }
         assertEquals(Double.NaN, array.optDouble(3));
         assertEquals(-1.0d, array.optDouble(3, -1.0d));
     }

     public void testJoin() throws JSONException {
         JSONArray array = new JSONArray();
         array.put(null);
         assertEquals("null", array.join(" & "));
         array.put("\"");
         assertEquals("null & \"\\\"\"", array.join(" & "));
         array.put(5);
         assertEquals("null & \"\\\"\" & 5", array.join(" & "));
         array.put(true);
         assertEquals("null & \"\\\"\" & 5 & true", array.join(" & "));
         array.put(new JSONArray(Arrays.asList(true, false)));
         assertEquals("null & \"\\\"\" & 5 & true & [true,false]", array.join(" & "));
         array.put(new JSONObject(Collections.singletonMap("x", 6)));
         assertEquals("null & \"\\\"\" & 5 & true & [true,false] & {\"x\":6}", array.join(" & "));
     }

     public void testJoinWithNull() throws JSONException {
         JSONArray array = new JSONArray(Arrays.asList(5, 6));
         assertEquals("5null6", array.join(null));
     }

     public void testJoinWithSpecialCharacters() throws JSONException {
         JSONArray array = new JSONArray(Arrays.asList(5, 6));
         assertEquals("5\"6", array.join("\""));
     }

     public void testToJSONObject() throws JSONException {
         JSONArray keys = new JSONArray();
         keys.put("a");
         keys.put("b");

         JSONArray values = new JSONArray();
         values.put(5.5d);
         values.put(false);

         JSONObject object = values.toJSONObject(keys);
         assertEquals(5.5d, object.get("a"));
         assertEquals(false, object.get("b"));

         keys.put(0, "a");
         values.put(0, 11.0d);
         assertEquals(5.5d, object.get("a"));
     }

     public void testToJSONObjectWithNulls() throws JSONException {
         JSONArray keys = new JSONArray();
         keys.put("a");
         keys.put("b");

         JSONArray values = new JSONArray();
         values.put(5.5d);
         values.put(null);

         // null values are stripped!
         JSONObject object = values.toJSONObject(keys);
         assertEquals(1, object.length());
         assertFalse(object.has("b"));
         assertEquals("{\"a\":5.5}", object.toString());
     }

     public void testToJSONObjectMoreNamesThanValues() throws JSONException {
         JSONArray keys = new JSONArray();
         keys.put("a");
         keys.put("b");
         JSONArray values = new JSONArray();
         values.put(5.5d);
         JSONObject object = values.toJSONObject(keys);
         assertEquals(1, object.length());
         assertEquals(5.5d, object.get("a"));
     }

     public void testToJSONObjectMoreValuesThanNames() throws JSONException {
         JSONArray keys = new JSONArray();
         keys.put("a");
         JSONArray values = new JSONArray();
         values.put(5.5d);
         values.put(11.0d);
         JSONObject object = values.toJSONObject(keys);
         assertEquals(1, object.length());
         assertEquals(5.5d, object.get("a"));
     }

     public void testToJSONObjectNullKey() throws JSONException {
         JSONArray keys = new JSONArray();
         keys.put(JSONObject.NULL);
         JSONArray values = new JSONArray();
         values.put(5.5d);
         JSONObject object = values.toJSONObject(keys);
         assertEquals(1, object.length());
         assertEquals(5.5d, object.get("null"));
     }

     public void testPutUnsupportedNumbers() throws JSONException {
         JSONArray array = new JSONArray();

         try {
             array.put(Double.NaN);
             fail();
         } catch (JSONException e) {
         }
         try {
             array.put(0, Double.NEGATIVE_INFINITY);
             fail();
         } catch (JSONException e) {
         }
         try {
             array.put(0, Double.POSITIVE_INFINITY);
             fail();
         } catch (JSONException e) {
         }
     }

     public void testPutUnsupportedNumbersAsObject() throws JSONException {
         JSONArray array = new JSONArray();
         array.put(Double.valueOf(Double.NaN));
         array.put(Double.valueOf(Double.NEGATIVE_INFINITY));
         array.put(Double.valueOf(Double.POSITIVE_INFINITY));
         assertEquals(null, array.toString());
     }

     /**
      * Although JSONArray is usually defensive about which numbers it accepts,
      * it doesn't check inputs in its constructor.
      */
     public void testCreateWithUnsupportedNumbers() throws JSONException {
         JSONArray array = new JSONArray(Arrays.asList(5.5, Double.NaN));
         assertEquals(2, array.length());
         assertEquals(5.5, array.getDouble(0));
         assertEquals(Double.NaN, array.getDouble(1));
     }

     public void testToStringWithUnsupportedNumbers() throws JSONException {
         // when the array contains an unsupported number, toString returns null!
         JSONArray array = new JSONArray(Arrays.asList(5.5, Double.NaN));
         assertNull(array.toString());
     }

     public void testListConstructorCopiesContents() throws JSONException {
         List<Object> contents = Arrays.<Object>asList(5);
         JSONArray array = new JSONArray(contents);
         contents.set(0, 10);
         assertEquals(5, array.get(0));
     }

     public void testTokenerConstructor() throws JSONException {
         JSONArray object = new JSONArray(new JSONTokener("[false]"));
         assertEquals(1, object.length());
         assertEquals(false, object.get(0));
     }

     public void testTokenerConstructorWrongType() throws JSONException {
         try {
             new JSONArray(new JSONTokener("{\"foo\": false}"));
             fail();
         } catch (JSONException e) {
         }
     }

     public void testTokenerConstructorNull() throws JSONException {
         try {
             new JSONArray((JSONTokener) null);
             fail();
         } catch (NullPointerException e) {
         }
     }

     public void testTokenerConstructorParseFail() {
         try {
             new JSONArray(new JSONTokener("["));
             fail();
         } catch (JSONException e) {
         } catch (StackOverflowError e) {
             fail("Stack overflowed on input: \"[\"");
         }
     }

     public void testStringConstructor() throws JSONException {
         JSONArray object = new JSONArray("[false]");
         assertEquals(1, object.length());
         assertEquals(false, object.get(0));
     }

     public void testStringConstructorWrongType() throws JSONException {
         try {
             new JSONArray("{\"foo\": false}");
             fail();
         } catch (JSONException e) {
         }
     }

     public void testStringConstructorNull() throws JSONException {
         try {
             new JSONArray((String) null);
             fail();
         } catch (NullPointerException e) {
         }
     }

     public void testStringConstructorParseFail() {
         try {
             new JSONArray("[");
             fail();
         } catch (JSONException e) {
         } catch (StackOverflowError e) {
             fail("Stack overflowed on input: \"[\"");
         }
     }

     public void testCreate() throws JSONException {
         JSONArray array = new JSONArray(Arrays.asList(5.5, true));
         assertEquals(2, array.length());
         assertEquals(5.5, array.getDouble(0));
         assertEquals(true, array.get(1));
         assertEquals("[5.5,true]", array.toString());
     }

     public void testAccessOutOfBounds() throws JSONException {
         JSONArray array = new JSONArray();
         array.put("foo");
         assertEquals(null, array.opt(3));
         assertEquals(null, array.opt(-3));
         assertEquals("", array.optString(3));
         assertEquals("", array.optString(-3));
         try {
             array.get(3);
             fail();
         } catch (JSONException e) {
         }
         try {
             array.get(-3);
             fail();
         } catch (JSONException e) {
         }
         try {
             array.getString(3);
             fail();
         } catch (JSONException e) {
         }
         try {
             array.getString(-3);
             fail();
         } catch (JSONException e) {
         }
     }
 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* 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.json;

	import java.util.Arrays;
	import java.util.Collections;
	import java.util.List;
	import junit.framework.TestCase;

	/**
	* This black box test was written without inspecting the non-free org.json sourcecode.
	*/
	public class JSONArrayTest extends TestCase {

	public void testEmptyArray() throws JSONException {
	JSONArray array = new JSONArray();
	assertEquals(0, array.length());
	assertEquals("", array.join(" AND "));
	try {
	array.get(0);
	fail();
	} catch (JSONException e) {
	}
	try {
	array.getBoolean(0);
	fail();
	} catch (JSONException e) {
	}

	assertEquals("[]", array.toString());
	assertEquals("[]", array.toString(4));

	// out of bounds is co-opted with defaulting
	assertTrue(array.isNull(0));
	assertNull(array.opt(0));
	assertFalse(array.optBoolean(0));
	assertTrue(array.optBoolean(0, true));

	// bogus (but documented) behaviour: returns null rather than an empty object!
	assertNull(array.toJSONObject(new JSONArray()));
	}

	public void testEqualsAndHashCode() throws JSONException {
	JSONArray a = new JSONArray();
	JSONArray b = new JSONArray();
	assertTrue(a.equals(b));
	assertEquals("equals() not consistent with hashCode()", a.hashCode(), b.hashCode());

	a.put(true);
	a.put(false);
	b.put(true);
	b.put(false);
	assertTrue(a.equals(b));
	assertEquals(a.hashCode(), b.hashCode());

	b.put(true);
	assertFalse(a.equals(b));
	assertTrue(a.hashCode() != b.hashCode());
	}

	public void testBooleans() throws JSONException {
	JSONArray array = new JSONArray();
	array.put(true);
	array.put(false);
	array.put(2, false);
	array.put(3, false);
	array.put(2, true);
	assertEquals("[true,false,true,false]", array.toString());
	assertEquals(4, array.length());
	assertEquals(Boolean.TRUE, array.get(0));
	assertEquals(Boolean.FALSE, array.get(1));
	assertEquals(Boolean.TRUE, array.get(2));
	assertEquals(Boolean.FALSE, array.get(3));
	assertFalse(array.isNull(0));
	assertFalse(array.isNull(1));
	assertFalse(array.isNull(2));
	assertFalse(array.isNull(3));
	assertEquals(true, array.optBoolean(0));
	assertEquals(false, array.optBoolean(1, true));
	assertEquals(true, array.optBoolean(2, false));
	assertEquals(false, array.optBoolean(3));
	assertEquals("true", array.getString(0));
	assertEquals("false", array.getString(1));
	assertEquals("true", array.optString(2));
	assertEquals("false", array.optString(3, "x"));
	assertEquals("[\n true,\n false,\n true,\n false\n]", array.toString(5));

	JSONArray other = new JSONArray();
	other.put(true);
	other.put(false);
	other.put(true);
	other.put(false);
	assertTrue(array.equals(other));
	other.put(true);
	assertFalse(array.equals(other));

	other = new JSONArray();
	other.put("true");
	other.put("false");
	other.put("truE");
	other.put("FALSE");
	assertFalse(array.equals(other));
	assertFalse(other.equals(array));
	assertEquals(true, other.getBoolean(0));
	assertEquals(false, other.optBoolean(1, true));
	assertEquals(true, other.optBoolean(2));
	assertEquals(false, other.getBoolean(3));
	}

	// http://code.google.com/p/android/issues/detail?id=16411
	public void testCoerceStringToBoolean() throws JSONException {
	JSONArray array = new JSONArray();
	array.put("maybe");
	try {
	array.getBoolean(0);
	fail();
	} catch (JSONException expected) {
	}
	assertEquals(false, array.optBoolean(0));
	assertEquals(true, array.optBoolean(0, true));
	}

	public void testNulls() throws JSONException {
	JSONArray array = new JSONArray();
	array.put(3, null);
	array.put(0, JSONObject.NULL);
	assertEquals(4, array.length());
	assertEquals("[null,null,null,null]", array.toString());

	// there's 2 ways to represent null; each behaves differently!
	assertEquals(JSONObject.NULL, array.get(0));
	try {
	array.get(1);
	fail();
	} catch (JSONException e) {
	}
	try {
	array.get(2);
	fail();
	} catch (JSONException e) {
	}
	try {
	array.get(3);
	fail();
	} catch (JSONException e) {
	}
	assertEquals(JSONObject.NULL, array.opt(0));
	assertEquals(null, array.opt(1));
	assertEquals(null, array.opt(2));
	assertEquals(null, array.opt(3));
	assertTrue(array.isNull(0));
	assertTrue(array.isNull(1));
	assertTrue(array.isNull(2));
	assertTrue(array.isNull(3));
	assertEquals("null", array.optString(0));
	assertEquals("", array.optString(1));
	assertEquals("", array.optString(2));
	assertEquals("", array.optString(3));
	}

	/**
	* Our behaviour is questioned by this bug:
	* http://code.google.com/p/android/issues/detail?id=7257
	*/
	public void testParseNullYieldsJSONObjectNull() throws JSONException {
	JSONArray array = new JSONArray("[\"null\",null]");
	array.put(null);
	assertEquals("null", array.get(0));
	assertEquals(JSONObject.NULL, array.get(1));
	try {
	array.get(2);
	fail();
	} catch (JSONException e) {
	}
	assertEquals("null", array.getString(0));
	assertEquals("null", array.getString(1));
	try {
	array.getString(2);
	fail();
	} catch (JSONException e) {
	}
	}

	public void testNumbers() throws JSONException {
	JSONArray array = new JSONArray();
	array.put(Double.MIN_VALUE);
	array.put(9223372036854775806L);
	array.put(Double.MAX_VALUE);
	array.put(-0d);
	assertEquals(4, array.length());

	// toString() and getString(int) return different values for -0d
	assertEquals("[4.9E-324,9223372036854775806,1.7976931348623157E308,-0]", array.toString());

	assertEquals(Double.MIN_VALUE, array.get(0));
	assertEquals(9223372036854775806L, array.get(1));
	assertEquals(Double.MAX_VALUE, array.get(2));
	assertEquals(-0d, array.get(3));
	assertEquals(Double.MIN_VALUE, array.getDouble(0));
	assertEquals(9.223372036854776E18, array.getDouble(1));
	assertEquals(Double.MAX_VALUE, array.getDouble(2));
	assertEquals(-0d, array.getDouble(3));
	assertEquals(0, array.getLong(0));
	assertEquals(9223372036854775806L, array.getLong(1));
	assertEquals(Long.MAX_VALUE, array.getLong(2));
	assertEquals(0, array.getLong(3));
	assertEquals(0, array.getInt(0));
	assertEquals(-2, array.getInt(1));
	assertEquals(Integer.MAX_VALUE, array.getInt(2));
	assertEquals(0, array.getInt(3));
	assertEquals(Double.MIN_VALUE, array.opt(0));
	assertEquals(Double.MIN_VALUE, array.optDouble(0));
	assertEquals(0, array.optLong(0, 1L));
	assertEquals(0, array.optInt(0, 1));
	assertEquals("4.9E-324", array.getString(0));
	assertEquals("9223372036854775806", array.getString(1));
	assertEquals("1.7976931348623157E308", array.getString(2));
	assertEquals("-0.0", array.getString(3));

	JSONArray other = new JSONArray();
	other.put(Double.MIN_VALUE);
	other.put(9223372036854775806L);
	other.put(Double.MAX_VALUE);
	other.put(-0d);
	assertTrue(array.equals(other));
	other.put(0, 0L);
	assertFalse(array.equals(other));
	}

	public void testStrings() throws JSONException {
	JSONArray array = new JSONArray();
	array.put("true");
	array.put("5.5");
	array.put("9223372036854775806");
	array.put("null");
	array.put("5\"8' tall");
	assertEquals(5, array.length());
	assertEquals("[\"true\",\"5.5\",\"9223372036854775806\",\"null\",\"5\\\"8' tall\"]",
	array.toString());

	// although the documentation doesn't mention it, join() escapes text and wraps
	// strings in quotes
	assertEquals("\"true\" \"5.5\" \"9223372036854775806\" \"null\" \"5\\\"8' tall\"",
	array.join(" "));

	assertEquals("true", array.get(0));
	assertEquals("null", array.getString(3));
	assertEquals("5\"8' tall", array.getString(4));
	assertEquals("true", array.opt(0));
	assertEquals("5.5", array.optString(1));
	assertEquals("9223372036854775806", array.optString(2, null));
	assertEquals("null", array.optString(3, "-1"));
	assertFalse(array.isNull(0));
	assertFalse(array.isNull(3));

	assertEquals(true, array.getBoolean(0));
	assertEquals(true, array.optBoolean(0));
	assertEquals(true, array.optBoolean(0, false));
	assertEquals(0, array.optInt(0));
	assertEquals(-2, array.optInt(0, -2));

	assertEquals(5.5d, array.getDouble(1));
	assertEquals(5L, array.getLong(1));
	assertEquals(5, array.getInt(1));
	assertEquals(5, array.optInt(1, 3));

	// The last digit of the string is a 6 but getLong returns a 7. It's probably parsing as a
	// double and then converting that to a long. This is consistent with JavaScript.
	assertEquals(9223372036854775807L, array.getLong(2));
	assertEquals(9.223372036854776E18, array.getDouble(2));
	assertEquals(Integer.MAX_VALUE, array.getInt(2));

	assertFalse(array.isNull(3));
	try {
	array.getDouble(3);
	fail();
	} catch (JSONException e) {
	}
	assertEquals(Double.NaN, array.optDouble(3));
	assertEquals(-1.0d, array.optDouble(3, -1.0d));
	}

	public void testJoin() throws JSONException {
	JSONArray array = new JSONArray();
	array.put(null);
	assertEquals("null", array.join(" & "));
	array.put("\"");
	assertEquals("null & \"\\\"\"", array.join(" & "));
	array.put(5);
	assertEquals("null & \"\\\"\" & 5", array.join(" & "));
	array.put(true);
	assertEquals("null & \"\\\"\" & 5 & true", array.join(" & "));
	array.put(new JSONArray(Arrays.asList(true, false)));
	assertEquals("null & \"\\\"\" & 5 & true & [true,false]", array.join(" & "));
	array.put(new JSONObject(Collections.singletonMap("x", 6)));
	assertEquals("null & \"\\\"\" & 5 & true & [true,false] & {\"x\":6}", array.join(" & "));
	}

	public void testJoinWithNull() throws JSONException {
	JSONArray array = new JSONArray(Arrays.asList(5, 6));
	assertEquals("5null6", array.join(null));
	}

	public void testJoinWithSpecialCharacters() throws JSONException {
	JSONArray array = new JSONArray(Arrays.asList(5, 6));
	assertEquals("5\"6", array.join("\""));
	}

	public void testToJSONObject() throws JSONException {
	JSONArray keys = new JSONArray();
	keys.put("a");
	keys.put("b");

	JSONArray values = new JSONArray();
	values.put(5.5d);
	values.put(false);

	JSONObject object = values.toJSONObject(keys);
	assertEquals(5.5d, object.get("a"));
	assertEquals(false, object.get("b"));

	keys.put(0, "a");
	values.put(0, 11.0d);
	assertEquals(5.5d, object.get("a"));
	}

	public void testToJSONObjectWithNulls() throws JSONException {
	JSONArray keys = new JSONArray();
	keys.put("a");
	keys.put("b");

	JSONArray values = new JSONArray();
	values.put(5.5d);
	values.put(null);

	// null values are stripped!
	JSONObject object = values.toJSONObject(keys);
	assertEquals(1, object.length());
	assertFalse(object.has("b"));
	assertEquals("{\"a\":5.5}", object.toString());
	}

	public void testToJSONObjectMoreNamesThanValues() throws JSONException {
	JSONArray keys = new JSONArray();
	keys.put("a");
	keys.put("b");
	JSONArray values = new JSONArray();
	values.put(5.5d);
	JSONObject object = values.toJSONObject(keys);
	assertEquals(1, object.length());
	assertEquals(5.5d, object.get("a"));
	}

	public void testToJSONObjectMoreValuesThanNames() throws JSONException {
	JSONArray keys = new JSONArray();
	keys.put("a");
	JSONArray values = new JSONArray();
	values.put(5.5d);
	values.put(11.0d);
	JSONObject object = values.toJSONObject(keys);
	assertEquals(1, object.length());
	assertEquals(5.5d, object.get("a"));
	}

	public void testToJSONObjectNullKey() throws JSONException {
	JSONArray keys = new JSONArray();
	keys.put(JSONObject.NULL);
	JSONArray values = new JSONArray();
	values.put(5.5d);
	JSONObject object = values.toJSONObject(keys);
	assertEquals(1, object.length());
	assertEquals(5.5d, object.get("null"));
	}

	public void testPutUnsupportedNumbers() throws JSONException {
	JSONArray array = new JSONArray();

	try {
	array.put(Double.NaN);
	fail();
	} catch (JSONException e) {
	}
	try {
	array.put(0, Double.NEGATIVE_INFINITY);
	fail();
	} catch (JSONException e) {
	}
	try {
	array.put(0, Double.POSITIVE_INFINITY);
	fail();
	} catch (JSONException e) {
	}
	}

	public void testPutUnsupportedNumbersAsObject() throws JSONException {
	JSONArray array = new JSONArray();
	array.put(Double.valueOf(Double.NaN));
	array.put(Double.valueOf(Double.NEGATIVE_INFINITY));
	array.put(Double.valueOf(Double.POSITIVE_INFINITY));
	assertEquals(null, array.toString());
	}

	/**
	* Although JSONArray is usually defensive about which numbers it accepts,
	* it doesn't check inputs in its constructor.
	*/
	public void testCreateWithUnsupportedNumbers() throws JSONException {
	JSONArray array = new JSONArray(Arrays.asList(5.5, Double.NaN));
	assertEquals(2, array.length());
	assertEquals(5.5, array.getDouble(0));
	assertEquals(Double.NaN, array.getDouble(1));
	}

	public void testToStringWithUnsupportedNumbers() throws JSONException {
	// when the array contains an unsupported number, toString returns null!
	JSONArray array = new JSONArray(Arrays.asList(5.5, Double.NaN));
	assertNull(array.toString());
	}

	public void testListConstructorCopiesContents() throws JSONException {
	List<Object> contents = Arrays.<Object>asList(5);
	JSONArray array = new JSONArray(contents);
	contents.set(0, 10);
	assertEquals(5, array.get(0));
	}

	public void testTokenerConstructor() throws JSONException {
	JSONArray object = new JSONArray(new JSONTokener("[false]"));
	assertEquals(1, object.length());
	assertEquals(false, object.get(0));
	}

	public void testTokenerConstructorWrongType() throws JSONException {
	try {
	new JSONArray(new JSONTokener("{\"foo\": false}"));
	fail();
	} catch (JSONException e) {
	}
	}

	public void testTokenerConstructorNull() throws JSONException {
	try {
	new JSONArray((JSONTokener) null);
	fail();
	} catch (NullPointerException e) {
	}
	}

	public void testTokenerConstructorParseFail() {
	try {
	new JSONArray(new JSONTokener("["));
	fail();
	} catch (JSONException e) {
	} catch (StackOverflowError e) {
	fail("Stack overflowed on input: \"[\"");
	}
	}

	public void testStringConstructor() throws JSONException {
	JSONArray object = new JSONArray("[false]");
	assertEquals(1, object.length());
	assertEquals(false, object.get(0));
	}

	public void testStringConstructorWrongType() throws JSONException {
	try {
	new JSONArray("{\"foo\": false}");
	fail();
	} catch (JSONException e) {
	}
	}

	public void testStringConstructorNull() throws JSONException {
	try {
	new JSONArray((String) null);
	fail();
	} catch (NullPointerException e) {
	}
	}

	public void testStringConstructorParseFail() {
	try {
	new JSONArray("[");
	fail();
	} catch (JSONException e) {
	} catch (StackOverflowError e) {
	fail("Stack overflowed on input: \"[\"");
	}
	}

	public void testCreate() throws JSONException {
	JSONArray array = new JSONArray(Arrays.asList(5.5, true));
	assertEquals(2, array.length());
	assertEquals(5.5, array.getDouble(0));
	assertEquals(true, array.get(1));
	assertEquals("[5.5,true]", array.toString());
	}

	public void testAccessOutOfBounds() throws JSONException {
	JSONArray array = new JSONArray();
	array.put("foo");
	assertEquals(null, array.opt(3));
	assertEquals(null, array.opt(-3));
	assertEquals("", array.optString(3));
	assertEquals("", array.optString(-3));
	try {
	array.get(3);
	fail();
	} catch (JSONException e) {
	}
	try {
	array.get(-3);
	fail();
	} catch (JSONException e) {
	}
	try {
	array.getString(3);
	fail();
	} catch (JSONException e) {
	}
	try {
	array.getString(-3);
	fail();
	} catch (JSONException e) {
	}
	}
	}