@Test public void testObjectMappingWithTypeReference() { JsonParser parser = JsonParser.newParser(); List<Object> values = new ArrayList<>(); parser.objectValueMode(); parser.handler(event -> values.add(event.mapTo(new TypeReference<TheObject>() {}))); parser.handle(new JsonObject().put("f", "the-value").toBuffer()); assertEquals(Collections.singletonList(new TheObject("the-value")), values); }
@Test public void testNullValue() { testValue("null", event -> { assertEquals(null, event.value()); assertFalse(event.isArray()); assertFalse(event.isObject()); assertFalse(event.isNumber()); assertTrue(event.isNull()); assertFalse(event.isBoolean()); assertFalse(event.isString()); assertNull(event.integerValue()); assertNull(event.longValue()); assertNull(event.floatValue()); assertNull(event.doubleValue()); assertNull(event.binaryValue()); assertNull(event.instantValue()); assertNull(event.objectValue()); assertNull(event.arrayValue()); assertNull(event.stringValue()); assertNull(event.binaryValue()); }); }
private void testValue(String jsonValue, Handler<JsonEvent> checker) { JsonParser parser = JsonParser.newParser(); AtomicInteger status = new AtomicInteger(); parser.handler(event -> { switch (status.getAndIncrement()) { case 0: assertEquals(JsonEventType.START_OBJECT, event.type()); assertNull(event.fieldName()); assertNull(event.value()); break; case 1: assertEquals(JsonEventType.VALUE, event.type()); checker.handle(event); assertEquals("foo", event.fieldName()); break; case 2: assertEquals(JsonEventType.END_OBJECT, event.type()); assertNull(event.fieldName()); assertNull(event.value()); break; } }); parser.handle(Buffer.buffer("{\"foo\":" + jsonValue + "}")); assertEquals(3, status.get()); }
@Test public void testDoubleValue() { testValue("567.45", event -> { assertEquals(567.45d, event.value()); assertFalse(event.isArray()); assertFalse(event.isObject()); assertTrue(event.isNumber()); assertFalse(event.isNull()); assertFalse(event.isBoolean()); assertFalse(event.isString()); assertEquals(567, (long)event.integerValue()); assertEquals(567L, (long)event.longValue()); assertEquals(567.45f, (float)event.floatValue(), 0.01f); assertEquals(567.45d, (double)event.doubleValue(), 0.01d); assertThrowCCE(event, JsonEvent::stringValue, JsonEvent::booleanValue, JsonEvent::binaryValue, JsonEvent::instantValue, JsonEvent::objectValue, JsonEvent::arrayValue); }); }
@Test public void testInstantValue() { Instant value = Instant.now(); String encoded = ISO_INSTANT.format(value); testValue('"' + encoded + '"', event -> { assertEquals(encoded, event.value()); assertFalse(event.isArray()); assertFalse(event.isObject()); assertFalse(event.isNumber()); assertFalse(event.isNull()); assertFalse(event.isBoolean()); assertTrue(event.isString()); assertEquals(encoded, event.stringValue()); assertEquals(value, event.instantValue()); assertThrowCCE(event, JsonEvent::integerValue, JsonEvent::longValue, JsonEvent::floatValue, JsonEvent::doubleValue, JsonEvent::booleanValue, JsonEvent::objectValue, JsonEvent::arrayValue); }); }
@Test public void testBooleanValue() { testValue("true", event -> { assertEquals(true, event.value()); assertFalse(event.isArray()); assertFalse(event.isObject()); assertFalse(event.isNumber()); assertFalse(event.isNull()); assertTrue(event.isBoolean()); assertFalse(event.isString()); assertTrue(event.booleanValue()); assertThrowCCE(event, JsonEvent::integerValue, }); testValue("false", event -> { assertEquals(false, event.value()); assertFalse(event.isArray()); assertFalse(event.isObject()); assertFalse(event.isNumber()); assertFalse(event.isNull()); assertTrue(event.isBoolean()); assertFalse(event.isString()); assertFalse(event.booleanValue()); assertThrowCCE(event, JsonEvent::integerValue,
switch (status.getAndIncrement()) { case 0: assertEquals(JsonEventType.START_OBJECT, event.type()); parser.objectValueMode(); break; case 1: assertEquals(JsonEventType.VALUE, event.type()); assertTrue(event.isObject()); assertEquals(new JsonObject(), event.value()); assertEquals("foo", event.fieldName()); break; case 2: assertEquals("bar", event.fieldName()); assertTrue(event.isObject()); assertEquals(JsonEventType.VALUE, event.type()); assertEquals(new JsonObject(), event.value()); break; case 3: assertEquals(JsonEventType.END_OBJECT, event.type()); break; default:
AtomicInteger stringCount = new AtomicInteger(); parser.handler(event -> { switch (event.type()) { case START_OBJECT: startCount.incrementAndGet(); break; case VALUE: if (event.isNull()) { nullCount.incrementAndGet(); } else if (event.isNumber()) { numberCount.incrementAndGet(); } else if (event.isString()) { stringCount.incrementAndGet(); } else { fail("Unexpected " + event.type()); fail("Unexpected " + event.type()); break;
@Test public void testObjectHandlerScope() { JsonParser parser = JsonParser.newParser(); List<JsonObject> objects = new ArrayList<>(); AtomicInteger ends = new AtomicInteger(); AtomicBoolean obj = new AtomicBoolean(); parser.handler(event -> { switch (event.type()) { case START_OBJECT: parser.objectValueMode(); break; case VALUE: if (obj.get()) { objects.add((JsonObject) event.value()); } break; case END_OBJECT: ends.incrementAndGet(); obj.set(true); break; } }); parser.handle(Buffer.buffer("[" + "{\"one\":1}," + "{\"two\":2}," + "{\"three\":3}" + "]")); assertEquals(1, ends.get()); assertEquals(Arrays.asList(new JsonObject().put("two", 2), new JsonObject().put("three", 3)), objects); }
switch (status.getAndIncrement()) { case 0: assertEquals(JsonEventType.START_ARRAY, event.type()); break; case 1: assertEquals(JsonEventType.VALUE, event.type()); assertTrue(event.isObject()); assertEquals(new JsonObject().put("one", 1), event.value()); break; case 2: assertEquals(JsonEventType.VALUE, event.type()); assertTrue(event.isObject()); assertEquals(new JsonObject().put("two", 2), event.value()); break; case 3: assertEquals(JsonEventType.VALUE, event.type()); assertTrue(event.isObject()); assertEquals(new JsonObject().put("three", 3), event.value()); break; case 4: assertEquals(JsonEventType.END_ARRAY, event.type()); break;
/** * @return the JSON object value or <code>null</code> if the event has no JSON value */ public JsonObject objectValue() { JsonObject ret = delegate.objectValue(); return ret; }
@Test public void testParseTopValues() { Map<String, Object> tests = new HashMap<>(); tests.put("\"a-string\"", "a-string"); tests.put("true", true); tests.put("false", false); tests.put("1234", 1234L); tests.put("" + Long.MAX_VALUE, Long.MAX_VALUE); tests.forEach((test, expected) -> { JsonParser parser = JsonParser.newParser(); List<Object> values = new ArrayList<>(); parser.handler(event -> values.add(event.value())); parser.handle(Buffer.buffer(test)); parser.end(); assertEquals(Collections.singletonList(expected), values); }); }
@Test public void testParseConcatedJSONStream() { JsonParser parser = JsonParser.newParser(); AtomicInteger startCount = new AtomicInteger(); AtomicInteger endCount = new AtomicInteger(); parser.handler(event -> { switch (event.type()) { case START_OBJECT: startCount.incrementAndGet(); break; case END_OBJECT: endCount.incrementAndGet(); break; default: fail(); break; } }); parser.handle(Buffer.buffer("{}{}")); assertEquals(2, startCount.get()); assertEquals(2, endCount.get()); }
/** * @return the JSON array value or <code>null</code> if the event has no JSON value */ public JsonArray arrayValue() { JsonArray ret = delegate.arrayValue(); return ret; }
/** * Return the binary value. * <p> * JSON itself has no notion of a binary, this extension complies to the RFC-7493, so this method assumes there is a * String value with the key and it contains a Base64 encoded binary, which it decodes if found and returns. * @return the binary value or <code>null</code> if the event has no JSON value */ public io.vertx.rxjava.core.buffer.Buffer binaryValue() { io.vertx.rxjava.core.buffer.Buffer ret = io.vertx.rxjava.core.buffer.Buffer.newInstance(delegate.binaryValue()); return ret; }
/** * @return the name of the field when the event is emitted as a JSON object member */ public String fieldName() { String ret = delegate.fieldName(); return ret; }
/** * @return the <code>Boolean</code> value or <code>null</code> if the event has no JSON value */ public Boolean booleanValue() { Boolean ret = delegate.booleanValue(); return ret; }
/** * @return the <code>Float</code> value or <code>null</code> if the event has no JSON value */ public Float floatValue() { Float ret = delegate.floatValue(); return ret; }
/** * @return the <code>Double</code> value or <code>null</code> if the event has no JSON value */ public Double doubleValue() { Double ret = delegate.doubleValue(); return ret; }