@Test void testKeys() { JsonParsers.forEachParser(jsonParser -> { String json = "{\"123\" : \"name\"}"; Map<Long, String> map = jsonParser.map("keys", Long.class).parse(json); assertEquals(1, map.size()); assertEquals("name", map.get(Long.valueOf(123))); }); JsonParsers.forEachParser(jsonParser -> { String json = "{\"eee\" : {\"123\" : \"name\"}}"; Map<String, Map<Long, String>> map2 = jsonParser.map("values.keys", Long.class).parse(json); assertEquals(1, map2.size()); Map<Long, String> map = map2.get("eee"); assertEquals(1, map.size()); assertEquals("name", map.get(Long.valueOf(123))); }); }
/** * Parses input JSON to a list with specified component type. */ public <T> List<T> parseAsList(final String string, final Class<T> componentType) { return new JsonParser() .map(JsonParser.VALUES, componentType) .parse(string); }
/** * Creates a lazy implementation of the JSON parser. */ public static JsonParser createLazyOne() { return new JsonParser().lazy(true); }
/** * Parses input JSON to {@link JsonArray}, special case of parsing. */ public JsonArray parseAsJsonArray(final String input) { return new JsonArray(parse(input)); }
@Override public <T> T parse(String string) { return new JsonParser().parse(string); }
@Test void testParseCatalogAsObjectWithClassname() { JsonParsers.forEachParser(jsonParser -> { String json = loadJSON("citm_catalog"); Catalog catalog = jsonParser.setClassMetadataName("class").parse(json, Catalog.class); assertCatalog(catalog); }); }
@Test void testCustomMap() { JsonParsers.forEachParser(jsonParser -> { String json = "{\"userId\" : 123, \"name\": 456}"; Map<String, Integer> map = jsonParser.parse(json); assertEquals(2, map.size()); assertEquals(Integer.valueOf(123), map.get("userId")); assertEquals(Integer.valueOf(456), map.get("name")); Map<String, Long> map2 = JsonParser .create() .map(JsonParser.VALUES, Long.class) .parse(json); assertEquals(2, map2.size()); assertEquals(Long.valueOf(123), map2.get("userId")); assertEquals(Long.valueOf(456), map2.get("name")); }); JsonParsers.forEachParser(jsonParser -> { String json = "{\"123\" : \"hey\", \"456\": \"man\"}"; Map<Long, String> map3 = jsonParser .map(JsonParser.KEYS, Long.class) .parse(json); assertEquals(2, map3.size()); assertEquals("hey", map3.get(Long.valueOf(123))); assertEquals("man", map3.get(Long.valueOf(456))); }); }
@Test void testQuotes() { JsonParsers.forEachParser(jsonParser -> { try { assertEquals("ABC", jsonParser.parse("'ABC'")); fail("error"); } catch (JsonException ignore) { } assertEquals("ABC", jsonParser.looseMode(true).parse("'ABC'")); assertEquals("AB'C", jsonParser.looseMode(true).parse("'AB\\'C'")); Map<String, Object> map = jsonParser.looseMode(true).parse("{'foo':'BAR'}"); assertEquals(1, map.size()); assertEquals("BAR", map.get("foo")); }); }
@Test void testParseCatalogAsMap() { JsonParsers.forEachParser(jsonParser -> { String json = loadJSON("citm_catalog"); Map catalog = jsonParser .map("values.keys", Long.class) .map("venueNames.keys", String.class) .useAltPaths() .parse(json); String newJson = new JsonSerializer().deep(true).serialize(catalog); Catalog jsonCatalog = jsonParser.parse(newJson, Catalog.class); assertCatalog(jsonCatalog); }); }
@Test void testPointWithException() { JsonParser.Defaults.classMetadataName = "__class"; JsonSerializer.Defaults.classMetadataName = "__class"; JsonParsers.forEachParser(jsonParser -> { jsonParser.allowClass("notAllowed"); final String json = new JsonSerializer().serialize(new Point2D.Float(1.0f, 2.0f)); assertThrows(JsonException.class, () -> { jsonParser.parse(json); }); jsonParser.allowAllClasses(); }); }
@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 testDeserializeInterfaces2() { JsonParsers.forEachParser(jsonParser -> { Hero superman = creator.createSuperman(); String json = new JsonSerializer().include("powers").withClassMetadata(true).serialize(superman); Hero jsonSuperMan = jsonParser.withClassMetadata(true).parse(json, Hero.class); assertNotNull(jsonSuperMan); assertEquals(4, jsonSuperMan.getPowers().size()); assertHeroHasSuperPowers(jsonSuperMan); }); }
/** * Static ctor. */ public static JsonParser create() { return new JsonParser(); }
@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")); } }
public static void forEachParser(final Consumer<JsonParser> jsonParserConsumer) { for (int i = 0; i < 2; i++) { final JsonParser jsonParser; switch (i) { case 0: jsonParser = JsonParser.create(); break; case 1: jsonParser = JsonParser.create().lazy(true); break; default: throw new IllegalArgumentException("Not good."); } jsonParserConsumer.accept(jsonParser); } } }
/** * Parses input JSON to {@link JsonObject}, special case of {@link #parse(String, Class)}. */ public JsonObject parseAsJsonObject(final String input) { return new JsonObject(parse(input)); }
@Override public <T> T parse(String string, Class<T> type) { return new JsonParser().parse(string, type); }
@Test void testMapWithEmbeddedObject() { JsonParsers.forEachParser(jsonParser -> { Map<String, Network> networks = jsonParser .setClassMetadataName("class") .parse("{\"1\": {\"class\":\"" + Network.class.getName() + "\", \"name\": \"Jodd\"} }"); assertNotNull(networks); assertEquals(1, networks.size()); assertTrue(networks.containsKey("1")); assertNotNull(networks.get("1")); assertEquals(Network.class, networks.get("1").getClass()); assertEquals("Jodd", networks.get("1").getName()); }); }
@Test void testUnquotes() { JsonParsers.forEachParser(jsonParser -> { Map<String, Object> map = jsonParser.looseMode(true).parse("{foo: BAR , who : me}"); assertEquals(2, map.size()); assertEquals("BAR", map.get("foo")); assertEquals("me", map.get("who")); try { jsonParser.looseMode(true).parse("{foo: BAR , who : m\te}"); fail("error"); } catch (JsonException ignore) { } }); }