From defe93b721bd3bf80f73edb6e67a8b1d6fd73749 Mon Sep 17 00:00:00 2001 From: Anton Pinsky Date: Fri, 24 Nov 2023 23:55:54 +0100 Subject: [PATCH 1/5] Implement stream methods in JsonStructureParser; fulfill more of JSONP Parser in it & JsonParserImpl; higher code coverage Signed-off-by: Anton Pinsky --- .../org/eclipse/parsson/JsonParserImpl.java | 109 +-- .../parsson/JsonParserStreamCreator.java | 108 +++ .../eclipse/parsson/JsonStructureParser.java | 149 ++-- .../org/eclipse/parsson/StreamCreator.java | 116 +++ .../eclipse/parsson/tests/JsonParserTest.java | 663 ++++++++++++++++++ 5 files changed, 986 insertions(+), 159 deletions(-) create mode 100644 impl/src/main/java/org/eclipse/parsson/JsonParserStreamCreator.java create mode 100644 impl/src/main/java/org/eclipse/parsson/StreamCreator.java diff --git a/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java b/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java index b60c7fb8..676746b3 100644 --- a/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java +++ b/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java @@ -22,15 +22,10 @@ import java.io.Reader; import java.math.BigDecimal; import java.nio.charset.Charset; -import java.util.AbstractMap; import java.util.Map; import java.util.NoSuchElementException; import java.util.Objects; -import java.util.Spliterator; -import java.util.Spliterators; -import java.util.function.Consumer; import java.util.stream.Stream; -import java.util.stream.StreamSupport; import jakarta.json.JsonArray; import jakarta.json.JsonArrayBuilder; @@ -60,7 +55,7 @@ * @author Jitendra Kotamraju * @author Kin-man Chung */ -public class JsonParserImpl implements JsonParser { +class JsonParserImpl implements JsonParser { private Context currentContext = new NoneContext(); private Event currentEvent; @@ -71,20 +66,24 @@ public class JsonParserImpl implements JsonParser { private final JsonContext jsonContext; - public JsonParserImpl(Reader reader, JsonContext jsonContext) { + private final JsonParserStreamCreator streamCreator = new JsonParserStreamCreator(this, true, () -> currentEvent, + () -> currentContext instanceof NoneContext); + + + JsonParserImpl(Reader reader, JsonContext jsonContext) { this.jsonContext = jsonContext; stack = new Stack(jsonContext.depthLimit()); this.tokenizer = new JsonTokenizer(reader, jsonContext); } - public JsonParserImpl(InputStream in, JsonContext jsonContext) { + JsonParserImpl(InputStream in, JsonContext jsonContext) { this.jsonContext = jsonContext; stack = new Stack(jsonContext.depthLimit()); UnicodeDetectingInputStream uin = new UnicodeDetectingInputStream(in); this.tokenizer = new JsonTokenizer(new InputStreamReader(uin, uin.getCharset()), jsonContext); } - public JsonParserImpl(InputStream in, Charset encoding, JsonContext jsonContext) { + JsonParserImpl(InputStream in, Charset encoding, JsonContext jsonContext) { this.jsonContext = jsonContext; stack = new Stack(jsonContext.depthLimit()); this.tokenizer = new JsonTokenizer(new InputStreamReader(in, encoding), jsonContext); @@ -194,103 +193,17 @@ public JsonValue getValue() { @Override public Stream getArrayStream() { - if (currentEvent != Event.START_ARRAY) { - throw new IllegalStateException( - JsonMessages.PARSER_GETARRAY_ERR(currentEvent)); - } - Spliterator spliterator = - new Spliterators.AbstractSpliterator(Long.MAX_VALUE, Spliterator.ORDERED) { - @Override - public Spliterator trySplit() { - return null; - } - - @Override - public boolean tryAdvance(Consumer action) { - if (action == null) { - throw new NullPointerException(); - } - if (!hasNext()) { - return false; - } - if (next() == JsonParser.Event.END_ARRAY) { - return false; - } - action.accept(getValue()); - return true; - } - }; - return StreamSupport.stream(spliterator, false); + return streamCreator.getArrayStream(); } @Override public Stream> getObjectStream() { - if (currentEvent != Event.START_OBJECT) { - throw new IllegalStateException( - JsonMessages.PARSER_GETOBJECT_ERR(currentEvent)); - } - Spliterator> spliterator = - new Spliterators.AbstractSpliterator>(Long.MAX_VALUE, Spliterator.ORDERED) { - @Override - public Spliterator> trySplit() { - return null; - } - - @Override - public boolean tryAdvance(Consumer> action) { - if (action == null) { - throw new NullPointerException(); - } - if (!hasNext()) { - return false; - } - JsonParser.Event e = next(); - if (e == JsonParser.Event.END_OBJECT) { - return false; - } - if (e != JsonParser.Event.KEY_NAME) { - throw new JsonException(JsonMessages.INTERNAL_ERROR()); - } - String key = getString(); - if (!hasNext()) { - throw new JsonException(JsonMessages.INTERNAL_ERROR()); - } - next(); - JsonValue value = getValue(); - action.accept(new AbstractMap.SimpleImmutableEntry<>(key, value)); - return true; - } - }; - return StreamSupport.stream(spliterator, false); + return streamCreator.getObjectStream(); } @Override public Stream getValueStream() { - if (! (currentContext instanceof NoneContext)) { - throw new IllegalStateException( - JsonMessages.PARSER_GETVALUESTREAM_ERR()); - } - Spliterator spliterator = - new Spliterators.AbstractSpliterator(Long.MAX_VALUE, Spliterator.ORDERED) { - @Override - public Spliterator trySplit() { - return null; - } - - @Override - public boolean tryAdvance(Consumer action) { - if (action == null) { - throw new NullPointerException(); - } - if (!hasNext()) { - return false; - } - next(); - action.accept(getValue()); - return true; - } - }; - return StreamSupport.stream(spliterator, false); + return streamCreator.getValueStream(); } @Override diff --git a/impl/src/main/java/org/eclipse/parsson/JsonParserStreamCreator.java b/impl/src/main/java/org/eclipse/parsson/JsonParserStreamCreator.java new file mode 100644 index 00000000..d38e4dc3 --- /dev/null +++ b/impl/src/main/java/org/eclipse/parsson/JsonParserStreamCreator.java @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ + +package org.eclipse.parsson; + +import java.util.AbstractMap; +import java.util.Map; +import java.util.Objects; +import java.util.function.Supplier; +import java.util.stream.Stream; + +import jakarta.json.JsonException; +import jakarta.json.JsonValue; +import jakarta.json.stream.JsonParser; +import jakarta.json.stream.JsonParser.Event; + +class JsonParserStreamCreator { + + private final JsonParser parser; + private final boolean nextBeforeCreationOfValueStream; + private final Supplier currenEventSupplier; + private final Supplier canProduceValueStream; + + JsonParserStreamCreator(JsonParser parser, boolean nextBeforeCreationOfValueStream, Supplier currenEventSupplier, + Supplier canProduceValueStream) { + + this.parser = Objects.requireNonNull(parser); + this.nextBeforeCreationOfValueStream = nextBeforeCreationOfValueStream; + this.currenEventSupplier = Objects.requireNonNull(currenEventSupplier); + this.canProduceValueStream = Objects.requireNonNull(canProduceValueStream); + } + + /** + * Creates new {@link Stream} from values from {@link Supplier}. The stream delivers the values as long as supplier delivers non-null values + * + * @param supplier supplier of the values + * @param type of the values which are delivered by the supplier and the stream + * @return stream of values from given supplier + */ + private static Stream streamFromSupplier(Supplier supplier) { + return StreamCreator.iterate(Objects.requireNonNull(supplier).get(), Objects::nonNull, value -> supplier.get()); + } + + public Stream getArrayStream() { + if (currenEventSupplier.get() == Event.START_ARRAY) { + return streamFromSupplier(() -> (parser.hasNext() && parser.next() != Event.END_ARRAY) ? parser.getValue() : null); + } else { + throw new IllegalStateException(JsonMessages.PARSER_GETARRAY_ERR(parser.currentEvent())); + } + } + + public Stream> getObjectStream() { + if (currenEventSupplier.get() == Event.START_OBJECT) { + return streamFromSupplier(() -> { + if (!parser.hasNext()) { + return null; + } + Event e = parser.next(); + if (e == Event.END_OBJECT) { + return null; + } else if (e != Event.KEY_NAME) { + throw new JsonException(JsonMessages.INTERNAL_ERROR()); + } else { + String key = parser.getString(); + if (!parser.hasNext()) { + throw new JsonException(JsonMessages.INTERNAL_ERROR()); + } else { + parser.next(); + return new AbstractMap.SimpleImmutableEntry<>(key, parser.getValue()); + } + } + }); + } else { + throw new IllegalStateException(JsonMessages.PARSER_GETOBJECT_ERR(parser.currentEvent())); + } + } + + public Stream getValueStream() { + if (canProduceValueStream.get()) { + if (nextBeforeCreationOfValueStream) { + parser.next(); + } + + return streamFromSupplier(() -> { + if (parser.hasNext()) { + return parser.getValue(); + } else { + return null; + } + }); + } else { + throw new IllegalStateException(JsonMessages.PARSER_GETVALUESTREAM_ERR()); + } + } +} diff --git a/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java b/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java index 3fed7c01..d16ef38d 100644 --- a/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java +++ b/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java @@ -25,6 +25,7 @@ import java.util.Iterator; import java.util.Map; import java.util.NoSuchElementException; +import java.util.stream.Stream; /** * {@link JsonParser} implementation on top of JsonArray/JsonObject @@ -33,9 +34,13 @@ */ class JsonStructureParser implements JsonParser { - private Scope current; + private Scope current; private Event state; - private final Deque scopeStack = new ArrayDeque<>(); + private final Deque> scopeStack = new ArrayDeque<>(); + + //JsonParserImpl delivers the whole object - so we have to call next() before creation of the stream + private final JsonParserStreamCreator streamCreator = new JsonParserStreamCreator(this, true, () -> state, scopeStack::isEmpty); + JsonStructureParser(JsonArray array) { current = new ArrayScope(array); @@ -96,6 +101,55 @@ public JsonLocation getLocation() { return JsonLocationImpl.UNKNOWN; } + @Override + public JsonObject getObject() { + if (state != Event.START_OBJECT) { + throw new IllegalStateException( + JsonMessages.PARSER_GETOBJECT_ERR(state)); + } + if (current == null) { + throw new NoSuchElementException(JsonMessages.INTERNAL_ERROR()); + } + state = Event.END_OBJECT; + return current.getJsonValue().asJsonObject(); + + } + + @Override + public JsonValue getValue() { + if (current == null) { + throw new IllegalStateException(JsonMessages.INTERNAL_ERROR()); + } + + switch (state) { + case START_OBJECT: + return getObject(); + case START_ARRAY: + return getArray(); + case KEY_NAME: + return Json.createValue(((ObjectScope)current).key); + case END_OBJECT: + case END_ARRAY: + throw new IllegalStateException(JsonMessages.INTERNAL_ERROR()); + default: + return current.getJsonValue(); + } + } + + @Override + public JsonArray getArray() { + if (state != Event.START_ARRAY) { + throw new IllegalStateException( + JsonMessages.PARSER_GETARRAY_ERR(state)); + } + Scope topOfTheStack = scopeStack.isEmpty() ? current : scopeStack.pop(); + if (topOfTheStack == null) { + throw new NoSuchElementException(JsonMessages.INTERNAL_ERROR()); + } + state = Event.END_ARRAY; + return topOfTheStack.getJsonValue().asJsonArray(); + } + @Override public boolean hasNext() { return !((state == Event.END_OBJECT || state == Event.END_ARRAY) && scopeStack.isEmpty()); @@ -153,59 +207,37 @@ public void close() { // no-op } + @Override + public Event currentEvent() { + return state; + } + + @Override + public Stream getArrayStream() { + return streamCreator.getArrayStream(); + } + + @Override + public Stream> getObjectStream() { + return streamCreator.getObjectStream(); + } + + @Override + public Stream getValueStream() { + return streamCreator.getValueStream(); + } + @Override public void skipObject() { if (current instanceof ObjectScope) { - int depth = 1; - do { - if (state == Event.KEY_NAME) { - state = getState(current.getJsonValue()); - switch (state) { - case START_OBJECT: - depth++; - break; - case END_OBJECT: - depth--; - break; - default: - //no-op - } - } else { - if (current.hasNext()) { - current.next(); - state = Event.KEY_NAME; - } else { - state = Event.END_OBJECT; - depth--; - } - } - } while (state != Event.END_OBJECT && depth > 0); + state = Event.END_OBJECT; } } @Override public void skipArray() { if (current instanceof ArrayScope) { - int depth = 1; - do { - if (current.hasNext()) { - current.next(); - state = getState(current.getJsonValue()); - switch (state) { - case START_ARRAY: - depth++; - break; - case END_ARRAY: - depth--; - break; - default: - //no-op - } - } else { - state = Event.END_ARRAY; - depth--; - } - } while (!(state == Event.END_ARRAY && depth == 0)); + state = Event.END_ARRAY; } } @@ -230,10 +262,13 @@ private static Event getState(JsonValue value) { } } - private static abstract class Scope implements Iterator { + private static abstract class Scope implements Iterator { + @Override + public final void remove() {throw new UnsupportedOperationException(); } + abstract JsonValue getJsonValue(); - static Scope createScope(JsonValue value) { + static Scope createScope(JsonValue value) { if (value instanceof JsonArray) { return new ArrayScope((JsonArray)value); } else if (value instanceof JsonObject) { @@ -243,7 +278,7 @@ static Scope createScope(JsonValue value) { } } - private static class ArrayScope extends Scope { + private static class ArrayScope extends Scope { private final Iterator it; private JsonValue value; @@ -262,11 +297,6 @@ public JsonValue next() { return value; } - @Override - public void remove() { - throw new UnsupportedOperationException(); - } - @Override JsonValue getJsonValue() { return value; @@ -274,12 +304,14 @@ JsonValue getJsonValue() { } - private static class ObjectScope extends Scope { + private static class ObjectScope extends Scope> { + private final JsonObject object; private final Iterator> it; private JsonValue value; private String key; ObjectScope(JsonObject object) { + this.object = object; this.it = object.entrySet().iterator(); } @@ -296,14 +328,9 @@ public Map.Entry next() { return next; } - @Override - public void remove() { - throw new UnsupportedOperationException(); - } - @Override JsonValue getJsonValue() { - return value; + return value == null ? object : value; } } diff --git a/impl/src/main/java/org/eclipse/parsson/StreamCreator.java b/impl/src/main/java/org/eclipse/parsson/StreamCreator.java new file mode 100644 index 00000000..cf391d1c --- /dev/null +++ b/impl/src/main/java/org/eclipse/parsson/StreamCreator.java @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ + +package org.eclipse.parsson; + +import java.util.Objects; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.function.Consumer; +import java.util.function.Predicate; +import java.util.function.UnaryOperator; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +/** + * Copy of public static Stream Stream#iterate(T seed, Predicate hasNext, UnaryOperator next) + * because the last is since Java 9 + */ +class StreamCreator { + /** + * Returns a sequential ordered {@code Stream} produced by iterative + * application of the given {@code next} function to an initial element, + * conditioned on satisfying the given {@code hasNext} predicate. The + * stream terminates as soon as the {@code hasNext} predicate returns false. + * + *

{@code Stream.iterate} should produce the same sequence of elements as + * produced by the corresponding for-loop: + * 

{@code
+     *     for (T index=seed; hasNext.test(index); index = next.apply(index)) {
+     *         ...
+     *     }
+     * }
+ * + *

The resulting sequence may be empty if the {@code hasNext} predicate + * does not hold on the seed value. Otherwise the first element will be the + * supplied {@code seed} value, the next element (if present) will be the + * result of applying the {@code next} function to the {@code seed} value, + * and so on iteratively until the {@code hasNext} predicate indicates that + * the stream should terminate. + * + *

The action of applying the {@code hasNext} predicate to an element + * happens-before + * the action of applying the {@code next} function to that element. The + * action of applying the {@code next} function for one element + * happens-before the action of applying the {@code hasNext} + * predicate for subsequent elements. For any given element an action may + * be performed in whatever thread the library chooses. + * + * @param the type of stream elements + * @param seed the initial element + * @param hasNext a predicate to apply to elements to determine when the + * stream must terminate. + * @param next a function to be applied to the previous element to produce + * a new element + * @return a new sequential {@code Stream} + * @since 9 + */ + public static Stream iterate(T seed, Predicate hasNext, UnaryOperator next) { + Objects.requireNonNull(next); + Objects.requireNonNull(hasNext); + Spliterator spliterator = new Spliterators.AbstractSpliterator(Long.MAX_VALUE, + Spliterator.ORDERED | Spliterator.IMMUTABLE) { + T prev; + boolean started, finished; + + @Override + public boolean tryAdvance(Consumer action) { + Objects.requireNonNull(action); + if (finished) + return false; + T t; + if (started) + t = next.apply(prev); + else { + t = seed; + started = true; + } + if (!hasNext.test(t)) { + prev = null; + finished = true; + return false; + } + action.accept(prev = t); + return true; + } + + @Override + public void forEachRemaining(Consumer action) { + Objects.requireNonNull(action); + if (finished) + return; + finished = true; + T t = started ? next.apply(prev) : seed; + prev = null; + while (hasNext.test(t)) { + action.accept(t); + t = next.apply(t); + } + } + }; + return StreamSupport.stream(spliterator, false); + } +} diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java index 3a36de44..4179893d 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java @@ -16,10 +16,17 @@ package org.eclipse.parsson.tests; +import static org.eclipse.parsson.JsonParserFixture.testWithCreateParserFromObject; +import static org.eclipse.parsson.JsonParserFixture.testWithCreateParserFromString; +import static org.hamcrest.Matchers.contains; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.fail; +import static org.hamcrest.MatcherAssert.assertThat; + import java.io.ByteArrayInputStream; import java.io.InputStream; import java.io.InputStreamReader; @@ -31,19 +38,32 @@ import jakarta.json.stream.JsonParser; import jakarta.json.stream.JsonParser.Event; import jakarta.json.stream.JsonParserFactory; + import java.math.BigDecimal; +import java.math.BigInteger; import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.EnumSet; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.NoSuchElementException; +import java.util.Objects; import java.util.Random; import java.util.Scanner; +import java.util.stream.Collector; +import java.util.stream.Collectors; + import jakarta.json.stream.JsonParsingException; import org.eclipse.parsson.api.BufferPool; +import org.hamcrest.Matcher; +import org.hamcrest.Matchers; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.function.Executable; /** * JsonParser Tests @@ -54,6 +74,22 @@ public class JsonParserTest { static final Charset UTF_32LE = Charset.forName("UTF-32LE"); static final Charset UTF_32BE = Charset.forName("UTF-32BE"); + private static final EnumSet GET_STRING_EVENT_ENUM_SET = + EnumSet.of(JsonParser.Event.KEY_NAME, JsonParser.Event.VALUE_STRING, JsonParser.Event.VALUE_NUMBER); + + private static final EnumSet NOT_GET_VALUE_EVENT_ENUM_SET = EnumSet.of(JsonParser.Event.END_OBJECT, JsonParser.Event.END_ARRAY); + + private static final Collector, ?, ArrayList> MAP_TO_LIST_COLLECTOR = Collector.of(ArrayList::new, + (list, entry) -> { + list.add(entry.getKey()); + list.add(entry.getValue().toString()); + }, + (left, right) -> { + left.addAll(right); + return left; + }, + Collector.Characteristics.IDENTITY_FINISH); + @Test void testReader() { JsonParser reader = Json.createParser( @@ -870,4 +906,631 @@ private void checkExceptionFromNext(String input) { } fail(); } + + @Nested + public class DirectParserTests { + @Test + void testNumbersStructure() { + testWithCreateParserFromObject(Json.createObjectBuilder() + .add("int", 1) + .add("long", 1L) + .add("double", 1d) + .add("BigInteger", BigInteger.TEN) + .add("BigDecimal", BigDecimal.TEN) + .build(), this::testNumbers); + } + + @Test + void testNumbersString() { + testWithCreateParserFromString("{\"int\":1,\"long\":1,\"double\":1.0,\"BigInteger\":10,\"BigDecimal\":10}", this::testNumbers); + } + + private void testNumbers(JsonParser parser) { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + assertTrue(parser.isIntegralNumber()); + assertEquals(1, parser.getInt()); + + parser.next(); + parser.getString(); + parser.next(); + assertTrue(parser.isIntegralNumber()); + assertEquals(1L, parser.getLong()); + + parser.next(); + parser.getString(); + parser.next(); + assertFalse(parser.isIntegralNumber()); + assertEquals(BigDecimal.valueOf(1d), parser.getBigDecimal()); + + parser.next(); + parser.getString(); + parser.next(); + assertTrue(parser.isIntegralNumber()); + assertEquals(BigDecimal.TEN, parser.getBigDecimal()); + + parser.next(); + parser.getString(); + parser.next(); + assertTrue(parser.isIntegralNumber()); + assertEquals(BigDecimal.TEN, parser.getBigDecimal()); + } + + @Test + void testParser_getStringStructure(){ + testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testParser_getString); + } + + @Test + void testParser_getStringString(){ + testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::testParser_getString); + } + + private void testParser_getString(JsonParser parser) { + List values = new ArrayList<>(); + parser.next(); + while (parser.hasNext()) { + Event event = parser.next(); + if (GET_STRING_EVENT_ENUM_SET.contains(event)) { + String strValue = Objects.toString(parser.getString(), "null"); + values.add(strValue); + } + } + + assertThat(values,TestData.FAMILY_MATCHER_WITH_NO_QUOTATION); + } + + @Test + void testParser_getValueStructure(){ + testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testParser_getValue); + } + + @Test + void testParser_getValueString(){ + testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::testParser_getValue); + } + + private void testParser_getValue(JsonParser parser) { + List values = new ArrayList<>(); + parser.next(); + while (parser.hasNext()) { + Event event = parser.next(); + if (!NOT_GET_VALUE_EVENT_ENUM_SET.contains(event)) { + String strValue = Objects.toString(parser.getValue(), "null"); + values.add(strValue); + } + } + + assertThat(values, TestData.FAMILY_MATCHER_KEYS_WITH_QUOTATION); + } + + @Test + void testSkipArrayStructure() { + testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::testSkipArray); + } + + @Test + void testSkipArrayString() { + testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_ARRAYS, this::testSkipArray); + } + + private void testSkipArray(JsonParser parser) { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + parser.skipArray(); + parser.next(); + String key = parser.getString(); + + assertEquals("secondElement", key); + } + + @Test + void testSkipObjectStructure() { + testWithCreateParserFromObject(TestData.createJsonObject(), this::testSkipObject); + } + + @Test + void testSkipObjectString() { + testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_OBJECTS, this::testSkipObject); + } + + private void testSkipObject(JsonParser parser) { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + parser.skipObject(); + parser.next(); + String key = parser.getString(); + + assertEquals("secondPerson", key); + } + + private void assertThrowsIllegalStateException(Executable executable) { + assertThrows(IllegalStateException.class, executable); + } + + @Test + void testErrorGetObjectStructure() { + assertThrowsIllegalStateException(() -> testWithCreateParserFromObject(TestData.createJsonObject(), JsonParser::getObject)); + } + + @Test + void testErrorGetObjectString() { + assertThrowsIllegalStateException(() -> testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_OBJECTS, JsonParser::getObject)); + } + + @Test + void testErrorGetArrayStructure() { + assertThrowsIllegalStateException(() -> testWithCreateParserFromObject(TestData.createJsonObject(), this::testErrorGetArray)); + } + + @Test + void testErrorGetArrayString() { + assertThrowsIllegalStateException(() -> testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_OBJECTS, this::testErrorGetArray)); + } + + private void testErrorGetArray(JsonParser parser) { + parser.next(); + parser.getArray(); + } + + @Test + void testErrorGetValueEndOfObjectStructure() { + assertThrowsIllegalStateException(() -> testWithCreateParserFromObject(TestData.createJsonObject(), this::testErrorGetValueEndOfObject)); + } + + @Test + void testErrorGetValueEndOfObjectString() { + assertThrowsIllegalStateException(() -> testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_OBJECTS, this::testErrorGetValueEndOfObject)); + } + + private void testErrorGetValueEndOfObject(JsonParser parser) { + parser.next(); + parser.skipObject(); + parser.getValue(); + } + + @Test + void testErrorGetValueEndOfArrayStructure() { + assertThrowsIllegalStateException(() -> testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::testErrorGetValueEndOfArray)); + } + + @Test + void testErrorGetValueEndOfArrayString() { + assertThrowsIllegalStateException(() -> testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_ARRAYS, this::testErrorGetValueEndOfArray)); + } + + private void testErrorGetValueEndOfArray(JsonParser parser) { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + parser.skipArray(); + parser.getValue(); + } + + @Test + void testBooleanNullandCurrentEventStructure() { + testWithCreateParserFromObject(Json.createObjectBuilder() + .add("true", true) + .add("false", false) + .addNull("null") + .build(), this::testBooleanNullandCurrentEvent); + } + + @Test + void testBooleanNullandCurrentEventString() { + testWithCreateParserFromString("{\"true\":true,\"false\":false,\"null\":null}", this::testBooleanNullandCurrentEvent); + } + + private void testBooleanNullandCurrentEvent(JsonParser parser) { + parser.next(); + parser.next(); + parser.getValue(); + parser.next(); + assertEquals(JsonValue.ValueType.TRUE, parser.getValue().getValueType()); + parser.next(); + parser.getValue(); + parser.next(); + assertEquals(JsonValue.ValueType.FALSE, parser.getValue().getValueType()); + parser.next(); + parser.getValue(); + parser.next(); + assertEquals(JsonValue.ValueType.NULL, parser.getValue().getValueType()); + assertEquals(Event.VALUE_NULL, parser.currentEvent()); + } + + @Test + void testBigLongAndDecimalsStructure() { + testWithCreateParserFromObject(Json.createObjectBuilder() + .add("long", 12345678901234567L) + .add("longer", 1234567890123456789L) + .build(), this::testBigLongAndDecimals); + } + + @Test + void testBigLongAndDecimalsString() { + testWithCreateParserFromString("{\"long\":12345678901234567,\"longer\":1234567890123456789}", this::testBigLongAndDecimals); + } + + private void testBigLongAndDecimals(JsonParser parser) { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + assertEquals("12345678901234567", parser.getValue().toString()); + parser.next(); + parser.getString(); + parser.next(); + assertEquals("1234567890123456789", parser.getValue().toString()); + } + + private void assertThrowsJsonParsingException(Executable executable) { + assertThrows(JsonParsingException.class, executable); + } + + @Test + void testWrongValueAndEndOfObjectInArray() {//509 ArrayContext.getNextEvent, no coma + assertThrowsJsonParsingException(() -> testWithCreateParserFromString("{\"a\":[5 }]}", parser -> { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + parser.getValue(); + })); + } + + @Test + void testWrongEndOfObjectInArray() {//518 ArrayContext.getNextEvent, at the end + assertThrowsJsonParsingException(() -> testWithCreateParserFromString("{\"a\":[}, 3]}", parser -> { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + parser.getValue(); + })); + } + + @Test + void testWrongKey() {//477 ObjectContext.getNextEvent, at the end + assertThrowsJsonParsingException(() -> testWithCreateParserFromString("{\"a\":1, 5}", parser -> { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + parser.getValue(); + parser.next(); + })); + } + + @Test + void testErrorInTheValue() {//470 ObjectContext.getNextEvent, no coma + assertThrowsJsonParsingException(() -> testWithCreateParserFromString("{\"a\":1:}", parser -> { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + parser.getValue(); + parser.next(); + })); + } + + @Test + void testNoValueAfterKey() {//452 ObjectContext.getNextEvent, no colon + assertThrowsJsonParsingException(() -> testWithCreateParserFromString("{\"a\"}", parser -> { + parser.next(); + parser.next(); + parser.getString(); + parser.next(); + })); + } + + @Test + void testNoJSONAtAll() {//382 NoneContext.getNextEvent, at the end + assertThrowsJsonParsingException(() -> testWithCreateParserFromString("", JsonParser::next)); + } + + @Test + void testWrongArrayEndWithComa() {//518 ArrayContext.getNextEvent, at the end + assertThrowsJsonParsingException(() -> testWithCreateParserFromString("[,", parser -> { + parser.next(); + parser.getArray(); + })); + } + } + + @Nested + class StreamTests { + @Test + void testGetValueStream_GetOneElement_Structure() { + testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testGetValueStream_GetOneElement); + } + + @Test + void testGetValueStream_GetOneElement_String() { + testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::testGetValueStream_GetOneElement); + } + + private void testGetValueStream_GetOneElement(JsonParser parser) { + JsonString name = (JsonString) parser.getValueStream() + .map(JsonValue::asJsonObject) + .map(JsonObject::values) + .findFirst() + .orElseThrow(() -> new NoSuchElementException("No value present")) + .stream() + .filter(e -> e.getValueType() == JsonValue.ValueType.STRING) + .findFirst() + .orElseThrow(() -> new RuntimeException("Name not found")); + + assertEquals("John", name.getString()); + } + + @Test + void testGetValueStream_GetListStructure() { + testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testGetValueStream_GetList); + } + + @Test + void testGetValueStream_GetListString() { + testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::testGetValueStream_GetList); + } + + private void testGetValueStream_GetList(JsonParser parser) { + List values = parser.getValueStream().map(value -> Objects.toString(value, "null")).collect(Collectors.toList()); + + assertThat(values, contains(TestData.JSON_FAMILY_STRING)); + } + + @Test + void testGetArrayStream_GetOneElementStructure() { + testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::testGetArrayStream_GetOneElement); + } + + @Test + void testGetArrayStream_GetOneElementString() { + testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_ARRAYS, this::testGetArrayStream_GetOneElement); + } + + private void testGetArrayStream_GetOneElement(JsonParser parser) { + parser.next(); + parser.next(); + String key = parser.getString(); + parser.next(); + JsonString element = (JsonString) parser.getArrayStream().filter(e -> e.getValueType() == JsonValue.ValueType.STRING) + .findFirst() + .orElseThrow(() -> new RuntimeException("Element not found")); + + assertEquals("first", element.getString()); + assertEquals("firstElement", key); + } + + @Test + void testGetArrayStream_GetListStructure() { + testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::testGetArrayStream_GetList); + } + + @Test + void testGetArrayStream_GetListString() { + testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_ARRAYS, this::testGetArrayStream_GetList); + } + + private void testGetArrayStream_GetList(JsonParser parser) { + parser.next(); + parser.next(); + String key = parser.getString(); + parser.next(); + List values = parser.getArrayStream().map(value -> Objects.toString(value, "null")).collect(Collectors.toList()); + + assertThat(values, TestData.ARRAY_STREAM_MATCHER); + assertEquals("firstElement", key); + } + + @Test + void testGetObjectStream_GetOneElementStructure() { + testWithCreateParserFromObject(TestData.createJsonObject(), this::testGetObjectStream_GetOneElement); + } + + @Test + void testGetObjectStream_GetOneElementString() { + testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_OBJECTS, this::testGetObjectStream_GetOneElement); + } + + private void testGetObjectStream_GetOneElement(JsonParser parser) { + parser.next(); + String surname = parser.getObjectStream().filter(e -> e.getKey().equals("firstPerson")) + .map(Map.Entry::getValue) + .map(JsonValue::asJsonObject) + .map(obj -> obj.getString("surname")) + .findFirst() + .orElseThrow(() -> new RuntimeException("Surname not found")); + + assertEquals("Smith", surname); + } + + @Test + void testGetObjectStream_GetListStructure() { + testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testGetObjectStream_GetList); + } + + @Test + void testGetObjectStream_GetListString() { + testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::testGetObjectStream_GetList); + } + + private void testGetObjectStream_GetList(JsonParser parser) { + parser.next(); + List values = parser.getObjectStream().collect(MAP_TO_LIST_COLLECTOR); + + assertThat(values, TestData.FAMILY_MATCHER_KEYS_WITHOUT_QUOTATION); + } + } + + @Nested + public class JSONPStandardParserTests { + @Test + void testStandardStructureParser_getValueStream() { + testWithCreateParserFromObject(TestData.createFamilyPerson(), this::test_getValueStream); + } + + @Test + void testStandardStringParser_getValueStream() { + testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::test_getValueStream); + } + + private void test_getValueStream(JsonParser parser) { + List values = parser.getValueStream().map(value -> Objects.toString(value, "null")).collect(Collectors.toList()); + + assertThat(values, contains(TestData.JSON_FAMILY_STRING)); + } + + @Test + void testStandardStructureParser_getArrayStream() { + testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::test_getArrayStream); + } + + @Test + void testStandardStringParser_getArrayStream() { + testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_ARRAYS, this::test_getArrayStream); + } + + private void test_getArrayStream(JsonParser parser) { + parser.next(); + parser.next(); + String key = parser.getString(); + parser.next(); + List values = parser.getArrayStream().map(value -> Objects.toString(value, "null")).collect(Collectors.toList()); + + assertThat(values, TestData.ARRAY_STREAM_MATCHER); + assertEquals("firstElement", key); + } + + @Test + void testStandardStructureParser_getObjectStream() { + testWithCreateParserFromObject(TestData.createFamilyPerson(), this::test_getObjectStream); + } + + @Test + void testStandardStringParser_getObjectStream() { + testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::test_getObjectStream); + } + + private void test_getObjectStream(JsonParser parser) { + parser.next(); + List values = parser.getObjectStream().collect(MAP_TO_LIST_COLLECTOR); + + assertThat(values, TestData.FAMILY_MATCHER_KEYS_WITHOUT_QUOTATION); + } + + @Test + void testStandardStructureParser_getValue() { + testWithCreateParserFromObject(TestData.createFamilyPerson(), this::test_getValue); + } + + @Test + void testStandardStringParser_getValue() { + testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::test_getValue); + } + + private void test_getValue(JsonParser parser) { + List values = new ArrayList<>(); + parser.next(); + while (parser.hasNext()) { + Event event = parser.next(); + if (!NOT_GET_VALUE_EVENT_ENUM_SET.contains(event)) { + String strValue = Objects.toString(parser.getValue(), "null"); + values.add(strValue); + } + } + + assertThat(values, TestData.FAMILY_MATCHER_KEYS_WITH_QUOTATION); + } + + @Test + void testStandardStructureParser_getString() { + testWithCreateParserFromObject(TestData.createFamilyPerson(), this::test_getString); + } + + @Test + void testStandardStringParser_getString() { + testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::test_getString); + } + + private void test_getString(JsonParser parser) { + List values = new ArrayList<>(); + parser.next(); + while (parser.hasNext()) { + Event event = parser.next(); + if (GET_STRING_EVENT_ENUM_SET.contains(event)) { + String strValue = Objects.toString(parser.getString(), "null"); + values.add(strValue); + } + } + + assertThat(values, TestData.FAMILY_MATCHER_WITH_NO_QUOTATION); + } + } + + private static class TestData { + private static final String JSON_OBJECT_WITH_OBJECTS = "{\"firstPerson\":{\"name\":\"John\", \"surname\":\"Smith\"}," + + "\"secondPerson\":{\"name\":\"Deborah\", \"surname\":\"Harris\"}}"; + + private static final String JSON_OBJECT_WITH_ARRAYS = "{\"firstElement\":[\"first\", \"second\"],\"secondElement\":[\"third\", \"fourth\"]}"; + + private static final String JSON_FAMILY_STRING = "{\"name\":\"John\",\"surname\":\"Smith\",\"age\":30,\"married\":true," + + "\"wife\":{\"name\":\"Deborah\",\"surname\":\"Harris\"},\"children\":[\"Jack\",\"Mike\"]}"; + + private static final Matcher> FAMILY_MATCHER_KEYS_WITHOUT_QUOTATION = + Matchers.contains("name", "\"John\"", "surname", "\"Smith\"", "age", "30", "married", "true", "wife", + "{\"name\":\"Deborah\",\"surname\":\"Harris\"}", "children", "[\"Jack\",\"Mike\"]"); + + private static final Matcher> FAMILY_MATCHER_KEYS_WITH_QUOTATION = + Matchers.contains("\"name\"", "\"John\"", "\"surname\"", "\"Smith\"", "\"age\"", "30", "\"married\"", "true", + "\"wife\"", "{\"name\":\"Deborah\",\"surname\":\"Harris\"}", "\"children\"", "[\"Jack\",\"Mike\"]"); + + private static final Matcher> FAMILY_MATCHER_WITH_NO_QUOTATION = + Matchers.contains("name", "John", "surname", "Smith", "age", "30", "married", + "wife", "name", "Deborah", "surname", "Harris", "children", "Jack", "Mike"); + + private static final Matcher> ARRAY_STREAM_MATCHER = Matchers.contains("\"first\"", "\"second\""); + + private static JsonObject createFamilyPerson() { + return Json.createObjectBuilder() + .add("name", "John") + .add("surname", "Smith") + .add("age", 30) + .add("married", true) + .add("wife", createPerson("Deborah", "Harris")) + .add("children", createArray("Jack", "Mike")) + .build(); + } + + private static JsonObject createObjectWithArrays() { + return Json.createObjectBuilder() + .add("firstElement", createArray("first", "second")) + .add("secondElement", createArray("third", "fourth")) + .build(); + } + + private static JsonArrayBuilder createArray(String firstElement, String secondElement) { + return Json.createArrayBuilder().add(firstElement).add(secondElement); + } + + private static JsonObject createJsonObject() { + return Json.createObjectBuilder() + .add("firstPerson", createPerson("John", "Smith")) + .add("secondPerson", createPerson("Deborah", "Harris")) + .build(); + } + + private static JsonObjectBuilder createPerson(String name, String surname) { + return Json.createObjectBuilder() + .add("name", name) + .add("surname", surname); + } + } } From 37637da94dc9a5fcb2cf6958d6fdecc6361bae73 Mon Sep 17 00:00:00 2001 From: Anton Pinsky Date: Sat, 25 Nov 2023 00:45:30 +0100 Subject: [PATCH 2/5] Deduplicate some code in both parsers Signed-off-by: Anton Pinsky --- .../org/eclipse/parsson/JsonParserImpl.java | 77 ++++++++----------- .../eclipse/parsson/JsonStructureParser.java | 50 ++++++------ 2 files changed, 55 insertions(+), 72 deletions(-) diff --git a/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java b/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java index 676746b3..374cc5ef 100644 --- a/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java +++ b/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java @@ -25,6 +25,7 @@ import java.util.Map; import java.util.NoSuchElementException; import java.util.Objects; +import java.util.function.Function; import java.util.stream.Stream; import jakarta.json.JsonArray; @@ -99,22 +100,22 @@ public String getString() { JsonMessages.PARSER_GETSTRING_ERR(currentEvent)); } - @Override - public boolean isIntegralNumber() { + private T getNumberValue(Function tokenizerFunction, Function exceptionMessageFunction) { if (currentEvent != Event.VALUE_NUMBER) { throw new IllegalStateException( - JsonMessages.PARSER_ISINTEGRALNUMBER_ERR(currentEvent)); + exceptionMessageFunction.apply(currentEvent)); } - return tokenizer.isIntegral(); + return tokenizerFunction.apply(tokenizer); + } + + @Override + public boolean isIntegralNumber() { + return getNumberValue(JsonTokenizer::isIntegral, JsonMessages::PARSER_ISINTEGRALNUMBER_ERR); } @Override public int getInt() { - if (currentEvent != Event.VALUE_NUMBER) { - throw new IllegalStateException( - JsonMessages.PARSER_GETINT_ERR(currentEvent)); - } - return tokenizer.getInt(); + return getNumberValue(JsonTokenizer::getInt, JsonMessages::PARSER_GETINT_ERR); } boolean isDefinitelyInt() { @@ -127,20 +128,12 @@ boolean isDefinitelyLong() { @Override public long getLong() { - if (currentEvent != Event.VALUE_NUMBER) { - throw new IllegalStateException( - JsonMessages.PARSER_GETLONG_ERR(currentEvent)); - } - return tokenizer.getLong(); + return getNumberValue(JsonTokenizer::getLong, JsonMessages::PARSER_GETLONG_ERR); } @Override public BigDecimal getBigDecimal() { - if (currentEvent != Event.VALUE_NUMBER) { - throw new IllegalStateException( - JsonMessages.PARSER_GETBIGDECIMAL_ERR(currentEvent)); - } - return tokenizer.getBigDecimal(); + return getNumberValue(JsonTokenizer::getBigDecimal, JsonMessages::PARSER_GETBIGDECIMAL_ERR); } @Override @@ -393,6 +386,8 @@ private abstract class SkippingContext extends Context { private final JsonToken openToken; private final JsonToken closeToken; + private boolean firstValue = true; + private SkippingContext(JsonToken openToken, JsonToken closeToken) { this.openToken = Objects.requireNonNull(openToken); this.closeToken = Objects.requireNonNull(closeToken); @@ -412,11 +407,21 @@ void skip() { } } while (!(token == closeToken && depth == 0)); } + + JsonToken firstValueOrJsonToken(JsonToken token) { + if (firstValue) { + firstValue = false; + } else { + if (token != COMMA) { + throw parsingException(token, "[COMMA]"); + } + token = tokenizer.nextToken(); + } + return token; + } } private final class ObjectContext extends SkippingContext { - private boolean firstValue = true; - private ObjectContext() { super(JsonToken.CURLYOPEN, JsonToken.CURLYCLOSE); } @@ -458,14 +463,8 @@ public Event getNextEvent() { currentContext = stack.pop(); return Event.END_OBJECT; } - if (firstValue) { - firstValue = false; - } else { - if (token != COMMA) { - throw parsingException(token, "[COMMA]"); - } - token = tokenizer.nextToken(); - } + + token = firstValueOrJsonToken(token); if (token == STRING) { return Event.KEY_NAME; } @@ -475,7 +474,6 @@ public Event getNextEvent() { } private final class ArrayContext extends SkippingContext { - private boolean firstValue = true; private ArrayContext() { super(JsonToken.SQUAREOPEN, JsonToken.SQUARECLOSE); @@ -486,25 +484,14 @@ private ArrayContext() { public Event getNextEvent() { JsonToken token = tokenizer.nextToken(); if (token == EOF) { - switch (currentEvent) { - case START_ARRAY: - throw parsingException(token, "[CURLYOPEN, SQUAREOPEN, STRING, NUMBER, TRUE, FALSE, NULL]"); - default: - throw parsingException(token, "[COMMA, CURLYCLOSE]"); - } - } + throw parsingException(token, (Objects.requireNonNull(currentEvent) == Event.START_ARRAY) ? + "[CURLYOPEN, SQUAREOPEN, STRING, NUMBER, TRUE, FALSE, NULL]" : "[COMMA, CURLYCLOSE]"); + } if (token == SQUARECLOSE) { currentContext = stack.pop(); return Event.END_ARRAY; } - if (firstValue) { - firstValue = false; - } else { - if (token != COMMA) { - throw parsingException(token, "[COMMA]"); - } - token = tokenizer.nextToken(); - } + token = firstValueOrJsonToken(token); Event event = nextEventIfValueOrObjectOrArrayStart(token); if (event != null) { diff --git a/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java b/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java index d16ef38d..eda31d24 100644 --- a/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java +++ b/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java @@ -25,6 +25,7 @@ import java.util.Iterator; import java.util.Map; import java.util.NoSuchElementException; +import java.util.function.Function; import java.util.stream.Stream; /** @@ -58,42 +59,37 @@ public String getString() { case VALUE_STRING: return ((JsonString)current.getJsonValue()).getString(); case VALUE_NUMBER: - return ((JsonNumber)current.getJsonValue()).toString(); + return current.getJsonValue().toString(); default: throw new IllegalStateException(JsonMessages.PARSER_GETSTRING_ERR(state)); } } - @Override - public boolean isIntegralNumber() { + private T getNumberValue(Function numberFunction, Function exceptionMessageFunction) { if (state == Event.VALUE_NUMBER) { - return ((JsonNumber)current.getJsonValue()).isIntegral(); + return numberFunction.apply((JsonNumber)current.getJsonValue()); } - throw new IllegalStateException(JsonMessages.PARSER_ISINTEGRALNUMBER_ERR(state)); + throw new IllegalStateException(exceptionMessageFunction.apply(state)); + } + + @Override + public boolean isIntegralNumber() { + return getNumberValue(JsonNumber::isIntegral, JsonMessages::PARSER_ISINTEGRALNUMBER_ERR); } @Override public int getInt() { - if (state == Event.VALUE_NUMBER) { - return ((JsonNumber)current.getJsonValue()).intValue(); - } - throw new IllegalStateException(JsonMessages.PARSER_GETINT_ERR(state)); + return getNumberValue(JsonNumber::intValue, JsonMessages::PARSER_GETINT_ERR); } @Override public long getLong() { - if (state == Event.VALUE_NUMBER) { - return ((JsonNumber)current.getJsonValue()).longValue(); - } - throw new IllegalStateException(JsonMessages.PARSER_GETLONG_ERR(state)); + return getNumberValue(JsonNumber::longValue, JsonMessages::PARSER_GETLONG_ERR); } @Override public BigDecimal getBigDecimal() { - if (state == Event.VALUE_NUMBER) { - return ((JsonNumber)current.getJsonValue()).bigDecimalValue(); - } - throw new IllegalStateException(JsonMessages.PARSER_GETBIGDECIMAL_ERR(state)); + return getNumberValue(JsonNumber::bigDecimalValue, JsonMessages::PARSER_GETBIGDECIMAL_ERR); } @Override @@ -174,22 +170,14 @@ private void transition() { if (current instanceof ArrayScope) { if (current.hasNext()) { current.next(); - state = getState(current.getJsonValue()); - if (state == Event.START_ARRAY || state == Event.START_OBJECT) { - scopeStack.push(current); - current = Scope.createScope(current.getJsonValue()); - } + nextStateAndEndOfTheObjectOrArray(); } else { state = Event.END_ARRAY; } } else { // ObjectScope if (state == Event.KEY_NAME) { - state = getState(current.getJsonValue()); - if (state == Event.START_ARRAY || state == Event.START_OBJECT) { - scopeStack.push(current); - current = Scope.createScope(current.getJsonValue()); - } + nextStateAndEndOfTheObjectOrArray(); } else { if (current.hasNext()) { current.next(); @@ -202,6 +190,14 @@ private void transition() { } } + private void nextStateAndEndOfTheObjectOrArray() { + state = getState(current.getJsonValue()); + if (state == Event.START_ARRAY || state == Event.START_OBJECT) { + scopeStack.push(current); + current = Scope.createScope(current.getJsonValue()); + } + } + @Override public void close() { // no-op From 5d2083a7a286d878923e4ba835aeaed2ba2204b7 Mon Sep 17 00:00:00 2001 From: Anton Pinsky Date: Sun, 26 Nov 2023 00:22:26 +0100 Subject: [PATCH 3/5] Small improvements in the tests Signed-off-by: Anton Pinsky --- .../eclipse/parsson/tests/JsonArrayTest.java | 10 +-- .../parsson/tests/JsonBuilderTest.java | 8 +-- .../parsson/tests/JsonDuplicateKeyTest.java | 11 ++-- .../parsson/tests/JsonGeneratorTest.java | 32 +++++----- .../parsson/tests/JsonMergePatchDiffTest.java | 4 +- .../parsson/tests/JsonMergePatchTest.java | 4 +- .../eclipse/parsson/tests/JsonNumberTest.java | 14 ++-- .../eclipse/parsson/tests/JsonObjectTest.java | 14 ++-- .../eclipse/parsson/tests/JsonParserTest.java | 64 +++++++++---------- .../parsson/tests/JsonPatchBugsTest.java | 4 +- .../parsson/tests/JsonPatchDiffTest.java | 1 + .../parsson/tests/JsonPatchOperationTest.java | 4 +- .../eclipse/parsson/tests/JsonPatchTest.java | 1 + .../tests/JsonPointerRemoveOperationTest.java | 2 +- .../parsson/tests/JsonPointerTest.java | 9 +-- .../eclipse/parsson/tests/JsonReaderTest.java | 52 +++++++-------- .../parsson/tests/JsonSamplesParsingTest.java | 19 ++---- .../eclipse/parsson/tests/JsonStringTest.java | 6 +- .../eclipse/parsson/tests/JsonValueTest.java | 61 +++++------------- .../eclipse/parsson/tests/JsonWriterTest.java | 6 +- 20 files changed, 144 insertions(+), 182 deletions(-) diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonArrayTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonArrayTest.java index 79efec4d..bab08019 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonArrayTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonArrayTest.java @@ -39,7 +39,7 @@ */ public class JsonArrayTest { @Test - void testArrayEquals() throws Exception { + void testArrayEquals() { JsonArray expected = Json.createArrayBuilder() .add(JsonValue.TRUE) .add(JsonValue.FALSE) @@ -96,7 +96,7 @@ void testArrayEqualsUsingCollection() { } @Test - void testStringValue() throws Exception { + void testStringValue() { JsonArray array = Json.createArrayBuilder() .add("John") .build(); @@ -104,7 +104,7 @@ void testStringValue() throws Exception { } @Test - void testIntValue() throws Exception { + void testIntValue() { JsonArray array = Json.createArrayBuilder() .add(20) .build(); @@ -134,7 +134,7 @@ void testRemove() { } @Test - void testNumberView() throws Exception { + void testNumberView() { JsonArray array = Json.createArrayBuilder().add(20).add(10).build(); List numberList = array.getValuesAs(JsonNumber.class); @@ -149,7 +149,7 @@ void testNumberView() throws Exception { @Test void testArrayBuilderNpe() { try { - JsonArray array = Json.createArrayBuilder().add((JsonValue)null).build(); + Json.createArrayBuilder().add((JsonValue)null).build(); fail("JsonArrayBuilder#add(null) should throw NullPointerException"); } catch(NullPointerException e) { // Expected diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderTest.java index 79a00b5f..3cbfad6b 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderTest.java @@ -39,7 +39,7 @@ public class JsonBuilderTest { @Test - void testEmptyObject() throws Exception { + void testEmptyObject() { JsonObject empty = Json.createObjectBuilder() .build(); @@ -47,7 +47,7 @@ void testEmptyObject() throws Exception { } @Test - void testEmptyArray() throws Exception { + void testEmptyArray() { JsonArray empty = Json.createArrayBuilder() .build(); @@ -55,13 +55,13 @@ void testEmptyArray() throws Exception { } @Test - void testObject() throws Exception { + void testObject() { JsonObject person = buildPerson(); JsonObjectTest.testPerson(person); } @Test - void testNumber() throws Exception { + void testNumber() { JsonObject person = buildPerson(); JsonNumber number = person.getJsonNumber("age"); assertEquals(25, number.intValueExact()); diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonDuplicateKeyTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonDuplicateKeyTest.java index 81765004..caa2ac41 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonDuplicateKeyTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonDuplicateKeyTest.java @@ -25,14 +25,13 @@ import jakarta.json.Json; import jakarta.json.JsonBuilderFactory; +import jakarta.json.JsonConfig; import jakarta.json.JsonObject; import jakarta.json.JsonObjectBuilder; import jakarta.json.JsonReader; import jakarta.json.JsonReaderFactory; import jakarta.json.stream.JsonParsingException; -import org.eclipse.parsson.api.JsonConfig; - import org.junit.jupiter.api.Test; @@ -48,7 +47,7 @@ void testJsonReaderDuplicateKey1() { @Test void testJsonReaderDuplicateKey2() { String json = "{\"a\":\"b\",\"a\":\"c\"}"; - JsonReaderFactory jsonReaderFactory = Json.createReaderFactory(Collections.singletonMap(JsonConfig.REJECT_DUPLICATE_KEYS, true)); + JsonReaderFactory jsonReaderFactory = Json.createReaderFactory(Collections.singletonMap(JsonConfig.KEY_STRATEGY, JsonConfig.KeyStrategy.NONE)); JsonReader jsonReader = jsonReaderFactory.createReader(new StringReader(json)); try { jsonReader.readObject(); @@ -69,8 +68,8 @@ void testJsonReaderDuplicateKey3() { @Test void testJsonReaderDuplicateKey4() { - String json = "{\"a\":\"b\",\"b\":{\"c\":\"d\",\"c\":\"e\"}}";; - JsonReaderFactory jsonReaderFactory = Json.createReaderFactory(Collections.singletonMap(JsonConfig.REJECT_DUPLICATE_KEYS, true)); + String json = "{\"a\":\"b\",\"b\":{\"c\":\"d\",\"c\":\"e\"}}"; + JsonReaderFactory jsonReaderFactory = Json.createReaderFactory(Collections.singletonMap(JsonConfig.KEY_STRATEGY, JsonConfig.KeyStrategy.NONE)); JsonReader jsonReader = jsonReaderFactory.createReader(new StringReader(json)); try { jsonReader.readObject(); @@ -90,7 +89,7 @@ void testJsonObjectBuilderDuplcateKey1() { @Test void testJsonObjectBuilderDuplcateKey2() { - JsonBuilderFactory jsonBuilderFactory = Json.createBuilderFactory(Collections.singletonMap(JsonConfig.REJECT_DUPLICATE_KEYS, true)); + JsonBuilderFactory jsonBuilderFactory = Json.createBuilderFactory(Collections.singletonMap(JsonConfig.KEY_STRATEGY, JsonConfig.KeyStrategy.NONE)); JsonObjectBuilder objectBuilder = jsonBuilderFactory.createObjectBuilder(); try { objectBuilder.add("a", "b").add("a", "c").build(); diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorTest.java index 16ddb0f1..8a34c409 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorTest.java @@ -81,7 +81,7 @@ void testObjectStream() throws Exception { in.close(); } - static void testObject(JsonGenerator generator) throws Exception { + static void testObject(JsonGenerator generator) { generator .writeStartObject() .write("firstName", "John") @@ -107,7 +107,7 @@ static void testObject(JsonGenerator generator) throws Exception { } @Test - void testArray() throws Exception { + void testArray() { Writer sw = new StringWriter(); JsonGenerator generator = Json.createGenerator(sw); generator @@ -185,7 +185,7 @@ void testEscapedString1() throws Exception { } @Test - void testGeneratorEquals() throws Exception { + void testGeneratorEquals() { StringWriter sw = new StringWriter(); JsonGenerator generator = Json.createGenerator(sw); generator.writeStartArray() @@ -283,7 +283,7 @@ void testPrettyObjectStream() throws Exception { } @Test - void testGenerationException1() throws Exception { + void testGenerationException1() { StringWriter writer = new StringWriter(); JsonGenerator generator = Json.createGenerator(writer); generator.writeStartObject(); @@ -296,7 +296,7 @@ void testGenerationException1() throws Exception { } @Test - void testGenerationException2() throws Exception { + void testGenerationException2() { StringWriter writer = new StringWriter(); JsonGenerator generator = Json.createGenerator(writer); generator.writeStartObject(); @@ -309,7 +309,7 @@ void testGenerationException2() throws Exception { } @Test - void testGenerationException3() throws Exception { + void testGenerationException3() { StringWriter writer = new StringWriter(); JsonGenerator generator = Json.createGenerator(writer); try { @@ -321,7 +321,7 @@ void testGenerationException3() throws Exception { } @Test - void testGenerationException4() throws Exception { + void testGenerationException4() { StringWriter writer = new StringWriter(); JsonGenerator generator = Json.createGenerator(writer); generator.writeStartArray(); @@ -334,7 +334,7 @@ void testGenerationException4() throws Exception { } @Test - void testGenerationException5() throws Exception { + void testGenerationException5() { StringWriter writer = new StringWriter(); JsonGenerator generator = Json.createGenerator(writer); generator.writeStartObject(); @@ -347,7 +347,7 @@ void testGenerationException5() throws Exception { } @Test - void testGenerationException6() throws Exception { + void testGenerationException6() { StringWriter writer = new StringWriter(); JsonGenerator generator = Json.createGenerator(writer); generator.writeStartObject().writeEnd(); @@ -360,7 +360,7 @@ void testGenerationException6() throws Exception { } @Test - void testGenerationException7() throws Exception { + void testGenerationException7() { StringWriter writer = new StringWriter(); JsonGenerator generator = Json.createGenerator(writer); generator.writeStartArray().writeEnd(); @@ -374,7 +374,7 @@ void testGenerationException7() throws Exception { @Test - void testGenerationException8() throws Exception { + void testGenerationException8() { StringWriter sWriter = new StringWriter(); JsonGenerator generator = Json.createGenerator(sWriter); generator.writeStartObject(); @@ -387,7 +387,7 @@ void testGenerationException8() throws Exception { } @Test - void testGenerationException9() throws Exception { + void testGenerationException9() { StringWriter sWriter = new StringWriter(); JsonGenerator generator = Json.createGenerator(sWriter); generator.writeStartObject(); @@ -400,7 +400,7 @@ void testGenerationException9() throws Exception { } @Test - void testGeneratorArrayDouble() throws Exception { + void testGeneratorArrayDouble() { StringWriter writer = new StringWriter(); JsonGenerator generator = Json.createGenerator(writer); generator.writeStartArray(); @@ -427,7 +427,7 @@ void testGeneratorArrayDouble() throws Exception { } @Test - void testGeneratorObjectDouble() throws Exception { + void testGeneratorObjectDouble() { StringWriter writer = new StringWriter(); JsonGenerator generator = Json.createGenerator(writer); generator.writeStartObject(); @@ -454,7 +454,7 @@ void testGeneratorObjectDouble() throws Exception { } @Test - void testIntGenerator() throws Exception { + void testIntGenerator() { Random r = new Random(System.currentTimeMillis()); JsonGeneratorFactory gf = Json.createGeneratorFactory(null); JsonReaderFactory rf = Json.createReaderFactory(null); @@ -476,7 +476,7 @@ void testIntGenerator() throws Exception { } @Test - void testGeneratorBuf() throws Exception { + void testGeneratorBuf() { JsonGeneratorFactory gf = Json.createGeneratorFactory(null); JsonReaderFactory rf = Json.createReaderFactory(null); JsonBuilderFactory bf = Json.createBuilderFactory(null); diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchDiffTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchDiffTest.java index 5177ea0b..a4bf5fee 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchDiffTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchDiffTest.java @@ -61,6 +61,7 @@ public static Iterable data() throws Exception { return examples; } + @SuppressWarnings("unchecked") private static Class createExceptionClass( JsonString exceptionClassName) throws ClassNotFoundException { if (exceptionClassName != null) { @@ -74,8 +75,7 @@ private static JsonArray loadData() { InputStream testData = JsonPatchTest.class .getResourceAsStream("/jsonmergepatchdiff.json"); JsonReader reader = Json.createReader(testData); - JsonArray data = (JsonArray) reader.read(); - return data; + return (JsonArray) reader.read(); } @MethodSource("data") diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchTest.java index fdd5622f..ab9ce696 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchTest.java @@ -61,6 +61,7 @@ public static Iterable data() throws Exception { return examples; } + @SuppressWarnings("unchecked") private static Class createExceptionClass( JsonString exceptionClassName) throws ClassNotFoundException { if (exceptionClassName != null) { @@ -74,8 +75,7 @@ private static JsonArray loadData() { InputStream testData = JsonPatchTest.class .getResourceAsStream("/jsonmergepatch.json"); JsonReader reader = Json.createReader(testData); - JsonArray data = (JsonArray) reader.read(); - return data; + return (JsonArray) reader.read(); } @MethodSource("data") diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonNumberTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonNumberTest.java index e1ff4581..2459a603 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonNumberTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonNumberTest.java @@ -72,7 +72,7 @@ public class JsonNumberTest { private static final int DEFAULT_MAX_BIGINTEGER_SCALE = 100000; @Test - void testFloating() throws Exception { + void testFloating() { JsonArray array1 = Json.createArrayBuilder().add(10.4).build(); JsonReader reader = Json.createReader(new StringReader("[10.4]")); JsonArray array2 = reader.readArray(); @@ -82,7 +82,7 @@ void testFloating() throws Exception { } @Test - void testBigDecimal() throws Exception { + void testBigDecimal() { JsonArray array1 = Json.createArrayBuilder().add(new BigDecimal("10.4")).build(); JsonReader reader = Json.createReader(new StringReader("[10.4]")); JsonArray array2 = reader.readArray(); @@ -92,14 +92,14 @@ void testBigDecimal() throws Exception { } @Test - void testIntNumberType() throws Exception { + void testIntNumberType() { JsonArray array1 = Json.createArrayBuilder() .add(Integer.MIN_VALUE) .add(Integer.MAX_VALUE) .add(Integer.MIN_VALUE + 1) .add(Integer.MAX_VALUE - 1) .add(12) - .add(12l) + .add(12L) .add(new BigInteger("0")) .build(); testNumberType(array1, true); @@ -128,7 +128,7 @@ private void testNumberType(JsonArray array, boolean integral) { } @Test - void testLongNumberType() throws Exception { + void testLongNumberType() { JsonArray array1 = Json.createArrayBuilder() .add(Long.MIN_VALUE) .add(Long.MAX_VALUE) @@ -180,7 +180,7 @@ void testLongNumberType() throws Exception { // } @Test - void testBigDecimalNumberType() throws Exception { + void testBigDecimalNumberType() { JsonArray array1 = Json.createArrayBuilder() .add(12d) .add(12.0d) @@ -206,7 +206,7 @@ void testBigDecimalNumberType() throws Exception { } @Test - void testMinMax() throws Exception { + void testMinMax() { JsonArray expected = Json.createArrayBuilder() .add(Integer.MIN_VALUE) .add(Integer.MAX_VALUE) diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonObjectTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonObjectTest.java index e2bd029d..32bfd341 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonObjectTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonObjectTest.java @@ -45,7 +45,7 @@ void test() { } @Test - void testEmptyObjectEquals() throws Exception { + void testEmptyObjectEquals() { JsonObject empty1 = Json.createObjectBuilder() .build(); @@ -56,7 +56,7 @@ void testEmptyObjectEquals() throws Exception { } @Test - void testPersonObjectEquals() throws Exception { + void testPersonObjectEquals() { JsonObject person1 = JsonBuilderTest.buildPerson(); JsonObject person2 = JsonReaderTest.readPerson(); @@ -64,7 +64,7 @@ void testPersonObjectEquals() throws Exception { } @Test - void testGetStringOrDefault() throws Exception { + void testGetStringOrDefault() { JsonObject object = Json.createObjectBuilder() .add("string", "value") .add("number", 25) @@ -76,7 +76,7 @@ void testGetStringOrDefault() throws Exception { } @Test - void testGetIntOrDefault() throws Exception { + void testGetIntOrDefault() { JsonObject object = Json.createObjectBuilder() .add("string", "value") .add("number", 25) @@ -88,7 +88,7 @@ void testGetIntOrDefault() throws Exception { } @Test - void testGetBooleanOrDefault() throws Exception { + void testGetBooleanOrDefault() { JsonObject object = Json.createObjectBuilder() .add("string", "value") .add("number", 25) @@ -227,7 +227,7 @@ void testObjectBuilderWithMap() { @Test void testObjectBuilderNpe() { try { - JsonObject obj = Json.createObjectBuilder().add(null, 1).build(); + Json.createObjectBuilder().add(null, 1).build(); fail("JsonObjectBuilder#add(null, 1) should throw NullPointerException"); } catch(NullPointerException e) { // Expected @@ -264,7 +264,7 @@ void testArrays() { m.put("floatArray", floatArr); JsonObject object = Json.createObjectBuilder(m).build(); assertEquals("b", object.get("stringArray").asJsonArray().getString(1)); - assertEquals(false, object.get("booleanArray").asJsonArray().getBoolean(1)); + assertFalse(object.get("booleanArray").asJsonArray().getBoolean(1)); assertEquals(2, object.get("intArray").asJsonArray().getInt(1)); assertEquals('b', object.get("charArray").asJsonArray().getInt(1)); assertEquals(2.0, object.get("floatArray").asJsonArray().getJsonNumber(1).doubleValue()); diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java index 4179893d..35dcf6d6 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java @@ -211,20 +211,20 @@ void testEmptyArrayStructureIterator() { } static void testEmptyArrayIterator(JsonParser parser) { - assertEquals(true, parser.hasNext()); - assertEquals(true, parser.hasNext()); + assertTrue(parser.hasNext()); + assertTrue(parser.hasNext()); assertEquals(Event.START_ARRAY, parser.next()); - assertEquals(true, parser.hasNext()); - assertEquals(true, parser.hasNext()); + assertTrue(parser.hasNext()); + assertTrue(parser.hasNext()); assertEquals(Event.END_ARRAY, parser.next()); - assertEquals(false, parser.hasNext()); - assertEquals(false, parser.hasNext()); + assertFalse(parser.hasNext()); + assertFalse(parser.hasNext()); try { parser.next(); fail("Should have thrown a NoSuchElementException"); - } catch (NoSuchElementException ne) { + } catch (NoSuchElementException ignored) { } } @@ -250,7 +250,7 @@ static void testEmptyArrayIterator2(JsonParser parser) { try { parser.next(); fail("Should have thrown a NoSuchElementException"); - } catch (NoSuchElementException ne) { + } catch (NoSuchElementException ignored) { } } @@ -272,11 +272,11 @@ void testEmptyArrayIterator3Structure() { static void testEmptyArrayIterator3(JsonParser parser) { assertEquals(Event.START_ARRAY, parser.next()); assertEquals(Event.END_ARRAY, parser.next()); - assertEquals(false, parser.hasNext()); + assertFalse(parser.hasNext()); try { parser.next(); fail("Should have thrown a NoSuchElementException"); - } catch (NoSuchElementException ne) { + } catch (NoSuchElementException ignored) { } } @@ -338,20 +338,20 @@ void testEmptyObjectIteratorStructure() { } static void testEmptyObjectIterator(JsonParser parser) { - assertEquals(true, parser.hasNext()); - assertEquals(true, parser.hasNext()); + assertTrue(parser.hasNext()); + assertTrue(parser.hasNext()); assertEquals(Event.START_OBJECT, parser.next()); - assertEquals(true, parser.hasNext()); - assertEquals(true, parser.hasNext()); + assertTrue(parser.hasNext()); + assertTrue(parser.hasNext()); assertEquals(Event.END_OBJECT, parser.next()); - assertEquals(false, parser.hasNext()); - assertEquals(false, parser.hasNext()); + assertFalse(parser.hasNext()); + assertFalse(parser.hasNext()); try { parser.next(); fail("Should have thrown a NoSuchElementException"); - } catch (NoSuchElementException ne) { + } catch (NoSuchElementException ignored) { } } @@ -377,7 +377,7 @@ static void testEmptyObjectIterator2(JsonParser parser) { try { parser.next(); fail("Should have thrown a NoSuchElementException"); - } catch (NoSuchElementException ne) { + } catch (NoSuchElementException ignored) { } } @@ -400,7 +400,7 @@ void testEmptyObjectIterator3Structure() { static void testEmptyObjectIterator3(JsonParser parser) { assertEquals(Event.START_OBJECT, parser.next()); assertEquals(Event.END_OBJECT, parser.next()); - assertEquals(false, parser.hasNext()); + assertFalse(parser.hasNext()); try { parser.next(); fail("Should have thrown a NoSuchElementException"); @@ -411,14 +411,14 @@ static void testEmptyObjectIterator3(JsonParser parser) { @Test - void testWikiIteratorReader() throws Exception { + void testWikiIteratorReader() { try (JsonParser parser = Json.createParser(wikiReader())) { testWikiIterator(parser); } } @Test - void testWikiIteratorStructure() throws Exception { + void testWikiIteratorStructure() { try (JsonParser parser = Json.createParserFactory(null).createParser( JsonBuilderTest.buildPerson())) { testWikiIterator(parser); @@ -426,21 +426,21 @@ void testWikiIteratorStructure() throws Exception { } @SuppressWarnings("UnusedDeclaration") - static void testWikiIterator(JsonParser parser) throws Exception { + static void testWikiIterator(JsonParser parser) { while (parser.hasNext()) { parser.next(); } } @Test - void testWikiInputStream() throws Exception { + void testWikiInputStream() { try (JsonParser parser = Json.createParser(wikiStream())) { testWiki(parser); } } @Test - void testWikiInputStreamUTF16LE() throws Exception { + void testWikiInputStreamUTF16LE() { ByteArrayInputStream bin = new ByteArrayInputStream(wikiString() .getBytes(StandardCharsets.UTF_16LE)); try (JsonParser parser = Json.createParser(bin)) { @@ -449,14 +449,14 @@ void testWikiInputStreamUTF16LE() throws Exception { } @Test - void testWikiReader() throws Exception { + void testWikiReader() { try (JsonParser parser = Json.createParser(wikiReader())) { testWiki(parser); } } @Test - void testWikiStructure() throws Exception { + void testWikiStructure() { try (JsonParser parser = Json.createParserFactory(null).createParser( JsonBuilderTest.buildPerson())) { testWiki(parser); @@ -562,19 +562,19 @@ static void testNestedArray(JsonParser parser) { assertEquals(Event.END_ARRAY, parser.next()); assertEquals(Event.END_ARRAY, parser.next()); assertEquals(Event.END_ARRAY, parser.next()); - assertEquals(false, parser.hasNext()); - assertEquals(false, parser.hasNext()); + assertFalse(parser.hasNext()); + assertFalse(parser.hasNext()); } @Test - void testExceptionsReader() throws Exception { + void testExceptionsReader() { try (JsonParser parser = Json.createParser(wikiReader())) { testExceptions(parser); } } @Test - void testExceptionsStructure() throws Exception { + void testExceptionsStructure() { try (JsonParser parser = Json.createParserFactory(null).createParser( JsonBuilderTest.buildPerson())) { testExceptions(parser); @@ -833,8 +833,8 @@ void testStringUsingBuffers() throws Throwable { parser.next(); assertEquals(name, parser.getString(), "value fails for buffer size=" + size + " name length=" + i); location = parser.getLocation(); - assertEquals(2 * name.length() + 6, location.getStreamOffset(), "Stream offset fails for buffer size=" + size + " name length=" + i); - assertEquals(2 * name.length() + 7, location.getColumnNumber(), "Column value fails for buffer size=" + size + " name length=" + i); + assertEquals(2L * name.length() + 6, location.getStreamOffset(), "Stream offset fails for buffer size=" + size + " name length=" + i); + assertEquals(2L * name.length() + 7, location.getColumnNumber(), "Column value fails for buffer size=" + size + " name length=" + i); assertEquals(1, location.getLineNumber(), "Line value fails for buffer size=" + size + " name length=" + i); } catch (Throwable e) { throw new Throwable("Failed for buffer size=" + size + " name length=" + i, e); diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchBugsTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchBugsTest.java index a1904940..8202967e 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchBugsTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchBugsTest.java @@ -48,7 +48,7 @@ void applyThrowsJsonException() { .replace("/0/name", "Bobek") .replace("/1/name", "Vila Amalka") .build(); - JsonArray result = patch.apply(array); + patch.apply(array); }); } @@ -78,7 +78,7 @@ void applyThrowsJsonException2() { // Applies the patch // It will throw a NullPointerException with no message - JsonStructure patched = patch.apply(target); + patch.apply(target); } }); } diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchDiffTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchDiffTest.java index 2b8ff623..e7581d48 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchDiffTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchDiffTest.java @@ -63,6 +63,7 @@ public static Iterable data() throws Exception { return examples; } + @SuppressWarnings("unchecked") private static Class createExceptionClass( JsonString exceptionClassName) throws ClassNotFoundException { if (exceptionClassName != null) { diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchOperationTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchOperationTest.java index 40d407a7..4a68eb2e 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchOperationTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchOperationTest.java @@ -44,8 +44,6 @@ void fromOperationName() { @Test void fromInvalidOperationName() { - assertThrows(JsonException.class, () -> { - Operation.fromOperationName("undef"); - }); + assertThrows(JsonException.class, () -> Operation.fromOperationName("undef")); } } diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchTest.java index f3fac7a2..f1ecf391 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchTest.java @@ -62,6 +62,7 @@ public static Iterable data() throws Exception { return examples; } + @SuppressWarnings("unchecked") private static Class createExceptionClass( JsonString exceptionClassName) throws ClassNotFoundException { if (exceptionClassName != null) { diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerRemoveOperationTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerRemoveOperationTest.java index 95759aea..d2c9660b 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerRemoveOperationTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerRemoveOperationTest.java @@ -49,7 +49,7 @@ public static Iterable data() throws Exception { @ParameterizedTest(name = "{index}: ({0})={1}") void shouldRemoveElementsToExistingJsonDocument(JsonObject pathOperation, JsonObject target, JsonValue expectedResult) { JsonPointer pointer = Json.createPointer(pathOperation.getString("path")); - JsonObject modified = (JsonObject) pointer.remove(target); + JsonObject modified = pointer.remove(target); assertThat(modified, is(expectedResult)); } diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerTest.java index 36bbcd3b..af45ca58 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerTest.java @@ -25,6 +25,7 @@ import java.io.InputStreamReader; import java.io.Reader; import java.util.Arrays; +import java.util.Objects; import jakarta.json.Json; import jakarta.json.JsonException; @@ -84,11 +85,11 @@ void shouldEvaluateJsonPointerExpressions(JsonPointer pointer, JsonValue expecte } } - static JsonObject readRfc6901Example() throws Exception { - Reader rfc6901Reader = new InputStreamReader(JsonReaderTest.class.getResourceAsStream("/rfc6901.json")); + static JsonObject readRfc6901Example() { + Reader rfc6901Reader = new InputStreamReader(Objects.requireNonNull(JsonReaderTest.class.getResourceAsStream("/rfc6901.json"))); JsonReader reader = Json.createReader(rfc6901Reader); - JsonValue value = reader.readObject(); + JsonObject value = reader.readObject(); reader.close(); - return (JsonObject) value; + return value; } } diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonReaderTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonReaderTest.java index f0d0863a..c24139eb 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonReaderTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonReaderTest.java @@ -25,6 +25,7 @@ import java.math.BigInteger; import java.util.HashMap; import java.util.Map; +import java.util.Objects; import jakarta.json.Json; import jakarta.json.JsonArray; @@ -33,7 +34,6 @@ import jakarta.json.JsonObject; import jakarta.json.JsonReader; import jakarta.json.JsonReaderFactory; -import jakarta.json.JsonValue; import org.eclipse.parsson.api.BufferPool; import org.eclipse.parsson.api.JsonConfig; @@ -47,13 +47,13 @@ public class JsonReaderTest { @Test - void testObject() throws Exception { + void testObject() { JsonObject person = readPerson(); JsonObjectTest.testPerson(person); } @Test - void testEscapedString() throws Exception { + void testEscapedString() { // u00ff is escaped once, not escaped once JsonReader reader = Json.createReader(new StringReader("[\"\\u0000\\u00ff\u00ff\"]")); JsonArray array = reader.readArray(); @@ -73,14 +73,11 @@ void testPrimitiveIntNumbers() { Long.toString(Integer.MIN_VALUE - 1L) }; for (String num : borderlineCases) { - JsonReader reader = Json.createReader(new StringReader("["+num+"]")); - try { - JsonArray array = reader.readArray(); - JsonNumber value = (JsonNumber) array.get(0); - assertEquals(new BigInteger(num).longValue(), value.longValue(), "Fails for num="+num); - } finally { - reader.close(); - } + try (JsonReader reader = Json.createReader(new StringReader("[" + num + "]"))) { + JsonArray array = reader.readArray(); + JsonNumber value = (JsonNumber) array.get(0); + assertEquals(new BigInteger(num).longValue(), value.longValue(), "Fails for num=" + num); + } } } @@ -95,31 +92,28 @@ void testPrimitiveLongNumbers() { new BigInteger(Long.toString(Long.MIN_VALUE)).subtract(BigInteger.ONE).toString() }; for (String num : borderlineCases) { - JsonReader reader = Json.createReader(new StringReader("["+num+"]")); - try { - JsonArray array = reader.readArray(); - JsonNumber value = (JsonNumber) array.get(0); - assertEquals(new BigInteger(num), value.bigIntegerValueExact(), "Fails for num="+num); - } finally { - reader.close(); - } + try (JsonReader reader = Json.createReader(new StringReader("[" + num + "]"))) { + JsonArray array = reader.readArray(); + JsonNumber value = (JsonNumber) array.get(0); + assertEquals(new BigInteger(num), value.bigIntegerValueExact(), "Fails for num=" + num); + } } } @Test - void testUnknownFeature() throws Exception { + void testUnknownFeature() { Map config = new HashMap<>(); config.put("foo", true); JsonReaderFactory factory = Json.createReaderFactory(config); factory.createReader(new StringReader("{}")); Map config1 = factory.getConfigInUse(); - if (config1.size() > 0) { + if (!config1.isEmpty()) { fail("Shouldn't have any config in use"); } } @Test - void testIllegalStateExcepton() throws Exception { + void testIllegalStateExcepton() { JsonReader reader = Json.createReader(new StringReader("{}")); reader.readObject(); try { @@ -148,12 +142,12 @@ void testIllegalStateExcepton() throws Exception { reader.close(); } - static JsonObject readPerson() throws Exception { - Reader wikiReader = new InputStreamReader(JsonReaderTest.class.getResourceAsStream("/wiki.json")); + static JsonObject readPerson() { + Reader wikiReader = new InputStreamReader(Objects.requireNonNull(JsonReaderTest.class.getResourceAsStream("/wiki.json"))); JsonReader reader = Json.createReader(wikiReader); - JsonValue value = reader.readObject(); + JsonObject value = reader.readObject(); reader.close(); - return (JsonObject) value; + return value; } // JSONP-23 cached empty string is not reset @@ -203,20 +197,20 @@ void testDuplicateKeysStrict() { try { reader.readObject(); fail("It is expected a JsonException"); - } catch (JsonException e) {} + } catch (JsonException ignored) {} } @Test void testDuplicateKeysStrictWithParssonConfig() { Map config = new HashMap<>(); - config.put(JsonConfig.REJECT_DUPLICATE_KEYS, "anything is valid here"); + config.put(jakarta.json.JsonConfig.KEY_STRATEGY, jakarta.json.JsonConfig.KeyStrategy.NONE); JsonReaderFactory factory = Json.createReaderFactory(config); String json = "{\"val1\":\"A\",\"val1\":\"B\"}"; JsonReader reader = factory.createReader(new StringReader(json)); try { reader.readObject(); fail("It is expected a JsonException"); - } catch (JsonException e) {} + } catch (JsonException ignored) {} } @Test diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonSamplesParsingTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonSamplesParsingTest.java index 126362fa..93866d4f 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonSamplesParsingTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonSamplesParsingTest.java @@ -19,6 +19,7 @@ import java.io.InputStreamReader; import java.io.Reader; import java.nio.charset.StandardCharsets; +import java.util.Objects; import jakarta.json.Json; import jakarta.json.JsonException; @@ -50,18 +51,12 @@ void testSampleFiles() { private void testSampleFile(String fileName) { Reader reader = new InputStreamReader( - JsonSamplesParsingTest.class.getResourceAsStream("/"+fileName), StandardCharsets.UTF_8); - JsonParser parser = null; - try { - parser = Json.createParser(reader); - while(parser.hasNext()) { - parser.next(); - } - } finally { - if (parser != null) { - parser.close(); - } - } + Objects.requireNonNull(JsonSamplesParsingTest.class.getResourceAsStream("/" + fileName)), StandardCharsets.UTF_8); + try (JsonParser parser = Json.createParser(reader)) { + while (parser.hasNext()) { + parser.next(); + } + } } } diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonStringTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonStringTest.java index 234cc442..5dfcf060 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonStringTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonStringTest.java @@ -35,7 +35,7 @@ public class JsonStringTest { // tests JsonString#toString() @Test - void testToString() throws Exception { + void testToString() { escapedString(""); escapedString("abc"); escapedString("abc\f"); @@ -52,7 +52,7 @@ void testToString() throws Exception { @Test void testHashCode() { - String string1 = new String("a"); + String string1 = "a"; JsonString jsonString1 = Json.createValue(string1); assertTrue(jsonString1.hashCode() == jsonString1.getString().hashCode()); @@ -63,7 +63,7 @@ void testHashCode() { assertTrue(jsonString1.hashCode() == jsonString2.hashCode()); } - void escapedString(String str) throws Exception { + void escapedString(String str) { JsonArray exp = Json.createArrayBuilder().add(str).build(); String parseStr = "["+exp.get(0).toString()+"]"; JsonReader jr = Json.createReader(new StringReader(parseStr)); diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonValueTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonValueTest.java index 944b7027..2410a02b 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonValueTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonValueTest.java @@ -40,58 +40,42 @@ public class JsonValueTest { @Test void arrayGetJsonObjectIdx() { - assertThrows(IndexOutOfBoundsException.class, () -> { - JsonValue.EMPTY_JSON_ARRAY.getJsonObject(0); - }); + assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getJsonObject(0)); } @Test void arrayGetJsonArrayIdx() { - assertThrows(IndexOutOfBoundsException.class, () -> { - JsonValue.EMPTY_JSON_ARRAY.getJsonArray(0); - }); + assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getJsonArray(0)); } @Test void arrayGetJsonNumberIdx() { - assertThrows(IndexOutOfBoundsException.class, () -> { - JsonValue.EMPTY_JSON_ARRAY.getJsonNumber(0); - }); + assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getJsonNumber(0)); } @Test void arrayGetJsonStringIdx() { - assertThrows(IndexOutOfBoundsException.class, () -> { - JsonValue.EMPTY_JSON_ARRAY.getJsonString(0); - }); + assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getJsonString(0)); } @Test void arrayGetStringIdx() { - assertThrows(IndexOutOfBoundsException.class, () -> { - JsonValue.EMPTY_JSON_ARRAY.getString(0); - }); + assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getString(0)); } @Test void arrayGetIntIdx() { - assertThrows(IndexOutOfBoundsException.class, () -> { - JsonValue.EMPTY_JSON_ARRAY.getInt(0); - }); + assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getInt(0)); } @Test void arrayGetBooleanIdx() { - assertThrows(IndexOutOfBoundsException.class, () -> { - JsonValue.EMPTY_JSON_ARRAY.getBoolean(0); - }); + assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getBoolean(0)); } @Test void arrayIsNull() { - assertThrows(IndexOutOfBoundsException.class, () -> { - JsonValue.EMPTY_JSON_ARRAY.isNull(0); - }); + assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.isNull(0)); } @Test @@ -99,44 +83,34 @@ void arrayMethods() { Assertions.assertEquals(JsonValue.ValueType.ARRAY, JsonValue.EMPTY_JSON_ARRAY.getValueType()); Assertions.assertEquals(Collections.emptyList(), JsonValue.EMPTY_JSON_ARRAY.getValuesAs(JsonObject.class)); Assertions.assertEquals(Collections.emptyList(), JsonValue.EMPTY_JSON_ARRAY.getValuesAs(JsonString::getString)); - Assertions.assertEquals(true, JsonValue.EMPTY_JSON_ARRAY.getBoolean(0, true)); + Assertions.assertTrue(JsonValue.EMPTY_JSON_ARRAY.getBoolean(0, true)); Assertions.assertEquals(42, JsonValue.EMPTY_JSON_ARRAY.getInt(0, 42)); Assertions.assertEquals("Sasek", JsonValue.EMPTY_JSON_ARRAY.getString(0, "Sasek")); } @Test void arrayIsImmutable() { - assertThrows(UnsupportedOperationException.class, () -> { - JsonValue.EMPTY_JSON_ARRAY.add(JsonValue.EMPTY_JSON_OBJECT); - }); + assertThrows(UnsupportedOperationException.class, () -> JsonValue.EMPTY_JSON_ARRAY.add(JsonValue.EMPTY_JSON_OBJECT)); } @Test void objectGetString() { - assertThrows(NullPointerException.class, () -> { - JsonValue.EMPTY_JSON_OBJECT.getString("normalni string"); - }); + assertThrows(NullPointerException.class, () -> JsonValue.EMPTY_JSON_OBJECT.getString("normalni string")); } @Test void objectGetInt() { - assertThrows(NullPointerException.class, () -> { - JsonValue.EMPTY_JSON_OBJECT.getInt("hledej cislo"); - }); + assertThrows(NullPointerException.class, () -> JsonValue.EMPTY_JSON_OBJECT.getInt("hledej cislo")); } @Test void objectGetBoolean() { - assertThrows(NullPointerException.class, () -> { - JsonValue.EMPTY_JSON_OBJECT.getBoolean("booo"); - }); + assertThrows(NullPointerException.class, () -> JsonValue.EMPTY_JSON_OBJECT.getBoolean("booo")); } @Test void objectIsNull() { - assertThrows(NullPointerException.class, () -> { - JsonValue.EMPTY_JSON_OBJECT.isNull("???"); - }); + assertThrows(NullPointerException.class, () -> JsonValue.EMPTY_JSON_OBJECT.isNull("???")); } @Test @@ -147,16 +121,14 @@ void objectMethods() { Assertions.assertNull(JsonValue.EMPTY_JSON_OBJECT.getJsonString("divnej string")); Assertions.assertEquals("ja jo", JsonValue.EMPTY_JSON_OBJECT.getString("nejsem tu", "ja jo")); - Assertions.assertEquals(false, JsonValue.EMPTY_JSON_OBJECT.getBoolean("najdes mne", false)); + Assertions.assertFalse(JsonValue.EMPTY_JSON_OBJECT.getBoolean("najdes mne", false)); Assertions.assertEquals(98, JsonValue.EMPTY_JSON_OBJECT.getInt("spatnej dotaz", 98)); } @Test void objectImmutable() { - assertThrows(UnsupportedOperationException.class, () -> { - JsonValue.EMPTY_JSON_OBJECT.put("klauni", JsonValue.EMPTY_JSON_ARRAY); - }); + assertThrows(UnsupportedOperationException.class, () -> JsonValue.EMPTY_JSON_OBJECT.put("klauni", JsonValue.EMPTY_JSON_ARRAY)); } @Test @@ -192,6 +164,7 @@ private byte[] serialize(Object o) { return baos.toByteArray(); } + @SuppressWarnings("unchecked") private T deserialize(Class type, byte[] data) { ByteArrayInputStream bais = new ByteArrayInputStream(data); try (ObjectInputStream ois = new ObjectInputStream(bais)) { diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonWriterTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonWriterTest.java index 01a1bd8b..3194c835 100644 --- a/impl/src/test/java/org/eclipse/parsson/tests/JsonWriterTest.java +++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonWriterTest.java @@ -158,7 +158,7 @@ void testFalseValue() throws Exception { } @Test - void testIllegalStateExcepton() throws Exception { + void testIllegalStateExcepton() { JsonObject obj = Json.createObjectBuilder().build(); JsonArray array = Json.createArrayBuilder().build(); @@ -200,7 +200,7 @@ void testNoCloseWriteObjectToStream() throws Exception { } @Test - void testNoCloseWriteObjectToWriter() throws Exception { + void testNoCloseWriteObjectToWriter() { StringWriter sw = new StringWriter(); JsonWriter writer = Json.createWriter(sw); writer.write(Json.createObjectBuilder().build()); @@ -218,7 +218,7 @@ void testNoCloseWriteArrayToStream() throws Exception { } @Test - void testNoCloseWriteArrayToWriter() throws Exception { + void testNoCloseWriteArrayToWriter() { StringWriter sw = new StringWriter(); JsonWriter writer = Json.createWriter(sw); writer.write(Json.createArrayBuilder().build()); From d5b4a4c5fbb645726ba7ee6c1263f38ec4f403d6 Mon Sep 17 00:00:00 2001 From: Lukas Jungmann Date: Mon, 26 Feb 2024 14:26:21 +0100 Subject: [PATCH 4/5] fix cp rights, access of JsonParserImpl, static imports removal Signed-off-by: Lukas Jungmann --- .../customprovider/test/TestProviderTest.java | 5 +- impl/pom.xml | 2 +- .../org/eclipse/parsson/JsonMessages.java | 2 +- .../org/eclipse/parsson/JsonParserImpl.java | 35 +- .../eclipse/parsson/JsonStructureParser.java | 2 +- .../org/eclipse/parsson/messages.properties | 3 +- .../eclipse/parsson/JsonParserFixture.java | 2 +- .../eclipse/parsson/tests/Issue25Test.java | 9 +- .../eclipse/parsson/tests/JsonArrayTest.java | 33 +- .../tests/JsonBigDecimalLengthLimitTest.java | 14 +- .../tests/JsonBigDecimalScaleLimitTest.java | 9 +- .../parsson/tests/JsonBuilderFactoryTest.java | 21 +- .../parsson/tests/JsonBuilderTest.java | 26 +- .../parsson/tests/JsonCollectorTest.java | 13 +- .../parsson/tests/JsonDuplicateKeyTest.java | 31 +- .../eclipse/parsson/tests/JsonFieldTest.java | 38 +- .../tests/JsonGeneratorFactoryTest.java | 7 +- .../parsson/tests/JsonGeneratorTest.java | 69 ++-- .../parsson/tests/JsonMergePatch2Test.java | 31 +- .../parsson/tests/JsonMergePatchDiffTest.java | 19 +- .../parsson/tests/JsonMergePatchTest.java | 19 +- .../parsson/tests/JsonNestingTest.java | 9 +- .../eclipse/parsson/tests/JsonNumberTest.java | 89 ++-- .../eclipse/parsson/tests/JsonObjectTest.java | 100 +++-- .../parsson/tests/JsonParserFactoryTest.java | 2 +- .../parsson/tests/JsonParserSkipTest.java | 115 +++--- .../eclipse/parsson/tests/JsonParserTest.java | 380 +++++++++--------- .../tests/JsonParsingExceptionTest.java | 14 +- .../parsson/tests/JsonPatchBugsTest.java | 9 +- .../parsson/tests/JsonPatchBuilderTest.java | 9 +- .../parsson/tests/JsonPatchDiffTest.java | 19 +- .../parsson/tests/JsonPatchOperationTest.java | 6 +- .../eclipse/parsson/tests/JsonPatchTest.java | 19 +- .../tests/JsonPointerAddOperationTest.java | 9 +- .../parsson/tests/JsonPointerEscapeTest.java | 13 +- .../tests/JsonPointerRemoveOperationTest.java | 9 +- .../JsonPointerReplaceOperationTest.java | 19 +- .../parsson/tests/JsonPointerTest.java | 19 +- .../tests/JsonPointerToStringTest.java | 10 +- .../eclipse/parsson/tests/JsonReaderTest.java | 54 ++- .../parsson/tests/JsonSamplesParsingTest.java | 2 +- .../eclipse/parsson/tests/JsonStringTest.java | 14 +- .../eclipse/parsson/tests/JsonValueTest.java | 32 +- .../eclipse/parsson/tests/JsonWriterTest.java | 40 +- .../eclipse/parsson/tests/RFC7159Test.java | 21 +- .../org/eclipse/parsson/tests/ToJsonTest.java | 13 +- .../parsson/tests/TwitterSearchTest.java | 2 +- pom.xml | 2 +- 48 files changed, 663 insertions(+), 757 deletions(-) diff --git a/demos/customprovider-jdk9/src/test/java/customprovider/test/TestProviderTest.java b/demos/customprovider-jdk9/src/test/java/customprovider/test/TestProviderTest.java index 32dff212..9ea7e613 100644 --- a/demos/customprovider-jdk9/src/test/java/customprovider/test/TestProviderTest.java +++ b/demos/customprovider-jdk9/src/test/java/customprovider/test/TestProviderTest.java @@ -10,12 +10,11 @@ package customprovider.test; -import static org.junit.jupiter.api.Assertions.assertInstanceOf; - import jakarta.json.Json; import jakarta.json.stream.JsonGenerator; import org.eclipse.parsson.demos.customprovider.TestGenerator; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -27,7 +26,7 @@ public class TestProviderTest { @Test void hello() { try (JsonGenerator generator = Json.createGenerator(System.out)) { - assertInstanceOf(TestGenerator.class, generator, "TestGenerator is not picked up"); + Assertions.assertInstanceOf(TestGenerator.class, generator, "TestGenerator is not picked up"); generator.writeStartArray().writeEnd(); } System.out.println(); diff --git a/impl/pom.xml b/impl/pom.xml index ddc698bd..110440e2 100644 --- a/impl/pom.xml +++ b/impl/pom.xml @@ -1,7 +1,7 @@