/*
* File: TestJSONObject.java Author: JSON.org
*/
package org.json.tests;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
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.json.XML;
import junit.framework.TestCase;
/**
* The Class TestJSONObject.
*/
public class TestJSONObject extends TestCase
{
/**
* The Class GoodJsonString.
*/
public class GoodJsonString implements JSONString
{
/*
* (non-Javadoc)
*
* @see org.json.JSONString#toJSONString()
*/
@Override
public String toJSONString()
{
return "jsonstring";
}
}
/**
* The Class NullJsonString.
*/
public class NullJsonString implements JSONString
{
/*
* (non-Javadoc)
*
* @see org.json.JSONString#toJSONString()
*/
@Override
public String toJSONString()
{
return null;
}
}
/**
* The Class BadJsonString.
*/
public class BadJsonString implements JSONString
{
/*
* (non-Javadoc)
*
* @see org.json.JSONString#toJSONString()
*/
@Override
public String toJSONString()
{
String[] arString = new String[]
{
"abc"
};
return arString[1];
}
}
/**
* The Class ObjectWithPrimatives.
*/
public class ObjectWithPrimatives
{
/** The i. */
public int i;
/** The null string. */
private String nullString;
/** The j. */
private String j;
/** The k. */
private double k;
/** The l. */
private long l;
/** The m. */
public boolean m;
/**
* Instantiates a new object with primatives.
*/
public ObjectWithPrimatives()
{
i = 3;
j = "3";
k = 10.03;
l = 5748548957230984584L;
m = true;
nullString = null;
}
/**
* Gets the i.
*
* @return the i
*/
public int getI()
{
return i;
}
/**
* Gets the j.
*
* @return the j
*/
public String getJ()
{
return j;
}
/**
* Gets the k.
*
* @return the k
*/
public double getK()
{
return k;
}
/**
* Gets the l.
*
* @return the l
*/
public long getL()
{
return l;
}
/**
* Gets the m.
*
* @return the m
*/
public boolean getM()
{
return m;
}
/**
* Gets the m.
*
* @param test
* the test
* @return the m
*/
public boolean getM(Boolean test)
{
return m;
}
/**
* Gets the null string.
*
* @return the null string
*/
public String getNullString()
{
return nullString;
}
/**
* Gets the zERO.
*
* @return the zERO
*/
public int getZERO()
{
return 0;
}
/**
* Gets the one.
*
* @return the one
*/
public int getone()
{
return 1;
}
/**
* Checks if is big.
*
* @return true, if is big
*/
public boolean isBig()
{
return false;
}
/**
* Checks if is small.
*
* @return true, if is small
*/
@SuppressWarnings("unused")
private boolean isSmall()
{
return true;
}
}
/**
* The Class ObjectWithPrimativesExtension.
*/
public class ObjectWithPrimativesExtension extends ObjectWithPrimatives
{
// Same Object
}
/** The jsonobject. */
JSONObject jsonobject = new JSONObject();
/** The iterator. */
Iterator<String> iterator;
/** The jsonarray. */
JSONArray jsonarray;
/** The object. */
Object object;
/** The string. */
String string;
/** The eps. */
double eps = 2.220446049250313e-16;
/**
* Tests the null method.
*
* @throws Exception
* the exception
*/
public void testNull() throws Exception
{
jsonobject = new JSONObject("{\"message\":\"null\"}");
assertFalse(jsonobject.isNull("message"));
assertEquals("null", jsonobject.getString("message"));
jsonobject = new JSONObject("{\"message\":null}");
assertTrue(jsonobject.isNull("message"));
}
/**
* Tests the constructor method using duplicate key.
*/
public void testConstructor_DuplicateKey()
{
try
{
string = "{\"koda\": true, \"koda\": true}";
jsonobject = new JSONObject(string);
fail("expecting JSONException here.");
} catch (JSONException jsone)
{
assertEquals("Duplicate key \"koda\"", jsone.getMessage());
}
}
/**
* Tests the constructor method using null key.
*/
public void testConstructor_NullKey()
{
try
{
jsonobject.put(null, "howard");
fail("expecting JSONException here.");
} catch (JSONException jsone)
{
assertEquals("Null key.", jsone.getMessage());
}
}
/**
* Tests the getDouble method using invalid key howard.
*/
public void testGetDouble_InvalidKeyHoward()
{
try
{
jsonobject.getDouble("howard");
fail("expecting JSONException here.");
} catch (JSONException jsone)
{
assertEquals("JSONObject[\"howard\"] not found.",
jsone.getMessage());
}
}
/**
* Tests the getDouble method using invalid key stooge.
*/
public void testGetDouble_InvalidKeyStooge()
{
jsonobject = new JSONObject();
try
{
jsonobject.getDouble("stooge");
fail("expecting JSONException here.");
} catch (JSONException jsone)
{
assertEquals("JSONObject[\"stooge\"] not found.",
jsone.getMessage());
}
}
/**
* Tests the isNull method.
*/
public void testIsNull()
{
try
{
jsonobject = new JSONObject();
object = null;
jsonobject.put("booga", object);
jsonobject.put("wooga", JSONObject.NULL);
assertEquals("{\"wooga\":null}", jsonobject.toString());
assertTrue(jsonobject.isNull("booga"));
} catch (JSONException e)
{
fail(e.toString());
}
}
/**
* Tests the increment method.
*/
public void testIncrement_NewKey()
{
try
{
jsonobject = new JSONObject();
jsonobject.increment("two");
jsonobject.increment("two");
assertEquals("{\"two\":2}", jsonobject.toString());
assertEquals(2, jsonobject.getInt("two"));
} catch (JSONException e)
{
fail(e.toString());
}
}
/**
* Tests the toString method using listof lists.
*/
public void testToString_ListofLists()
{
try
{
string = "{ \"list of lists\" : [ [1, 2, 3], [4, 5, 6], ] }";
jsonobject = new JSONObject(string);
assertEquals("{\"list of lists\": [\n" + " [\n" + " 1,\n"
+ " 2,\n" + " 3\n" + " ],\n" + " [\n"
+ " 4,\n" + " 5,\n" + " 6\n"
+ " ]\n" + "]}", jsonobject.toString(4));
} catch (JSONException e)
{
fail(e.toString());
}
}
/**
* Tests the toString method using indentation.
*/
public void testToString_Indentation()
{
try
{
string = "{ \"entity\": { \"imageURL\": \"\", \"name\": \"IXXXXXXXXXXXXX\", \"id\": 12336, \"ratingCount\": null, \"averageRating\": null } }";
jsonobject = new JSONObject(string);
assertEquals(
"{\"entity\": {\n \"id\": 12336,\n \"averageRating\": null,\n \"ratingCount\": null,\n \"name\": \"IXXXXXXXXXXXXX\",\n \"imageURL\": \"\"\n}}",
jsonobject.toString(2));
} catch (JSONException e)
{
fail(e.toString());
}
}
/**
* Tests the multipleThings method.
*/
public void testMultipleThings()
{
try
{
jsonobject = new JSONObject(
"{foo: [true, false,9876543210, 0.0, 1.00000001, 1.000000000001, 1.00000000000000001,"
+ " .00000000000000001, 2.00, 0.1, 2e100, -32,[],{}, \"string\"], "
+ " to : null, op : 'Good',"
+ "ten:10} postfix comment");
jsonobject.put("String", "98.6");
jsonobject.put("JSONObject", new JSONObject());
jsonobject.put("JSONArray", new JSONArray());
jsonobject.put("int", 57);
jsonobject.put("double", 123456789012345678901234567890.);
jsonobject.put("true", true);
jsonobject.put("false", false);
jsonobject.put("null", JSONObject.NULL);
jsonobject.put("bool", "true");
jsonobject.put("zero", -0.0);
jsonobject.put("\\u2028", "\u2028");
jsonobject.put("\\u2029", "\u2029");
jsonarray = jsonobject.getJSONArray("foo");
jsonarray.put(666);
jsonarray.put(2001.99);
jsonarray.put("so \"fine\".");
jsonarray.put("so <fine>.");
jsonarray.put(true);
jsonarray.put(false);
jsonarray.put(new JSONArray());
jsonarray.put(new JSONObject());
jsonobject.put("keys", JSONObject.getNames(jsonobject));
assertEquals(
"{\n \"to\": null,\n \"ten\": 10,\n \"JSONObject\": {},\n \"JSONArray\": [],\n \"op\": \"Good\",\n \"keys\": [\n \"to\",\n \"ten\",\n \"JSONObject\",\n \"JSONArray\",\n \"op\",\n \"int\",\n \"true\",\n \"foo\",\n \"zero\",\n \"double\",\n \"String\",\n \"false\",\n \"bool\",\n \"\\\\u2028\",\n \"\\\\u2029\",\n \"null\"\n ],\n \"int\": 57,\n \"true\": true,\n \"foo\": [\n true,\n false,\n 9876543210,\n 0,\n 1.00000001,\n 1.000000000001,\n 1,\n 1.0E-17,\n 2,\n 0.1,\n 2.0E100,\n -32,\n [],\n {},\n \"string\",\n 666,\n 2001.99,\n \"so \\\"fine\\\".\",\n \"so <fine>.\",\n true,\n false,\n [],\n {}\n ],\n \"zero\": -0,\n \"double\": 1.2345678901234568E29,\n \"String\": \"98.6\",\n \"false\": false,\n \"bool\": \"true\",\n \"\\\\u2028\": \"\\u2028\",\n \"\\\\u2029\": \"\\u2029\",\n \"null\": null\n}",
jsonobject.toString(4));
assertEquals(
"<to>null</to><ten>10</ten><JSONObject></JSONObject><op>Good</op><keys>to</keys><keys>ten</keys><keys>JSONObject</keys><keys>JSONArray</keys><keys>op</keys><keys>int</keys><keys>true</keys><keys>foo</keys><keys>zero</keys><keys>double</keys><keys>String</keys><keys>false</keys><keys>bool</keys><keys>\\u2028</keys><keys>\\u2029</keys><keys>null</keys><int>57</int><true>true</true><foo>true</foo><foo>false</foo><foo>9876543210</foo><foo>0.0</foo><foo>1.00000001</foo><foo>1.000000000001</foo><foo>1.0</foo><foo>1.0E-17</foo><foo>2.0</foo><foo>0.1</foo><foo>2.0E100</foo><foo>-32</foo><foo></foo><foo></foo><foo>string</foo><foo>666</foo><foo>2001.99</foo><foo>so "fine".</foo><foo>so <fine>.</foo><foo>true</foo><foo>false</foo><foo></foo><foo></foo><zero>-0.0</zero><double>1.2345678901234568E29</double><String>98.6</String><false>false</false><bool>true</bool><\\u2028>\u2028</\\u2028><\\u2029>\u2029</\\u2029><null>null</null>",
XML.toString(jsonobject));
assertEquals(98.6d, jsonobject.getDouble("String"), eps);
assertTrue(jsonobject.getBoolean("bool"));
assertEquals(
"[true,false,9876543210,0,1.00000001,1.000000000001,1,1.0E-17,2,0.1,2.0E100,-32,[],{},\"string\",666,2001.99,\"so \\\"fine\\\".\",\"so <fine>.\",true,false,[],{}]",
jsonobject.getJSONArray("foo").toString());
assertEquals("Good", jsonobject.getString("op"));
assertEquals(10, jsonobject.getInt("ten"));
assertFalse(jsonobject.optBoolean("oops"));
} catch (JSONException e)
{
fail(e.toString());
}
}
/**
* Tests the multipleThings2 method.
*/
public void testMultipleThings2()
{
try
{
jsonobject = new JSONObject(
"{string: \"98.6\", long: 2147483648, int: 2147483647, longer: 9223372036854775807, double: 9223372036854775808}");
assertEquals(
"{\n \"int\": 2147483647,\n \"string\": \"98.6\",\n \"longer\": 9223372036854775807,\n \"double\": \"9223372036854775808\",\n \"long\": 2147483648\n}",
jsonobject.toString(1));
// getInt
assertEquals(2147483647, jsonobject.getInt("int"));
assertEquals(-2147483648, jsonobject.getInt("long"));
assertEquals(-1, jsonobject.getInt("longer"));
try
{
jsonobject.getInt("double");
fail("should fail with - JSONObject[\"double\"] is not an int.");
} catch (JSONException expected)
{
assertEquals("JSONObject[\"double\"] is not an int.",
expected.getMessage());
}
try
{
jsonobject.getInt("string");
fail("should fail with - JSONObject[\"string\"] is not an int.");
} catch (JSONException expected)
{
assertEquals("JSONObject[\"string\"] is not an int.",
expected.getMessage());
}
// getLong
assertEquals(2147483647, jsonobject.getLong("int"));
assertEquals(2147483648l, jsonobject.getLong("long"));
assertEquals(9223372036854775807l, jsonobject.getLong("longer"));
try
{
jsonobject.getLong("double");
fail("should fail with - JSONObject[\"double\"] is not a long.");
} catch (JSONException expected)
{
assertEquals("JSONObject[\"double\"] is not a long.",
expected.getMessage());
}
try
{
jsonobject.getLong("string");
fail("should fail with - JSONObject[\"string\"] is not a long.");
} catch (JSONException expected)
{
assertEquals("JSONObject[\"string\"] is not a long.",
expected.getMessage());
}
// getDouble
assertEquals(2.147483647E9, jsonobject.getDouble("int"), eps);
assertEquals(2.147483648E9, jsonobject.getDouble("long"), eps);
assertEquals(9.223372036854776E18, jsonobject.getDouble("longer"),
eps);
assertEquals(9223372036854775808d, jsonobject.getDouble("double"),
eps);
assertEquals(98.6, jsonobject.getDouble("string"), eps);
jsonobject.put("good sized", 9223372036854775807L);
assertEquals(
"{\n \"int\": 2147483647,\n \"string\": \"98.6\",\n \"longer\": 9223372036854775807,\n \"good sized\": 9223372036854775807,\n \"double\": \"9223372036854775808\",\n \"long\": 2147483648\n}",
jsonobject.toString(1));
jsonarray = new JSONArray(
"[2147483647, 2147483648, 9223372036854775807, 9223372036854775808]");
assertEquals(
"[\n 2147483647,\n 2147483648,\n 9223372036854775807,\n \"9223372036854775808\"\n]",
jsonarray.toString(1));
List<String> expectedKeys = new ArrayList<String>(6);
expectedKeys.add("int");
expectedKeys.add("string");
expectedKeys.add("longer");
expectedKeys.add("good sized");
expectedKeys.add("double");
expectedKeys.add("long");
iterator = jsonobject.keys();
while (iterator.hasNext())
{
string = iterator.next();
assertTrue(expectedKeys.remove(string));
}
assertEquals(0, expectedKeys.size());
} catch (JSONException e)
{
fail(e.toString());
}
}
/**
* Tests the put method using collection and map.
*/
public void testPut_CollectionAndMap()
{
try
{
string = "{plist=Apple; AnimalSmells = { pig = piggish; lamb = lambish; worm = wormy; }; AnimalSounds = { pig = oink; lamb = baa; worm = baa; Lisa = \"Why is the worm talking like a lamb?\" } ; AnimalColors = { pig = pink; lamb = black; worm = pink; } } ";
jsonobject = new JSONObject(string);
assertEquals(
"{\"AnimalColors\":{\"worm\":\"pink\",\"lamb\":\"black\",\"pig\":\"pink\"},\"plist\":\"Apple\",\"AnimalSounds\":{\"worm\":\"baa\",\"Lisa\":\"Why is the worm talking like a lamb?\",\"lamb\":\"baa\",\"pig\":\"oink\"},\"AnimalSmells\":{\"worm\":\"wormy\",\"lamb\":\"lambish\",\"pig\":\"piggish\"}}",
jsonobject.toString());
Collection<Object> collection = null;
Map<String, Object> map = null;
jsonobject = new JSONObject(map);
jsonarray = new JSONArray(collection);
jsonobject.append("stooge", "Joe DeRita");
jsonobject.append("stooge", "Shemp");
jsonobject.accumulate("stooges", "Curly");
jsonobject.accumulate("stooges", "Larry");
jsonobject.accumulate("stooges", "Moe");
jsonobject.accumulate("stoogearray", jsonobject.get("stooges"));
jsonobject.put("map", map);
jsonobject.put("collection", collection);
jsonobject.put("array", jsonarray);
jsonarray.put(map);
jsonarray.put(collection);
assertEquals(
"{\"stooge\":[\"Joe DeRita\",\"Shemp\"],\"map\":{},\"stooges\":[\"Curly\",\"Larry\",\"Moe\"],\"collection\":[],\"stoogearray\":[[\"Curly\",\"Larry\",\"Moe\"]],\"array\":[{},[]]}",
jsonobject.toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the accumulate method.
*/
public void testAccumulate()
{
try
{
jsonobject = new JSONObject();
jsonobject.accumulate("stooge", "Curly");
jsonobject.accumulate("stooge", "Larry");
jsonobject.accumulate("stooge", "Moe");
jsonarray = jsonobject.getJSONArray("stooge");
jsonarray.put(5, "Shemp");
assertEquals("{\"stooge\": [\n" + " \"Curly\",\n"
+ " \"Larry\",\n" + " \"Moe\",\n" + " null,\n"
+ " null,\n" + " \"Shemp\"\n" + "]}",
jsonobject.toString(4));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the write method.
*/
public void testWrite()
{
try
{
jsonobject = new JSONObject();
jsonobject.accumulate("stooge", "Curly");
jsonobject.accumulate("stooge", "Larry");
jsonobject.accumulate("stooge", "Moe");
jsonarray = jsonobject.getJSONArray("stooge");
jsonarray.put(5, "Shemp");
assertEquals(
"{\"stooge\":[\"Curly\",\"Larry\",\"Moe\",null,null,\"Shemp\"]}",
jsonobject.write(new StringWriter()).toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the toString method using html.
*/
public void testToString_Html()
{
try
{
jsonobject = new JSONObject(
"{script: 'It is not allowed in HTML to send a close script tag in a string<script>because it confuses browsers</script>so we insert a backslash before the /'}");
assertEquals(
"{\"script\":\"It is not allowed in HTML to send a close script tag in a string<script>because it confuses browsers<\\/script>so we insert a backslash before the /\"}",
jsonobject.toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the toString method using multiple test cases.
*/
public void testToString_MultipleTestCases()
{
try
{
jsonobject = new JSONObject(
"{ fun => with non-standard forms ; forgiving => This package can be used to parse formats that are similar to but not stricting conforming to JSON; why=To make it easier to migrate existing data to JSON,one = [[1.00]]; uno=[[{1=>1}]];'+':+6e66 ;pluses=+++;empty = '' , 'double':0.666,true: TRUE, false: FALSE, null=NULL;[true] = [[!,@;*]]; string=> o. k. ; \r oct=0666; hex=0x666; dec=666; o=0999; noh=0x0x}");
assertEquals(
"{\n \"noh\": \"0x0x\",\n \"one\": [[1]],\n \"o\": 999,\n \"+\": 6.0E66,\n \"true\": true,\n \"forgiving\": \"This package can be used to parse formats that are similar to but not stricting conforming to JSON\",\n \"fun\": \"with non-standard forms\",\n \"double\": 0.666,\n \"uno\": [[{\"1\": 1}]],\n \"dec\": 666,\n \"oct\": 666,\n \"hex\": \"0x666\",\n \"string\": \"o. k.\",\n \"empty\": \"\",\n \"false\": false,\n \"[true]\": [[\n \"!\",\n \"@\",\n \"*\"\n ]],\n \"pluses\": \"+++\",\n \"why\": \"To make it easier to migrate existing data to JSON\",\n \"null\": null\n}",
jsonobject.toString(1));
assertTrue(jsonobject.getBoolean("true"));
assertFalse(jsonobject.getBoolean("false"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the populateMap method using priative class.
*/
public void testConstructor_PriativeClass()
{
jsonobject = new JSONObject(new ObjectWithPrimatives());
assertEquals(
"{\"l\":5748548957230984584,\"m\":true,\"big\":false,\"j\":\"3\",\"k\":10.03,\"ZERO\":0,\"i\":3}",
jsonobject.toString());
}
/**
* Tests the populateMap method using sub class.
*/
public void testConstructor_SubClass()
{
ObjectWithPrimatives ob = new ObjectWithPrimativesExtension();
jsonobject = new JSONObject(ob);
assertEquals(
"{\"l\":5748548957230984584,\"m\":true,\"big\":false,\"j\":\"3\",\"k\":10.03,\"ZERO\":0,\"i\":3}",
jsonobject.toString());
}
/**
* Tests the populateMap method using private class.
*/
public void testConstructor_PrivateClass()
{
class PrivateObject
{
private int i;
public PrivateObject()
{
i = 3;
}
@SuppressWarnings("unused")
public int getI()
{
return i;
}
}
jsonobject = new JSONObject(new PrivateObject());
assertEquals("{}", jsonobject.toString());
}
/**
* Tests the populateMap method using array list.
*/
public void testConstructor_ArrayList()
{
List<String> ar = new ArrayList<String>();
ar.add("test1");
ar.add("test2");
jsonobject = new JSONObject(ar);
assertEquals("{\"empty\":false}", jsonobject.toString());
}
/**
* Tests the populateMap method using class class.
*/
public void testConstructor_ClassClass()
{
try
{
jsonobject = new JSONObject(this.getClass());
assertEquals("class junit.framework.TestCase",
jsonobject.get("genericSuperclass").toString());
} catch (Exception e)
{
fail(e.getMessage());
}
}
/**
* Tests the constructor method using french resource bundle.
*/
public static void testConstructor_FrenchResourceBundle()
{
try
{
Locale currentLocale = new Locale("fr", "CA", "UNIX");
assertEquals(
"{\"ASCII\":\"Number that represent chraracters\",\"JSON\":\"What are we testing?\",\"JAVA\":\"The language you are running to see this\"}",
new JSONObject("org.json.tests.SampleResourceBundle",
currentLocale).toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the constructor method using us resource bundle.
*/
public static void testConstructor_UsResourceBundle()
{
try
{
Locale currentLocale = new Locale("en", "US");
assertEquals(
"{\"ASCII\":\"American Standard Code for Information Interchange\",\"JSON\":\"JavaScript Object Notation\",\"JAVA\":{\"desc\":\"Just Another Vague Acronym\",\"data\":\"Sweet language\"}}",
new JSONObject("org.json.tests.SampleResourceBundle",
currentLocale).toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the constructor method using object with string array.
*/
public void testConstructor_ObjectWithStringArray()
{
assertEquals("{\"m\":true,\"i\":3}", new JSONObject(
new ObjectWithPrimatives(), new String[]
{
"i", "m", "k"
}).toString());
}
/**
* Tests the opt method.
*/
public void testOpt()
{
try
{
jsonobject = new JSONObject("{\"a\":2}");
assertEquals(2, jsonobject.opt("a"));
assertEquals(null, jsonobject.opt("b"));
assertEquals(null, jsonobject.opt(null));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the stringToValue method.
*/
public static void testStringToValue()
{
assertEquals("", JSONObject.stringToValue(""));
assertEquals(true, JSONObject.stringToValue("true"));
assertEquals(false, JSONObject.stringToValue("false"));
assertEquals(JSONObject.NULL, JSONObject.stringToValue("null"));
assertEquals(10, JSONObject.stringToValue("10"));
assertEquals(10000.0, JSONObject.stringToValue("10e3"));
assertEquals(10000.0, JSONObject.stringToValue("10E3"));
assertEquals("10E3000000000", JSONObject.stringToValue("10E3000000000"));
}
/**
* Tests the quote method.
*/
public static void testQuote()
{
assertEquals("\"\"", JSONObject.quote(""));
assertEquals("\"\"", JSONObject.quote(null));
assertEquals("\"true\"", JSONObject.quote("true"));
assertEquals("\"10\"", JSONObject.quote("10"));
assertEquals("\"\\b\\t\\n\\f\\r\"", JSONObject.quote("\b\t\n\f\r"));
assertEquals("\"\\u0012\\u0085\\u2086\u2286\"",
JSONObject.quote("\u0012\u0085\u2086\u2286"));
}
/**
* Tests the getNames method.
*/
public void testGetNames()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("a", "123");
jsonobject.put("b", "123");
jsonobject.put("c", "123");
String[] names = JSONObject.getNames(jsonobject);
assertEquals(3, names.length);
assertEquals("b", names[0]);
assertEquals("c", names[1]);
assertEquals("a", names[2]);
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getNames method using empty json object.
*/
public void testGetNames_EmptyJsonObject()
{
jsonobject = new JSONObject();
assertEquals(null, JSONObject.getNames(jsonobject));
}
/**
* Tests the getNames method using object with primatives.
*/
public void testGetNames_ObjectWithPrimatives()
{
String[] names = JSONObject.getNames(new ObjectWithPrimatives());
assertEquals(2, names.length);
assertEquals("i", names[0]);
assertEquals("m", names[1]);
}
/**
* Tests the getNames method using empty object.
*/
public static void testGetNames_EmptyObject()
{
class EmptyObject
{
// Empty Object
}
assertEquals(null, JSONObject.getNames(new EmptyObject()));
}
/**
* Tests the getNames method using null.
*/
public static void testGetNames_Null()
{
ObjectWithPrimatives owp = null;
assertEquals(null, JSONObject.getNames(owp));
}
/**
* Tests the getLong method.
*/
public void testGetLong_Long()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "98765432");
jsonobject.put("123", 98765432);
assertEquals(98765432, jsonobject.getLong("abc"));
assertEquals(98765432, jsonobject.getLong("123"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getJsonObject method using json object.
*/
public void testGetJsonObject_JsonObject()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", new JSONObject());
assertEquals("{}", jsonobject.getJSONObject("abc").toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getJsonObject method using int.
*/
public void testGetJsonObject_Int()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", 45);
jsonobject.getJSONObject("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] is not a JSONObject.",
e.getMessage());
}
}
/**
* Tests the getJsonObject method using invalid key.
*/
public void testGetJsonObject_InvalidKey()
{
try
{
jsonobject = new JSONObject();
jsonobject.getJSONObject("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] not found.", e.getMessage());
}
}
/**
* Tests the getJsonArray method using json array.
*/
public void testGetJsonArray_JsonArray()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", new JSONArray());
assertEquals("[]", jsonobject.getJSONArray("abc").toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getJsonArray method using int.
*/
public void testGetJsonArray_Int()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", 45);
jsonobject.getJSONArray("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] is not a JSONArray.",
e.getMessage());
}
}
/**
* Tests the getJsonArray method using invalid key.
*/
public void testGetJsonArray_InvalidKey()
{
try
{
jsonobject = new JSONObject();
jsonobject.getJSONArray("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] not found.", e.getMessage());
}
}
/**
* Tests the getInt method using int.
*/
public void testGetInt_Int()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", 45);
assertEquals(45, jsonobject.getInt("abc"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getInt method using int string.
*/
public void testGetInt_IntString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "45");
assertEquals(45, jsonobject.getInt("abc"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getInt method using letter string.
*/
public void testGetInt_LetterString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "def");
jsonobject.getInt("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] is not an int.", e.getMessage());
}
}
/**
* Tests the getInt method using invalid key.
*/
public void testGetInt_InvalidKey()
{
try
{
jsonobject = new JSONObject();
jsonobject.getInt("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] not found.", e.getMessage());
}
}
/**
* Tests the getDouble method using double.
*/
public void testGetDouble_Double()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", 45.10);
assertEquals(45.10, jsonobject.getDouble("abc"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getDouble method using double string.
*/
public void testGetDouble_DoubleString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "45.20");
assertEquals(45.20, jsonobject.getDouble("abc"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getDouble method using letter string.
*/
public void testGetDouble_LetterString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "def");
jsonobject.getDouble("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] is not a number.", e.getMessage());
}
}
/**
* Tests the getDouble method using invalid key.
*/
public void testGetDouble_InvalidKey()
{
try
{
jsonobject = new JSONObject();
jsonobject.getDouble("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] not found.", e.getMessage());
}
}
/**
* Tests the getBoolean method using boolean.
*/
public void testGetBoolean_Boolean()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", true);
jsonobject.put("123", false);
assertTrue(jsonobject.getBoolean("abc"));
assertFalse(jsonobject.getBoolean("123"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getBoolean method using boolean string.
*/
public void testGetBoolean_BooleanString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "true");
jsonobject.put("123", "false");
jsonobject.put("ABC", "TRUE");
jsonobject.put("456", "FALSE");
assertTrue(jsonobject.getBoolean("abc"));
assertFalse(jsonobject.getBoolean("123"));
assertTrue(jsonobject.getBoolean("ABC"));
assertFalse(jsonobject.getBoolean("456"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getBoolean method using letter string.
*/
public void testGetBoolean_LetterString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "def");
jsonobject.getBoolean("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] is not a Boolean.",
e.getMessage());
}
}
/**
* Tests the getBoolean method using int.
*/
public void testGetBoolean_Int()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", 45);
jsonobject.getBoolean("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] is not a Boolean.",
e.getMessage());
}
}
/**
* Tests the getBoolean method using invalid key.
*/
public void testGetBoolean_InvalidKey()
{
try
{
jsonobject = new JSONObject();
jsonobject.getBoolean("abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] not found.", e.getMessage());
}
}
/**
* Tests the get method using null key.
*/
public void testGet_NullKey()
{
try
{
jsonobject = new JSONObject();
jsonobject.get(null);
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("Null key.", e.getMessage());
}
}
/**
* Tests the toString method using indents.
*/
public void testToString_Indents()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
jsonobject.put("1235", new JSONObject().put("abc", "123"));
jsonobject.put("1234", "abc");
jsonobject.put(
"1239",
new JSONObject().put("1fd23", new JSONObject()).put(
"12gfdgfg3",
new JSONObject().put("f123", "123").put("12fgfg3",
"abc")));
assertEquals(
"{\n \"1234\": \"abc\",\n \"1235\": {\"abc\": \"123\"},\n \"123\": \"123\",\n \"1239\": {\n \"1fd23\": {},\n \"12gfdgfg3\": {\n \"f123\": \"123\",\n \"12fgfg3\": \"abc\"\n }\n }\n}",
jsonobject.toString(4));
assertEquals("{\"1gg23\": \"123\"}",
new JSONObject().put("1gg23", "123").toString(4));
assertEquals("{}", new JSONObject().toString(4));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the toString method using exception.
*/
public void testToString_Exception()
{
try
{
jsonobject.put("abc", new BadJsonString());
assertEquals(null, jsonobject.toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the numberToString method.
*/
public static void testNumberToString()
{
try
{
assertEquals("30.7", JSONObject.numberToString(30.70));
assertEquals("3.0E71", JSONObject.numberToString(30e70));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the numberToString method using null.
*/
public static void testNumberToString_Null()
{
try
{
JSONObject.numberToString(null);
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("Null pointer", e.getMessage());
}
}
/**
* Tests the wrap method.
*/
public void testWrap()
{
try
{
assertEquals(true, JSONObject.wrap(true));
assertEquals(35, JSONObject.wrap(35));
assertEquals(35.5, JSONObject.wrap(35.50));
assertEquals(56456456L, JSONObject.wrap(56456456L));
assertEquals(JSONObject.NULL, JSONObject.wrap(null));
assertEquals(JSONObject.NULL, JSONObject.wrap(JSONObject.NULL));
BadJsonString a = new BadJsonString();
assertEquals(a, JSONObject.wrap(a));
NullJsonString q = new NullJsonString();
assertEquals(q, JSONObject.wrap(q));
assertEquals((short) 12, JSONObject.wrap((short) 12));
assertEquals('a', JSONObject.wrap('a'));
assertEquals((byte) 15, JSONObject.wrap((byte) 15));
assertEquals((float) 15.2, JSONObject.wrap((float) 15.2));
JSONObject b;
b = new JSONObject().put("abc", "123");
assertEquals(b, JSONObject.wrap(b));
JSONArray c = new JSONArray().put("abc");
assertEquals(c, JSONObject.wrap(c));
Collection<String> stringCol = new Stack<String>();
stringCol.add("string1");
assertEquals("[\"string1\"]", JSONObject.wrap(stringCol).toString());
assertEquals("[\"abc\",\"123\"]", JSONObject.wrap(new String[]
{
"abc", "123"
}).toString());
Map<String, Object> map = new HashMap<String, Object>();
map.put("abc", "123");
assertEquals("{\"abc\":\"123\"}", JSONObject.wrap(map).toString());
assertEquals("java.io.IOException",
JSONObject.wrap(new java.io.IOException()));
Class<?> d = this.getClass();
assertEquals("class org.json.tests.TestJSONObject",
JSONObject.wrap(d));
class testClass
{
// Empty Class
}
assertEquals("{}", JSONObject.wrap(new testClass()).toString());
class BadCollection<E> implements Collection<E>
{
/*
* (non-Javadoc)
*
* @see java.util.Collection#size()
*/
@Override
public int size()
{
return 0;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#isEmpty()
*/
@Override
public boolean isEmpty()
{
return false;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#contains(java.lang.Object)
*/
@Override
public boolean contains(Object o)
{
return false;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#iterator()
*/
@Override
public Iterator<E> iterator()
{
@SuppressWarnings("unchecked")
Iterator<E>[] i = new Iterator[0];
return i[1];
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#toArray()
*/
@Override
public Object[] toArray()
{
return null;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#toArray(T[])
*/
@SuppressWarnings("unchecked")
@Override
public Object[] toArray(Object[] Type)
{
return null;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#add(java.lang.Object)
*/
@Override
public boolean add(Object e)
{
return false;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#remove(java.lang.Object)
*/
@Override
public boolean remove(Object o)
{
return false;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#containsAll(java.util.Collection)
*/
@Override
public boolean containsAll(Collection<?> collection)
{
return false;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#addAll(java.util.Collection)
*/
@Override
public boolean addAll(Collection<? extends E> collection)
{
return false;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#removeAll(java.util.Collection)
*/
@Override
public boolean removeAll(Collection<?> collection)
{
return false;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#retainAll(java.util.Collection)
*/
@Override
public boolean retainAll(Collection<?> collection)
{
return false;
}
/*
* (non-Javadoc)
*
* @see java.util.Collection#clear()
*/
@Override
public void clear()
{
//Do Nothing
}
}
try
{
JSONObject.wrap(new BadCollection<String>()).toString();
fail("Should have thrown exception.");
} catch (Exception e)
{
assertEquals(null, e.getMessage());
}
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the writer method.
*/
public void testWriter()
{
try
{
StringWriter sw = new StringWriter();
jsonobject = new JSONObject();
jsonobject.put("1ghr23", "123");
jsonobject.put("1ss23", "-12");
jsonobject.put("1tr23", 45);
jsonobject.put("1trt23", -98);
jsonobject.put("1hh23", new JSONObject().put("123", "abc"));
jsonobject.put("1er23", "-12");
jsonobject.put("1re23", "abc");
jsonobject.put("1fde23", "123");
jsonobject.put("1fd23", "123");
jsonobject.put("1ffdsf23", new JSONObject().put("abc", "123"));
jsonobject.put("fd123", "abc");
jsonobject.put("12fdsf3", "123");
jsonobject.write(sw);
assertEquals(
"{\"1tr23\":45,\"1ss23\":\"-12\",\"1fd23\":\"123\",\"1trt23\":-98,\"1ffdsf23\":{\"abc\":\"123\"},\"1ghr23\":\"123\",\"1fde23\":\"123\",\"fd123\":\"abc\",\"12fdsf3\":\"123\",\"1hh23\":{\"123\":\"abc\"},\"1re23\":\"abc\",\"1er23\":\"-12\"}",
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();
jsonobject = new JSONObject();
jsonobject.put("1ghr23", "123");
jsonobject.put("1ss23", "-12");
jsonobject.put("1tr23", 45);
jsonobject.put("1trt23", -98);
jsonobject.put("1hh23", new JSONObject().put("123", "abc"));
jsonobject.put("1er23", "-12");
jsonobject.put("1re23", "abc");
jsonobject.put("1fde23", "123");
jsonobject.put("1fd23", "123");
jsonobject.put("1ffdsf23", new JSONObject().put("abc", "123"));
jsonobject.put("fd123", "abc");
jsonobject.put("12fdsf3", "123");
jsonobject.write(sw);
} catch (JSONException e)
{
assertEquals("Test Message From Bad Writer", e.getMessage());
}
}
/**
* Tests the increment method.
*/
public void testIncrement()
{
try
{
Map<String, Object> map = new HashMap<String, Object>();
map.put("1ghr23", 30.56);
map.put("1ss23", -12.22);
map.put("1tr23", 45);
map.put("1trt23", -98);
map.put("1hh23", (float) 12.6);
map.put("1er23", (float) -456.255);
map.put("1re23", 5543L);
map.put("1fde23", -46546546L);
jsonobject = new JSONObject(map);
jsonobject.increment("1ghr23");
jsonobject.increment("1ss23");
jsonobject.increment("1tr23");
jsonobject.increment("1trt23");
jsonobject.increment("1hh23");
jsonobject.increment("1er23");
jsonobject.increment("1re23");
jsonobject.increment("1fde23");
assertEquals(31.56, jsonobject.get("1ghr23"));
assertEquals(-11.22, jsonobject.get("1ss23"));
assertEquals(46, jsonobject.get("1tr23"));
assertEquals(-97, jsonobject.get("1trt23"));
assertEquals(13.6f, (Double) jsonobject.get("1hh23"), eps);
assertEquals(-455.255f, (Double) jsonobject.get("1er23"), eps);
assertEquals(5544L, jsonobject.get("1re23"));
assertEquals(-46546545L, jsonobject.get("1fde23"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the increment method using string.
*/
public void testIncrement_String()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "abc");
jsonobject.increment("123");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("Unable to increment [\"123\"].", e.getMessage());
}
}
/**
* Tests the get method using invalid index.
*/
public void testGet_InvalidIndex()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("554", "123");
jsonobject.get("abc");
} catch (JSONException e)
{
assertEquals("JSONObject[\"abc\"] not found.", e.getMessage());
}
}
/**
* Tests the get method using valid index.
*/
public void testGet_ValidIndex()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "123");
assertEquals("123", jsonobject.get("abc"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getBoolean method.
*/
public void testGetBoolean()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("1gg23", "true");
jsonobject.put("1dd23", "false");
jsonobject.put("1ff23", true);
jsonobject.put("1rr23", false);
jsonobject.put("1hh23", "TRUE");
jsonobject.put("1hhhgf23", "FALSE");
assertTrue(jsonobject.getBoolean("1gg23"));
assertFalse(jsonobject.getBoolean("1dd23"));
assertTrue(jsonobject.getBoolean("1ff23"));
assertFalse(jsonobject.getBoolean("1rr23"));
assertTrue(jsonobject.getBoolean("1hh23"));
assertFalse(jsonobject.getBoolean("1hhhgf23"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getBoolean method using non boolean.
*/
public void testGetBoolean_NonBoolean()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
jsonobject.getBoolean("123");
} catch (JSONException e)
{
assertEquals("JSONObject[\"123\"] is not a Boolean.",
e.getMessage());
}
}
/**
* Tests the optBoolean method.
*/
public void testOptBoolean()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("1gg23", "true");
jsonobject.put("1dd23", "false");
jsonobject.put("1ff23", true);
jsonobject.put("1rr23", false);
jsonobject.put("1hh23", "TRUE");
jsonobject.put("1hhhgf23", "FALSE");
assertTrue(jsonobject.optBoolean("1gg23"));
assertFalse(jsonobject.optBoolean("1dd23"));
assertTrue(jsonobject.optBoolean("1ff23"));
assertFalse(jsonobject.optBoolean("1rr23"));
assertTrue(jsonobject.optBoolean("1hh23"));
assertFalse(jsonobject.optBoolean("1hhhgf23"));
assertFalse(jsonobject.optBoolean("chicken"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getInt method.
*/
public void testGetInt()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("1gg23", "123");
jsonobject.put("1g23", "-12");
jsonobject.put("123", 45);
jsonobject.put("1rr23", -98);
assertEquals(123, jsonobject.getInt("1gg23"));
assertEquals(-12, jsonobject.getInt("1g23"));
assertEquals(45, jsonobject.getInt("123"));
assertEquals(-98, jsonobject.getInt("1rr23"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getInt method using non integer.
*/
public void testGetInt_NonInteger()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "abc");
jsonobject.getInt("123");
} catch (JSONException e)
{
assertEquals("JSONObject[\"123\"] is not an int.", e.getMessage());
}
}
/**
* Tests the optInt method.
*/
public void testOptInt()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("1gg23", "123");
jsonobject.put("1g23", "-12");
jsonobject.put("123", 45);
jsonobject.put("1rr23", -98);
assertEquals(123, jsonobject.optInt("1gg23"));
assertEquals(-12, jsonobject.optInt("1g23"));
assertEquals(45, jsonobject.optInt("123"));
assertEquals(-98, jsonobject.optInt("1rr23"));
assertEquals(0, jsonobject.optInt("catfish"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getDouble method.
*/
public void testGetDouble()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
jsonobject.put("1fd23", "-12");
jsonobject.put("1gfd23", 45);
jsonobject.put("1gg23", -98);
jsonobject.put("1f23", "123.5");
jsonobject.put("1ss23", "-12.87");
jsonobject.put("1ew23", 45.22);
jsonobject.put("1tt23", -98.18);
assertEquals(123.0, jsonobject.getDouble("123"));
assertEquals(-12.0, jsonobject.getDouble("1fd23"));
assertEquals(45.0, jsonobject.getDouble("1gfd23"));
assertEquals(-98.0, jsonobject.getDouble("1gg23"));
assertEquals(123.5, jsonobject.getDouble("1f23"));
assertEquals(-12.87, jsonobject.getDouble("1ss23"));
assertEquals(45.22, jsonobject.getDouble("1ew23"));
assertEquals(-98.18, jsonobject.getDouble("1tt23"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getDouble method using non double.
*/
public void testGetDouble_NonDouble()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "abc");
jsonobject.getDouble("123");
} catch (JSONException e)
{
assertEquals("JSONObject[\"123\"] is not a number.", e.getMessage());
}
}
/**
* Tests the optDouble method.
*/
public void testOptDouble()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
jsonobject.put("1fd23", "-12");
jsonobject.put("1gfd23", 45);
jsonobject.put("1gg23", -98);
jsonobject.put("1f23", "123.5");
jsonobject.put("1ss23", "-12.87");
jsonobject.put("1ew23", 45.22);
jsonobject.put("1tt23", -98.18);
assertEquals(123.0, jsonobject.optDouble("123"));
assertEquals(-12.0, jsonobject.optDouble("1fd23"));
assertEquals(45.0, jsonobject.optDouble("1gfd23"));
assertEquals(-98.0, jsonobject.optDouble("1gg23"));
assertEquals(123.5, jsonobject.optDouble("1f23"));
assertEquals(-12.87, jsonobject.optDouble("1ss23"));
assertEquals(45.22, jsonobject.optDouble("1ew23"));
assertEquals(-98.18, jsonobject.optDouble("1tt23"));
assertEquals(Double.NaN, jsonobject.optDouble("rabbit"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getLong method.
*/
public void testGetLong()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
jsonobject.put("12gh3", "-12");
jsonobject.put("1f23", 45L);
jsonobject.put("1re23", -98L);
assertEquals(123, jsonobject.getLong("123"));
assertEquals(-12, jsonobject.getLong("12gh3"));
assertEquals(45, jsonobject.getLong("1f23"));
assertEquals(-98, jsonobject.getLong("1re23"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getLong method using non long.
*/
public void testGetLong_NonLong()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "abc");
jsonobject.getLong("123");
} catch (JSONException e)
{
assertEquals("JSONObject[\"123\"] is not a long.", e.getMessage());
}
}
/**
* Tests the optLong method.
*/
public void testOptLong()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
jsonobject.put("12gh3", "-12");
jsonobject.put("1f23", 45L);
jsonobject.put("1re23", -98L);
assertEquals(123, jsonobject.optLong("123"));
assertEquals(-12, jsonobject.optLong("12gh3"));
assertEquals(45, jsonobject.optLong("1f23"));
assertEquals(-98, jsonobject.optLong("1re23"));
assertEquals(0, jsonobject.optLong("randomString"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getString method.
*/
public void testGetString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
jsonobject.put("12gf3", "-12");
jsonobject.put("1fg23", "abc");
jsonobject.put("1d23", "123");
assertEquals("123", jsonobject.getString("123"));
assertEquals("-12", jsonobject.getString("12gf3"));
assertEquals("abc", jsonobject.getString("1fg23"));
assertEquals("123", jsonobject.getString("1d23"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the getString method using non string.
*/
public void testGetString_NonString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", 123);
jsonobject.getString("123");
} catch (JSONException e)
{
assertEquals("JSONObject[\"123\"] not a string.", e.getMessage());
}
}
/**
* Tests the optString method.
*/
public void testOptString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
jsonobject.put("12gf3", "-12");
jsonobject.put("1fg23", "abc");
jsonobject.put("1d23", "123");
assertEquals("123", jsonobject.optString("123"));
assertEquals("-12", jsonobject.optString("12gf3"));
assertEquals("abc", jsonobject.optString("1fg23"));
assertEquals("123", jsonobject.optString("1d23"));
assertEquals("", jsonobject.optString("pandora"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the optJSONObject method using simple object.
*/
public void testOptJSONObject_SimpleObject()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", new JSONObject().put("abc", "123"));
assertEquals("{\"abc\":\"123\"}", jsonobject.optJSONObject("123")
.toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the optJSONObject method using non json object.
*/
public void testOptJSONObject_NonJsonObject()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
assertEquals(null, jsonobject.optJSONObject("123"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the optJSONArray method.
*/
public void testOptJSONArray()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", new JSONArray().put("abc"));
assertEquals("[\"abc\"]", jsonobject.optJSONArray("123").toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the optJSONArray method using non json array.
*/
public void testOptJSONArray_NonJsonArray()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
assertEquals(null, jsonobject.optJSONArray("123"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the has method.
*/
public void testHas()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("123", "123");
assertTrue(jsonobject.has("123"));
assertFalse(jsonobject.has("124"));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the append method.
*/
public void testAppend()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("string", "123");
jsonobject.put("jsonarray", new JSONArray().put("abc"));
jsonobject.append("jsonarray", "123");
jsonobject.append("george", "def");
try
{
jsonobject.append("string", "abc");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("JSONObject[string] is not a JSONArray.",
e.getMessage());
}
assertEquals(
"{\"george\":[\"def\"],\"string\":\"123\",\"jsonarray\":[\"abc\",\"123\"]}",
jsonobject.toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the constuctor method using strings.
*/
public void testConstuctor_Strings()
{
try
{
jsonobject = new JSONObject("123");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals(
"A JSONObject text must begin with '{' at 1 [character 2 line 1]",
e.getMessage());
}
try
{
jsonobject = new JSONObject("{\"123\":34");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("Expected a ',' or '}' at 10 [character 11 line 1]",
e.getMessage());
}
try
{
jsonobject = new JSONObject("{\"123\",34}");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals(
"Expected a ':' after a key at 7 [character 8 line 1]",
e.getMessage());
}
try
{
jsonobject = new JSONObject("{");
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals(
"A JSONObject text must end with '}' at 2 [character 3 line 1]",
e.getMessage());
}
}
/**
* Tests the testValidity method.
*/
public static void testTestValidity()
{
try
{
JSONObject.testValidity(null);
JSONObject.testValidity(50.4);
JSONObject.testValidity(70.8);
JSONObject.testValidity(50.4f);
JSONObject.testValidity(70.8f);
try
{
JSONObject.testValidity(Double.NaN);
fail("Should have throw exception.");
} catch (JSONException e)
{
assertEquals("JSON does not allow non-finite numbers.",
e.getMessage());
}
try
{
JSONObject.testValidity(Double.NEGATIVE_INFINITY);
fail("Should have throw exception.");
} catch (JSONException e)
{
assertEquals("JSON does not allow non-finite numbers.",
e.getMessage());
}
try
{
JSONObject.testValidity(Double.POSITIVE_INFINITY);
fail("Should have throw exception.");
} catch (JSONException e)
{
assertEquals("JSON does not allow non-finite numbers.",
e.getMessage());
}
try
{
JSONObject.testValidity(Float.NaN);
fail("Should have throw exception.");
} catch (JSONException e)
{
assertEquals("JSON does not allow non-finite numbers.",
e.getMessage());
}
try
{
JSONObject.testValidity(Float.NEGATIVE_INFINITY);
fail("Should have throw exception.");
} catch (JSONException e)
{
assertEquals("JSON does not allow non-finite numbers.",
e.getMessage());
}
try
{
JSONObject.testValidity(Float.POSITIVE_INFINITY);
fail("Should have throw exception.");
} catch (JSONException e)
{
assertEquals("JSON does not allow non-finite numbers.",
e.getMessage());
}
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the names method.
*/
public void testNames()
{
try
{
jsonobject = new JSONObject();
assertEquals(null, jsonobject.names());
jsonobject.put("abc", "123");
assertEquals("[\"abc\"]", jsonobject.names().toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the constructor method using copy subset.
*/
public void testConstructor_CopySubset()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "123");
jsonobject.put("abcd", "1234");
jsonobject.put("abcde", "12345");
jsonobject.put("abcdef", "123456");
assertEquals("{\"abc\":\"123\",\"abcde\":\"12345\"}",
new JSONObject(jsonobject, new String[]
{
"abc", "abc", "abcde"
}).toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the putOnce method.
*/
public void testPutOnce()
{
try
{
jsonobject = new JSONObject();
jsonobject.putOnce("abc", "123").putOnce("abcd", "1234")
.putOnce(null, "12345").putOnce("abcdef", null);
assertEquals("{\"abc\":\"123\",\"abcd\":\"1234\"}",
jsonobject.toString());
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the toJsonArray method.
*/
public void testToJsonArray()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "123");
jsonobject.put("abcd", "1234");
jsonobject.put("abcde", "12345");
jsonobject.put("abcdef", "123456");
assertEquals("[\"123\",\"123\",\"12345\"]",
jsonobject.toJSONArray(new JSONArray(new String[]
{
"abc", "abc", "abcde"
})).toString());
assertEquals(null, jsonobject.toJSONArray(new JSONArray()));
assertEquals(null, jsonobject.toJSONArray(null));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the valueToString method.
*/
public void testValueToString()
{
try
{
jsonobject = new JSONObject();
jsonobject.put("abc", "123");
jsonobject.put("abcd", "1234");
BadJsonString bjs = new BadJsonString();
jsonobject.put("cd", bjs);
jsonobject.put("acd", new GoodJsonString());
NullJsonString q = new NullJsonString();
jsonobject.put("zzz", q);
Map<String, Object> map = new HashMap<String, Object>();
map.put("abc", "123");
Collection<String> stringCol = new Stack<String>();
stringCol.add("string1");
jsonobject.put("de", map);
jsonobject.put("e", stringCol);
jsonobject.put("abcde", new JSONArray().put("123"));
jsonobject.put("abcdef", new JSONObject().put("123", "123456"));
JSONObject nulljo = null;
JSONArray nullja = null;
jsonobject.put("bcde", nulljo);
jsonobject.put("bcdef", nullja);
assertEquals(
"{\n \"de\": {\"abc\": \"123\"},\n \"abc\": \"123\",\n \"e\": [\"string1\"],\n \"zzz\": \""
+ q.toString()
+ "\",\n \"abcdef\": {\"123\": \"123456\"},\n \"abcde\": [\"123\"],\n \"acd\": jsonstring,\n \"abcd\": \"1234\",\n \"cd\": \""
+ bjs.toString() + "\"\n}", jsonobject.toString(4));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the valueToString method using object.
*/
public void testValueToString_Object()
{
try
{
Map<String, Object> map = new HashMap<String, Object>();
map.put("abcd", "1234");
Collection<String> stringCol = new Stack<String>();
stringCol.add("string1");
jsonobject = new JSONObject();
jsonobject.put("abc", "123");
assertEquals("{\"abc\":\"123\"}",
JSONObject.valueToString(jsonobject));
assertEquals("{\"abcd\":\"1234\"}", JSONObject.valueToString(map));
assertEquals("[\"string1\"]", JSONObject.valueToString(stringCol));
try
{
JSONObject.valueToString(new BadJsonString());
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("1", e.getMessage());
}
try
{
JSONObject.valueToString(new NullJsonString());
fail("Should have thrown exception.");
} catch (JSONException e)
{
assertEquals("Bad value from toJSONString: null",
e.getMessage());
}
assertEquals("jsonstring",
JSONObject.valueToString(new GoodJsonString()));
assertEquals("null", JSONObject.valueToString(null));
assertEquals("null", JSONObject.valueToString(JSONObject.NULL));
assertEquals("[\"abc\",\"123\"]",
JSONObject.valueToString(new String[]
{
"abc", "123"
}));
} catch (JSONException e)
{
fail(e.getMessage());
}
}
/**
* Tests the doubleToString method.
*/
public static void testDoubleToString()
{
assertEquals("10.66", JSONObject.doubleToString(10.66));
assertEquals("10", JSONObject.doubleToString(10));
assertEquals("null", JSONObject.doubleToString(Double.NaN));
assertEquals("null",
JSONObject.doubleToString(Double.NEGATIVE_INFINITY));
assertEquals("null",
JSONObject.doubleToString(Double.POSITIVE_INFINITY));
assertEquals("1.0E89", JSONObject.doubleToString(10e88));
assertEquals("1.0E89", JSONObject.doubleToString(10E88));
}
}