/** * Like {@link #getString(String)} but specifies a default value to return if there is no entry. */ public String getString(final String key, final String def) { String val = getString(key); if (val == null) { if (map.containsKey(key)) { return null; } return def; } return val; }
@Test void testCreateFromMapNestedMap() { Map<String, Object> map = new HashMap<>(); Map<String, Object> nestedMap = new HashMap<>(); nestedMap.put("foo", "bar"); map.put("nested", nestedMap); JsonObject obj = new JsonObject(map); JsonObject nestedRetrieved = obj.getJsonObject("nested"); assertEquals("bar", nestedRetrieved.getString("foo")); }
@Test void testCreateFromMapCharSequence() { Map<String, Object> map = new HashMap<>(); map.put("foo", "bar"); map.put("quux", 123); map.put("eeek", new StringBuilder("blah")); JsonObject obj = new JsonObject(map); assertEquals("bar", obj.getString("foo")); assertEquals(Integer.valueOf(123), obj.getInteger("quux")); assertEquals("blah", obj.getString("eeek")); assertSame(map, obj.map()); }
@Test void testGetStringDefault() { JsonObject jsonObject = new JsonObject(); jsonObject.put("foo", "bar"); assertEquals("bar", jsonObject.getString("foo", "wibble")); assertEquals("bar", jsonObject.getString("foo", null)); jsonObject.put("bar", 123); try { jsonObject.getString("bar", "wibble"); fail("error"); } catch (ClassCastException e) { // Ok } // Null and absent values jsonObject.putNull("foo"); assertNull(jsonObject.getString("foo", "wibble")); assertEquals("wibble", jsonObject.getString("absent", "wibble")); assertNull(jsonObject.getString("foo", null)); assertNull(jsonObject.getString("absent", null)); }
@Test void testGetString() { JsonObject jsonObject = new JsonObject(); jsonObject.put("foo", "bar"); assertEquals("bar", jsonObject.getString("foo")); jsonObject.put("bar", 123); try { jsonObject.getString("bar"); fail("error"); } catch (ClassCastException e) { // Ok } // Null and absent values jsonObject.putNull("foo"); assertNull(jsonObject.getString("foo")); assertNull(jsonObject.getString("absent")); }
@Test void testCreateFromMap() { Map<String, Object> map = new HashMap<>(); map.put("foo", "bar"); map.put("quux", 123); JsonObject obj = new JsonObject(map); assertEquals("bar", obj.getString("foo")); assertEquals(Integer.valueOf(123), obj.getInteger("quux")); assertSame(map, obj.map()); }
@Test void testCreateFromMapNestedJsonObject() { Map<String, Object> map = new HashMap<>(); JsonObject nestedObj = new JsonObject().put("foo", "bar"); map.put("nested", nestedObj); JsonObject obj = new JsonObject(map); JsonObject nestedRetrieved = obj.getJsonObject("nested"); assertEquals("bar", nestedRetrieved.getString("foo")); }
@Test void testPutCharSequence() { JsonObject jsonObject = new JsonObject(); assertSame(jsonObject, jsonObject.put("foo", new StringBuilder("bar"))); assertEquals("bar", jsonObject.getString("foo")); assertEquals("bar", jsonObject.getString("foo", "def")); jsonObject.put("quux", new StringBuilder("wibble")); assertEquals("wibble", jsonObject.getString("quux")); assertEquals("bar", jsonObject.getString("foo")); jsonObject.put("foo", new StringBuilder("blah")); assertEquals("blah", jsonObject.getString("foo")); jsonObject.put("foo", (CharSequence) null); assertTrue(jsonObject.containsKey("foo")); try { jsonObject.put(null, (CharSequence) "blah"); fail("error"); } catch (NullPointerException e) { // OK } }
@Test void testMergeIn1() { JsonObject jsonObject = new JsonObject(); JsonObject obj1 = new JsonObject().put("foo", "bar"); JsonObject obj2 = new JsonObject().put("eek", "flurb"); obj1.mergeIn(obj2); assertEquals(2, obj1.size()); assertEquals("bar", obj1.getString("foo")); assertEquals("flurb", obj1.getString("eek")); assertEquals(1, obj2.size()); assertEquals("flurb", obj2.getString("eek")); }
@Test void testPutString() { JsonObject jsonObject = new JsonObject(); assertSame(jsonObject, jsonObject.put("foo", "bar")); assertEquals("bar", jsonObject.getString("foo")); jsonObject.put("quux", "wibble"); assertEquals("wibble", jsonObject.getString("quux")); assertEquals("bar", jsonObject.getString("foo")); jsonObject.put("foo", "blah"); assertEquals("blah", jsonObject.getString("foo")); jsonObject.put("foo", (String) null); assertTrue(jsonObject.containsKey("foo")); try { jsonObject.put(null, "blah"); fail("error"); } catch (NullPointerException e) { // OK } }
@Test void testMergeIn2() { JsonObject obj1 = new JsonObject().put("foo", "bar"); JsonObject obj2 = new JsonObject().put("foo", "flurb"); obj1.mergeIn(obj2); assertEquals(1, obj1.size()); assertEquals("flurb", obj1.getString("foo")); assertEquals(1, obj2.size()); assertEquals("flurb", obj2.getString("foo")); }
@Test void testDecode() { JsonParsers.forEachParser(jsonParser -> { byte[] bytes = randomByteArray(10); String strBytes = Base64.getEncoder().encodeToString(bytes); String json = "{\"mystr\":\"foo\",\"myint\":123,\"mylong\":1234,\"myfloat\":1.23,\"mydouble\":2.34,\"" + "myboolean\":true,\"mybinary\":\"" + strBytes + "\",\"mynull\":null,\"myobj\":{\"foo\":\"bar\"},\"myarr\":[\"foo\",123]}"; JsonObject obj = new JsonObject(jsonParser.parse(json)); assertEquals("foo", obj.getString("mystr")); assertEquals(Integer.valueOf(123), obj.getInteger("myint")); assertEquals(Long.valueOf(1234), obj.getLong("mylong")); assertEquals(Float.valueOf(1.23f), obj.getFloat("myfloat")); assertEquals(Double.valueOf(2.34d), obj.getDouble("mydouble")); assertTrue(obj.getBoolean("myboolean")); assertArrayEquals(bytes, obj.getBinary("mybinary")); assertTrue(obj.containsKey("mynull")); JsonObject nestedObj = obj.getJsonObject("myobj"); assertEquals("bar", nestedObj.getString("foo")); JsonArray nestedArr = obj.getJsonArray("myarr"); assertEquals("foo", nestedArr.getString(0)); assertEquals(Integer.valueOf(123), Integer.valueOf(nestedArr.getInteger(1))); }); }
@Test void testDecode() { JsonParsers.forEachParser(jsonParser -> { byte[] bytes = randomByteArray(10); String strBytes = Base64.getEncoder().encodeToString(bytes); String json = "[\"foo\",123,1234,1.23,2.34,true,\"" + strBytes + "\",null,{\"foo\":\"bar\"},[\"foo\",123]]"; JsonArray arr = jsonParser.parseAsJsonArray(json); assertEquals("foo", arr.getString(0)); assertEquals(Integer.valueOf(123), arr.getInteger(1)); assertEquals(Long.valueOf(1234L), arr.getLong(2)); assertEquals(Float.valueOf(1.23f), arr.getFloat(3)); assertEquals(Double.valueOf(2.34d), arr.getDouble(4)); assertEquals(true, arr.getBoolean(5)); assertArrayEquals(bytes, arr.getBinary(6)); assertTrue(arr.hasNull(7)); JsonObject obj = arr.getJsonObject(8); assertEquals("bar", obj.getString("foo")); JsonArray arr2 = arr.getJsonArray(9); assertEquals("foo", arr2.getString(0)); assertEquals(Integer.valueOf(123), arr2.getInteger(1)); }); }
@Test void testPutEnum() { JsonObject jsonObject = new JsonObject(); assertSame(jsonObject, jsonObject.put("foo", SomeEnum.FOO)); assertEquals(SomeEnum.FOO.toString(), jsonObject.getString("foo")); assertTrue(jsonObject.containsKey("foo")); try { jsonObject.put(null, SomeEnum.FOO); fail("error"); } catch (NullPointerException e) { // OK } }
@Test void testMergeInDepth2() { { JsonObject obj1 = new JsonObject(JsonParser.create().parse("{ \"foo\": \"bar\", \"flurb\": { \"eek\": \"foo\", \"bar\": \"flurb\"}}")); JsonObject obj2 = new JsonObject(JsonParser.create().parse("{ \"flurb\": { \"bar\": \"flurb1\" }}")); obj1.mergeIn(obj2, 2); assertEquals(2, obj1.size()); assertEquals(2, obj1.getJsonObject("flurb").size()); assertEquals("foo", obj1.getJsonObject("flurb").getString("eek")); assertEquals("flurb1", obj1.getJsonObject("flurb").getString("bar")); } { JsonObject obj1 = new JsonObject(JsonParser.createLazyOne().parse("{ \"foo\": \"bar\", \"flurb\": { \"eek\": \"foo\", \"bar\": \"flurb\"}}")); JsonObject obj2 = new JsonObject(JsonParser.createLazyOne().parse("{ \"flurb\": { \"bar\": \"flurb1\" }}")); obj1.mergeIn(obj2, 2); assertEquals(2, obj1.size()); assertEquals(2, obj1.getJsonObject("flurb").size()); assertEquals("foo", obj1.getJsonObject("flurb").getString("eek")); assertEquals("flurb1", obj1.getJsonObject("flurb").getString("bar")); } }
@Test void testMergeInFlat() { JsonParsers.forEachParser(jsonParser -> { JsonObject obj1 = jsonParser.parseAsJsonObject("{ \"foo\": { \"bar\": \"flurb\", \"eek\": 32 }}"); JsonObject obj2 = jsonParser.parseAsJsonObject("{ \"foo\": { \"bar\": \"eek\" }}"); obj1.mergeIn(obj2); assertEquals(1, obj1.size()); assertEquals(1, obj1.getJsonObject("foo").size()); assertEquals("eek", obj1.getJsonObject("foo").getString("bar")); }); }
@Test void testMergeInDepth0() { { JsonObject obj1 = JsonParser.create().parseAsJsonObject("{ \"foo\": { \"bar\": \"flurb\" }}"); JsonObject obj2 = JsonParser.create().parseAsJsonObject("{ \"foo\": { \"bar\": \"eek\" }}"); obj1.mergeIn(obj2, 0); assertEquals(1, obj1.size()); assertEquals(1, obj1.getJsonObject("foo").size()); assertEquals("flurb", obj1.getJsonObject("foo").getString("bar")); } { JsonObject obj1 = JsonParser.createLazyOne().parseAsJsonObject("{ \"foo\": { \"bar\": \"flurb\" }}"); JsonObject obj2 = JsonParser.createLazyOne().parseAsJsonObject("{ \"foo\": { \"bar\": \"eek\" }}"); obj1.mergeIn(obj2, 0); assertEquals(1, obj1.size()); assertEquals(1, obj1.getJsonObject("foo").size()); assertEquals("flurb", obj1.getJsonObject("foo").getString("bar")); } }
@Test void testMergeInDepth1() { { JsonObject obj1 = JsonParser.create().parseAsJsonObject("{ \"foo\": \"bar\", \"flurb\": { \"eek\": \"foo\", \"bar\": \"flurb\"}}"); JsonObject obj2 = JsonParser.create().parseAsJsonObject("{ \"flurb\": { \"bar\": \"flurb1\" }}"); obj1.mergeIn(obj2, 1); assertEquals(2, obj1.size()); assertEquals(1, obj1.getJsonObject("flurb").size()); assertEquals("flurb1", obj1.getJsonObject("flurb").getString("bar")); } { JsonObject obj1 = JsonParser.createLazyOne().parseAsJsonObject("{ \"foo\": \"bar\", \"flurb\": { \"eek\": \"foo\", \"bar\": \"flurb\"}}"); JsonObject obj2 = JsonParser.createLazyOne().parseAsJsonObject("{ \"flurb\": { \"bar\": \"flurb1\" }}"); obj1.mergeIn(obj2, 1); assertEquals(2, obj1.size()); assertEquals(1, obj1.getJsonObject("flurb").size()); assertEquals("flurb1", obj1.getJsonObject("flurb").getString("bar")); } }
@Test void testRemoveMethodReturnedObject() { JsonArray obj = new JsonArray(); obj.add("bar") .add(new JsonObject().put("name", "vert.x").put("count", 2)) .add(new JsonArray().add(1.0).add(2.0)); Object removed = obj.remove(0); assertTrue(removed instanceof String); removed = obj.remove(0); assertTrue(removed instanceof JsonObject); assertEquals(((JsonObject) removed).getString("name"), "vert.x"); removed = obj.remove(0); assertTrue(removed instanceof JsonArray); assertEquals(((JsonArray) removed).getDouble(0), 1.0, 0.1); }
@Test void testRemoveMethodReturnedObject() { JsonObject obj = new JsonObject(); obj.put("simple", "bar") .put("object", new JsonObject().put("name", "vert.x").put("count", 2)) .put("array", new JsonArray().add(1.0).add(2.0)); Object removed = obj.remove("missing"); assertNull(removed); removed = obj.remove("simple"); assertTrue(removed instanceof String); removed = obj.remove("object"); assertTrue(removed instanceof JsonObject); assertEquals(((JsonObject) removed).getString("name"), "vert.x"); removed = obj.remove("array"); assertTrue(removed instanceof JsonArray); assertEquals(((JsonArray) removed).getDouble(0), 1.0, 0.1); }