mirror of
https://github.com/ethauvin/JSON-java.git
synced 2025-06-17 16:00:51 -07:00
1440 lines
No EOL
40 KiB
Java
1440 lines
No EOL
40 KiB
Java
/*
|
|
* File: TestJSONArray.java Author: JSON.org
|
|
*/
|
|
package org.json.tests;
|
|
|
|
import java.io.IOException;
|
|
import java.io.StringWriter;
|
|
import java.io.Writer;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Stack;
|
|
|
|
import org.json.JSONArray;
|
|
import org.json.JSONException;
|
|
import org.json.JSONObject;
|
|
import org.json.JSONString;
|
|
import org.junit.Before;
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
/**
|
|
* The Class TestJSONArray.
|
|
*/
|
|
public class TestJSONArray extends TestCase
|
|
{
|
|
|
|
/** The jsonarray. */
|
|
private JSONArray jsonarray;
|
|
|
|
/** The string. */
|
|
private String string;
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see junit.framework.TestCase#setUp()
|
|
*/
|
|
@Override
|
|
@Before
|
|
public void setUp()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
string = "";
|
|
}
|
|
|
|
/**
|
|
* The Class testObject.
|
|
*/
|
|
public class testObject
|
|
{
|
|
//Do Nothing
|
|
}
|
|
|
|
/**
|
|
* Tests the jsonArray method using int with leading zeros.
|
|
*/
|
|
public static void testJsonArray_IntWithLeadingZeros()
|
|
{
|
|
JSONArray jsonarray;
|
|
String string;
|
|
|
|
try
|
|
{
|
|
string = "[001122334455]";
|
|
jsonarray = new JSONArray(string);
|
|
assertEquals("[1122334455]", jsonarray.toString());
|
|
} catch (Exception e)
|
|
{
|
|
fail(e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the jsonArray method using scintific notation.
|
|
*/
|
|
public static void testJsonArray_ScintificNotation()
|
|
{
|
|
JSONArray jsonarray;
|
|
String string;
|
|
|
|
try
|
|
{
|
|
string = "[666e666]";
|
|
jsonarray = new JSONArray(string);
|
|
assertEquals("[\"666e666\"]", jsonarray.toString());
|
|
} catch (Exception e)
|
|
{
|
|
fail(e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the jsonArray method using double with leading and trailing zeros.
|
|
*/
|
|
public static void testJsonArray_DoubleWithLeadingAndTrailingZeros()
|
|
{
|
|
JSONArray jsonarray;
|
|
String string;
|
|
|
|
try
|
|
{
|
|
string = "[00.10]";
|
|
jsonarray = new JSONArray(string);
|
|
assertEquals("[0.1]", jsonarray.toString());
|
|
} catch (Exception e)
|
|
{
|
|
fail(e.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using missing value.
|
|
*/
|
|
public void testConstructor_MissingValue()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray("[\n\r\n\r}");
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals("Missing value at 5 [character 0 line 4]",
|
|
jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using nan.
|
|
*/
|
|
public void testConstructor_Nan()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(Double.NaN);
|
|
jsonarray.toString();
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals("JSON does not allow non-finite numbers.",
|
|
jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using negative infinity.
|
|
*/
|
|
public void testConstructor_NegativeInfinity()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(Double.NEGATIVE_INFINITY);
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals("JSON does not allow non-finite numbers.",
|
|
jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using positive infinity.
|
|
*/
|
|
public void testConstructor_PositiveInfinity()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(Double.POSITIVE_INFINITY);
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals("JSON does not allow non-finite numbers.",
|
|
jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using positive infinity.
|
|
*/
|
|
public void testPut_PositiveInfinity()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(Double.POSITIVE_INFINITY);
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals("JSON does not allow non-finite numbers.",
|
|
jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getDouble method using empty array.
|
|
*/
|
|
public void testGetDouble_EmptyArray()
|
|
{
|
|
|
|
try
|
|
{
|
|
jsonarray.getDouble(0);
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals("JSONArray[0] not found.", jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the get method using negative index.
|
|
*/
|
|
public void testGet_NegativeIndex()
|
|
{
|
|
|
|
try
|
|
{
|
|
jsonarray.get(-1);
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals("JSONArray[-1] not found.", jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using nan.
|
|
*/
|
|
public void testPut_Nan()
|
|
{
|
|
try
|
|
{
|
|
jsonarray.put(Double.NaN);
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals("JSON does not allow non-finite numbers.",
|
|
jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using object.
|
|
*/
|
|
public void testConstructor_Object()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray(new Object());
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals(
|
|
"JSONArray initial value should be a string or collection or array.",
|
|
jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using bad json.
|
|
*/
|
|
public void testConstructor_BadJson()
|
|
{
|
|
|
|
try
|
|
{
|
|
string = "[)";
|
|
jsonarray = new JSONArray(string);
|
|
fail("expecting JSONException here.");
|
|
} catch (JSONException jsone)
|
|
{
|
|
assertEquals("Expected a ',' or ']' at 3 [character 4 line 1]",
|
|
jsone.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the toString method using locations.
|
|
*/
|
|
public void testToString_Locations()
|
|
{
|
|
try
|
|
{
|
|
string = " [\"San Francisco\", \"New York\", \"Seoul\", \"London\", \"Seattle\", \"Shanghai\"]";
|
|
jsonarray = new JSONArray(string);
|
|
assertEquals(
|
|
"[\"San Francisco\",\"New York\",\"Seoul\",\"London\",\"Seattle\",\"Shanghai\"]",
|
|
jsonarray.toString());
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using collection.
|
|
*/
|
|
public void testConstructor_Collection()
|
|
{
|
|
Collection<String> stringCol = new Stack<String>();
|
|
stringCol.add("string1");
|
|
stringCol.add("string2");
|
|
stringCol.add("string3");
|
|
stringCol.add("string4");
|
|
jsonarray = new JSONArray(stringCol);
|
|
assertEquals("[\"string1\",\"string2\",\"string3\",\"string4\"]",
|
|
jsonarray.toString());
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using null collection.
|
|
*/
|
|
public void testConstructor_NullCollection()
|
|
{
|
|
Collection<String> stringCol = null;
|
|
jsonarray = new JSONArray(stringCol);
|
|
assertEquals("[]", jsonarray.toString());
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using string array.
|
|
*/
|
|
public void testConstructor_StringArray()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray(new String[]
|
|
{
|
|
"string1", "string2"
|
|
});
|
|
assertEquals("[\"string1\",\"string2\"]", jsonarray.toString());
|
|
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the opt method.
|
|
*/
|
|
public void testOpt()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray(new String[]
|
|
{
|
|
"string1", "string2"
|
|
});
|
|
assertEquals("string1", jsonarray.opt(0));
|
|
assertEquals("string2", jsonarray.opt(1));
|
|
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the toString method using exception.
|
|
*/
|
|
public void testToString_Exception()
|
|
{
|
|
class BadJsonString implements JSONString
|
|
{
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see org.json.JSONString#toJSONString()
|
|
*/
|
|
@Override
|
|
public String toJSONString()
|
|
{
|
|
String[] arString = new String[]
|
|
{
|
|
"abc"
|
|
};
|
|
return arString[1];
|
|
}
|
|
|
|
}
|
|
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(new BadJsonString());
|
|
assertEquals(null, jsonarray.toString());
|
|
}
|
|
|
|
/**
|
|
* Tests the toString method using indents.
|
|
*/
|
|
public void testToString_Indents()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put(new JSONObject().put("abc", "123"));
|
|
jsonarray.put("abc");
|
|
jsonarray.put(new JSONArray().put(new JSONArray()).put(
|
|
new JSONArray().put("123").put("abc")));
|
|
assertEquals(
|
|
"[\n \"123\",\n {\"abc\": \"123\"},\n \"abc\",\n [\n [],\n [\n \"123\",\n \"abc\"\n ]\n ]\n]",
|
|
jsonarray.toString(4));
|
|
assertEquals("[\"123\"]", new JSONArray().put("123").toString(4));
|
|
assertEquals("[]", new JSONArray().toString(4));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the get method using invalid index.
|
|
*/
|
|
public void testGet_InvalidIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.get(1);
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[1] not found.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the get method using valid index.
|
|
*/
|
|
public void testGet_ValidIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
assertEquals("123", jsonarray.get(0));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getBoolean method.
|
|
*/
|
|
public void testGetBoolean()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("true");
|
|
jsonarray.put("false");
|
|
jsonarray.put(true);
|
|
jsonarray.put(false);
|
|
jsonarray.put("TRUE");
|
|
jsonarray.put("FALSE");
|
|
assertTrue(jsonarray.getBoolean(0));
|
|
assertFalse(jsonarray.getBoolean(1));
|
|
assertTrue(jsonarray.getBoolean(2));
|
|
assertFalse(jsonarray.getBoolean(3));
|
|
assertTrue(jsonarray.getBoolean(4));
|
|
assertFalse(jsonarray.getBoolean(5));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getBoolean method using non boolean.
|
|
*/
|
|
public void testGetBoolean_NonBoolean()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.getBoolean(0);
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[0] is not a boolean.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the optBoolean method.
|
|
*/
|
|
public void testOptBoolean()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("true");
|
|
jsonarray.put("false");
|
|
jsonarray.put(true);
|
|
jsonarray.put(false);
|
|
jsonarray.put("TRUE");
|
|
jsonarray.put("FALSE");
|
|
jsonarray.put("grass");
|
|
assertTrue(jsonarray.optBoolean(0));
|
|
assertFalse(jsonarray.optBoolean(1));
|
|
assertTrue(jsonarray.optBoolean(2));
|
|
assertFalse(jsonarray.optBoolean(3));
|
|
assertTrue(jsonarray.optBoolean(4));
|
|
assertFalse(jsonarray.optBoolean(5));
|
|
assertFalse(jsonarray.optBoolean(6));
|
|
}
|
|
|
|
/**
|
|
* Tests the getInt method.
|
|
*/
|
|
public void testGetInt()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put(45);
|
|
jsonarray.put(-98);
|
|
assertEquals(123, jsonarray.getInt(0));
|
|
assertEquals(-12, jsonarray.getInt(1));
|
|
assertEquals(45, jsonarray.getInt(2));
|
|
assertEquals(-98, jsonarray.getInt(3));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getInt method using non integer.
|
|
*/
|
|
public void testGetInt_NonInteger()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("abc");
|
|
jsonarray.getInt(0);
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[0] is not a number.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the optInt method.
|
|
*/
|
|
public void testOptInt()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put(45);
|
|
jsonarray.put(-98);
|
|
jsonarray.put("abc");
|
|
assertEquals(123, jsonarray.optInt(0));
|
|
assertEquals(-12, jsonarray.optInt(1));
|
|
assertEquals(45, jsonarray.optInt(2));
|
|
assertEquals(-98, jsonarray.optInt(3));
|
|
assertEquals(0, jsonarray.optInt(4));
|
|
}
|
|
|
|
/**
|
|
* Tests the getDouble method.
|
|
*/
|
|
public void testGetDouble()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put(45);
|
|
jsonarray.put(-98);
|
|
jsonarray.put("123.5");
|
|
jsonarray.put("-12.87");
|
|
jsonarray.put(45.22);
|
|
jsonarray.put(-98.18);
|
|
assertEquals(123.0, jsonarray.getDouble(0));
|
|
assertEquals(-12.0, jsonarray.getDouble(1));
|
|
assertEquals(45.0, jsonarray.getDouble(2));
|
|
assertEquals(-98.0, jsonarray.getDouble(3));
|
|
assertEquals(123.5, jsonarray.getDouble(4));
|
|
assertEquals(-12.87, jsonarray.getDouble(5));
|
|
assertEquals(45.22, jsonarray.getDouble(6));
|
|
assertEquals(-98.18, jsonarray.getDouble(7));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getDouble method using non double.
|
|
*/
|
|
public void testGetDouble_NonDouble()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("abc");
|
|
jsonarray.getDouble(0);
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[0] is not a number.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the optDouble method.
|
|
*/
|
|
public void testOptDouble()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put(45);
|
|
jsonarray.put(-98);
|
|
jsonarray.put("123.5");
|
|
jsonarray.put("-12.87");
|
|
try
|
|
{
|
|
jsonarray.put(45.22);
|
|
jsonarray.put(-98.18);
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
assertEquals(123.0, jsonarray.optDouble(0));
|
|
assertEquals(-12.0, jsonarray.optDouble(1));
|
|
assertEquals(45.0, jsonarray.optDouble(2));
|
|
assertEquals(-98.0, jsonarray.optDouble(3));
|
|
assertEquals(123.5, jsonarray.optDouble(4));
|
|
assertEquals(-12.87, jsonarray.optDouble(5));
|
|
assertEquals(45.22, jsonarray.optDouble(6));
|
|
assertEquals(-98.18, jsonarray.optDouble(7));
|
|
assertEquals(Double.NaN, jsonarray.optDouble(8));
|
|
}
|
|
|
|
/**
|
|
* Tests the getLong method.
|
|
*/
|
|
public void testGetLong()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put(45L);
|
|
jsonarray.put(-98L);
|
|
assertEquals(123, jsonarray.getLong(0));
|
|
assertEquals(-12, jsonarray.getLong(1));
|
|
assertEquals(45, jsonarray.getLong(2));
|
|
assertEquals(-98, jsonarray.getLong(3));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getLong method using non long.
|
|
*/
|
|
public void testGetLong_NonLong()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("abc");
|
|
jsonarray.getLong(0);
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[0] is not a number.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the optLong method.
|
|
*/
|
|
public void testOptLong()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put(45L);
|
|
jsonarray.put(-98L);
|
|
assertEquals(123, jsonarray.optLong(0));
|
|
assertEquals(-12, jsonarray.optLong(1));
|
|
assertEquals(45, jsonarray.optLong(2));
|
|
assertEquals(-98, jsonarray.optLong(3));
|
|
assertEquals(0, jsonarray.optLong(8));
|
|
}
|
|
|
|
/**
|
|
* Tests the getString method.
|
|
*/
|
|
public void testGetString()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put("abc");
|
|
jsonarray.put("123");
|
|
assertEquals("123", jsonarray.getString(0));
|
|
assertEquals("-12", jsonarray.getString(1));
|
|
assertEquals("abc", jsonarray.getString(2));
|
|
assertEquals("123", jsonarray.getString(3));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getString method using non string.
|
|
*/
|
|
public void testGetString_NonString()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(123);
|
|
jsonarray.getString(0);
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[0] not a string.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the optString method.
|
|
*/
|
|
public void testOptString()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put("abc");
|
|
jsonarray.put("123");
|
|
assertEquals("123", jsonarray.optString(0));
|
|
assertEquals("-12", jsonarray.optString(1));
|
|
assertEquals("abc", jsonarray.optString(2));
|
|
assertEquals("123", jsonarray.optString(3));
|
|
assertEquals("", jsonarray.optString(4));
|
|
}
|
|
|
|
/**
|
|
* Tests the optJSONObject method.
|
|
*/
|
|
public void testOptJSONObject()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(new JSONObject().put("abc", "123"));
|
|
assertEquals("{\"abc\":\"123\"}", jsonarray.optJSONObject(0).toString());
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the optJSONObject method using non json object.
|
|
*/
|
|
public void testOptJSONObject_NonJsonObject()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
assertEquals(null, jsonarray.optJSONObject(0));
|
|
}
|
|
|
|
/**
|
|
* Tests the optJSONArray method.
|
|
*/
|
|
public void testOptJSONArray()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(new JSONArray().put("abc"));
|
|
assertEquals("[\"abc\"]", jsonarray.optJSONArray(0).toString());
|
|
}
|
|
|
|
/**
|
|
* Tests the optJSONArray method using non json array.
|
|
*/
|
|
public void testOptJSONArray_NonJsonArray()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
assertEquals(null, jsonarray.optJSONArray(0));
|
|
}
|
|
|
|
/**
|
|
* Tests the isNull method.
|
|
*/
|
|
public void testIsNull()
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(JSONObject.NULL);
|
|
jsonarray.put("null");
|
|
assertTrue(jsonarray.isNull(0));
|
|
assertFalse(jsonarray.isNull(1));
|
|
}
|
|
|
|
/**
|
|
* Tests the writer method.
|
|
*/
|
|
public void testWriter()
|
|
{
|
|
try
|
|
{
|
|
StringWriter sw = new StringWriter();
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put(45);
|
|
jsonarray.put(-98);
|
|
jsonarray.put(new JSONArray().put("abc"));
|
|
jsonarray.put("-12");
|
|
jsonarray.put("abc");
|
|
jsonarray.put("123");
|
|
jsonarray.put("123");
|
|
jsonarray.put(new JSONObject().put("abc", "123"));
|
|
jsonarray.put("abc");
|
|
jsonarray.put("123");
|
|
jsonarray.write(sw);
|
|
assertEquals(
|
|
"[\"123\",\"-12\",45,-98,[\"abc\"],\"-12\",\"abc\",\"123\",\"123\",{\"abc\":\"123\"},\"abc\",\"123\"]",
|
|
sw.toString());
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the writer method using bad writer.
|
|
*/
|
|
public void testWriter_BadWriter()
|
|
{
|
|
class BadWriter extends Writer
|
|
{
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see java.io.Writer#write(char[], int, int)
|
|
*/
|
|
@Override
|
|
public void write(char[] cbuf, int off, int len) throws IOException
|
|
{
|
|
throw new IOException("Test Message From Bad Writer");
|
|
}
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see java.io.Writer#flush()
|
|
*/
|
|
@Override
|
|
public void flush() throws IOException
|
|
{
|
|
//Do Nothing
|
|
}
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see java.io.Writer#close()
|
|
*/
|
|
@Override
|
|
public void close() throws IOException
|
|
{
|
|
// Do nothing
|
|
}
|
|
|
|
}
|
|
try
|
|
{
|
|
BadWriter sw = new BadWriter();
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put(45);
|
|
jsonarray.put(-98);
|
|
jsonarray.put(new JSONArray().put("abc"));
|
|
jsonarray.put("-12");
|
|
jsonarray.put("abc");
|
|
jsonarray.put("123");
|
|
jsonarray.put("123");
|
|
jsonarray.put(new JSONObject().put("abc", "123"));
|
|
jsonarray.put("abc");
|
|
jsonarray.put("123");
|
|
jsonarray.write(sw);
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("Test Message From Bad Writer", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using object and specific index.
|
|
*/
|
|
public void testPut_ObjectAndSpecificIndex()
|
|
{
|
|
try
|
|
{
|
|
testObject a = new testObject();
|
|
testObject b = new testObject();
|
|
testObject c = new testObject();
|
|
testObject d = new testObject();
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(0, a);
|
|
jsonarray.put(1, b);
|
|
assertEquals(a, jsonarray.get(0));
|
|
assertEquals(b, jsonarray.get(1));
|
|
jsonarray.put(0, c);
|
|
assertEquals(c, jsonarray.get(0));
|
|
assertEquals(b, jsonarray.get(1));
|
|
jsonarray.put(8, d);
|
|
assertEquals(d, jsonarray.get(8));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(2));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(3));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(4));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(5));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(6));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(7));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using object and negative index.
|
|
*/
|
|
public void testPut_ObjectAndNegativeIndex()
|
|
{
|
|
try
|
|
{
|
|
testObject a = new testObject();
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(-1, a);
|
|
fail("Should have thrown exception");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[-1] not found.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the toJSONObject method.
|
|
*/
|
|
public void testToJSONObject()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.put("-12");
|
|
jsonarray.put(45);
|
|
jsonarray.put(-98);
|
|
jsonarray.put(new JSONArray().put("abc"));
|
|
jsonarray.put(new JSONObject().put("abc", "123"));
|
|
JSONArray names = new JSONArray(new String[]
|
|
{
|
|
"bdd", "fdsa", "fds", "ewre", "rer", "gfs"
|
|
});
|
|
assertEquals(
|
|
"{\"gfs\":{\"abc\":\"123\"},\"fdsa\":\"-12\",\"bdd\":\"123\",\"ewre\":-98,\"rer\":[\"abc\"],\"fds\":45}",
|
|
jsonarray.toJSONObject(names).toString());
|
|
assertEquals(null, jsonarray.toJSONObject(new JSONArray()));
|
|
assertEquals(null, jsonarray.toJSONObject(null));
|
|
assertEquals(null, new JSONArray().toJSONObject(names));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getJSONObject method.
|
|
*/
|
|
public void testGetJSONObject()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(new JSONObject().put("abc", "123"));
|
|
assertEquals("{\"abc\":\"123\"}", jsonarray.getJSONObject(0).toString());
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getJSONObject method using non json object.
|
|
*/
|
|
public void testGetJSONObject_NonJsonObject()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.getJSONObject(0);
|
|
fail("Should have thrown exception.");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[0] is not a JSONObject.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getJSONArray method.
|
|
*/
|
|
public void testGetJSONArray()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(new JSONArray().put("abc"));
|
|
assertEquals("[\"abc\"]", jsonarray.getJSONArray(0).toString());
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the getJSONArray method using non json array.
|
|
*/
|
|
public void testGetJSONArray_NonJsonArray()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put("123");
|
|
jsonarray.getJSONArray(0);
|
|
fail("Should have thrown exception.");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[0] is not a JSONArray.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using map.
|
|
*/
|
|
public void testPut_Map()
|
|
{
|
|
Map<String, Object> map = new HashMap<String, Object>();
|
|
map.put("abc", "123");
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(map);
|
|
assertEquals("[{\"abc\":\"123\"}]", jsonarray.toString());
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method using bad json array.
|
|
*/
|
|
public void testConstructor_BadJsonArray()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray("abc");
|
|
fail("Should have thrown exception.");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("A JSONArray text must start with '[' at 1 [character 2 line 1]", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the constructor method.
|
|
*/
|
|
public void testConstructor()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray("[]");
|
|
assertEquals("[]", jsonarray.toString());
|
|
jsonarray = new JSONArray("[\"abc\"]");
|
|
assertEquals("[\"abc\"]", jsonarray.toString());
|
|
jsonarray = new JSONArray("[\"abc\",\"123\"]");
|
|
assertEquals("[\"abc\",\"123\"]", jsonarray.toString());
|
|
jsonarray = new JSONArray("[123,{}]");
|
|
assertEquals("[123,{}]", jsonarray.toString());
|
|
jsonarray = new JSONArray("[123,,{}]");
|
|
assertEquals("[123,null,{}]", jsonarray.toString());
|
|
jsonarray = new JSONArray("[123,,{},]");
|
|
assertEquals("[123,null,{}]", jsonarray.toString());
|
|
jsonarray = new JSONArray("[123,,{};]");
|
|
assertEquals("[123,null,{}]", jsonarray.toString());
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using collection.
|
|
*/
|
|
public void testPut_Collection()
|
|
{
|
|
Collection<Object> stringCol = new Stack<Object>();
|
|
stringCol.add("string1");
|
|
stringCol.add("string2");
|
|
stringCol.add("string3");
|
|
stringCol.add("string4");
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(stringCol);
|
|
assertEquals("[[\"string1\",\"string2\",\"string3\",\"string4\"]]",
|
|
jsonarray.toString());
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using boolean and specific index.
|
|
*/
|
|
public void testPut_BooleanAndSpecificIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(0, true);
|
|
jsonarray.put(1, true);
|
|
assertEquals(true, jsonarray.get(0));
|
|
assertEquals(true, jsonarray.get(1));
|
|
jsonarray.put(0, false);
|
|
assertEquals(false, jsonarray.get(0));
|
|
assertEquals(true, jsonarray.get(1));
|
|
jsonarray.put(8, false);
|
|
assertEquals(false, jsonarray.get(8));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(2));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(3));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(4));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(5));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(6));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(7));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using boolean and negative index.
|
|
*/
|
|
public void testPut_BooleanAndNegativeIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(-1, true);
|
|
fail("Should have thrown exception");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[-1] not found.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using collection and specific index.
|
|
*/
|
|
public void testPut_CollectionAndSpecificIndex()
|
|
{
|
|
try
|
|
{
|
|
Collection<Object> a = new Stack<Object>();
|
|
a.add("string1");
|
|
a.add("string4");
|
|
Collection<Object> b = new Stack<Object>();
|
|
b.add("string2");
|
|
b.add("string3");
|
|
Collection<Object> c = new Stack<Object>();
|
|
c.add("string3");
|
|
c.add("string4");
|
|
Collection<Object> d = new Stack<Object>();
|
|
d.add("string1");
|
|
d.add("string2");
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(0, a);
|
|
jsonarray.put(1, b);
|
|
assertEquals(new JSONArray(a).toString(), jsonarray.get(0).toString());
|
|
assertEquals(new JSONArray(b).toString(), jsonarray.get(1).toString());
|
|
jsonarray.put(0, c);
|
|
assertEquals(new JSONArray(c).toString(), jsonarray.get(0).toString());
|
|
assertEquals(new JSONArray(b).toString(), jsonarray.get(1).toString());
|
|
jsonarray.put(8, d);
|
|
assertEquals(new JSONArray(d).toString(), jsonarray.get(8).toString());
|
|
assertEquals(JSONObject.NULL, jsonarray.get(2));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(3));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(4));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(5));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(6));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(7));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using collection and negative index.
|
|
*/
|
|
public void testPut_CollectionAndNegativeIndex()
|
|
{
|
|
try
|
|
{
|
|
Collection<Object> a = new Stack<Object>();
|
|
a.add("string1");
|
|
a.add("string4");
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(-1, a);
|
|
fail("Should have thrown exception");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[-1] not found.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using double and specific index.
|
|
*/
|
|
public void testPut_DoubleAndSpecificIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(0, 10.0);
|
|
jsonarray.put(1, 30.2);
|
|
assertEquals(10.0, jsonarray.get(0));
|
|
assertEquals(30.2, jsonarray.get(1));
|
|
jsonarray.put(0, 52.64);
|
|
assertEquals(52.64, jsonarray.get(0));
|
|
assertEquals(30.2, jsonarray.get(1));
|
|
jsonarray.put(8, 14.23);
|
|
assertEquals(14.23, jsonarray.get(8));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(2));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(3));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(4));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(5));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(6));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(7));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using double and negative index.
|
|
*/
|
|
public void testPut_DoubleAndNegativeIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(-1, 30.65);
|
|
fail("Should have thrown exception");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[-1] not found.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using int and specific index.
|
|
*/
|
|
public void testPut_IntAndSpecificIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(0, 54);
|
|
jsonarray.put(1, 82);
|
|
assertEquals(54, jsonarray.get(0));
|
|
assertEquals(82, jsonarray.get(1));
|
|
jsonarray.put(0, 36);
|
|
assertEquals(36, jsonarray.get(0));
|
|
assertEquals(82, jsonarray.get(1));
|
|
jsonarray.put(8, 67);
|
|
assertEquals(67, jsonarray.get(8));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(2));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(3));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(4));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(5));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(6));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(7));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using int and negative index.
|
|
*/
|
|
public void testPut_IntAndNegativeIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(-1, 3);
|
|
fail("Should have thrown exception");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[-1] not found.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using long and specific index.
|
|
*/
|
|
public void testPut_LongAndSpecificIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(0, 54L);
|
|
jsonarray.put(1, 456789123L);
|
|
assertEquals(54L, jsonarray.get(0));
|
|
assertEquals(456789123L, jsonarray.get(1));
|
|
jsonarray.put(0, 72887L);
|
|
assertEquals(72887L, jsonarray.get(0));
|
|
assertEquals(456789123L, jsonarray.get(1));
|
|
jsonarray.put(8, 39397L);
|
|
assertEquals(39397L, jsonarray.get(8));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(2));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(3));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(4));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(5));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(6));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(7));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using long and negative index.
|
|
*/
|
|
public void testPut_LongAndNegativeIndex()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(-1, 456486794L);
|
|
fail("Should have thrown exception");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[-1] not found.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using map and specific index.
|
|
*/
|
|
public void testPut_MapAndSpecificIndex()
|
|
{
|
|
try
|
|
{
|
|
Map<String, Object> a = new HashMap<String, Object>();
|
|
a.put("abc", "123");
|
|
Map<String, Object> b = new HashMap<String, Object>();
|
|
b.put("abffc", "1253");
|
|
Map<String, Object> c = new HashMap<String, Object>();
|
|
c.put("addbc", "145623");
|
|
Map<String, Object> d = new HashMap<String, Object>();
|
|
d.put("abffdc", "122623");
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(0, a);
|
|
jsonarray.put(1, b);
|
|
assertEquals(new JSONObject(a).toString(), jsonarray.get(0).toString());
|
|
assertEquals(new JSONObject(b).toString(), jsonarray.get(1).toString());
|
|
jsonarray.put(0, c);
|
|
assertEquals(new JSONObject(c).toString(), jsonarray.get(0).toString());
|
|
assertEquals(new JSONObject(b).toString(), jsonarray.get(1).toString());
|
|
jsonarray.put(8, d);
|
|
assertEquals(new JSONObject(d).toString(), jsonarray.get(8).toString());
|
|
assertEquals(JSONObject.NULL, jsonarray.get(2));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(3));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(4));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(5));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(6));
|
|
assertEquals(JSONObject.NULL, jsonarray.get(7));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the put method using map and negative index.
|
|
*/
|
|
public void testPut_MapAndNegativeIndex()
|
|
{
|
|
try
|
|
{
|
|
Map<String, Object> a = new HashMap<String, Object>();
|
|
a.put("abc", "123");
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(-1, a);
|
|
fail("Should have thrown exception");
|
|
} catch (JSONException e)
|
|
{
|
|
assertEquals("JSONArray[-1] not found.", e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests the remove method.
|
|
*/
|
|
public void testRemove()
|
|
{
|
|
try
|
|
{
|
|
jsonarray = new JSONArray();
|
|
jsonarray.put(0, 54);
|
|
jsonarray.put(1, 456789123);
|
|
jsonarray.put(2, 72887);
|
|
jsonarray.remove(1);
|
|
assertEquals(54, jsonarray.get(0));
|
|
assertEquals(72887, jsonarray.get(1));
|
|
} catch (JSONException e)
|
|
{
|
|
fail(e.getMessage());
|
|
}
|
|
}
|
|
|
|
} |