@Test public void parseNumberFormatException() { Buffer data = Buffer.buffer(Long.MAX_VALUE + "0"); try { JsonParser.newParser().handler(val -> {}).write(data).end(); fail(); } catch (DecodeException expected) { } List<Throwable> errors = new ArrayList<>(); JsonParser.newParser().exceptionHandler(errors::add).handler(val -> {}).write(data).end(); assertEquals(1, errors.size()); }
@Test public void testObjectMapping() { JsonParser parser = JsonParser.newParser(); List<Object> values = new ArrayList<>(); parser.objectValueMode(); parser.handler(event -> values.add(event.mapTo(TheObject.class))); parser.handle(new JsonObject().put("f", "the-value").toBuffer()); assertEquals(Collections.singletonList(new TheObject("the-value")), values); }
@Test public void testParseEmptyObject() { JsonParser parser = JsonParser.newParser(); AtomicInteger status = new AtomicInteger(); parser.handler(event -> { assertNull(event.fieldName()); assertNull(event.value()); parser.endHandler(v -> count.incrementAndGet()); parser.handle(Buffer.buffer("{}")); assertEquals(2, status.get()); assertEquals(0, count.get()); parser.end(); assertEquals(1, count.get()); assertEquals(2, status.get()); try { parser.end(); fail(); } catch (IllegalStateException ignore) {
@Test public void parseUnfinished() { Buffer data = Buffer.buffer("{\"un\":\"finished\""); try { JsonParser parser = JsonParser.newParser(); parser.handle(data); parser.end(); fail(); } catch (DecodeException expected) { } JsonParser parser = JsonParser.newParser(); List<Throwable> errors = new ArrayList<>(); parser.exceptionHandler(errors::add); parser.handle(data); parser.end(); assertEquals(1, errors.size()); }
@Test public void testArrayMapping() { JsonParser parser = JsonParser.newParser(); List<Object> values = new ArrayList<>(); parser.arrayValueMode(); parser.handler(event -> values.add(event.mapTo(LinkedList.class))); parser.handle(new JsonArray().add(0).add(1).add(2).toBuffer()); assertEquals(Collections.singletonList(Arrays.asList(0L, 1L, 2L)), values); assertEquals(LinkedList.class, values.get(0).getClass()); }
@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()); }
@Test public void testStreamFetch() { FakeStream stream = new FakeStream(); JsonParser parser = JsonParser.newParser(stream); List<JsonEvent> events = new ArrayList<>(); parser.handler(events::add); parser.pause(); stream.handle("{}"); parser.fetch(1); assertEquals(1, events.size()); assertTrue(stream.isPaused()); }
JsonParser jsonParser = JsonParser.newParser(asyncFile); jsonParser.objectValueMode() .exceptionHandler(t -> { t.printStackTrace(); asyncFile.close(); }) .endHandler(v -> { System.out.println("Done!"); asyncFile.close(); }).handler(event -> {
@Test public void testStreamPause() { FakeStream stream = new FakeStream(); JsonParser parser = JsonParser.newParser(stream); List<JsonEvent> events = new ArrayList<>(); parser.handler(events::add); parser.pause(); stream.handle("1234"); assertTrue(stream.isPaused()); assertEquals(0, events.size()); }
@Test public void testStreamResume() { FakeStream stream = new FakeStream(); JsonParser parser = JsonParser.newParser(stream); List<JsonEvent> events = new ArrayList<>(); parser.handler(events::add); parser.pause(); stream.handle("{}"); parser.resume(); assertEquals(2, events.size()); assertFalse(stream.isPaused()); }
@Test public void testStreamEnd() { FakeStream stream = new FakeStream(); JsonParser parser = JsonParser.newParser(stream); List<JsonEvent> events = new ArrayList<>(); parser.handler(events::add); AtomicInteger ended = new AtomicInteger(); parser.endHandler(v -> ended.incrementAndGet()); stream.end(); assertEquals(0, events.size()); assertEquals(1, ended.get()); //regression check for #2790 - ensure that by accident resume method is not called. assertEquals(0, stream.pauseCount()); assertEquals(0, stream.resumeCount()); }
private void watch(WebClient client, String token, String resourceVersion) { String path = "/api/v1/namespaces/" + namespace + "/services"; JsonParser parser = JsonParser.newParser().objectValueMode() .handler(event -> onChunk(event.objectValue()));
/** * Create a new <code>JsonParser</code> instance. * @return */ public static io.vertx.rxjava.core.parsetools.JsonParser newParser() { io.vertx.rxjava.core.parsetools.JsonParser ret = io.vertx.rxjava.core.parsetools.JsonParser.newInstance(io.vertx.core.parsetools.JsonParser.newParser()); return ret; }
@Override public void end() { parser.end(); }
@Override public WriteStream<Buffer> exceptionHandler(Handler<Throwable> handler) { parser.exceptionHandler(handler); return this; }
public io.vertx.rxjava.core.parsetools.JsonParser handler(Handler<io.vertx.rxjava.core.parsetools.JsonEvent> handler) { delegate.handler(new Handler<io.vertx.core.parsetools.JsonEvent>() { public void handle(io.vertx.core.parsetools.JsonEvent event) { handler.handle(io.vertx.rxjava.core.parsetools.JsonEvent.newInstance(event)); } }); return this; }
/** * Flip the parser to emit a single value event for each new json object. * </p> * Json object currently streamed won't be affected. * @return a reference to this, so the API can be used fluently */ public io.vertx.rxjava.core.parsetools.JsonParser objectValueMode() { delegate.objectValueMode(); return this; }
@Override public WriteStream<Buffer> write(Buffer buffer) { parser.handle(buffer); return this; }
@Override public WriteStream<Buffer> write(Buffer data) { parser.write(data); return this; }