@Test void testNumberEquality() { assertNumberEquals(4, 4); assertNumberEquals(4, (long) 4); assertNumberEquals(4, 4f); assertNumberEquals(4, 4D); assertNumberEquals((long) 4, (long) 4); assertNumberEquals((long) 4, 4f); assertNumberEquals((long) 4, 4D); assertNumberEquals(4f, 4f); assertNumberEquals(4f, 4D); assertNumberEquals(4D, 4D); assertNumberEquals(4.1D, 4.1D); assertNumberEquals(4.1f, 4.1f); assertNumberNotEquals(4.1f, 4.1D); assertNumberEquals(4.5D, 4.5D); assertNumberEquals(4.5f, 4.5f); assertNumberEquals(4.5f, 4.5D); assertNumberNotEquals(4, 5); assertNumberNotEquals(4, (long) 5); assertNumberNotEquals(4, 5D); assertNumberNotEquals(4, 5f); assertNumberNotEquals((long) 4, (long) 5); assertNumberNotEquals((long) 4, 5D); assertNumberNotEquals((long) 4, 5f); assertNumberNotEquals(4f, 5f); assertNumberNotEquals(4f, 5D); assertNumberNotEquals(4D, 5D); }
@Test void testStream() { JsonObject jsonObject = new JsonObject(); jsonObject.put("foo", "bar"); jsonObject.put("quux", 123); JsonObject obj = createJsonObject(); jsonObject.put("wibble", obj); List<Map.Entry<String, Object>> list = jsonObject.stream().collect(Collectors.toList()); Iterator<Map.Entry<String, Object>> iter = list.iterator(); assertTrue(iter.hasNext()); Map.Entry<String, Object> entry = iter.next(); assertEquals("foo", entry.getKey()); assertEquals("bar", entry.getValue()); assertTrue(iter.hasNext()); entry = iter.next(); assertEquals("quux", entry.getKey()); assertEquals(123, entry.getValue()); assertTrue(iter.hasNext()); entry = iter.next(); assertEquals("wibble", entry.getKey()); assertEquals(obj, entry.getValue()); assertFalse(iter.hasNext()); }
private JsonObject createJsonObject() { JsonObject obj = new JsonObject(); obj.put("mystr", "bar"); obj.put("myint", Integer.MAX_VALUE); obj.put("mylong", Long.MAX_VALUE); obj.put("myfloat", Float.MAX_VALUE); obj.put("mydouble", Double.MAX_VALUE); obj.put("myboolean", true); obj.put("mybinary", randomByteArray(100)); return obj; }
@Test void testPutBinary() { JsonObject jsonObject = new JsonObject(); byte[] bin1 = randomByteArray(100); byte[] bin2 = randomByteArray(100); byte[] bin3 = randomByteArray(100); assertSame(jsonObject, jsonObject.put("foo", bin1)); assertArrayEquals(bin1, jsonObject.getBinary("foo")); jsonObject.put("quux", bin2); assertArrayEquals(bin2, jsonObject.getBinary("quux")); assertArrayEquals(bin1, jsonObject.getBinary("foo")); jsonObject.put("foo", bin3); assertArrayEquals(bin3, jsonObject.getBinary("foo")); jsonObject.put("foo", (byte[]) null); assertTrue(jsonObject.containsKey("foo")); try { jsonObject.put(null, bin1); fail("error"); } catch (NullPointerException e) { // OK } }
@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 testIterator() { JsonObject jsonObject = new JsonObject(); jsonObject.put("foo", "bar"); jsonObject.put("quux", 123); JsonObject obj = createJsonObject(); jsonObject.put("wibble", obj); Iterator<Map.Entry<String, Object>> iter = jsonObject.iterator(); assertTrue(iter.hasNext()); Map.Entry<String, Object> entry = iter.next(); assertEquals("foo", entry.getKey()); assertEquals("bar", entry.getValue()); assertTrue(iter.hasNext()); entry = iter.next(); assertEquals("quux", entry.getKey()); assertEquals(123, entry.getValue()); assertTrue(iter.hasNext()); entry = iter.next(); assertEquals("wibble", entry.getKey()); assertEquals(obj, entry.getValue()); assertFalse(iter.hasNext()); iter.remove(); assertFalse(obj.containsKey("wibble")); assertEquals(2, jsonObject.size()); }
jsonObject.put("double", (Object) (Double.valueOf(1.23d))); jsonObject.put("boolean", (Object) true); byte[] bytes = randomByteArray(10); jsonObject.put("binary", (Object) bytes); JsonObject obj = new JsonObject().put("foo", "blah");
@Test void testGetMap() { JsonObject jsonObject = new JsonObject(); jsonObject.put("foo", "bar"); jsonObject.put("quux", 123); JsonObject obj = createJsonObject(); jsonObject.put("wibble", obj); Map<String, Object> map = jsonObject.map(); map.remove("foo"); assertFalse(jsonObject.containsKey("foo")); map.put("bleep", "flarp"); assertTrue(jsonObject.containsKey("bleep")); jsonObject.remove("quux"); assertFalse(map.containsKey("quux")); jsonObject.put("wooble", "plink"); assertTrue(map.containsKey("wooble")); assertSame(obj, map.get("wibble")); }
@Test void testGetBinary() { JsonObject jsonObject = new JsonObject(); byte[] bytes = randomByteArray(100); jsonObject.put("foo", bytes); assertArrayEquals(bytes, jsonObject.getBinary("foo")); // Can also get as string: String val = jsonObject.getString("foo"); assertNotNull(val); byte[] retrieved = Base64.getDecoder().decode(val); assertArrayEquals(bytes, retrieved); jsonObject.put("foo", 123); try { jsonObject.getBinary("foo"); fail("error"); } catch (ClassCastException e) { // Ok } jsonObject.putNull("foo"); assertNull(jsonObject.getBinary("foo")); assertNull(jsonObject.getBinary("absent")); }
@Test void testGetBinaryDefault() { JsonObject jsonObject = new JsonObject(); byte[] bytes = randomByteArray(100); byte[] defBytes = randomByteArray(100); jsonObject.put("foo", bytes); assertArrayEquals(bytes, jsonObject.getBinary("foo", defBytes)); assertArrayEquals(bytes, jsonObject.getBinary("foo", null)); jsonObject.put("foo", 123); try { jsonObject.getBinary("foo", defBytes); fail("error"); } catch (ClassCastException e) { // Ok } jsonObject.putNull("foo"); assertNull(jsonObject.getBinary("foo", defBytes)); assertArrayEquals(defBytes, jsonObject.getBinary("absent", defBytes)); assertNull(jsonObject.getBinary("foo", null)); assertNull(jsonObject.getBinary("absent", null)); }
jsonObject.put("foo", arr); assertEquals(arr, jsonObject.getValue("foo")); byte[] bytes = randomByteArray(100); jsonObject.put("foo", bytes); assertArrayEquals(bytes, Base64.getDecoder().decode((String) jsonObject.getValue("foo")));
@Test void testEncode() { JsonParsers.forEachParser(jsonParser -> { JsonObject jsonObject = new JsonObject(); jsonObject.put("mystr", "foo"); jsonObject.put("mycharsequence", new StringBuilder("oob")); jsonObject.put("myint", 123); jsonObject.put("mylong", 1234L); jsonObject.put("myfloat", 1.23f); jsonObject.put("mydouble", 2.34d); jsonObject.put("myboolean", true); byte[] bytes = randomByteArray(10); jsonObject.put("mybinary", bytes); jsonObject.putNull("mynull"); jsonObject.put("myobj", new JsonObject().put("foo", "bar")); jsonObject.put("myarr", new JsonArray().add("foo").add(123)); String json = JsonSerializer.create().serialize(jsonObject); JsonObject expectedParsedJsonObject = jsonParser.parseAsJsonObject(json); // need to replace float with double, as decoding will do so jsonObject.put("myfloat", 1.23d); assertEquals(expectedParsedJsonObject, jsonObject); }); }
assertEquals(arr, jsonObject.getValue("foo", "blah")); assertEquals(arr, jsonObject.getValue("foo", null)); byte[] bytes = randomByteArray(100); jsonObject.put("foo", bytes); assertArrayEquals(bytes, Base64.getDecoder().decode(jsonObject.getValue("foo", "blah")));