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 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2011, 2023 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2011, 2024 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
diff --git a/impl/src/main/java/org/eclipse/parsson/JsonMessages.java b/impl/src/main/java/org/eclipse/parsson/JsonMessages.java
index 09ab8cda..cd502536 100644
--- a/impl/src/main/java/org/eclipse/parsson/JsonMessages.java
+++ b/impl/src/main/java/org/eclipse/parsson/JsonMessages.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2024 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
diff --git a/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java b/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java
index b60c7fb8..454f7b31 100644
--- a/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java
+++ b/impl/src/main/java/org/eclipse/parsson/JsonParserImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -22,15 +22,11 @@
 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.function.Function;
 import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
 
 import jakarta.json.JsonArray;
 import jakarta.json.JsonArrayBuilder;
@@ -44,15 +40,6 @@
 
 import org.eclipse.parsson.JsonTokenizer.JsonToken;
 
-import static org.eclipse.parsson.JsonTokenizer.JsonToken.COLON;
-import static org.eclipse.parsson.JsonTokenizer.JsonToken.COMMA;
-import static org.eclipse.parsson.JsonTokenizer.JsonToken.CURLYCLOSE;
-import static org.eclipse.parsson.JsonTokenizer.JsonToken.CURLYOPEN;
-import static org.eclipse.parsson.JsonTokenizer.JsonToken.EOF;
-import static org.eclipse.parsson.JsonTokenizer.JsonToken.SQUARECLOSE;
-import static org.eclipse.parsson.JsonTokenizer.JsonToken.SQUAREOPEN;
-import static org.eclipse.parsson.JsonTokenizer.JsonToken.STRING;
-
 /**
  * JSON parser implementation. NoneContext, ArrayContext, ObjectContext is used
  * to go to next parser state.
@@ -71,20 +58,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);
@@ -100,22 +91,22 @@ public String getString() {
                 JsonMessages.PARSER_GETSTRING_ERR(currentEvent));
     }
 
-    @Override
-    public boolean isIntegralNumber() {
+    private <T> T getNumberValue(Function<JsonTokenizer, T> tokenizerFunction, Function<Event, String> 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() {
@@ -128,20 +119,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
@@ -194,103 +177,17 @@ public JsonValue getValue() {
 
     @Override
     public Stream<JsonValue> getArrayStream() {
-        if (currentEvent != Event.START_ARRAY) {
-            throw new IllegalStateException(
-                JsonMessages.PARSER_GETARRAY_ERR(currentEvent));
-        }
-        Spliterator<JsonValue> spliterator =
-                new Spliterators.AbstractSpliterator<JsonValue>(Long.MAX_VALUE, Spliterator.ORDERED) {
-                    @Override
-                    public Spliterator<JsonValue> trySplit() {
-                        return null;
-                    }
-
-                    @Override
-                    public boolean tryAdvance(Consumer<? super JsonValue> 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<Map.Entry<String, JsonValue>> getObjectStream() {
-        if (currentEvent != Event.START_OBJECT) {
-            throw new IllegalStateException(
-                JsonMessages.PARSER_GETOBJECT_ERR(currentEvent));
-        }
-        Spliterator<Map.Entry<String, JsonValue>> spliterator =
-                new Spliterators.AbstractSpliterator<Map.Entry<String, JsonValue>>(Long.MAX_VALUE, Spliterator.ORDERED) {
-                    @Override
-                    public Spliterator<Map.Entry<String, JsonValue>> trySplit() {
-                        return null;
-                    }
-
-                    @Override
-                    public boolean tryAdvance(Consumer<? super Map.Entry<String, JsonValue>> 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<JsonValue> getValueStream() {
-        if (! (currentContext instanceof NoneContext)) {
-            throw new IllegalStateException(
-                JsonMessages.PARSER_GETVALUESTREAM_ERR());
-        }
-        Spliterator<JsonValue> spliterator =
-                new Spliterators.AbstractSpliterator<JsonValue>(Long.MAX_VALUE, Spliterator.ORDERED) {
-                    @Override
-                    public Spliterator<JsonValue> trySplit() {
-                        return null;
-                    }
-
-                    @Override
-                    public boolean tryAdvance(Consumer<? super JsonValue> 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
@@ -319,7 +216,7 @@ private JsonArray getArray(JsonArrayBuilder builder) {
             }
             builder.add(getValue());
         }
-        throw parsingException(EOF, "[CURLYOPEN, SQUAREOPEN, STRING, NUMBER, TRUE, FALSE, NULL, SQUARECLOSE]");
+        throw parsingException(JsonToken.EOF, "[CURLYOPEN, SQUAREOPEN, STRING, NUMBER, TRUE, FALSE, NULL, SQUARECLOSE]");
     }
 
     private CharSequence getCharSequence() {
@@ -340,7 +237,7 @@ private JsonObject getObject(JsonObjectBuilder builder) {
             next();
             builder.add(key, getValue());
         }
-        throw parsingException(EOF, "[STRING, CURLYCLOSE]");
+        throw parsingException(JsonToken.EOF, "[STRING, CURLYCLOSE]");
     }
 
     @Override
@@ -356,7 +253,7 @@ public JsonLocation getLastCharLocation() {
     public boolean hasNext() {
         if (stack.isEmpty() && (currentEvent != null && currentEvent.compareTo(Event.KEY_NAME) > 0)) {
             JsonToken token = tokenizer.nextToken();
-            if (token != EOF) {
+            if (token != JsonToken.EOF) {
                 throw new JsonParsingException(JsonMessages.PARSER_EXPECTED_EOF(token),
                         getLastCharLocation());
             }
@@ -443,7 +340,7 @@ protected Event nextEventIfValueOrObjectOrArrayStart(JsonToken token) {
                 stack.push(currentContext);
                 currentContext = new ObjectContext();
                 return Event.START_OBJECT;
-            } else if (token == SQUAREOPEN) {
+            } else if (token == JsonToken.SQUAREOPEN) {
                 stack.push(currentContext);
                 currentContext = new ArrayContext();
                 return Event.START_ARRAY;
@@ -480,6 +377,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);
@@ -499,11 +398,21 @@ void skip() {
                 }
             } while (!(token == closeToken && depth == 0));
         }
+
+        JsonToken firstValueOrJsonToken(JsonToken token) {
+            if (firstValue) {
+                firstValue = false;
+            } else {
+                if (token != JsonToken.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);
         }
@@ -519,7 +428,7 @@ private ObjectContext() {
         public Event getNextEvent() {
             // Handle 1. }   2. name:value   3. ,name:value
             JsonToken token = tokenizer.nextToken();
-            if (token == EOF) {
+            if (token == JsonToken.EOF) {
                 switch (currentEvent) {
                     case START_OBJECT:
                         throw parsingException(token, "[STRING, CURLYCLOSE]");
@@ -530,7 +439,7 @@ public Event getNextEvent() {
                 }
             } else if (currentEvent == Event.KEY_NAME) {
                 // Handle 1. :value
-                if (token != COLON) {
+                if (token != JsonToken.COLON) {
                     throw parsingException(token, "[COLON]");
                 }
                 token = tokenizer.nextToken();
@@ -541,19 +450,13 @@ public Event getNextEvent() {
                 throw parsingException(token, "[CURLYOPEN, SQUAREOPEN, STRING, NUMBER, TRUE, FALSE, NULL]");
             } else {
                 // Handle 1. }   2. name   3. ,name
-                if (token == CURLYCLOSE) {
+                if (token == JsonToken.CURLYCLOSE) {
                     currentContext = stack.pop();
                     return Event.END_OBJECT;
                 }
-                if (firstValue) {
-                    firstValue = false;
-                } else {
-                    if (token != COMMA) {
-                        throw parsingException(token, "[COMMA]");
-                    }
-                    token = tokenizer.nextToken();
-                }
-                if (token == STRING) {
+
+                token = firstValueOrJsonToken(token);
+                if (token == JsonToken.STRING) {
                     return Event.KEY_NAME;
                 }
                 throw parsingException(token, "[STRING]");
@@ -562,7 +465,6 @@ public Event getNextEvent() {
     }
 
     private final class ArrayContext extends SkippingContext {
-        private boolean firstValue = true;
 
         private ArrayContext() {
             super(JsonToken.SQUAREOPEN, JsonToken.SQUARECLOSE);
@@ -572,26 +474,15 @@ private ArrayContext() {
         @Override
         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]");
-                }
-            }
-            if (token == SQUARECLOSE) {
+            if (token == JsonToken.EOF) {
+                throw parsingException(token, (Objects.requireNonNull(currentEvent) == Event.START_ARRAY) ?
+                        "[CURLYOPEN, SQUAREOPEN, STRING, NUMBER, TRUE, FALSE, NULL]" : "[COMMA, CURLYCLOSE]");
+			}
+            if (token == JsonToken.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/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<Event> currenEventSupplier;
+    private final Supplier<Boolean> canProduceValueStream;
+
+    JsonParserStreamCreator(JsonParser parser, boolean nextBeforeCreationOfValueStream, Supplier<Event> currenEventSupplier,
+            Supplier<Boolean> 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 <T>      type of the values which are delivered by the supplier and the stream
+     * @return stream of values from given supplier
+     */
+    private static <T> Stream<T> streamFromSupplier(Supplier<T> supplier) {
+        return StreamCreator.iterate(Objects.requireNonNull(supplier).get(), Objects::nonNull, value -> supplier.get());
+    }
+
+    public Stream<JsonValue> 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<Map.Entry<String, JsonValue>> 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<JsonValue> 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..d59d982a 100644
--- a/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java
+++ b/impl/src/main/java/org/eclipse/parsson/JsonStructureParser.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -25,6 +25,8 @@
 import java.util.Iterator;
 import java.util.Map;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Stream;
 
 /**
  * {@link JsonParser} implementation on top of JsonArray/JsonObject
@@ -33,9 +35,13 @@
  */
 class JsonStructureParser implements JsonParser {
 
-    private Scope current;
+    private Scope<?> current;
     private Event state;
-    private final Deque<Scope> scopeStack = new ArrayDeque<>();
+    private final Deque<Scope<?>> 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);
@@ -53,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> T getNumberValue(Function<JsonNumber, T> numberFunction, Function<Event, String> 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
@@ -96,6 +97,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());
@@ -120,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();
@@ -148,64 +190,50 @@ 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
     }
 
+    @Override
+    public Event currentEvent() {
+        return state;
+    }
+
+    @Override
+    public Stream<JsonValue> getArrayStream() {
+        return streamCreator.getArrayStream();
+    }
+
+    @Override
+    public Stream<Map.Entry<String, JsonValue>> getObjectStream() {
+        return streamCreator.getObjectStream();
+    }
+
+    @Override
+    public Stream<JsonValue> 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 +258,13 @@ private static Event getState(JsonValue value) {
         }
     }
 
-    private static abstract class Scope implements Iterator {
+    private static abstract class Scope<T> implements Iterator<T> {
+        @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 +274,7 @@ static Scope createScope(JsonValue value) {
         }
     }
 
-    private static class ArrayScope extends Scope {
+    private static class ArrayScope extends Scope<JsonValue> {
         private final Iterator<JsonValue> it;
         private JsonValue value;
 
@@ -262,11 +293,6 @@ public JsonValue next() {
             return value;
         }
 
-        @Override
-        public void remove() {
-            throw new UnsupportedOperationException();
-        }
-
         @Override
         JsonValue getJsonValue() {
             return value;
@@ -274,12 +300,14 @@ JsonValue getJsonValue() {
 
     }
 
-    private static class ObjectScope extends Scope {
+    private static class ObjectScope extends Scope<Map.Entry<String, JsonValue>> {
+        private final JsonObject object;
         private final Iterator<Map.Entry<String, JsonValue>> it;
         private JsonValue value;
         private String key;
 
         ObjectScope(JsonObject object) {
+            this.object = object;
             this.it = object.entrySet().iterator();
         }
 
@@ -296,14 +324,9 @@ public Map.Entry<String, JsonValue> 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<T> Stream<T> Stream#iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> 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.
+     *
+     * <p>{@code Stream.iterate} should produce the same sequence of elements as
+     * produced by the corresponding for-loop:
+     * <pre>{@code
+     *     for (T index=seed; hasNext.test(index); index = next.apply(index)) {
+     *         ...
+     *     }
+     * }</pre>
+     *
+     * <p>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.
+     *
+     * <p>The action of applying the {@code hasNext} predicate to an element
+     * <a href="../concurrent/package-summary.html#MemoryVisibility"><i>happens-before</i></a>
+     * the action of applying the {@code next} function to that element.  The
+     * action of applying the {@code next} function for one element
+     * <i>happens-before</i> 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 <T> 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<T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
+        Objects.requireNonNull(next);
+        Objects.requireNonNull(hasNext);
+        Spliterator<T> spliterator = new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE,
+                Spliterator.ORDERED | Spliterator.IMMUTABLE) {
+            T prev;
+            boolean started, finished;
+
+            @Override
+            public boolean tryAdvance(Consumer<? super T> 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<? super T> 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/main/resources/org/eclipse/parsson/messages.properties b/impl/src/main/resources/org/eclipse/parsson/messages.properties
index 6162b37b..3eb5250d 100644
--- a/impl/src/main/resources/org/eclipse/parsson/messages.properties
+++ b/impl/src/main/resources/org/eclipse/parsson/messages.properties
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2013, 2024 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
@@ -16,6 +16,7 @@
 
 
 
+
 internal.error=Internal Error
 
 parser.getString.err=JsonParser#getString() is valid only for KEY_NAME, VALUE_STRING, VALUE_NUMBER parser states. \
diff --git a/impl/src/test/java/org/eclipse/parsson/JsonParserFixture.java b/impl/src/test/java/org/eclipse/parsson/JsonParserFixture.java
index 3642ec38..07c4acd3 100644
--- a/impl/src/test/java/org/eclipse/parsson/JsonParserFixture.java
+++ b/impl/src/test/java/org/eclipse/parsson/JsonParserFixture.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2024 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
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/Issue25Test.java b/impl/src/test/java/org/eclipse/parsson/tests/Issue25Test.java
index 545d19ed..4325818c 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/Issue25Test.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/Issue25Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2024 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
@@ -16,13 +16,12 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 import java.io.ByteArrayInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import jakarta.json.JsonObject;
@@ -39,7 +38,7 @@ void doubleClose() throws IOException {
             try (InputStream in = new ByteArrayInputStream(content)) {
                 try (JsonParser parser = json.createParser(in)) {
                     JsonParser.Event firstEvent = parser.next();
-                    assertEquals(JsonParser.Event.START_ARRAY, firstEvent);
+                    Assertions.assertEquals(JsonParser.Event.START_ARRAY, firstEvent);
                     while (parser.hasNext()) {
                         JsonParser.Event event = parser.next();
                         if (event == JsonParser.Event.START_OBJECT) {
@@ -61,7 +60,7 @@ void doubleCloseWithMoreContent() throws IOException {
             try (InputStream in = new ByteArrayInputStream(content)) {
                 try (JsonParser parser = json.createParser(in)) {
                     JsonParser.Event firstEvent = parser.next();
-                    assertEquals(JsonParser.Event.START_ARRAY, firstEvent);
+                    Assertions.assertEquals(JsonParser.Event.START_ARRAY, firstEvent);
                     while (parser.hasNext()) {
                         JsonParser.Event event = parser.next();
                         if (event == JsonParser.Event.START_OBJECT) {
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..814bb805 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonArrayTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonArrayTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -16,10 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.StringReader;
 import java.io.StringWriter;
 import java.util.ArrayList;
@@ -32,6 +28,7 @@
 import jakarta.json.JsonValue;
 import jakarta.json.JsonWriter;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -39,7 +36,7 @@
  */
 public class JsonArrayTest {
     @Test
-    void testArrayEquals() throws Exception {
+    void testArrayEquals() {
         JsonArray expected = Json.createArrayBuilder()
                 .add(JsonValue.TRUE)
                 .add(JsonValue.FALSE)
@@ -63,7 +60,7 @@ void testArrayEquals() throws Exception {
         JsonArray actual = reader.readArray();
         reader.close();
 
-        assertEquals(expected, actual);
+        Assertions.assertEquals(expected, actual);
     }
 
     @Test
@@ -92,23 +89,23 @@ void testArrayEqualsUsingCollection() {
         JsonArray actual = reader.readArray();
         reader.close();
 
-        assertEquals(expected, actual);
+        Assertions.assertEquals(expected, actual);
     }
 
     @Test
-    void testStringValue() throws Exception {
+    void testStringValue() {
         JsonArray array = Json.createArrayBuilder()
                 .add("John")
                 .build();
-        assertEquals("John", array.getString(0));
+        Assertions.assertEquals("John", array.getString(0));
     }
 
     @Test
-    void testIntValue() throws Exception {
+    void testIntValue() {
         JsonArray array = Json.createArrayBuilder()
                 .add(20)
                 .build();
-        assertEquals(20, array.getInt(0));
+        Assertions.assertEquals(20, array.getInt(0));
     }
 
     @Test
@@ -116,7 +113,7 @@ void testAdd() {
         JsonArray array = Json.createArrayBuilder().build();
         try {
             array.add(JsonValue.FALSE);
-            fail("JsonArray#add() should throw UnsupportedOperationException");
+            Assertions.fail("JsonArray#add() should throw UnsupportedOperationException");
         } catch(UnsupportedOperationException e) {
             // Expected
         }
@@ -127,14 +124,14 @@ void testRemove() {
         JsonArray array = Json.createArrayBuilder().build();
         try {
             array.remove(0);
-            fail("JsonArray#remove() should throw UnsupportedOperationException");
+            Assertions.fail("JsonArray#remove() should throw UnsupportedOperationException");
         } catch(UnsupportedOperationException e) {
             // Expected
         }
     }
 
     @Test
-    void testNumberView() throws Exception {
+    void testNumberView() {
         JsonArray array = Json.createArrayBuilder().add(20).add(10).build();
 
         List<JsonNumber> numberList = array.getValuesAs(JsonNumber.class);
@@ -142,15 +139,15 @@ void testNumberView() throws Exception {
             num.intValue();
         }
 
-        assertEquals(20, array.getInt(0));
-        assertEquals(10, array.getInt(1));
+        Assertions.assertEquals(20, array.getInt(0));
+        Assertions.assertEquals(10, array.getInt(1));
     }
 
     @Test
     void testArrayBuilderNpe() {
         try {
-            JsonArray array = Json.createArrayBuilder().add((JsonValue)null).build();
-            fail("JsonArrayBuilder#add(null) should throw NullPointerException");
+            Json.createArrayBuilder().add((JsonValue)null).build();
+            Assertions.fail("JsonArrayBuilder#add(null) should throw NullPointerException");
         } catch(NullPointerException e) {
             // Expected
         }
@@ -159,16 +156,16 @@ void testArrayBuilderNpe() {
     @Test
     void testHashCode() {
         JsonArray array1 = Json.createArrayBuilder().add(1).add(2).add(3).build();
-        assertTrue(array1.hashCode() == array1.hashCode()); //1st call compute hashCode, 2nd call returns cached value
+        Assertions.assertTrue(array1.hashCode() == array1.hashCode()); //1st call compute hashCode, 2nd call returns cached value
 
         JsonArray array2 = Json.createArrayBuilder().add(1).add(2).add(3).build();
-        assertTrue(array1.hashCode() == array2.hashCode());
+        Assertions.assertTrue(array1.hashCode() == array2.hashCode());
 
         JsonArray array3 = Json.createArrayBuilder().build(); //org.eclipse.parsson.JsonArrayBuilderImpl.JsonArrayImpl
         JsonArray array4 = JsonValue.EMPTY_JSON_ARRAY; //jakarta.json.EmptyArray
 
-        assertTrue(array3.equals(array4));
-        assertTrue(array3.hashCode() == array4.hashCode()); //equal instances have same hashCode
+        Assertions.assertTrue(array3.equals(array4));
+        Assertions.assertTrue(array3.hashCode() == array4.hashCode()); //equal instances have same hashCode
     }
 
 }
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonBigDecimalLengthLimitTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonBigDecimalLengthLimitTest.java
index 9490d291..89c6a9fd 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonBigDecimalLengthLimitTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonBigDecimalLengthLimitTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2024 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
@@ -16,9 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.StringReader;
 import java.math.BigDecimal;
 
@@ -29,6 +26,7 @@
 
 import org.eclipse.parsson.api.JsonConfig;
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -54,8 +52,8 @@ void testLargeBigDecimalBellowLimit() {
         JsonReader reader = Json.createReader(new StringReader(JsonNumberTest.Π_500));
         JsonNumber check = Json.createValue(new BigDecimal(JsonNumberTest.Π_500));
         JsonValue value = reader.readValue();
-        assertEquals(value.getValueType(), JsonValue.ValueType.NUMBER);
-        assertEquals(value, check);
+        Assertions.assertEquals(value.getValueType(), JsonValue.ValueType.NUMBER);
+        Assertions.assertEquals(value, check);
     }
 
     // Test BigDecimal max source characters array length using length above system property limit of 500.
@@ -65,10 +63,10 @@ void testLargeBigDecimalAboveLimit() {
         JsonReader reader = Json.createReader(new StringReader(JsonNumberTest.Π_501));
         try {
             reader.readValue();
-            fail("No exception was thrown from BigDecimal parsing with source characters array length over limit");
+            Assertions.fail("No exception was thrown from BigDecimal parsing with source characters array length over limit");
         } catch (UnsupportedOperationException e) {
             // UnsupportedOperationException is expected to be thrown
-            assertEquals(
+            Assertions.assertEquals(
                     "Number of BigDecimal source characters 501 exceeded maximal allowed value of 500",
                     e.getMessage());
         }
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonBigDecimalScaleLimitTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonBigDecimalScaleLimitTest.java
index 8de53fdd..eba2666f 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonBigDecimalScaleLimitTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonBigDecimalScaleLimitTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2024 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
@@ -16,8 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 
@@ -26,6 +24,7 @@
 import org.eclipse.parsson.api.JsonConfig;
 
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -65,7 +64,7 @@ void testSystemPropertyBigIntegerScaleAboveLimit() {
                 .setScale(50001, RoundingMode.HALF_UP);
         try {
             Json.createValue(value).bigIntegerValue();
-            fail("No exception was thrown from bigIntegerValue with scale over limit");
+            Assertions.fail("No exception was thrown from bigIntegerValue with scale over limit");
         } catch (UnsupportedOperationException e) {
             // UnsupportedOperationException is expected to be thrown
             JsonNumberTest.assertExceptionMessageContainsNumber(e, 50001);
@@ -84,7 +83,7 @@ void testSystemPropertyBigIntegerNegScaleAboveLimit() {
                 .setScale(-50001, RoundingMode.HALF_UP);
         try {
             Json.createValue(value).bigIntegerValue();
-            fail("No exception was thrown from bigIntegerValue with scale over limit");
+            Assertions.fail("No exception was thrown from bigIntegerValue with scale over limit");
         } catch (UnsupportedOperationException e) {
             // UnsupportedOperationException is expected to be thrown
             JsonNumberTest.assertExceptionMessageContainsNumber(e, -50001);
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderFactoryTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderFactoryTest.java
index 55d4d6eb..512cd226 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderFactoryTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderFactoryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2024 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
@@ -16,10 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
 import java.util.Map;
 
 import jakarta.json.Json;
@@ -28,6 +24,7 @@
 import jakarta.json.JsonObject;
 import jakarta.json.JsonObjectBuilder;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -39,12 +36,12 @@ public class JsonBuilderFactoryTest {
     @Test
     void testArrayBuilder() {
         JsonBuilderFactory builderFactory = Json.createBuilderFactory(null);
-        assertNotNull(builderFactory.createArrayBuilder());
+        Assertions.assertNotNull(builderFactory.createArrayBuilder());
     }
 
     @Test
     void testArrayBuilderNPE() {
-        assertThrows(NullPointerException.class, () -> {
+        Assertions.assertThrows(NullPointerException.class, () -> {
             JsonBuilderFactory builderFactory = Json.createBuilderFactory(null);
             builderFactory.createArrayBuilder(null);
         });
@@ -54,18 +51,18 @@ void testArrayBuilderNPE() {
     void testArrayBuilderFromArray() {
         JsonBuilderFactory builderFactory = Json.createBuilderFactory(null);
         JsonArrayBuilder builder = builderFactory.createArrayBuilder(JsonBuilderTest.buildPhone());
-        assertEquals(JsonBuilderTest.buildPhone(), builder.build());
+        Assertions.assertEquals(JsonBuilderTest.buildPhone(), builder.build());
     }
 
     @Test
     void testObjectBuilder() {
         JsonBuilderFactory builderFactory = Json.createBuilderFactory(null);
-        assertNotNull(builderFactory.createObjectBuilder());
+        Assertions.assertNotNull(builderFactory.createObjectBuilder());
     }
 
     @Test
     void testObjectBuilderNPE() {
-        assertThrows(NullPointerException.class, () -> {
+        Assertions.assertThrows(NullPointerException.class, () -> {
             JsonBuilderFactory builderFactory = Json.createBuilderFactory(null);
             builderFactory.createObjectBuilder((JsonObject) null);
         });
@@ -73,7 +70,7 @@ void testObjectBuilderNPE() {
 
     @Test
     void testObjectBuilderNPE_map() {
-        assertThrows(NullPointerException.class, () -> {
+        Assertions.assertThrows(NullPointerException.class, () -> {
             JsonBuilderFactory builderFactory = Json.createBuilderFactory(null);
             builderFactory.createObjectBuilder((Map<String, Object>) null);
         });
@@ -83,6 +80,6 @@ void testObjectBuilderNPE_map() {
     void testObjectBuilderFromObject() {
         JsonBuilderFactory builderFactory = Json.createBuilderFactory(null);
         JsonObjectBuilder builder = builderFactory.createObjectBuilder(JsonBuilderTest.buildPerson());
-        assertEquals(JsonBuilderTest.buildPerson(), builder.build());
+        Assertions.assertEquals(JsonBuilderTest.buildPerson(), builder.build());
     }
 }
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..c9bd7bc0 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonBuilderTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -16,9 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -31,6 +28,7 @@
 import jakarta.json.JsonObject;
 import jakarta.json.JsonObjectBuilder;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -39,7 +37,7 @@
 public class JsonBuilderTest {
     
     @Test
-    void testEmptyObject() throws Exception {
+    void testEmptyObject() {
         JsonObject empty = Json.createObjectBuilder()
                 .build();
 
@@ -47,26 +45,26 @@ void testEmptyObject() throws Exception {
     }
 
     @Test
-    void testEmptyArray() throws Exception {
+    void testEmptyArray() {
         JsonArray empty = Json.createArrayBuilder()
                 .build();
 
-        assertTrue(empty.isEmpty());
+        Assertions.assertTrue(empty.isEmpty());
     }
 
     @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());
-        assertEquals(25, number.intValue());
-        assertTrue(number.isIntegral());
+        Assertions.assertEquals(25, number.intValueExact());
+        Assertions.assertEquals(25, number.intValue());
+        Assertions.assertTrue(number.isIntegral());
         JsonObjectTest.testPerson(person);
     }
 
@@ -77,9 +75,9 @@ void testJsonObjectCopy() {
         final JsonObject copyPerson = objectBuilder.build();
 
         JsonNumber number = copyPerson.getJsonNumber("age");
-        assertEquals(25, number.intValueExact());
-        assertEquals(25, number.intValue());
-        assertTrue(number.isIntegral());
+        Assertions.assertEquals(25, number.intValueExact());
+        Assertions.assertEquals(25, number.intValue());
+        Assertions.assertTrue(number.isIntegral());
         JsonObjectTest.testPerson(copyPerson);
 
     }
@@ -91,9 +89,9 @@ void testJsonObjectMap() {
         final JsonObject copyPerson = objectBuilder.build();
 
         JsonNumber number = copyPerson.getJsonNumber("age");
-        assertEquals(25, number.intValueExact());
-        assertEquals(25, number.intValue());
-        assertTrue(number.isIntegral());
+        Assertions.assertEquals(25, number.intValueExact());
+        Assertions.assertEquals(25, number.intValue());
+        Assertions.assertTrue(number.isIntegral());
         JsonObjectTest.testPerson(copyPerson);
     }
 
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonCollectorTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonCollectorTest.java
index f4406ffc..346815ba 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonCollectorTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonCollectorTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,8 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 import jakarta.json.Json;
 import jakarta.json.JsonArray;
 import jakarta.json.JsonObject;
@@ -26,6 +24,7 @@
 import jakarta.json.stream.JsonCollectors;
 
 import org.eclipse.parsson.TestUtils;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
@@ -71,7 +70,7 @@ void testToJsonArray() {
                    .map(x-> x.get("name"))
                    .collect(JsonCollectors.toJsonArray());
         JsonValue expected = TestUtils.toJson("['Jane','Joanna']");
-        assertEquals(expected, result);
+        Assertions.assertEquals(expected, result);
     }
 
     @Test
@@ -88,7 +87,7 @@ void testToJsonObject() {
                     ;
         JsonValue expected = TestUtils.toJson(
                 "{'Jane': '707-999-5555', 'Joanna': '505-333-4444'}");
-        assertEquals(expected, result);
+        Assertions.assertEquals(expected, result);
     }
 
     @Test
@@ -123,7 +122,7 @@ void testGroupBy() {
         "  ]                                 " +
         "}");
 
-        assertEquals(result,expected);
+        Assertions.assertEquals(result,expected);
     }
 
     static int index; //for keeping track of the array index
@@ -161,6 +160,6 @@ void testQueryAndPatch() {
         "       'mobile': '505-333-4444'}} " +
         " ]");
  
-        assertEquals(expected, result);
+        Assertions.assertEquals(expected, result);
     }
 }
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..10ff23d7 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonDuplicateKeyTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonDuplicateKeyTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2024 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
@@ -16,23 +16,19 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.StringReader;
 import java.util.Collections;
 
 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.Assertions;
 import org.junit.jupiter.api.Test;
 
 
@@ -42,20 +38,20 @@ void testJsonReaderDuplicateKey1() {
         String json = "{\"a\":\"b\",\"a\":\"c\"}";
         JsonReader jsonReader = Json.createReader(new StringReader(json));
         JsonObject jsonObject = jsonReader.readObject();
-        assertEquals(jsonObject.getString("a"), "c");
+        Assertions.assertEquals(jsonObject.getString("a"), "c");
     }
 
     @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();
-            fail();
+            Assertions.fail();
         } catch (Exception e) {
-            assertTrue(e instanceof JsonParsingException);
-            assertEquals("Duplicate key 'a' is not allowed", e.getMessage());
+            Assertions.assertTrue(e instanceof JsonParsingException);
+            Assertions.assertEquals("Duplicate key 'a' is not allowed", e.getMessage());
         }
     }
 
@@ -64,20 +60,20 @@ void testJsonReaderDuplicateKey3() {
         String json = "{\"a\":\"b\",\"b\":{\"c\":\"d\",\"c\":\"e\"}}";
         JsonReader jsonReader = Json.createReader(new StringReader(json));
         JsonObject jsonObject = jsonReader.readObject();
-        assertEquals(jsonObject.getJsonObject("b").getString("c"), "e");
+        Assertions.assertEquals(jsonObject.getJsonObject("b").getString("c"), "e");
     }
 
     @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();
-            fail();
+            Assertions.fail();
         } catch (Exception e) {
-            assertTrue(e instanceof JsonParsingException);
-            assertEquals("Duplicate key 'c' is not allowed", e.getMessage());
+            Assertions.assertTrue(e instanceof JsonParsingException);
+            Assertions.assertEquals("Duplicate key 'c' is not allowed", e.getMessage());
         }
     }
 
@@ -85,19 +81,19 @@ void testJsonReaderDuplicateKey4() {
     void testJsonObjectBuilderDuplcateKey1() {
         JsonObjectBuilder objectBuilder = Json.createObjectBuilder();
         JsonObject jsonObject = objectBuilder.add("a", "b").add("a", "c").build();
-        assertEquals(jsonObject.getString("a"), "c");
+        Assertions.assertEquals(jsonObject.getString("a"), "c");
     }
 
     @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();
-            fail();
+            Assertions.fail();
         } catch (Exception e) {
-            assertTrue(e instanceof IllegalStateException);
-            assertEquals("Duplicate key 'a' is not allowed", e.getMessage());
+            Assertions.assertTrue(e instanceof IllegalStateException);
+            Assertions.assertEquals("Duplicate key 'a' is not allowed", e.getMessage());
         }
     }
 }
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonFieldTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonFieldTest.java
index 827b8ccf..1f43218c 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonFieldTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonFieldTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2024 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
@@ -16,9 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.StringWriter;
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -29,6 +26,7 @@
 import jakarta.json.stream.JsonGenerationException;
 import jakarta.json.stream.JsonGenerator;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 
@@ -50,7 +48,7 @@ void testFieldAsOnlyMember() {
         generator.writeEnd();
 
         generator.close();
-        assertEquals("{\"fName\":\"fValue\"}", sw.toString());
+        Assertions.assertEquals("{\"fName\":\"fValue\"}", sw.toString());
     }
 
     @Test
@@ -65,7 +63,7 @@ void testFieldAsFirstMember() {
         generator.writeEnd();
 
         generator.close();
-        assertEquals("{\"f1Name\":\"f1Value\",\"f2Name\":\"f2Value\"}", sw.toString());
+        Assertions.assertEquals("{\"f1Name\":\"f1Value\",\"f2Name\":\"f2Value\"}", sw.toString());
     }
 
     @Test
@@ -80,7 +78,7 @@ void testFieldAsLastMember() {
         generator.writeEnd();
 
         generator.close();
-        assertEquals("{\"f1Name\":\"f1Value\",\"f2Name\":\"f2Value\"}", sw.toString());
+        Assertions.assertEquals("{\"f1Name\":\"f1Value\",\"f2Name\":\"f2Value\"}", sw.toString());
     }
 
 
@@ -98,7 +96,7 @@ void testFieldObject() {
         generator.writeEnd();
 
         generator.close();
-        assertEquals("{\"f1Name\":{\"innerFieldName\":\"innerFieldValue\"},\"f2Name\":\"f2Value\"}", sw.toString());
+        Assertions.assertEquals("{\"f1Name\":{\"innerFieldName\":\"innerFieldValue\"},\"f2Name\":\"f2Value\"}", sw.toString());
     }
 
     @Test
@@ -115,7 +113,7 @@ void testFieldArray() {
         generator.writeEnd();
 
         generator.close();
-        assertEquals("{\"f1Name\":[\"arrayValue\"],\"f2Name\":\"f2Value\"}", sw.toString());
+        Assertions.assertEquals("{\"f1Name\":[\"arrayValue\"],\"f2Name\":\"f2Value\"}", sw.toString());
     }
 
     @Test
@@ -128,7 +126,7 @@ void testFailFieldInField() {
 
         try {
             generator.write("f2Name", "f2Value");
-            fail("Field value, start object/array expected");
+            Assertions.fail("Field value, start object/array expected");
         } catch (JsonGenerationException exception) {
             //ok
         }
@@ -144,7 +142,7 @@ void testFailFieldKeyInArray() {
 
         try {
             generator.writeKey("f1Value");
-            fail("Not allowed in array .");
+            Assertions.fail("Not allowed in array .");
         } catch (JsonGenerationException exception) {
             //ok
         }
@@ -152,42 +150,42 @@ void testFailFieldKeyInArray() {
 
     @Test
     void testWriteString() {
-        assertEquals("{\"f1Name\":\"f1Value\"}", writeValue((gen)->gen.write("f1Value")));
+        Assertions.assertEquals("{\"f1Name\":\"f1Value\"}", writeValue((gen)->gen.write("f1Value")));
     }
 
     @Test
     void testWriteBigDec() {
-        assertEquals("{\"f1Name\":10}", writeValue((gen)->gen.write(BigDecimal.TEN)));
+        Assertions.assertEquals("{\"f1Name\":10}", writeValue((gen)->gen.write(BigDecimal.TEN)));
     }
 
     @Test
     void testWriteBigInt() {
-        assertEquals("{\"f1Name\":10}", writeValue((gen)->gen.write(BigInteger.TEN)));
+        Assertions.assertEquals("{\"f1Name\":10}", writeValue((gen)->gen.write(BigInteger.TEN)));
     }
 
     @Test
     void testWriteBool() {
-        assertEquals("{\"f1Name\":true}", writeValue((gen)->gen.write(true)));
+        Assertions.assertEquals("{\"f1Name\":true}", writeValue((gen)->gen.write(true)));
     }
 
     @Test
     void testWriteInt() {
-        assertEquals("{\"f1Name\":10}", writeValue((gen)->gen.write(10)));
+        Assertions.assertEquals("{\"f1Name\":10}", writeValue((gen)->gen.write(10)));
     }
 
     @Test
     void testWriteLong() {
-        assertEquals("{\"f1Name\":10}", writeValue((gen)->gen.write(10L)));
+        Assertions.assertEquals("{\"f1Name\":10}", writeValue((gen)->gen.write(10L)));
     }
 
     @Test
     void testWriteDouble() {
-        assertEquals("{\"f1Name\":10.0}", writeValue((gen)->gen.write(10d)));
+        Assertions.assertEquals("{\"f1Name\":10.0}", writeValue((gen)->gen.write(10d)));
     }
 
     @Test
     void testWriteNull() {
-        assertEquals("{\"f1Name\":null}", writeValue(JsonGenerator::writeNull));
+        Assertions.assertEquals("{\"f1Name\":null}", writeValue(JsonGenerator::writeNull));
     }
 
     @Test
@@ -195,7 +193,7 @@ void testWriteJsonValue() {
         JsonObjectBuilder builder = Json.createObjectBuilder();
         builder.add("first", "value");
         final JsonObject build = builder.build();
-        assertEquals("{\"f1Name\":\"value\"}", writeValue((gen)->gen.write(build.getValue("/first"))));
+        Assertions.assertEquals("{\"f1Name\":\"value\"}", writeValue((gen)->gen.write(build.getValue("/first"))));
     }
 
     private String writeValue(WriteValueFunction writeValueCallback) {
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorFactoryTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorFactoryTest.java
index d9fc2728..144e5b6a 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorFactoryTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorFactoryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -16,8 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 import java.io.StringWriter;
 import java.util.HashMap;
 import java.util.Map;
@@ -27,6 +25,7 @@
 import jakarta.json.stream.JsonGenerator;
 import jakarta.json.stream.JsonGeneratorFactory;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 
@@ -59,7 +58,7 @@ void testGeneratorFactoryWithConfig() {
         if (config1.size() != 1) {
             throw new JsonException("Expecting no of properties=1, got="+config1.size());
         }
-        assertTrue(config1.containsKey(JsonGenerator.PRETTY_PRINTING));
+        Assertions.assertTrue(config1.containsKey(JsonGenerator.PRETTY_PRINTING));
 
         JsonGenerator generator1 = generatorFactory.createGenerator(new StringWriter());
         generator1.writeStartArray().writeEnd();
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..eca28b50 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonGeneratorTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2022 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -16,10 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -44,6 +40,7 @@
 
 import org.eclipse.parsson.api.BufferPool;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 /**
  * {@link JsonGenerator} tests
@@ -81,7 +78,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 +104,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
@@ -153,7 +150,7 @@ void testArrayString() throws Exception {
         generator.close();
         writer.close();
 
-        assertEquals("[\"string\"]", writer.toString());
+        Assertions.assertEquals("[\"string\"]", writer.toString());
     }
 
     @Test
@@ -164,7 +161,7 @@ void testEscapedString() throws Exception {
         generator.close();
         writer.close();
 
-        assertEquals("[\"\\u0000\"]", writer.toString());
+        Assertions.assertEquals("[\"\\u0000\"]", writer.toString());
     }
 
     @Test
@@ -181,11 +178,11 @@ void testEscapedString1() throws Exception {
         String got = array.getString(0);
         jr.close();
 
-        assertEquals(expected, got);
+        Assertions.assertEquals(expected, got);
     }
 
     @Test
-    void testGeneratorEquals() throws Exception {
+    void testGeneratorEquals() {
         StringWriter sw = new StringWriter();
         JsonGenerator generator = Json.createGenerator(sw);
         generator.writeStartArray()
@@ -217,7 +214,7 @@ void testGeneratorEquals() throws Exception {
                 .add(Double.MIN_VALUE)
                 .build();
 
-        assertEquals(expected, actual);
+        Assertions.assertEquals(expected, actual);
     }
 
     @Test
@@ -257,10 +254,10 @@ void testPrettyPrinting() throws Exception {
         while ((line = reader.readLine()) != null) {
             numberOfLines++;
             if (numberOfLines > 1 && numberOfLines < 4) {
-                assertTrue(line.contains("\"" + lines[numberOfLines - 2][0] + "\": \"" + lines[numberOfLines - 2][1] + "\""));
+                Assertions.assertTrue(line.contains("\"" + lines[numberOfLines - 2][0] + "\": \"" + lines[numberOfLines - 2][1] + "\""));
             }
         }
-        assertEquals(4, numberOfLines);
+        Assertions.assertEquals(4, numberOfLines);
     }
 
     @Test
@@ -283,90 +280,90 @@ void testPrettyObjectStream() throws Exception {
     }
 
     @Test
-    void testGenerationException1() throws Exception {
+    void testGenerationException1() {
         StringWriter writer = new StringWriter();
         JsonGenerator generator = Json.createGenerator(writer);
         generator.writeStartObject();
         try {
             generator.writeStartObject();
-            fail("Expected JsonGenerationException, writeStartObject() cannot be called more than once");
+            Assertions.fail("Expected JsonGenerationException, writeStartObject() cannot be called more than once");
         } catch (JsonGenerationException je) {
             // Expected exception
         }
     }
 
     @Test
-    void testGenerationException2() throws Exception {
+    void testGenerationException2() {
         StringWriter writer = new StringWriter();
         JsonGenerator generator = Json.createGenerator(writer);
         generator.writeStartObject();
         try {
             generator.writeStartArray();
-            fail("Expected JsonGenerationException, writeStartArray() is valid in no context");
+            Assertions.fail("Expected JsonGenerationException, writeStartArray() is valid in no context");
         } catch (JsonGenerationException je) {
             // Expected exception
         }
     }
 
     @Test
-    void testGenerationException3() throws Exception {
+    void testGenerationException3() {
         StringWriter writer = new StringWriter();
         JsonGenerator generator = Json.createGenerator(writer);
         try {
             generator.close();
-            fail("Expected JsonGenerationException, no JSON is generated");
+            Assertions.fail("Expected JsonGenerationException, no JSON is generated");
         } catch (JsonGenerationException je) {
             // Expected exception
         }
     }
 
     @Test
-    void testGenerationException4() throws Exception {
+    void testGenerationException4() {
         StringWriter writer = new StringWriter();
         JsonGenerator generator = Json.createGenerator(writer);
         generator.writeStartArray();
         try {
             generator.close();
-            fail("Expected JsonGenerationException, writeEnd() is not called");
+            Assertions.fail("Expected JsonGenerationException, writeEnd() is not called");
         } catch (JsonGenerationException je) {
             // Expected exception
         }
     }
 
     @Test
-    void testGenerationException5() throws Exception {
+    void testGenerationException5() {
         StringWriter writer = new StringWriter();
         JsonGenerator generator = Json.createGenerator(writer);
         generator.writeStartObject();
         try {
             generator.close();
-            fail("Expected JsonGenerationException, writeEnd() is not called");
+            Assertions.fail("Expected JsonGenerationException, writeEnd() is not called");
         } catch (JsonGenerationException je) {
             // Expected exception
         }
     }
 
     @Test
-    void testGenerationException6() throws Exception {
+    void testGenerationException6() {
         StringWriter writer = new StringWriter();
         JsonGenerator generator = Json.createGenerator(writer);
         generator.writeStartObject().writeEnd();
         try {
             generator.writeStartObject();
-            fail("Expected JsonGenerationException, cannot generate one more JSON text");
+            Assertions.fail("Expected JsonGenerationException, cannot generate one more JSON text");
         } catch (JsonGenerationException je) {
             // Expected exception
         }
     }
 
     @Test
-    void testGenerationException7() throws Exception {
+    void testGenerationException7() {
         StringWriter writer = new StringWriter();
         JsonGenerator generator = Json.createGenerator(writer);
         generator.writeStartArray().writeEnd();
         try {
             generator.writeStartArray();
-            fail("Expected JsonGenerationException, cannot generate one more JSON text");
+            Assertions.fail("Expected JsonGenerationException, cannot generate one more JSON text");
         } catch (JsonGenerationException je) {
             // Expected exception
         }
@@ -374,51 +371,51 @@ void testGenerationException7() throws Exception {
 
 
     @Test
-    void testGenerationException8() throws Exception {
+    void testGenerationException8() {
         StringWriter sWriter = new StringWriter();
         JsonGenerator generator = Json.createGenerator(sWriter);
         generator.writeStartObject();
         try {
             generator.write(JsonValue.TRUE);
-            fail("Expected JsonGenerationException, cannot generate one more JSON text");
+            Assertions.fail("Expected JsonGenerationException, cannot generate one more JSON text");
         } catch (JsonGenerationException je) {
             // Expected exception
         }
     }
 
     @Test
-    void testGenerationException9() throws Exception {
+    void testGenerationException9() {
         StringWriter sWriter = new StringWriter();
         JsonGenerator generator = Json.createGenerator(sWriter);
         generator.writeStartObject();
         try {
             generator.write("name");
-            fail("Expected JsonGenerationException, cannot generate one more JSON text");
+            Assertions.fail("Expected JsonGenerationException, cannot generate one more JSON text");
         } catch (JsonGenerationException je) {
             // Expected exception
         }
     }
 
     @Test
-    void testGeneratorArrayDouble() throws Exception {
+    void testGeneratorArrayDouble() {
         StringWriter writer = new StringWriter();
         JsonGenerator generator = Json.createGenerator(writer);
         generator.writeStartArray();
         try {
             generator.write(Double.NaN);
-            fail("JsonGenerator.write(Double.NaN) should produce NumberFormatException");
+            Assertions.fail("JsonGenerator.write(Double.NaN) should produce NumberFormatException");
         } catch (NumberFormatException ne) {
             // expected
         }
         try {
             generator.write(Double.POSITIVE_INFINITY);
-            fail("JsonGenerator.write(Double.POSITIVE_INIFINITY) should produce NumberFormatException");
+            Assertions.fail("JsonGenerator.write(Double.POSITIVE_INIFINITY) should produce NumberFormatException");
         } catch (NumberFormatException ne) {
             // expected
         }
         try {
             generator.write(Double.NEGATIVE_INFINITY);
-            fail("JsonGenerator.write(Double.NEGATIVE_INIFINITY) should produce NumberFormatException");
+            Assertions.fail("JsonGenerator.write(Double.NEGATIVE_INIFINITY) should produce NumberFormatException");
         } catch (NumberFormatException ne) {
             // expected
         }
@@ -427,25 +424,25 @@ void testGeneratorArrayDouble() throws Exception {
     }
 
     @Test
-    void testGeneratorObjectDouble() throws Exception {
+    void testGeneratorObjectDouble() {
         StringWriter writer = new StringWriter();
         JsonGenerator generator = Json.createGenerator(writer);
         generator.writeStartObject();
         try {
             generator.write("foo", Double.NaN);
-            fail("JsonGenerator.write(String, Double.NaN) should produce NumberFormatException");
+            Assertions.fail("JsonGenerator.write(String, Double.NaN) should produce NumberFormatException");
         } catch (NumberFormatException ne) {
             // expected
         }
         try {
             generator.write("foo", Double.POSITIVE_INFINITY);
-            fail("JsonGenerator.write(String, Double.POSITIVE_INIFINITY) should produce NumberFormatException");
+            Assertions.fail("JsonGenerator.write(String, Double.POSITIVE_INIFINITY) should produce NumberFormatException");
         } catch (NumberFormatException ne) {
             // expected
         }
         try {
             generator.write("foo", Double.NEGATIVE_INFINITY);
-            fail("JsonGenerator.write(String, Double.NEGATIVE_INIFINITY) should produce NumberFormatException");
+            Assertions.fail("JsonGenerator.write(String, Double.NEGATIVE_INIFINITY) should produce NumberFormatException");
         } catch (NumberFormatException ne) {
             // expected
         }
@@ -454,7 +451,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);
@@ -471,12 +468,12 @@ void testIntGenerator() throws Exception {
 
             JsonArray expected = bf.createArrayBuilder().add(num).build();
 
-            assertEquals(expected, got);
+            Assertions.assertEquals(expected, got);
         }
     }
 
     @Test
-    void testGeneratorBuf() throws Exception {
+    void testGeneratorBuf() {
         JsonGeneratorFactory gf = Json.createGeneratorFactory(null);
         JsonReaderFactory rf = Json.createReaderFactory(null);
         JsonBuilderFactory bf = Json.createBuilderFactory(null);
@@ -495,7 +492,7 @@ void testGeneratorBuf() throws Exception {
 
             JsonObject expected = bf.createObjectBuilder().add(name, value).build();
 
-            assertEquals(expected, got);
+            Assertions.assertEquals(expected, got);
         }
     }
 
@@ -511,8 +508,8 @@ void testBufferPoolFeature() {
         generator.writeStartArray();
         generator.writeEnd();
         generator.close();
-        assertTrue(bufferPool.isTakeCalled());
-        assertTrue(bufferPool.isRecycleCalled());
+        Assertions.assertTrue(bufferPool.isTakeCalled());
+        Assertions.assertTrue(bufferPool.isRecycleCalled());
     }
 
     @Test
@@ -541,7 +538,7 @@ void testBufferSizes() {
 
                 JsonObject expected = bf.createObjectBuilder().add(name, value).build();
 
-                assertEquals(expected, got);
+                Assertions.assertEquals(expected, got);
             }
 
         }
@@ -573,7 +570,7 @@ void escapedString(String expected) throws Exception {
         String got = array.getString(0);
         jr.close();
 
-        assertEquals(expected, got);
+        Assertions.assertEquals(expected, got);
     }
 
     @Test
@@ -583,7 +580,7 @@ void testFlush() throws Exception {
         gen.writeStartObject().writeEnd();
         gen.flush();
 
-        assertEquals("{}", baos.toString("UTF-8"));
+        Assertions.assertEquals("{}", baos.toString("UTF-8"));
     }
 
     @Test
@@ -595,7 +592,7 @@ void testClose() {
             generator.writeEnd();
             // Unnecessary close()
             generator.close();
-            assertEquals("{}", sw.toString());
+            Assertions.assertEquals("{}", sw.toString());
         } 
         StringWriter sw1 = new StringWriter();
         StringWriter sw2 = new StringWriter();
@@ -614,7 +611,7 @@ void testClose() {
             
             generator1.writeEnd();
         }
-        assertEquals("{\"key\":\"value\",\"key2\":\"value2\"}", sw1.toString());
-        assertEquals("[\"item\",\"item2\"]", sw2.toString());
+        Assertions.assertEquals("{\"key\":\"value\",\"key2\":\"value2\"}", sw1.toString());
+        Assertions.assertEquals("[\"item\",\"item2\"]", sw2.toString());
     }
 }
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatch2Test.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatch2Test.java
index d7e393aa..d6353377 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatch2Test.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatch2Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2024 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
@@ -16,10 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 import jakarta.json.Json;
 import jakarta.json.JsonArray;
 import jakarta.json.JsonMergePatch;
@@ -27,6 +23,7 @@
 
 import org.eclipse.parsson.TestUtils;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 
@@ -36,9 +33,9 @@ public class JsonMergePatch2Test {
     void testToString() {
         JsonArray jsonArray = Json.createArrayBuilder().add(Json.createValue(1)).build();
         JsonPatch jsonPatch = Json.createPatchBuilder(jsonArray).build();
-        assertEquals("[1]", jsonPatch.toString());
+        Assertions.assertEquals("[1]", jsonPatch.toString());
         JsonMergePatch jsonMergePatch = Json.createMergePatch(jsonArray);
-        assertEquals("[1]", jsonMergePatch.toString());
+        Assertions.assertEquals("[1]", jsonMergePatch.toString());
     }
 
     @Test
@@ -49,20 +46,20 @@ void testEquals() {
         JsonMergePatch j4 = TestUtils.createJsonMergePatchImpl(Json.createValue("test2"));
         JsonMergePatch j5 = TestUtils.createJsonMergePatchImpl(null);
 
-        assertTrue(j1.equals(j1));
+        Assertions.assertTrue(j1.equals(j1));
 
-        assertTrue(j1.equals(j2));
-        assertTrue(j2.equals(j1));
+        Assertions.assertTrue(j1.equals(j2));
+        Assertions.assertTrue(j2.equals(j1));
 
-        assertTrue(j1.equals(j3));
-        assertTrue(j3.equals(j1));
+        Assertions.assertTrue(j1.equals(j3));
+        Assertions.assertTrue(j3.equals(j1));
 
-        assertTrue(j2.equals(j3));
-        assertTrue(j3.equals(j2));
+        Assertions.assertTrue(j2.equals(j3));
+        Assertions.assertTrue(j3.equals(j2));
 
-        assertFalse(j1.equals(j4));
-        assertFalse(j1.equals(j5));
-        assertFalse(j1.equals(null));
+        Assertions.assertFalse(j1.equals(j4));
+        Assertions.assertFalse(j1.equals(j5));
+        Assertions.assertFalse(j1.equals(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..6f42c404 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchDiffTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchDiffTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,12 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
@@ -33,6 +27,9 @@
 import jakarta.json.JsonString;
 import jakarta.json.JsonValue;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -61,6 +58,7 @@ public static Iterable<Object[]> data() throws Exception {
         return examples;
     }
 
+    @SuppressWarnings("unchecked")
     private static Class<? extends Exception> createExceptionClass(
             JsonString exceptionClassName) throws ClassNotFoundException {
         if (exceptionClassName != null) {
@@ -74,8 +72,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")
@@ -83,13 +80,13 @@ private static JsonArray loadData() {
     void shouldExecuteJsonMergePatchDiffOperationsToJsonDocument(JsonValue original, JsonValue target, JsonValue expected, Class<? extends Exception> expectedException) {
         try {
             JsonValue output = Json.createMergeDiff(original, target).toJsonValue();
-            assertThat(output, is(expected));
-            assertThat(expectedException, nullValue());
+            MatcherAssert.assertThat(output, CoreMatchers.is(expected));
+            MatcherAssert.assertThat(expectedException, CoreMatchers.nullValue());
         } catch (Exception e) {
             if (expectedException == null) {
-                fail(e.getMessage());
+                Assertions.fail(e.getMessage());
             } else {
-                assertThat(e, instanceOf(expectedException));
+                MatcherAssert.assertThat(e, CoreMatchers.instanceOf(expectedException));
             }
         }
     }
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..d45a760d 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonMergePatchTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,12 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
@@ -33,6 +27,9 @@
 import jakarta.json.JsonString;
 import jakarta.json.JsonValue;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -61,6 +58,7 @@ public static Iterable<Object[]> data() throws Exception {
             return examples;
         }
 
+        @SuppressWarnings("unchecked")
         private static Class<? extends Exception> createExceptionClass(
                 JsonString exceptionClassName) throws ClassNotFoundException {
             if (exceptionClassName != null) {
@@ -74,8 +72,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")
@@ -83,13 +80,13 @@ private static JsonArray loadData() {
     void shouldExecuteJsonMergePatchDiffOperationsToJsonDocument(JsonValue patch, JsonValue target, JsonValue expected, Class<? extends Exception> expectedException) {
             try {
                 JsonValue output = Json.createMergePatch(patch).apply(target);
-                assertThat(output, is(expected));
-                assertThat(expectedException, nullValue());
+                MatcherAssert.assertThat(output, CoreMatchers.is(expected));
+                MatcherAssert.assertThat(expectedException, CoreMatchers.nullValue());
             } catch (Exception e) {
                 if (expectedException == null) {
-                    fail(e.getMessage());
+                    Assertions.fail(e.getMessage());
                 } else {
-                    assertThat(e, instanceOf(expectedException));
+                    MatcherAssert.assertThat(e, CoreMatchers.instanceOf(expectedException));
                 }
             }
         }
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonNestingTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonNestingTest.java
index 3b295920..583919c2 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonNestingTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonNestingTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2024 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
@@ -16,20 +16,19 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
 import java.io.StringReader;
 
 import jakarta.json.Json;
 import jakarta.json.stream.JsonParser;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 public class JsonNestingTest {
 
     @Test
     void testArrayNestingException() {
-        assertThrows(RuntimeException.class, () -> {
+        Assertions.assertThrows(RuntimeException.class, () -> {
             String json = createDeepNestedDoc(500);
             try (JsonParser parser = Json.createParser(new StringReader(json))) {
                 while (parser.hasNext()) {
@@ -57,7 +56,7 @@ void testArrayNesting() {
 
     @Test
     void testObjectNestingException() {
-        assertThrows(RuntimeException.class, () -> {
+        Assertions.assertThrows(RuntimeException.class, () -> {
             String json = createDeepNestedDoc(500);
             try (JsonParser parser = Json.createParser(new StringReader(json))) {
                 while (parser.hasNext()) {
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..58f01da1 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonNumberTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonNumberTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -16,10 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.StringReader;
 import java.io.StringWriter;
 import java.math.BigDecimal;
@@ -37,6 +33,7 @@
 import jakarta.json.JsonWriter;
 
 import org.eclipse.parsson.api.JsonConfig;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 
@@ -72,34 +69,34 @@ 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();
 
-        assertEquals(array1.get(0), array2.get(0));
-        assertEquals(array1, array2);
+        Assertions.assertEquals(array1.get(0), array2.get(0));
+        Assertions.assertEquals(array1, array2);
     }
 
     @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();
 
-        assertEquals(array1.get(0), array2.get(0));
-        assertEquals(array1, array2);
+        Assertions.assertEquals(array1.get(0), array2.get(0));
+        Assertions.assertEquals(array1, array2);
     }
 
     @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);
@@ -118,17 +115,17 @@ void testIntNumberType() throws Exception {
         reader.close();
         testNumberType(array2, true);
 
-        assertEquals(array1, array2);
+        Assertions.assertEquals(array1, array2);
     }
 
     private void testNumberType(JsonArray array, boolean integral) {
         for (JsonValue value : array) {
-            assertEquals(integral, ((JsonNumber) value).isIntegral());
+            Assertions.assertEquals(integral, ((JsonNumber) value).isIntegral());
         }
     }
 
     @Test
-    void testLongNumberType() throws Exception {
+    void testLongNumberType() {
         JsonArray array1 = Json.createArrayBuilder()
                 .add(Long.MIN_VALUE)
                 .add(Long.MAX_VALUE)
@@ -152,7 +149,7 @@ void testLongNumberType() throws Exception {
         reader.close();
         testNumberType(array2, true);
 
-        assertEquals(array1, array2);
+        Assertions.assertEquals(array1, array2);
     }
 
 
@@ -180,7 +177,7 @@ void testLongNumberType() throws Exception {
 //    }
 
     @Test
-    void testBigDecimalNumberType() throws Exception {
+    void testBigDecimalNumberType() {
         JsonArray array1 = Json.createArrayBuilder()
                 .add(12d)
                 .add(12.0d)
@@ -202,11 +199,11 @@ void testBigDecimalNumberType() throws Exception {
         reader.close();
         testNumberType(array2, false);
 
-        assertEquals(array1, array2);
+        Assertions.assertEquals(array1, array2);
     }
 
     @Test
-    void testMinMax() throws Exception {
+    void testMinMax() {
         JsonArray expected = Json.createArrayBuilder()
                 .add(Integer.MIN_VALUE)
                 .add(Integer.MAX_VALUE)
@@ -225,7 +222,7 @@ void testMinMax() throws Exception {
         JsonArray actual = reader.readArray();
         reader.close();
 
-        assertEquals(expected, actual);
+        Assertions.assertEquals(expected, actual);
     }
 
     @Test
@@ -239,7 +236,7 @@ void testLeadingZeroes() {
         jw.write(array);
         jw.close();
 
-        assertEquals("[12.1]", sw.toString());
+        Assertions.assertEquals("[12.1]", sw.toString());
     }
 
     @Test
@@ -247,7 +244,7 @@ void testBigIntegerExact() {
         try {
             JsonArray array = Json.createArrayBuilder().add(12345.12345).build();
             array.getJsonNumber(0).bigIntegerValueExact();
-            fail("Expected Arithmetic exception");
+            Assertions.fail("Expected Arithmetic exception");
         } catch (ArithmeticException expected) {
             // no-op
         }
@@ -256,30 +253,30 @@ void testBigIntegerExact() {
     @Test
     void testHashCode() {
         JsonNumber jsonNumber1 = Json.createValue(1);
-        assertTrue(jsonNumber1.hashCode() == jsonNumber1.bigDecimalValue().hashCode());
+        Assertions.assertTrue(jsonNumber1.hashCode() == jsonNumber1.bigDecimalValue().hashCode());
 
         JsonNumber jsonNumber2 = Json.createValue(1);
 
-        assertTrue(jsonNumber1.equals(jsonNumber2));
-        assertTrue(jsonNumber1.hashCode() == jsonNumber2.hashCode());
+        Assertions.assertTrue(jsonNumber1.equals(jsonNumber2));
+        Assertions.assertTrue(jsonNumber1.hashCode() == jsonNumber2.hashCode());
     }
 
     @Test
     void testNumber() {
-        assertEquals(Json.createValue(1), Json.createValue(Byte.valueOf((byte) 1)));
-        assertEquals(Json.createValue(1).toString(), Json.createValue(Byte.valueOf((byte) 1)).toString());
-        assertEquals(Json.createValue(1), Json.createValue(Short.valueOf((short) 1)));
-        assertEquals(Json.createValue(1).toString(), Json.createValue(Short.valueOf((short) 1)).toString());
-        assertEquals(Json.createValue(1), Json.createValue(Integer.valueOf(1)));
-        assertEquals(Json.createValue(1).toString(), Json.createValue(Integer.valueOf(1)).toString());
-        assertEquals(Json.createValue(1L), Json.createValue(Long.valueOf(1)));
-        assertEquals(Json.createValue(1L).toString(), Json.createValue(Long.valueOf(1)).toString());
-        assertEquals(Json.createValue(1D), Json.createValue(Float.valueOf(1)));
-        assertEquals(Json.createValue(1D).toString(), Json.createValue(Float.valueOf(1)).toString());
-        assertEquals(Json.createValue(1D), Json.createValue(Double.valueOf(1)));
-        assertEquals(Json.createValue(1D).toString(), Json.createValue(Double.valueOf(1)).toString());
-        assertEquals(Json.createValue(1), Json.createValue(new CustomNumber(1)));
-        assertEquals(Json.createValue(1).toString(), Json.createValue(new CustomNumber(1)).toString());
+        Assertions.assertEquals(Json.createValue(1), Json.createValue(Byte.valueOf((byte) 1)));
+        Assertions.assertEquals(Json.createValue(1).toString(), Json.createValue(Byte.valueOf((byte) 1)).toString());
+        Assertions.assertEquals(Json.createValue(1), Json.createValue(Short.valueOf((short) 1)));
+        Assertions.assertEquals(Json.createValue(1).toString(), Json.createValue(Short.valueOf((short) 1)).toString());
+        Assertions.assertEquals(Json.createValue(1), Json.createValue(Integer.valueOf(1)));
+        Assertions.assertEquals(Json.createValue(1).toString(), Json.createValue(Integer.valueOf(1)).toString());
+        Assertions.assertEquals(Json.createValue(1L), Json.createValue(Long.valueOf(1)));
+        Assertions.assertEquals(Json.createValue(1L).toString(), Json.createValue(Long.valueOf(1)).toString());
+        Assertions.assertEquals(Json.createValue(1D), Json.createValue(Float.valueOf(1)));
+        Assertions.assertEquals(Json.createValue(1D).toString(), Json.createValue(Float.valueOf(1)).toString());
+        Assertions.assertEquals(Json.createValue(1D), Json.createValue(Double.valueOf(1)));
+        Assertions.assertEquals(Json.createValue(1D).toString(), Json.createValue(Double.valueOf(1)).toString());
+        Assertions.assertEquals(Json.createValue(1), Json.createValue(new CustomNumber(1)));
+        Assertions.assertEquals(Json.createValue(1).toString(), Json.createValue(new CustomNumber(1)).toString());
     }
 
     // Test default BigInteger scale value limit using value bellow limit.
@@ -298,7 +295,7 @@ void testDefaultBigIntegerScaleAboveLimit() {
                 .setScale(100001, RoundingMode.HALF_UP);
         try {
             Json.createValue(value).bigIntegerValue();
-            fail("No exception was thrown from bigIntegerValue with scale over limit");
+            Assertions.fail("No exception was thrown from bigIntegerValue with scale over limit");
         } catch (UnsupportedOperationException e) {
             // UnsupportedOperationException is expected to be thrown
             assertExceptionMessageContainsNumber(e, 100001);
@@ -314,7 +311,7 @@ void testDefaultBigIntegerNegScaleAboveLimit() {
                 .setScale(-100001, RoundingMode.HALF_UP);
         try {
             Json.createValue(value).bigIntegerValue();
-            fail("No exception was thrown from bigIntegerValue with scale over limit");
+            Assertions.fail("No exception was thrown from bigIntegerValue with scale over limit");
         } catch (UnsupportedOperationException e) {
             // UnsupportedOperationException is expected to be thrown
             assertExceptionMessageContainsNumber(e, -100001);
@@ -338,7 +335,7 @@ void testConfigBigIntegerScaleAboveLimit() {
                     .add("bigDecimal", value)
                     .build();
             jsonObject.getJsonNumber("bigDecimal").bigIntegerValue();
-            fail("No exception was thrown from bigIntegerValue with scale over limit");
+            Assertions.fail("No exception was thrown from bigIntegerValue with scale over limit");
         } catch (UnsupportedOperationException e) {
             // UnsupportedOperationException is expected to be thrown
             assertExceptionMessageContainsNumber(e, 50001);
@@ -362,7 +359,7 @@ void testConfigBigIntegerNegScaleAboveLimit() {
                     .add("bigDecimal", value)
                     .build();
             jsonObject.getJsonNumber("bigDecimal").bigIntegerValue();
-            fail("No exception was thrown from bigIntegerValue with scale over limit");
+            Assertions.fail("No exception was thrown from bigIntegerValue with scale over limit");
         } catch (UnsupportedOperationException e) {
             // UnsupportedOperationException is expected to be thrown
             assertExceptionMessageContainsNumber(e, -50001);
@@ -377,8 +374,8 @@ void testLargeBigDecimalBellowLimit() {
         JsonReader reader = Json.createReader(new StringReader(Π_1100));
         JsonNumber check = Json.createValue(new BigDecimal(Π_1100));
         JsonValue value = reader.readValue();
-        assertEquals(value.getValueType(), JsonValue.ValueType.NUMBER);
-        assertEquals(value, check);
+        Assertions.assertEquals(value.getValueType(), JsonValue.ValueType.NUMBER);
+        Assertions.assertEquals(value, check);
     }
 
     // Test BigDecimal max source characters array length using length above default limit of 1100.
@@ -388,10 +385,10 @@ void testLargeBigDecimalAboveLimit() {
         JsonReader reader = Json.createReader(new StringReader(Π_1101));
         try {
             reader.readValue();
-            fail("No exception was thrown from BigDecimal parsing with source characters array length over limit");
+            Assertions.fail("No exception was thrown from BigDecimal parsing with source characters array length over limit");
         } catch (UnsupportedOperationException e) {
             // UnsupportedOperationException is expected to be thrown
-            assertEquals(
+            Assertions.assertEquals(
                     "Number of BigDecimal source characters 1101 exceeded maximal allowed value of 1100",
                     e.getMessage());
         }
@@ -405,8 +402,8 @@ void testLargeBigDecimalBellowCustomLimit() {
         JsonReader reader = Json.createReaderFactory(config).createReader(new StringReader(Π_500));
         JsonNumber check = Json.createValue(new BigDecimal(Π_500));
         JsonValue value = reader.readValue();
-        assertEquals(value.getValueType(), JsonValue.ValueType.NUMBER);
-        assertEquals(value, check);
+        Assertions.assertEquals(value.getValueType(), JsonValue.ValueType.NUMBER);
+        Assertions.assertEquals(value, check);
     }
 
     // Test BigDecimal max source characters array length using length equal to custom limit of 200.
@@ -417,10 +414,10 @@ void testLargeBigDecimalAboveCustomLimit() {
         JsonReader reader = Json.createReaderFactory(config).createReader(new StringReader(Π_501));
         try {
             reader.readValue();
-            fail("No exception was thrown from BigDecimal parsing with source characters array length over limit");
+            Assertions.fail("No exception was thrown from BigDecimal parsing with source characters array length over limit");
         } catch (UnsupportedOperationException e) {
             // UnsupportedOperationException is expected to be thrown
-            assertEquals(
+            Assertions.assertEquals(
                     "Number of BigDecimal source characters 501 exceeded maximal allowed value of 500",
                     e.getMessage());
         }
@@ -429,7 +426,7 @@ void testLargeBigDecimalAboveCustomLimit() {
     static void assertExceptionMessageContainsNumber(Exception e, int number) {
         // Format the number as being written to message from messages bundle
         String numberString = MessageFormat.format("{0}", number);
-        assertTrue(e.getMessage().contains(numberString),
+        Assertions.assertTrue(e.getMessage().contains(numberString),
                    "Substring \"" + numberString + "\" was not found in \"" + e.getMessage() + "\"");
     }
 
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..cc276488 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonObjectTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonObjectTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -16,11 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.StringReader;
 import java.io.StringWriter;
 import java.util.HashMap;
@@ -33,6 +28,7 @@
 import jakarta.json.JsonValue;
 import jakarta.json.JsonWriter;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -45,92 +41,92 @@ void test() {
     }
 
     @Test
-    void testEmptyObjectEquals() throws Exception {
+    void testEmptyObjectEquals() {
         JsonObject empty1 = Json.createObjectBuilder()
                 .build();
 
         JsonObject empty2 = Json.createObjectBuilder()
                 .build();
 
-        assertEquals(empty1, empty2);
+        Assertions.assertEquals(empty1, empty2);
     }
 
     @Test
-    void testPersonObjectEquals() throws Exception {
+    void testPersonObjectEquals() {
         JsonObject person1 = JsonBuilderTest.buildPerson();
         JsonObject person2 = JsonReaderTest.readPerson();
 
-        assertEquals(person1, person2);
+        Assertions.assertEquals(person1, person2);
     }
 
     @Test
-    void testGetStringOrDefault() throws Exception {
+    void testGetStringOrDefault() {
         JsonObject object = Json.createObjectBuilder()
                 .add("string", "value")
                 .add("number", 25)
                 .add("boolean", false)
                 .build();
-        assertEquals("value", object.getString("string", "default"));
-        assertEquals("default", object.getString("missing", "default"));
-        assertEquals("default", object.getString("number", "default"));
+        Assertions.assertEquals("value", object.getString("string", "default"));
+        Assertions.assertEquals("default", object.getString("missing", "default"));
+        Assertions.assertEquals("default", object.getString("number", "default"));
     }
 
     @Test
-    void testGetIntOrDefault() throws Exception {
+    void testGetIntOrDefault() {
         JsonObject object = Json.createObjectBuilder()
                 .add("string", "value")
                 .add("number", 25)
                 .add("boolean", false)
                 .build();
-        assertEquals(25, object.getInt("number", 10));
-        assertEquals(10, object.getInt("missing", 10));
-        assertEquals(10, object.getInt("string", 10));
+        Assertions.assertEquals(25, object.getInt("number", 10));
+        Assertions.assertEquals(10, object.getInt("missing", 10));
+        Assertions.assertEquals(10, object.getInt("string", 10));
     }
 
     @Test
-    void testGetBooleanOrDefault() throws Exception {
+    void testGetBooleanOrDefault() {
         JsonObject object = Json.createObjectBuilder()
                 .add("string", "value")
                 .add("number", 25)
                 .add("boolean", false)
                 .build();
-        assertFalse(object.getBoolean("boolean", true));
-        assertTrue(object.getBoolean("missing", true));
-        assertTrue(object.getBoolean("string", true));
+        Assertions.assertFalse(object.getBoolean("boolean", true));
+        Assertions.assertTrue(object.getBoolean("missing", true));
+        Assertions.assertTrue(object.getBoolean("string", true));
     }
 
     static void testPerson(JsonObject person) {
-        assertEquals(5, person.size());
-        assertEquals("John", person.getString("firstName"));
-        assertEquals("Smith", person.getString("lastName"));
-        assertEquals(25, person.getJsonNumber("age").intValue());
-        assertEquals(25, person.getInt("age"));
+        Assertions.assertEquals(5, person.size());
+        Assertions.assertEquals("John", person.getString("firstName"));
+        Assertions.assertEquals("Smith", person.getString("lastName"));
+        Assertions.assertEquals(25, person.getJsonNumber("age").intValue());
+        Assertions.assertEquals(25, person.getInt("age"));
 
         JsonObject address = person.getJsonObject("address");
-        assertEquals(4, address.size());
-        assertEquals("21 2nd Street", address.getString("streetAddress"));
-        assertEquals("New York", address.getString("city"));
-        assertEquals("NY", address.getString("state"));
-        assertEquals("10021", address.getString("postalCode"));
+        Assertions.assertEquals(4, address.size());
+        Assertions.assertEquals("21 2nd Street", address.getString("streetAddress"));
+        Assertions.assertEquals("New York", address.getString("city"));
+        Assertions.assertEquals("NY", address.getString("state"));
+        Assertions.assertEquals("10021", address.getString("postalCode"));
 
         JsonArray phoneNumber = person.getJsonArray("phoneNumber");
-        assertEquals(2, phoneNumber.size());
+        Assertions.assertEquals(2, phoneNumber.size());
         JsonObject home = phoneNumber.getJsonObject(0);
-        assertEquals(2, home.size());
-        assertEquals("home", home.getString("type"));
-        assertEquals("212 555-1234", home.getString("number"));
-        assertEquals("212 555-1234", home.getString("number"));
+        Assertions.assertEquals(2, home.size());
+        Assertions.assertEquals("home", home.getString("type"));
+        Assertions.assertEquals("212 555-1234", home.getString("number"));
+        Assertions.assertEquals("212 555-1234", home.getString("number"));
 
         JsonObject fax = phoneNumber.getJsonObject(1);
-        assertEquals(2, fax.size());
-        assertEquals("fax", fax.getString("type"));
-        assertEquals("646 555-4567", fax.getString("number"));
+        Assertions.assertEquals(2, fax.size());
+        Assertions.assertEquals("fax", fax.getString("type"));
+        Assertions.assertEquals("646 555-4567", fax.getString("number"));
 
-        assertEquals("\"646 555-4567\"", fax.getJsonString("number").toString());
+        Assertions.assertEquals("\"646 555-4567\"", fax.getJsonString("number").toString());
     }
 
     static void testEmpty(JsonObject empty) {
-        assertTrue(empty.isEmpty());
+        Assertions.assertTrue(empty.isEmpty());
     }
 
     @Test
@@ -139,7 +135,7 @@ void testClassCastException() {
                 .add("foo", JsonValue.FALSE).build();
         try {
             obj.getJsonNumber("foo");
-            fail("Expected ClassCastException for casting JsonValue.FALSE to JsonNumber");
+            Assertions.fail("Expected ClassCastException for casting JsonValue.FALSE to JsonNumber");
         } catch (ClassCastException ce) {
             // Expected
         }
@@ -150,7 +146,7 @@ void testPut() {
         JsonObject obj = Json.createObjectBuilder().add("foo", 1).build();
         try {
             obj.put("bar", JsonValue.FALSE);
-            fail("JsonObject#put() should throw UnsupportedOperationException");
+            Assertions.fail("JsonObject#put() should throw UnsupportedOperationException");
         } catch(UnsupportedOperationException e) {
             // Expected
         }
@@ -161,7 +157,7 @@ void testRemove() {
         JsonObject obj = Json.createObjectBuilder().add("foo", 1).build();
         try {
             obj.remove("foo");
-            fail("JsonObject#remove() should throw UnsupportedOperationException");
+            Assertions.fail("JsonObject#remove() should throw UnsupportedOperationException");
         } catch(UnsupportedOperationException e) {
             // Expected
         }
@@ -192,7 +188,7 @@ void testObjectBuilderWithVariousValues() {
         JsonObject actual = reader.readObject();
         reader.close();
 
-        assertEquals(expected, actual);
+        Assertions.assertEquals(expected, actual);
     }
 
     @Test
@@ -221,14 +217,14 @@ void testObjectBuilderWithMap() {
         JsonObject actual = reader.readObject();
         reader.close();
 
-        assertEquals(expected, actual);
+        Assertions.assertEquals(expected, actual);
     }
 
     @Test
     void testObjectBuilderNpe() {
         try {
-            JsonObject obj = Json.createObjectBuilder().add(null, 1).build();
-            fail("JsonObjectBuilder#add(null, 1) should throw NullPointerException");
+            Json.createObjectBuilder().add(null, 1).build();
+            Assertions.fail("JsonObjectBuilder#add(null, 1) should throw NullPointerException");
         } catch(NullPointerException e) {
             // Expected
         }
@@ -237,16 +233,16 @@ void testObjectBuilderNpe() {
     @Test
     void testHashCode() {
         JsonObject object1 = Json.createObjectBuilder().add("a", 1).add("b", 2).add("c", 3).build();
-        assertTrue(object1.hashCode() == object1.hashCode()); //1st call compute hashCode, 2nd call returns cached value
+        Assertions.assertTrue(object1.hashCode() == object1.hashCode()); //1st call compute hashCode, 2nd call returns cached value
 
         JsonObject object2 = Json.createObjectBuilder().add("a", 1).add("b", 2).add("c", 3).build();
-        assertTrue(object1.hashCode() == object2.hashCode());
+        Assertions.assertTrue(object1.hashCode() == object2.hashCode());
 
         JsonObject object3 = Json.createObjectBuilder().build(); //org.eclipse.parsson.JsonArrayBuilderImpl.JsonArrayImpl
         JsonObject object4 = JsonValue.EMPTY_JSON_OBJECT; //jakarta.json.EmptyObject
 
-        assertTrue(object3.equals(object4));
-        assertTrue(object3.hashCode() == object4.hashCode()); //equal instances have same hashCode
+        Assertions.assertTrue(object3.equals(object4));
+        Assertions.assertTrue(object3.hashCode() == object4.hashCode()); //equal instances have same hashCode
     }
 
     @Test
@@ -263,10 +259,10 @@ void testArrays() {
         m.put("charArray", charArr);
         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));
-        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());
+        Assertions.assertEquals("b", object.get("stringArray").asJsonArray().getString(1));
+		Assertions.assertFalse(object.get("booleanArray").asJsonArray().getBoolean(1));
+        Assertions.assertEquals(2, object.get("intArray").asJsonArray().getInt(1));
+        Assertions.assertEquals('b', object.get("charArray").asJsonArray().getInt(1));
+        Assertions.assertEquals(2.0, object.get("floatArray").asJsonArray().getJsonNumber(1).doubleValue());
     }
 }
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonParserFactoryTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonParserFactoryTest.java
index 6c33bccd..39fa1aaa 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonParserFactoryTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonParserFactoryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonParserSkipTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonParserSkipTest.java
index dcf76b6b..a575c972 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonParserSkipTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonParserSkipTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2024 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
@@ -16,16 +16,11 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.eclipse.parsson.JsonParserFixture.testWithCreateParserFromArray;
-import static org.eclipse.parsson.JsonParserFixture.testWithCreateParserFromObject;
-import static org.eclipse.parsson.JsonParserFixture.testWithCreateParserFromString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 import jakarta.json.Json;
 import jakarta.json.stream.JsonParser;
 
+import org.eclipse.parsson.JsonParserFixture;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -36,12 +31,12 @@ public class JsonParserSkipTest {
 
     @Test
     void testSkipArrayReader() {
-        testWithCreateParserFromString("[[],[[]]]", JsonParserSkipTest::testSkipArray);
+        JsonParserFixture.testWithCreateParserFromString("[[],[[]]]", JsonParserSkipTest::testSkipArray);
     }
 
     @Test
     void testSkipArrayStructure() {
-        testWithCreateParserFromArray(Json.createArrayBuilder()
+        JsonParserFixture.testWithCreateParserFromArray(Json.createArrayBuilder()
                 .add(Json.createArrayBuilder())
                 .add(Json.createArrayBuilder()
                         .add(Json.createArrayBuilder()))
@@ -49,59 +44,59 @@ void testSkipArrayStructure() {
     }
 
     private static void testSkipArray(JsonParser parser) {
-        assertEquals(JsonParser.Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_ARRAY, parser.next());
         parser.skipArray();
-		assertFalse(parser.hasNext());
+		Assertions.assertFalse(parser.hasNext());
     }
 
     @Test
     void testSkipInsideArrayReader() {
-        testWithCreateParserFromString("[\"test\"]", JsonParserSkipTest::testSkipInsideArray);
+        JsonParserFixture.testWithCreateParserFromString("[\"test\"]", JsonParserSkipTest::testSkipInsideArray);
     }
 
     @Test
     void testSkipInsideArrayStructure() {
-        testWithCreateParserFromArray(Json.createArrayBuilder()
+        JsonParserFixture.testWithCreateParserFromArray(Json.createArrayBuilder()
                 .add("test")
                 .build(), JsonParserSkipTest::testSkipInsideArray);
     }
 
     private static void testSkipInsideArray(JsonParser parser) {
-        assertEquals(JsonParser.Event.START_ARRAY, parser.next());
-        assertEquals(JsonParser.Event.VALUE_STRING, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(JsonParser.Event.VALUE_STRING, parser.next());
         parser.skipArray();
-		assertFalse(parser.hasNext());
+		Assertions.assertFalse(parser.hasNext());
     }
 
     @Test
     void testNoSkipArrayReader() {
-        testWithCreateParserFromString("{\"key\":\"value\"}", JsonParserSkipTest::testNoSkipArray);
+        JsonParserFixture.testWithCreateParserFromString("{\"key\":\"value\"}", JsonParserSkipTest::testNoSkipArray);
     }
 
     @Test
     void testNoSkipArrayStructure() {
-        testWithCreateParserFromObject(Json.createObjectBuilder()
+        JsonParserFixture.testWithCreateParserFromObject(Json.createObjectBuilder()
                 .add("key","value")
                 .build(), JsonParserSkipTest::testNoSkipArray);
     }
 
     private static void testNoSkipArray(JsonParser parser) {
-        assertEquals(JsonParser.Event.START_OBJECT, parser.next());
-        assertEquals(JsonParser.Event.KEY_NAME, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_OBJECT, parser.next());
+        Assertions.assertEquals(JsonParser.Event.KEY_NAME, parser.next());
         parser.skipArray();
-        assertEquals(JsonParser.Event.VALUE_STRING, parser.next());
-        assertEquals(JsonParser.Event.END_OBJECT, parser.next());
-        assertFalse(parser.hasNext());
+        Assertions.assertEquals(JsonParser.Event.VALUE_STRING, parser.next());
+        Assertions.assertEquals(JsonParser.Event.END_OBJECT, parser.next());
+        Assertions.assertFalse(parser.hasNext());
     }
 
     @Test
     void testSkipArrayInObjectReader() {
-        testWithCreateParserFromString("{\"array\":[[],[[]]],\"object\":\"value2\"}", JsonParserSkipTest::testSkipArrayInObject);
+        JsonParserFixture.testWithCreateParserFromString("{\"array\":[[],[[]]],\"object\":\"value2\"}", JsonParserSkipTest::testSkipArrayInObject);
     }
 
     @Test
     void testSkipArrayInObjectStructure() {
-        testWithCreateParserFromObject(Json.createObjectBuilder().add("array", Json.createArrayBuilder()
+        JsonParserFixture.testWithCreateParserFromObject(Json.createObjectBuilder().add("array", Json.createArrayBuilder()
                         .add(Json.createArrayBuilder())
                         .add(Json.createArrayBuilder()
                                 .add(Json.createArrayBuilder()))
@@ -110,25 +105,25 @@ void testSkipArrayInObjectStructure() {
     }
 
     private static void testSkipArrayInObject(JsonParser parser) {
-        assertEquals(JsonParser.Event.START_OBJECT, parser.next());
-        assertEquals(JsonParser.Event.KEY_NAME, parser.next());
-        assertEquals(JsonParser.Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_OBJECT, parser.next());
+        Assertions.assertEquals(JsonParser.Event.KEY_NAME, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_ARRAY, parser.next());
         parser.skipArray();
-        assertTrue(parser.hasNext());
-        assertEquals(JsonParser.Event.KEY_NAME, parser.next());
-        assertEquals(JsonParser.Event.VALUE_STRING, parser.next());
-        assertEquals(JsonParser.Event.END_OBJECT, parser.next());
-        assertFalse(parser.hasNext());
+        Assertions.assertTrue(parser.hasNext());
+        Assertions.assertEquals(JsonParser.Event.KEY_NAME, parser.next());
+        Assertions.assertEquals(JsonParser.Event.VALUE_STRING, parser.next());
+        Assertions.assertEquals(JsonParser.Event.END_OBJECT, parser.next());
+        Assertions.assertFalse(parser.hasNext());
     }
 
     @Test
     void testSkipObjectReader() {
-        testWithCreateParserFromString("{\"array\":[],\"objectToSkip\":{\"huge key\":\"huge value\"},\"simple\":2}", JsonParserSkipTest::testSkipObject);
+        JsonParserFixture.testWithCreateParserFromString("{\"array\":[],\"objectToSkip\":{\"huge key\":\"huge value\"},\"simple\":2}", JsonParserSkipTest::testSkipObject);
     }
 
     @Test
     void testSkipObjectStructure() {
-        testWithCreateParserFromObject(Json.createObjectBuilder()
+        JsonParserFixture.testWithCreateParserFromObject(Json.createObjectBuilder()
                 .add("array", Json.createArrayBuilder().build())
                 .add("objectToSkip", Json.createObjectBuilder().add("huge key", "huge value"))
                 .add("simple", 2)
@@ -136,59 +131,59 @@ void testSkipObjectStructure() {
     }
 
     private static void testSkipObject(JsonParser parser) {
-        assertEquals(JsonParser.Event.START_OBJECT, parser.next());
-        assertEquals(JsonParser.Event.KEY_NAME, parser.next());
-        assertEquals(JsonParser.Event.START_ARRAY, parser.next());
-        assertEquals(JsonParser.Event.END_ARRAY, parser.next());
-        assertEquals(JsonParser.Event.KEY_NAME, parser.next());
-        assertEquals(JsonParser.Event.START_OBJECT, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_OBJECT, parser.next());
+        Assertions.assertEquals(JsonParser.Event.KEY_NAME, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(JsonParser.Event.END_ARRAY, parser.next());
+        Assertions.assertEquals(JsonParser.Event.KEY_NAME, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_OBJECT, parser.next());
         parser.skipObject();
-        assertEquals(JsonParser.Event.KEY_NAME, parser.next());
-        assertEquals(JsonParser.Event.VALUE_NUMBER, parser.next());
-        assertEquals(JsonParser.Event.END_OBJECT, parser.next());
-		assertFalse(parser.hasNext());
+        Assertions.assertEquals(JsonParser.Event.KEY_NAME, parser.next());
+        Assertions.assertEquals(JsonParser.Event.VALUE_NUMBER, parser.next());
+        Assertions.assertEquals(JsonParser.Event.END_OBJECT, parser.next());
+		Assertions.assertFalse(parser.hasNext());
     }
 
     @Test
     void testSkipInsideObjectReader() {
-        testWithCreateParserFromString("{\"objectToSkip\":{\"huge key\":\"huge value\"},\"simple\":2}", JsonParserSkipTest::testSkipInsideObject);
+        JsonParserFixture.testWithCreateParserFromString("{\"objectToSkip\":{\"huge key\":\"huge value\"},\"simple\":2}", JsonParserSkipTest::testSkipInsideObject);
     }
 
     @Test
     void testSkipInsideObjectStructure() {
-        testWithCreateParserFromObject(Json.createObjectBuilder()
+        JsonParserFixture.testWithCreateParserFromObject(Json.createObjectBuilder()
                 .add("objectToSkip", Json.createObjectBuilder().add("huge key", "huge value"))
                 .add("simple", 2)
                 .build(), JsonParserSkipTest::testSkipInsideObject);
     }
 
     private static void testSkipInsideObject(JsonParser parser) {
-        assertEquals(JsonParser.Event.START_OBJECT, parser.next());
-        assertEquals(JsonParser.Event.KEY_NAME, parser.next());
-        assertEquals(JsonParser.Event.START_OBJECT, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_OBJECT, parser.next());
+        Assertions.assertEquals(JsonParser.Event.KEY_NAME, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_OBJECT, parser.next());
         parser.skipObject();
-        assertEquals(JsonParser.Event.KEY_NAME, parser.next());
-        assertEquals(JsonParser.Event.VALUE_NUMBER, parser.next());
-        assertEquals(JsonParser.Event.END_OBJECT, parser.next());
-		assertFalse(parser.hasNext());
+        Assertions.assertEquals(JsonParser.Event.KEY_NAME, parser.next());
+        Assertions.assertEquals(JsonParser.Event.VALUE_NUMBER, parser.next());
+        Assertions.assertEquals(JsonParser.Event.END_OBJECT, parser.next());
+		Assertions.assertFalse(parser.hasNext());
     }
 
     @Test
     void testNoSkipObjectReader() {
-        testWithCreateParserFromString("{\"key\":\"value\"}", JsonParserSkipTest::testNoSkipObject);
+        JsonParserFixture.testWithCreateParserFromString("{\"key\":\"value\"}", JsonParserSkipTest::testNoSkipObject);
     }
 
     @Test
     void testNoSkipObjectStructure() {
-        testWithCreateParserFromObject(Json.createObjectBuilder()
+        JsonParserFixture.testWithCreateParserFromObject(Json.createObjectBuilder()
                 .add("Key", "value")
                 .build(), JsonParserSkipTest::testNoSkipObject);
     }
 
     private static void testNoSkipObject(JsonParser parser) {
-        assertEquals(JsonParser.Event.START_OBJECT, parser.next());
-        assertEquals(JsonParser.Event.KEY_NAME, parser.next());
+        Assertions.assertEquals(JsonParser.Event.START_OBJECT, parser.next());
+        Assertions.assertEquals(JsonParser.Event.KEY_NAME, parser.next());
         parser.skipObject();
-		assertFalse(parser.hasNext());
+		Assertions.assertFalse(parser.hasNext());
     }
 }
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..6ac8c210 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonParserTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -16,10 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.io.InputStreamReader;
@@ -31,19 +27,35 @@
 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.JsonParserFixture;
 import org.eclipse.parsson.api.BufferPool;
+import org.hamcrest.Matcher;
+import org.hamcrest.MatcherAssert;
+import org.hamcrest.Matchers;
 
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
 
 /**
  * JsonParser Tests
@@ -54,6 +66,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<Event> GET_STRING_EVENT_ENUM_SET =
+            EnumSet.of(JsonParser.Event.KEY_NAME, JsonParser.Event.VALUE_STRING, JsonParser.Event.VALUE_NUMBER);
+
+    private static final EnumSet<JsonParser.Event> NOT_GET_VALUE_EVENT_ENUM_SET = EnumSet.of(JsonParser.Event.END_OBJECT, JsonParser.Event.END_ARRAY);
+
+    private static final Collector<Map.Entry<String, JsonValue>, ?, ArrayList<String>> 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(
@@ -175,20 +203,20 @@ void testEmptyArrayStructureIterator() {
     }
 
     static void testEmptyArrayIterator(JsonParser parser) {
-        assertEquals(true, parser.hasNext());
-        assertEquals(true, parser.hasNext());
-        assertEquals(Event.START_ARRAY, parser.next());
+		Assertions.assertTrue(parser.hasNext());
+		Assertions.assertTrue(parser.hasNext());
+        Assertions.assertEquals(Event.START_ARRAY, parser.next());
 
-        assertEquals(true, parser.hasNext());
-        assertEquals(true, parser.hasNext());
-        assertEquals(Event.END_ARRAY, parser.next());
+		Assertions.assertTrue(parser.hasNext());
+		Assertions.assertTrue(parser.hasNext());
+        Assertions.assertEquals(Event.END_ARRAY, parser.next());
 
-        assertEquals(false, parser.hasNext());
-        assertEquals(false, parser.hasNext());
+		Assertions.assertFalse(parser.hasNext());
+		Assertions.assertFalse(parser.hasNext());
         try {
             parser.next();
-            fail("Should have thrown a NoSuchElementException");
-        } catch (NoSuchElementException ne) {
+            Assertions.fail("Should have thrown a NoSuchElementException");
+        } catch (NoSuchElementException ignored) {
         }
     }
 
@@ -209,12 +237,12 @@ void testEmptyArrayIterator2Structure() {
     }
 
     static void testEmptyArrayIterator2(JsonParser parser) {
-        assertEquals(Event.START_ARRAY, parser.next());
-        assertEquals(Event.END_ARRAY, parser.next());
+        Assertions.assertEquals(Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(Event.END_ARRAY, parser.next());
         try {
             parser.next();
-            fail("Should have thrown a NoSuchElementException");
-        } catch (NoSuchElementException ne) {
+            Assertions.fail("Should have thrown a NoSuchElementException");
+        } catch (NoSuchElementException ignored) {
         }
     }
 
@@ -234,13 +262,13 @@ void testEmptyArrayIterator3Structure() {
     }
 
     static void testEmptyArrayIterator3(JsonParser parser) {
-        assertEquals(Event.START_ARRAY, parser.next());
-        assertEquals(Event.END_ARRAY, parser.next());
-        assertEquals(false, parser.hasNext());
+        Assertions.assertEquals(Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(Event.END_ARRAY, parser.next());
+		Assertions.assertFalse(parser.hasNext());
         try {
             parser.next();
-            fail("Should have thrown a NoSuchElementException");
-        } catch (NoSuchElementException ne) {
+            Assertions.fail("Should have thrown a NoSuchElementException");
+        } catch (NoSuchElementException ignored) {
         }
     }
 
@@ -302,20 +330,20 @@ void testEmptyObjectIteratorStructure() {
     }
 
     static void testEmptyObjectIterator(JsonParser parser) {
-        assertEquals(true, parser.hasNext());
-        assertEquals(true, parser.hasNext());
-        assertEquals(Event.START_OBJECT, parser.next());
+		Assertions.assertTrue(parser.hasNext());
+		Assertions.assertTrue(parser.hasNext());
+        Assertions.assertEquals(Event.START_OBJECT, parser.next());
 
-        assertEquals(true, parser.hasNext());
-        assertEquals(true, parser.hasNext());
-        assertEquals(Event.END_OBJECT, parser.next());
+		Assertions.assertTrue(parser.hasNext());
+		Assertions.assertTrue(parser.hasNext());
+        Assertions.assertEquals(Event.END_OBJECT, parser.next());
 
-        assertEquals(false, parser.hasNext());
-        assertEquals(false, parser.hasNext());
+		Assertions.assertFalse(parser.hasNext());
+		Assertions.assertFalse(parser.hasNext());
         try {
             parser.next();
-            fail("Should have thrown a NoSuchElementException");
-        } catch (NoSuchElementException ne) {
+            Assertions.fail("Should have thrown a NoSuchElementException");
+        } catch (NoSuchElementException ignored) {
         }
     }
 
@@ -336,12 +364,12 @@ void testEmptyObjectIterator2Structure() {
     }
 
     static void testEmptyObjectIterator2(JsonParser parser) {
-        assertEquals(Event.START_OBJECT, parser.next());
-        assertEquals(Event.END_OBJECT, parser.next());
+        Assertions.assertEquals(Event.START_OBJECT, parser.next());
+        Assertions.assertEquals(Event.END_OBJECT, parser.next());
         try {
             parser.next();
-            fail("Should have thrown a NoSuchElementException");
-        } catch (NoSuchElementException ne) {
+            Assertions.fail("Should have thrown a NoSuchElementException");
+        } catch (NoSuchElementException ignored) {
         }
     }
 
@@ -362,12 +390,12 @@ void testEmptyObjectIterator3Structure() {
     }
 
     static void testEmptyObjectIterator3(JsonParser parser) {
-        assertEquals(Event.START_OBJECT, parser.next());
-        assertEquals(Event.END_OBJECT, parser.next());
-        assertEquals(false, parser.hasNext());
+        Assertions.assertEquals(Event.START_OBJECT, parser.next());
+        Assertions.assertEquals(Event.END_OBJECT, parser.next());
+		Assertions.assertFalse(parser.hasNext());
         try {
             parser.next();
-            fail("Should have thrown a NoSuchElementException");
+            Assertions.fail("Should have thrown a NoSuchElementException");
         } catch (NoSuchElementException ne) {
             // expected
         }
@@ -375,14 +403,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);
@@ -390,21 +418,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)) {
@@ -413,14 +441,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);
@@ -430,28 +458,28 @@ void testWikiStructure() throws Exception {
     static void testWiki(JsonParser parser) {
 
         Event event = parser.next();
-        assertEquals(Event.START_OBJECT, event);
+        Assertions.assertEquals(Event.START_OBJECT, event);
 
         testObjectStringValue(parser, "firstName", "John");
         testObjectStringValue(parser, "lastName", "Smith");
 
         event = parser.next();
-        assertEquals(Event.KEY_NAME, event);
-        assertEquals("age", parser.getString());
+        Assertions.assertEquals(Event.KEY_NAME, event);
+        Assertions.assertEquals("age", parser.getString());
 
         event = parser.next();
-        assertEquals(Event.VALUE_NUMBER, event);
-        assertEquals(25, parser.getInt());
-        assertEquals(25, parser.getLong());
-        assertEquals(25, parser.getBigDecimal().intValue());
-        assertTrue( parser.isIntegralNumber());
+        Assertions.assertEquals(Event.VALUE_NUMBER, event);
+        Assertions.assertEquals(25, parser.getInt());
+        Assertions.assertEquals(25, parser.getLong());
+        Assertions.assertEquals(25, parser.getBigDecimal().intValue());
+        Assertions.assertTrue( parser.isIntegralNumber());
 
         event = parser.next();
-        assertEquals(Event.KEY_NAME, event);
-        assertEquals("address", parser.getString());
+        Assertions.assertEquals(Event.KEY_NAME, event);
+        Assertions.assertEquals("address", parser.getString());
 
         event = parser.next();
-        assertEquals(Event.START_OBJECT, event);
+        Assertions.assertEquals(Event.START_OBJECT, event);
 
 
         testObjectStringValue(parser, "streetAddress", "21 2nd Street");
@@ -460,42 +488,42 @@ static void testWiki(JsonParser parser) {
         testObjectStringValue(parser, "postalCode", "10021");
 
         event = parser.next();
-        assertEquals(Event.END_OBJECT, event);
+        Assertions.assertEquals(Event.END_OBJECT, event);
 
         event = parser.next();
-        assertEquals(Event.KEY_NAME, event);
-        assertEquals("phoneNumber", parser.getString());
+        Assertions.assertEquals(Event.KEY_NAME, event);
+        Assertions.assertEquals("phoneNumber", parser.getString());
 
         event = parser.next();
-        assertEquals(Event.START_ARRAY, event);
+        Assertions.assertEquals(Event.START_ARRAY, event);
         event = parser.next();
-        assertEquals(Event.START_OBJECT, event);
+        Assertions.assertEquals(Event.START_OBJECT, event);
         testObjectStringValue(parser, "type", "home");
         testObjectStringValue(parser, "number", "212 555-1234");
         event = parser.next();
-        assertEquals(Event.END_OBJECT, event);
+        Assertions.assertEquals(Event.END_OBJECT, event);
 
         event = parser.next();
-        assertEquals(Event.START_OBJECT, event);
+        Assertions.assertEquals(Event.START_OBJECT, event);
         testObjectStringValue(parser, "type", "fax");
         testObjectStringValue(parser, "number", "646 555-4567");
         event = parser.next();
-        assertEquals(Event.END_OBJECT, event);
+        Assertions.assertEquals(Event.END_OBJECT, event);
         event = parser.next();
-        assertEquals(Event.END_ARRAY, event);
+        Assertions.assertEquals(Event.END_ARRAY, event);
 
         event = parser.next();
-        assertEquals(Event.END_OBJECT, event);
+        Assertions.assertEquals(Event.END_OBJECT, event);
     }
 
     static void testObjectStringValue(JsonParser parser, String name, String value) {
         Event event = parser.next();
-        assertEquals(Event.KEY_NAME, event);
-        assertEquals(name, parser.getString());
+        Assertions.assertEquals(Event.KEY_NAME, event);
+        Assertions.assertEquals(name, parser.getString());
 
         event = parser.next();
-        assertEquals(Event.VALUE_STRING, event);
-        assertEquals(value, parser.getString());
+        Assertions.assertEquals(Event.VALUE_STRING, event);
+        Assertions.assertEquals(value, parser.getString());
     }
 
     @Test
@@ -518,27 +546,27 @@ void testNestedArrayStructure() {
     }
 
     static void testNestedArray(JsonParser parser) {
-        assertEquals(Event.START_ARRAY, parser.next());
-        assertEquals(Event.START_ARRAY, parser.next());
-        assertEquals(Event.END_ARRAY, parser.next());
-        assertEquals(Event.START_ARRAY, parser.next());
-        assertEquals(Event.START_ARRAY, parser.next());
-        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());
+        Assertions.assertEquals(Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(Event.END_ARRAY, parser.next());
+        Assertions.assertEquals(Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(Event.START_ARRAY, parser.next());
+        Assertions.assertEquals(Event.END_ARRAY, parser.next());
+        Assertions.assertEquals(Event.END_ARRAY, parser.next());
+        Assertions.assertEquals(Event.END_ARRAY, parser.next());
+		Assertions.assertFalse(parser.hasNext());
+		Assertions.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);
@@ -548,39 +576,39 @@ void testExceptionsStructure() throws Exception {
     static void testExceptions(JsonParser parser) {
 
         Event event = parser.next();
-        assertEquals(Event.START_OBJECT, event);
+        Assertions.assertEquals(Event.START_OBJECT, event);
 
         try {
             parser.getString();
-            fail("JsonParser#getString() should have thrown exception in START_OBJECT state");
+            Assertions.fail("JsonParser#getString() should have thrown exception in START_OBJECT state");
         } catch (IllegalStateException expected) {
             // no-op
         }
 
         try {
             parser.isIntegralNumber();
-            fail("JsonParser#getNumberType() should have thrown exception in START_OBJECT state");
+            Assertions.fail("JsonParser#getNumberType() should have thrown exception in START_OBJECT state");
         } catch (IllegalStateException expected) {
             // no-op
         }
 
         try {
             parser.getInt();
-            fail("JsonParser#getInt() should have thrown exception in START_OBJECT state");
+            Assertions.fail("JsonParser#getInt() should have thrown exception in START_OBJECT state");
         } catch (IllegalStateException expected) {
             // no-op
         }
 
         try {
             parser.getLong();
-            fail("JsonParser#getLong() should have thrown exception in START_OBJECT state");
+            Assertions.fail("JsonParser#getLong() should have thrown exception in START_OBJECT state");
         } catch (IllegalStateException expected) {
             // no-op
         }
 
         try {
             parser.getBigDecimal();
-            fail("JsonParser#getBigDecimal() should have thrown exception in START_OBJECT state");
+            Assertions.fail("JsonParser#getBigDecimal() should have thrown exception in START_OBJECT state");
         } catch (IllegalStateException expected) {
             // no-op
         }
@@ -615,7 +643,7 @@ void testIntNumber() {
             try (JsonParser parser = factory.createParser(new StringReader("["+num+"]"))) {
                 parser.next();
                 parser.next();
-                assertEquals(new BigDecimal(num).intValue(), parser.getInt(), "Fails for num="+num);
+                Assertions.assertEquals(new BigDecimal(num).intValue(), parser.getInt(), "Fails for num="+num);
             }
         }
 
@@ -629,7 +657,7 @@ void testBigDecimalGetString() {
             parser.next();
             parser.next();
             parser.next();
-            assertEquals("1", parser.getString(), "Fails for BigDecimal=1");
+            Assertions.assertEquals("1", parser.getString(), "Fails for BigDecimal=1");
         }
     }
 
@@ -641,7 +669,7 @@ void testIntGetString() {
             parser.next();
             parser.next();
             parser.next();
-            assertEquals("5", parser.getString(), "Fails for int=5");
+            Assertions.assertEquals("5", parser.getString(), "Fails for int=5");
         }
     }
 
@@ -686,8 +714,8 @@ void testBufferPoolFeature() {
             parser.next();
             parser.next();
         }
-        assertTrue(bufferPool.isTakeCalled());
-        assertTrue(bufferPool.isRecycleCalled());
+        Assertions.assertTrue(bufferPool.isTakeCalled());
+        Assertions.assertTrue(bufferPool.isRecycleCalled());
     }
 
     @Test
@@ -709,10 +737,10 @@ void testBufferSizes() {
                 try (JsonParser parser = factory.createParser(new StringReader(str))) {
                     parser.next();
                     parser.next();
-                    assertEquals(name, parser.getString(), "Fails for " + str);
+                    Assertions.assertEquals(name, parser.getString(), "Fails for " + str);
                     parser.next();
                     parser.next();
-                    assertEquals(new BigDecimal(num).intValue(), parser.getInt(), "Fails for "+str);
+                    Assertions.assertEquals(new BigDecimal(num).intValue(), parser.getInt(), "Fails for "+str);
                 }
             }
         }
@@ -734,9 +762,9 @@ void testStringUsingStandardBuffer() throws Throwable {
             try (JsonParser parser = factory.createParser(new StringReader(str))) {
                 parser.next();
                 parser.next();
-                assertEquals(name, parser.getString(), "Fails for size=" + i);
+                Assertions.assertEquals(name, parser.getString(), "Fails for size=" + i);
                 parser.next();
-                assertEquals(name, parser.getString(), "Fails for size=" + i);
+                Assertions.assertEquals(name, parser.getString(), "Fails for size=" + i);
             } catch (Throwable e) {
                 throw new Throwable("Failed for size=" + i, e);
             }
@@ -761,9 +789,9 @@ void testIntegerUsingStandardBuffer() throws Throwable {
             try (JsonParser parser = factory.createParser(new StringReader(str))) {
                 parser.next();
                 parser.next();
-                assertEquals(name, parser.getString(), "Fails for size=" + i);
+                Assertions.assertEquals(name, parser.getString(), "Fails for size=" + i);
                 parser.next();
-                assertEquals(num, parser.getInt(), "Fails for size=" + i);
+                Assertions.assertEquals(num, parser.getInt(), "Fails for size=" + i);
             } catch (Throwable e) {
                 throw new Throwable("Failed for size=" + i, e);
             }
@@ -788,18 +816,18 @@ void testStringUsingBuffers() throws Throwable {
                 try (JsonParser parser = factory.createParser(new StringReader(str))) {
                     parser.next();
                     parser.next();
-                    assertEquals(name, parser.getString(), "name fails for buffer size=" + size + " name length=" + i);
+                    Assertions.assertEquals(name, parser.getString(), "name fails for buffer size=" + size + " name length=" + i);
                     location = parser.getLocation();
-                    assertEquals(name.length() + 3, location.getStreamOffset(), "Stream offset fails for buffer size=" + size + " name length=" + i);
-                    assertEquals(name.length() + 4, 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);
+                    Assertions.assertEquals(name.length() + 3, location.getStreamOffset(), "Stream offset fails for buffer size=" + size + " name length=" + i);
+                    Assertions.assertEquals(name.length() + 4, location.getColumnNumber(), "Column value fails for buffer size=" + size + " name length=" + i);
+                    Assertions.assertEquals(1, location.getLineNumber(), "Line value fails for buffer size=" + size + " name length=" + i);
 
                     parser.next();
-                    assertEquals(name, parser.getString(), "value fails for buffer size=" + size + " name length=" + i);
+                    Assertions.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(1, location.getLineNumber(), "Line value fails for buffer size=" + size + " name length=" + i);
+                    Assertions.assertEquals(2L * name.length() + 6, location.getStreamOffset(), "Stream offset fails for buffer size=" + size + " name length=" + i);
+                    Assertions.assertEquals(2L * name.length() + 7, location.getColumnNumber(), "Column value fails for buffer size=" + size + " name length=" + i);
+                    Assertions.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);
                 }
@@ -846,7 +874,7 @@ private void checkExceptionFromHasNext(String input) {
                     try {
                         parser.next();
                     } catch (Throwable t1) {
-                        fail("Exception should occur from hasNext() for '" + input + "'");
+                        Assertions.fail("Exception should occur from hasNext() for '" + input + "'");
                     }
                 }
             } catch (JsonParsingException t) {
@@ -854,7 +882,7 @@ private void checkExceptionFromHasNext(String input) {
                 return;
             }
         }
-        fail();
+        Assertions.fail();
     }
 
     private void checkExceptionFromNext(String input) {
@@ -868,6 +896,633 @@ private void checkExceptionFromNext(String input) {
                 }
             }
         }
-        fail();
+        Assertions.fail();
+    }
+
+    @Nested
+    public class DirectParserTests {
+        @Test
+        void testNumbersStructure() {
+            JsonParserFixture.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() {
+            JsonParserFixture.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();
+            Assertions.assertTrue(parser.isIntegralNumber());
+            Assertions.assertEquals(1, parser.getInt());
+
+            parser.next();
+            parser.getString();
+            parser.next();
+            Assertions.assertTrue(parser.isIntegralNumber());
+            Assertions.assertEquals(1L, parser.getLong());
+
+            parser.next();
+            parser.getString();
+            parser.next();
+            Assertions.assertFalse(parser.isIntegralNumber());
+            Assertions.assertEquals(BigDecimal.valueOf(1d), parser.getBigDecimal());
+
+            parser.next();
+            parser.getString();
+            parser.next();
+            Assertions.assertTrue(parser.isIntegralNumber());
+            Assertions.assertEquals(BigDecimal.TEN, parser.getBigDecimal());
+
+            parser.next();
+            parser.getString();
+            parser.next();
+            Assertions.assertTrue(parser.isIntegralNumber());
+            Assertions.assertEquals(BigDecimal.TEN, parser.getBigDecimal());
+        }
+
+        @Test
+        void testParser_getStringStructure(){
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testParser_getString);
+        }
+
+        @Test
+        void testParser_getStringString(){
+            JsonParserFixture.testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::testParser_getString);
+        }
+
+        private void testParser_getString(JsonParser parser) {
+            List<String> 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);
+                }
+            }
+
+            MatcherAssert.assertThat(values,TestData.FAMILY_MATCHER_WITH_NO_QUOTATION);
+        }
+
+        @Test
+        void testParser_getValueStructure(){
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testParser_getValue);
+        }
+
+        @Test
+        void testParser_getValueString(){
+            JsonParserFixture.testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::testParser_getValue);
+        }
+
+        private void testParser_getValue(JsonParser parser) {
+            List<String> 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);
+                }
+            }
+
+            MatcherAssert.assertThat(values, TestData.FAMILY_MATCHER_KEYS_WITH_QUOTATION);
+        }
+
+        @Test
+        void testSkipArrayStructure() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::testSkipArray);
+        }
+
+        @Test
+        void testSkipArrayString() {
+            JsonParserFixture.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();
+
+            Assertions.assertEquals("secondElement", key);
+        }
+
+        @Test
+        void testSkipObjectStructure() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createJsonObject(), this::testSkipObject);
+        }
+
+        @Test
+        void testSkipObjectString() {
+            JsonParserFixture.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();
+
+            Assertions.assertEquals("secondPerson", key);
+        }
+
+        private void assertThrowsIllegalStateException(Executable executable) {
+            Assertions.assertThrows(IllegalStateException.class, executable);
+        }
+
+        @Test
+        void testErrorGetObjectStructure() {
+            assertThrowsIllegalStateException(() -> JsonParserFixture.testWithCreateParserFromObject(TestData.createJsonObject(), JsonParser::getObject));
+        }
+
+        @Test
+        void testErrorGetObjectString() {
+            assertThrowsIllegalStateException(() -> JsonParserFixture.testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_OBJECTS, JsonParser::getObject));
+        }
+
+        @Test
+        void testErrorGetArrayStructure() {
+            assertThrowsIllegalStateException(() -> JsonParserFixture.testWithCreateParserFromObject(TestData.createJsonObject(), this::testErrorGetArray));
+        }
+
+        @Test
+        void testErrorGetArrayString() {
+            assertThrowsIllegalStateException(() -> JsonParserFixture.testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_OBJECTS, this::testErrorGetArray));
+        }
+
+        private void testErrorGetArray(JsonParser parser) {
+            parser.next();
+            parser.getArray();
+        }
+
+        @Test
+        void testErrorGetValueEndOfObjectStructure() {
+            assertThrowsIllegalStateException(() -> JsonParserFixture.testWithCreateParserFromObject(TestData.createJsonObject(), this::testErrorGetValueEndOfObject));
+        }
+
+        @Test
+        void testErrorGetValueEndOfObjectString() {
+            assertThrowsIllegalStateException(() -> JsonParserFixture.testWithCreateParserFromString(TestData.JSON_OBJECT_WITH_OBJECTS, this::testErrorGetValueEndOfObject));
+        }
+
+        private void testErrorGetValueEndOfObject(JsonParser parser) {
+            parser.next();
+            parser.skipObject();
+            parser.getValue();
+        }
+
+        @Test
+        void testErrorGetValueEndOfArrayStructure() {
+            assertThrowsIllegalStateException(() -> JsonParserFixture.testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::testErrorGetValueEndOfArray));
+        }
+
+        @Test
+        void testErrorGetValueEndOfArrayString() {
+            assertThrowsIllegalStateException(() -> JsonParserFixture.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() {
+            JsonParserFixture.testWithCreateParserFromObject(Json.createObjectBuilder()
+                    .add("true", true)
+                    .add("false", false)
+                    .addNull("null")
+                    .build(), this::testBooleanNullandCurrentEvent);
+        }
+
+        @Test
+        void testBooleanNullandCurrentEventString() {
+            JsonParserFixture.testWithCreateParserFromString("{\"true\":true,\"false\":false,\"null\":null}", this::testBooleanNullandCurrentEvent);
+        }
+
+        private void testBooleanNullandCurrentEvent(JsonParser parser) {
+            parser.next();
+            parser.next();
+            parser.getValue();
+            parser.next();
+            Assertions.assertEquals(JsonValue.ValueType.TRUE, parser.getValue().getValueType());
+            parser.next();
+            parser.getValue();
+            parser.next();
+            Assertions.assertEquals(JsonValue.ValueType.FALSE, parser.getValue().getValueType());
+            parser.next();
+            parser.getValue();
+            parser.next();
+            Assertions.assertEquals(JsonValue.ValueType.NULL, parser.getValue().getValueType());
+            Assertions.assertEquals(Event.VALUE_NULL, parser.currentEvent());
+        }
+
+        @Test
+        void testBigLongAndDecimalsStructure() {
+            JsonParserFixture.testWithCreateParserFromObject(Json.createObjectBuilder()
+                    .add("long", 12345678901234567L)
+                    .add("longer", 1234567890123456789L)
+                    .build(), this::testBigLongAndDecimals);
+        }
+
+        @Test
+        void testBigLongAndDecimalsString() {
+            JsonParserFixture.testWithCreateParserFromString("{\"long\":12345678901234567,\"longer\":1234567890123456789}", this::testBigLongAndDecimals);
+        }
+
+        private void testBigLongAndDecimals(JsonParser parser) {
+            parser.next();
+            parser.next();
+            parser.getString();
+            parser.next();
+            Assertions.assertEquals("12345678901234567", parser.getValue().toString());
+            parser.next();
+            parser.getString();
+            parser.next();
+            Assertions.assertEquals("1234567890123456789", parser.getValue().toString());
+        }
+
+        private void assertThrowsJsonParsingException(Executable executable) {
+            Assertions.assertThrows(JsonParsingException.class, executable);
+        }
+
+        @Test
+        void testWrongValueAndEndOfObjectInArray() {//509 ArrayContext.getNextEvent, no coma
+            assertThrowsJsonParsingException(() -> JsonParserFixture.testWithCreateParserFromString("{\"a\":[5 }]}", parser -> {
+                parser.next();
+                parser.next();
+                parser.getString();
+                parser.next();
+                parser.getValue();
+            }));
+        }
+
+        @Test
+        void testWrongEndOfObjectInArray() {//518 ArrayContext.getNextEvent, at the end
+            assertThrowsJsonParsingException(() -> JsonParserFixture.testWithCreateParserFromString("{\"a\":[}, 3]}", parser -> {
+                parser.next();
+                parser.next();
+                parser.getString();
+                parser.next();
+                parser.getValue();
+            }));
+        }
+
+        @Test
+        void testWrongKey() {//477 ObjectContext.getNextEvent, at the end
+            assertThrowsJsonParsingException(() -> JsonParserFixture.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(() -> JsonParserFixture.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(() -> JsonParserFixture.testWithCreateParserFromString("{\"a\"}", parser -> {
+                parser.next();
+                parser.next();
+                parser.getString();
+                parser.next();
+            }));
+        }
+
+        @Test
+        void testNoJSONAtAll() {//382 NoneContext.getNextEvent, at the end
+            assertThrowsJsonParsingException(() -> JsonParserFixture.testWithCreateParserFromString("", JsonParser::next));
+        }
+
+        @Test
+        void testWrongArrayEndWithComa() {//518 ArrayContext.getNextEvent, at the end
+            assertThrowsJsonParsingException(() -> JsonParserFixture.testWithCreateParserFromString("[,", parser -> {
+                parser.next();
+                parser.getArray();
+            }));
+        }
+    }
+
+    @Nested
+    class StreamTests {
+        @Test
+        void testGetValueStream_GetOneElement_Structure() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testGetValueStream_GetOneElement);
+        }
+
+        @Test
+        void testGetValueStream_GetOneElement_String() {
+            JsonParserFixture.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"));
+
+            Assertions.assertEquals("John", name.getString());
+        }
+
+        @Test
+        void testGetValueStream_GetListStructure() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testGetValueStream_GetList);
+        }
+
+        @Test
+        void testGetValueStream_GetListString() {
+            JsonParserFixture.testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::testGetValueStream_GetList);
+        }
+
+        private void testGetValueStream_GetList(JsonParser parser) {
+            List<String> values = parser.getValueStream().map(value -> Objects.toString(value, "null")).collect(Collectors.toList());
+
+            MatcherAssert.assertThat(values, Matchers.contains(TestData.JSON_FAMILY_STRING));
+        }
+
+        @Test
+        void testGetArrayStream_GetOneElementStructure() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::testGetArrayStream_GetOneElement);
+        }
+
+        @Test
+        void testGetArrayStream_GetOneElementString() {
+            JsonParserFixture.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"));
+
+            Assertions.assertEquals("first", element.getString());
+            Assertions.assertEquals("firstElement", key);
+        }
+
+        @Test
+        void testGetArrayStream_GetListStructure() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::testGetArrayStream_GetList);
+        }
+
+        @Test
+        void testGetArrayStream_GetListString() {
+            JsonParserFixture.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<String> values = parser.getArrayStream().map(value -> Objects.toString(value, "null")).collect(Collectors.toList());
+
+            MatcherAssert.assertThat(values, TestData.ARRAY_STREAM_MATCHER);
+            Assertions.assertEquals("firstElement", key);
+        }
+
+        @Test
+        void testGetObjectStream_GetOneElementStructure() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createJsonObject(), this::testGetObjectStream_GetOneElement);
+        }
+
+        @Test
+        void testGetObjectStream_GetOneElementString() {
+            JsonParserFixture.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"));
+
+            Assertions.assertEquals("Smith", surname);
+        }
+
+        @Test
+        void testGetObjectStream_GetListStructure() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createFamilyPerson(), this::testGetObjectStream_GetList);
+        }
+
+        @Test
+        void testGetObjectStream_GetListString() {
+            JsonParserFixture.testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::testGetObjectStream_GetList);
+        }
+
+        private void testGetObjectStream_GetList(JsonParser parser) {
+            parser.next();
+            List<String> values = parser.getObjectStream().collect(MAP_TO_LIST_COLLECTOR);
+
+            MatcherAssert.assertThat(values, TestData.FAMILY_MATCHER_KEYS_WITHOUT_QUOTATION);
+        }
+    }
+
+    @Nested
+    public class JSONPStandardParserTests {
+        @Test
+        void testStandardStructureParser_getValueStream() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createFamilyPerson(), this::test_getValueStream);
+        }
+
+        @Test
+        void testStandardStringParser_getValueStream() {
+            JsonParserFixture.testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::test_getValueStream);
+        }
+
+        private void test_getValueStream(JsonParser parser) {
+            List<String> values = parser.getValueStream().map(value -> Objects.toString(value, "null")).collect(Collectors.toList());
+
+            MatcherAssert.assertThat(values, Matchers.contains(TestData.JSON_FAMILY_STRING));
+        }
+
+        @Test
+        void testStandardStructureParser_getArrayStream() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createObjectWithArrays(), this::test_getArrayStream);
+        }
+
+        @Test
+        void testStandardStringParser_getArrayStream() {
+            JsonParserFixture.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<String> values = parser.getArrayStream().map(value -> Objects.toString(value, "null")).collect(Collectors.toList());
+
+            MatcherAssert.assertThat(values, TestData.ARRAY_STREAM_MATCHER);
+            Assertions.assertEquals("firstElement", key);
+        }
+
+        @Test
+        void testStandardStructureParser_getObjectStream() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createFamilyPerson(), this::test_getObjectStream);
+        }
+
+        @Test
+        void testStandardStringParser_getObjectStream() {
+            JsonParserFixture.testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::test_getObjectStream);
+        }
+
+        private void test_getObjectStream(JsonParser parser) {
+            parser.next();
+            List<String> values = parser.getObjectStream().collect(MAP_TO_LIST_COLLECTOR);
+
+            MatcherAssert.assertThat(values, TestData.FAMILY_MATCHER_KEYS_WITHOUT_QUOTATION);
+        }
+
+        @Test
+        void testStandardStructureParser_getValue() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createFamilyPerson(), this::test_getValue);
+        }
+
+        @Test
+        void testStandardStringParser_getValue() {
+            JsonParserFixture.testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::test_getValue);
+        }
+
+        private void test_getValue(JsonParser parser) {
+            List<String> 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);
+                }
+            }
+
+            MatcherAssert.assertThat(values, TestData.FAMILY_MATCHER_KEYS_WITH_QUOTATION);
+        }
+
+        @Test
+        void testStandardStructureParser_getString() {
+            JsonParserFixture.testWithCreateParserFromObject(TestData.createFamilyPerson(), this::test_getString);
+        }
+
+        @Test
+        void testStandardStringParser_getString() {
+            JsonParserFixture.testWithCreateParserFromString(TestData.JSON_FAMILY_STRING, this::test_getString);
+        }
+
+        private void test_getString(JsonParser parser) {
+            List<String> 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);
+                }
+            }
+
+            MatcherAssert.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<Iterable<? extends String>> 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<Iterable<? extends String>> 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<Iterable<? extends String>> 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<Iterable<? extends String>> 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);
+        }
     }
 }
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonParsingExceptionTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonParsingExceptionTest.java
index 316d5794..b2cf9d08 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonParsingExceptionTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonParsingExceptionTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2024 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
@@ -16,9 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.StringReader;
 
 import jakarta.json.Json;
@@ -26,6 +23,7 @@
 import jakarta.json.stream.JsonParser;
 import jakarta.json.stream.JsonParsingException;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -131,14 +129,14 @@ private void testMalformedJson(String json, JsonLocation expected) {
             while (parser.hasNext()) {
                 parser.next();
             }
-            fail("Expected to throw JsonParsingException for " + json);
+            Assertions.fail("Expected to throw JsonParsingException for " + json);
         } catch (JsonParsingException je) {
             // Expected
             if (expected != null) {
                 JsonLocation got = je.getLocation();
-                assertEquals(expected.getLineNumber(), got.getLineNumber());
-                assertEquals(expected.getColumnNumber(), got.getColumnNumber());
-                assertEquals(expected.getStreamOffset(), got.getStreamOffset());
+                Assertions.assertEquals(expected.getLineNumber(), got.getLineNumber());
+                Assertions.assertEquals(expected.getColumnNumber(), got.getColumnNumber());
+                Assertions.assertEquals(expected.getStreamOffset(), got.getStreamOffset());
             }
         }
     }
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..57020724 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchBugsTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchBugsTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2024 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
@@ -25,8 +25,7 @@
 
 import java.io.StringReader;
 
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -38,7 +37,7 @@ public class JsonPatchBugsTest {
     // https://github.com/javaee/jsonp/issues/58
     @Test
     void applyThrowsJsonException() {
-        assertThrows(JsonException.class, () -> {
+        Assertions.assertThrows(JsonException.class, () -> {
             JsonArray array = Json.createArrayBuilder()
                     .add(Json.createObjectBuilder()
                             .add("name", "Bob")
@@ -48,14 +47,14 @@ void applyThrowsJsonException() {
                     .replace("/0/name", "Bobek")
                     .replace("/1/name", "Vila Amalka")
                     .build();
-            JsonArray result = patch.apply(array);
+            patch.apply(array);
         });
     }
 
     // https://github.com/eclipse-ee4j/jsonp/issues/181
     @Test
     void applyThrowsJsonException2() {
-        assertThrows(JsonException.class, () -> {
+        Assertions.assertThrows(JsonException.class, () -> {
             // JSON document to be patched
             String targetDocument
                     = "{\n"
@@ -78,7 +77,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/JsonPatchBuilderTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchBuilderTest.java
index c4eab5f3..cc52d00d 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchBuilderTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchBuilderTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,13 +16,12 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
 import jakarta.json.Json;
 import jakarta.json.JsonObject;
 import jakarta.json.JsonPatchBuilder;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -42,7 +41,7 @@ void shouldBuildJsonPatchExpressionUsingJsonPatchBuilder() {
                     .copy("/address/lastName", "/lastName")
                     .build()
                     .apply(buildPerson());
-        assertThat(result, is(expectedBuildPerson()));
+        MatcherAssert.assertThat(result, CoreMatchers.is(expectedBuildPerson()));
         
     }
 
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..3c74944a 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchDiffTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchDiffTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,12 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
@@ -35,6 +29,9 @@
 import jakarta.json.JsonStructure;
 import jakarta.json.JsonValue;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -63,6 +60,7 @@ public static Iterable<Object[]> data() throws Exception {
         return examples;
     }
 
+    @SuppressWarnings("unchecked")
     private static Class<? extends Exception> createExceptionClass(
             JsonString exceptionClassName) throws ClassNotFoundException {
         if (exceptionClassName != null) {
@@ -89,13 +87,13 @@ private static JsonArray loadData() {
     void shouldExecuteJsonPatchDiffOperationsToJsonDocument(JsonStructure original, JsonStructure target, JsonValue expected, Class<? extends Exception> expectedException) {
         try {
             JsonPatch diff = Json.createDiff(original, target);
-            assertThat(diff, is(Json.createPatchBuilder((JsonArray) expected).build()));
-            assertThat(expectedException, nullValue());
+            MatcherAssert.assertThat(diff, CoreMatchers.is(Json.createPatchBuilder((JsonArray) expected).build()));
+            MatcherAssert.assertThat(expectedException, CoreMatchers.nullValue());
         } catch (Exception e) {
             if (expectedException == null) {
-                fail(e.getMessage());
+                Assertions.fail(e.getMessage());
             } else {
-                assertThat(e, instanceOf(expectedException));
+                MatcherAssert.assertThat(e, CoreMatchers.instanceOf(expectedException));
             }
         }
     }
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..3fd22fff 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchOperationTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchOperationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2024 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
@@ -16,8 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
 import jakarta.json.JsonException;
 import jakarta.json.JsonPatch.Operation;
 
@@ -44,8 +42,6 @@ void fromOperationName() {
 
     @Test
     void fromInvalidOperationName() {
-        assertThrows(JsonException.class, () -> {
-            Operation.fromOperationName("undef");
-        });
+        Assertions.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..6717085b 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPatchTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,12 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
@@ -35,6 +29,9 @@
 import jakarta.json.JsonStructure;
 import jakarta.json.JsonValue;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -62,6 +59,7 @@ public static Iterable<Object[]> data() throws Exception {
         return examples;
     }
 
+    @SuppressWarnings("unchecked")
     private static Class<? extends Exception> createExceptionClass(
             JsonString exceptionClassName) throws ClassNotFoundException {
         if (exceptionClassName != null) {
@@ -88,13 +86,13 @@ void shouldExecuteJsonPatchOperationsToJsonDocument(JsonArray arrayPatch, JsonSt
         try {
             JsonPatch patch = Json.createPatchBuilder(arrayPatch).build();
             JsonStructure output = patch.apply(target);
-            assertThat(output, is(expected));
-            assertThat(expectedException, nullValue());
+            MatcherAssert.assertThat(output, CoreMatchers.is(expected));
+            MatcherAssert.assertThat(expectedException, CoreMatchers.nullValue());
         } catch (Exception e) {
             if (expectedException == null) {
-                fail(e.getMessage());
+                Assertions.fail(e.getMessage());
             } else {
-                assertThat(e, instanceOf(expectedException));
+                MatcherAssert.assertThat(e, CoreMatchers.instanceOf(expectedException));
             }
         }
     }
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerAddOperationTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerAddOperationTest.java
index e3b4156a..5a749136 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerAddOperationTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerAddOperationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,9 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
 import java.util.Arrays;
 
 import jakarta.json.Json;
@@ -27,6 +24,8 @@
 import jakarta.json.JsonStructure;
 import jakarta.json.JsonValue;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -51,7 +50,7 @@ public static Iterable<Object[]> data() throws Exception {
     void shouldAddElementsToExistingJsonDocument(JsonObject pathOperation, JsonStructure target, JsonValue expectedResult) {
         JsonPointer pointer = Json.createPointer(pathOperation.getString("path"));
         JsonObject modified = (JsonObject) pointer.add(target, pathOperation.get("value"));
-        assertThat(modified, is(expectedResult));
+        MatcherAssert.assertThat(modified, CoreMatchers.is(expectedResult));
     }
 
     static JsonObject buildAddress() {
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerEscapeTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerEscapeTest.java
index 6e566c85..830756f8 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerEscapeTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerEscapeTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2024 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
@@ -16,11 +16,10 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 
 import jakarta.json.Json;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -32,13 +31,13 @@ public class JsonPointerEscapeTest {
 
     @Test
     void escapeTest() {
-        assertEquals("a~1b", Json.encodePointer("a/b"));
-        assertEquals("a~0b~1c", Json.encodePointer("a~b/c"));
+        Assertions.assertEquals("a~1b", Json.encodePointer("a/b"));
+        Assertions.assertEquals("a~0b~1c", Json.encodePointer("a~b/c"));
     }
 
     @Test
     void unescapeTest() {
-        assertEquals("/a/b", Json.decodePointer("/a~1b"));
-        assertEquals("/~1", Json.decodePointer("/~01"));
+        Assertions.assertEquals("/a/b", Json.decodePointer("/a~1b"));
+        Assertions.assertEquals("/~1", Json.decodePointer("/~01"));
     }
 }
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..eb8f081e 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerRemoveOperationTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerRemoveOperationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,9 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
 import java.util.Arrays;
 
 import jakarta.json.Json;
@@ -26,6 +23,8 @@
 import jakarta.json.JsonPointer;
 import jakarta.json.JsonValue;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -49,8 +48,8 @@ public static Iterable<Object[]> 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);
-        assertThat(modified, is(expectedResult));
+        JsonObject modified = pointer.remove(target);
+        MatcherAssert.assertThat(modified, CoreMatchers.is(expectedResult));
     }
 
     static JsonObject buildPerson() {
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerReplaceOperationTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerReplaceOperationTest.java
index f66bd6ed..c669129b 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerReplaceOperationTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerReplaceOperationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,12 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.util.Arrays;
 
 import jakarta.json.Json;
@@ -31,6 +25,9 @@
 import jakarta.json.JsonStructure;
 import jakarta.json.JsonValue;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -57,13 +54,13 @@ void shouldReplaceElementsToExistingJsonDocument(JsonObject pathOperation, JsonS
         try {
         JsonPointer pointer = Json.createPointer(pathOperation.getString("path"));
         JsonObject modified = (JsonObject) pointer.replace(target, pathOperation.get("value"));
-        assertThat(modified, is(expectedResult));
-        assertThat(expectedException, nullValue());
+        MatcherAssert.assertThat(modified, CoreMatchers.is(expectedResult));
+        MatcherAssert.assertThat(expectedException, CoreMatchers.nullValue());
         } catch(Exception e) {
             if(expectedException == null) {
-                fail(e.getMessage());
+                Assertions.fail(e.getMessage());
             } else {
-                assertThat(e, instanceOf(expectedException));
+                MatcherAssert.assertThat(e, CoreMatchers.instanceOf(expectedException));
             }
         }
     }
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..f2423176 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,15 +16,10 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.util.Arrays;
+import java.util.Objects;
 
 import jakarta.json.Json;
 import jakarta.json.JsonException;
@@ -33,6 +28,9 @@
 import jakarta.json.JsonReader;
 import jakarta.json.JsonValue;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -73,22 +71,22 @@ public static Iterable<Object[]> data() throws Exception {
     void shouldEvaluateJsonPointerExpressions(JsonPointer pointer, JsonValue expected, Class<? extends Exception> expectedException) {
         try {
             JsonValue result = pointer.getValue(rfc6901Example);
-            assertThat(result, is(expected));
-            assertThat(expectedException, nullValue());
+            MatcherAssert.assertThat(result, CoreMatchers.is(expected));
+            MatcherAssert.assertThat(expectedException, CoreMatchers.nullValue());
         } catch(Exception e) {
             if(expectedException == null) {
-                fail(e.getMessage());
+                Assertions.fail(e.getMessage());
             } else {
-                assertThat(e, instanceOf(expectedException));
+                MatcherAssert.assertThat(e, CoreMatchers.instanceOf(expectedException));
             }
         }
     }
 
-    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/JsonPointerToStringTest.java b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerToStringTest.java
index 7061ac85..4fb867d7 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerToStringTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonPointerToStringTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,15 +16,13 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
 import java.util.Arrays;
 
 import jakarta.json.Json;
 import jakarta.json.JsonPointer;
 
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.MatcherAssert;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -43,6 +41,6 @@ public static Iterable<Object> data() {
     @ParameterizedTest(name = "{index}: {0}")
     void shouldReturnOriginalEscapedString(String expected) {
         JsonPointer pointer = Json.createPointer(expected);
-        assertThat(pointer.toString(), is(equalTo(expected)));
+        MatcherAssert.assertThat(pointer.toString(), CoreMatchers.is(CoreMatchers.equalTo(expected)));
     }
 }
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..c8ed5a17 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonReaderTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonReaderTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -16,15 +16,13 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
-
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.StringReader;
 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,11 +31,11 @@
 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;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 
@@ -47,19 +45,19 @@
 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();
         reader.close();
         String str = array.getString(0);
-        assertEquals("\u0000\u00ff\u00ff", str);
+        Assertions.assertEquals("\u0000\u00ff\u00ff", str);
     }
 
     @Test
@@ -73,14 +71,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);
+				Assertions.assertEquals(new BigInteger(num).longValue(), value.longValue(), "Fails for num=" + num);
+			}
         }
     }
 
@@ -95,31 +90,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);
+				Assertions.assertEquals(new BigInteger(num), value.bigIntegerValueExact(), "Fails for num=" + num);
+			}
         }
     }
 
     @Test
-    void testUnknownFeature() throws Exception {
+    void testUnknownFeature() {
         Map<String, Object> config = new HashMap<>();
         config.put("foo", true);
         JsonReaderFactory factory = Json.createReaderFactory(config);
         factory.createReader(new StringReader("{}"));
         Map<String, ?> config1 = factory.getConfigInUse();
-        if (config1.size() > 0) {
-            fail("Shouldn't have any config in use");
+        if (!config1.isEmpty()) {
+            Assertions.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 +140,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
@@ -168,13 +160,13 @@ void testEmptyStringUsingStandardBuffer() throws Throwable {
             try {
                 JsonReader reader = factory.createReader(new StringReader(str));
                 JsonArray array = reader.readArray();
-                assertEquals(1, array.getInt(0));
-                assertEquals("", array.getString(1));
-                assertEquals(name, array.getString(2));
-                assertEquals("", array.getString(3));
-                assertEquals(name, array.getString(4));
-                assertEquals("", array.getString(5));
-                assertEquals(100, array.getInt(6));
+                Assertions.assertEquals(1, array.getInt(0));
+                Assertions.assertEquals("", array.getString(1));
+                Assertions.assertEquals(name, array.getString(2));
+                Assertions.assertEquals("", array.getString(3));
+                Assertions.assertEquals(name, array.getString(4));
+                Assertions.assertEquals("", array.getString(5));
+                Assertions.assertEquals(100, array.getInt(6));
                 reader.close();
             } catch (Throwable t) {
                 throw new Throwable("Failed for name length="+i, t);
@@ -190,7 +182,7 @@ void testDuplicateKeysDefault() {
         JsonReader reader = factory.createReader(new StringReader(json));
         JsonObject object = reader.readObject();
         reader.close();
-        assertEquals("B", object.getString("val1"));
+        Assertions.assertEquals("B", object.getString("val1"));
     }
 
     @Test
@@ -202,21 +194,21 @@ void testDuplicateKeysStrict() {
         JsonReader reader = factory.createReader(new StringReader(json));
         try {
             reader.readObject();
-            fail("It is expected a JsonException");
-        } catch (JsonException e) {}
+            Assertions.fail("It is expected a JsonException");
+        } catch (JsonException ignored) {}
     }
 
     @Test
     void testDuplicateKeysStrictWithParssonConfig() {
         Map<String, Object> 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) {}
+            Assertions.fail("It is expected a JsonException");
+        } catch (JsonException ignored) {}
     }
 
     @Test
@@ -228,7 +220,7 @@ void testDuplicateKeysFirst() {
         JsonReader reader = factory.createReader(new StringReader(json));
         JsonObject object = reader.readObject();
         reader.close();
-        assertEquals("A", object.getString("val1"));
+        Assertions.assertEquals("A", object.getString("val1"));
     }
 
     @Test
@@ -242,7 +234,7 @@ void testDuplicateKeysFirstWithParssonConfig() {
         JsonReader reader = factory.createReader(new StringReader(json));
         JsonObject object = reader.readObject();
         reader.close();
-        assertEquals("A", object.getString("val1"));
+        Assertions.assertEquals("A", object.getString("val1"));
     }
 
     @Test
@@ -254,7 +246,7 @@ void testDuplicateKeysLast() {
         JsonReader reader = factory.createReader(new StringReader(json));
         JsonObject object = reader.readObject();
         reader.close();
-        assertEquals("B", object.getString("val1"));
+        Assertions.assertEquals("B", object.getString("val1"));
     }
 
     // JSONP-23 cached empty string is not reset
@@ -275,13 +267,13 @@ void testEmptyStringUsingBuffers() throws Throwable {
                 try {
                     JsonReader reader = factory.createReader(new StringReader(str));
                     JsonArray array = reader.readArray();
-                    assertEquals(1, array.getInt(0));
-                    assertEquals("", array.getString(1));
-                    assertEquals(name, array.getString(2));
-                    assertEquals("", array.getString(3));
-                    assertEquals(name, array.getString(4));
-                    assertEquals("", array.getString(5));
-                    assertEquals(100, array.getInt(6));
+                    Assertions.assertEquals(1, array.getInt(0));
+                    Assertions.assertEquals("", array.getString(1));
+                    Assertions.assertEquals(name, array.getString(2));
+                    Assertions.assertEquals("", array.getString(3));
+                    Assertions.assertEquals(name, array.getString(4));
+                    Assertions.assertEquals("", array.getString(5));
+                    Assertions.assertEquals(100, array.getInt(6));
                     reader.close();
                 } catch (Throwable t) {
                     throw new Throwable("Failed for buffer size="+size+" name length="+i, t);
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..f78fd6a2 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonSamplesParsingTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonSamplesParsingTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2024 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
@@ -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..5ff56f24 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonStringTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonStringTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2024 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
@@ -16,9 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 import java.io.StringReader;
 
 import jakarta.json.Json;
@@ -26,6 +23,7 @@
 import jakarta.json.JsonReader;
 import jakarta.json.JsonString;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -35,7 +33,7 @@ public class JsonStringTest {
 
     // tests JsonString#toString()
     @Test
-    void testToString() throws Exception {
+    void testToString() {
         escapedString("");
         escapedString("abc");
         escapedString("abc\f");
@@ -52,23 +50,23 @@ 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());
+        Assertions.assertTrue(jsonString1.hashCode() == jsonString1.getString().hashCode());
 
         String string2 = new String("a");
         JsonString jsonString2 = Json.createValue(string2);
 
-        assertTrue(jsonString1.equals(jsonString2));
-        assertTrue(jsonString1.hashCode() == jsonString2.hashCode());
+        Assertions.assertTrue(jsonString1.equals(jsonString2));
+        Assertions.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));
         JsonArray got = jr.readArray();
-        assertEquals(exp, got);
+        Assertions.assertEquals(exp, got);
         jr.close();
     }
 
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..db23e24e 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonValueTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonValueTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2024 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
@@ -16,8 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -40,58 +38,42 @@ public class JsonValueTest {
 
     @Test
     void arrayGetJsonObjectIdx() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            JsonValue.EMPTY_JSON_ARRAY.getJsonObject(0);
-        });
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getJsonObject(0));
     }
 
     @Test
     void arrayGetJsonArrayIdx() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            JsonValue.EMPTY_JSON_ARRAY.getJsonArray(0);
-        });
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getJsonArray(0));
     }
 
     @Test
     void arrayGetJsonNumberIdx() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            JsonValue.EMPTY_JSON_ARRAY.getJsonNumber(0);
-        });
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getJsonNumber(0));
     }
 
     @Test
     void arrayGetJsonStringIdx() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            JsonValue.EMPTY_JSON_ARRAY.getJsonString(0);
-        });
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getJsonString(0));
     }
 
     @Test
     void arrayGetStringIdx() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            JsonValue.EMPTY_JSON_ARRAY.getString(0);
-        });
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getString(0));
     }
 
     @Test
     void arrayGetIntIdx() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            JsonValue.EMPTY_JSON_ARRAY.getInt(0);
-        });
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getInt(0));
     }
 
     @Test
     void arrayGetBooleanIdx() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            JsonValue.EMPTY_JSON_ARRAY.getBoolean(0);
-        });
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.getBoolean(0));
     }
 
     @Test
     void arrayIsNull() {
-        assertThrows(IndexOutOfBoundsException.class, () -> {
-            JsonValue.EMPTY_JSON_ARRAY.isNull(0);
-        });
+        Assertions.assertThrows(IndexOutOfBoundsException.class, () -> JsonValue.EMPTY_JSON_ARRAY.isNull(0));
     }
 
     @Test
@@ -99,44 +81,34 @@ void arrayMethods() {
         Assertions.assertEquals(JsonValue.ValueType.ARRAY, JsonValue.EMPTY_JSON_ARRAY.getValueType());
         Assertions.assertEquals(Collections.<JsonObject>emptyList(), JsonValue.EMPTY_JSON_ARRAY.getValuesAs(JsonObject.class));
         Assertions.assertEquals(Collections.<String>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);
-        });
+        Assertions.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");
-        });
+        Assertions.assertThrows(NullPointerException.class, () -> JsonValue.EMPTY_JSON_OBJECT.getString("normalni string"));
     }
 
     @Test
     void objectGetInt() {
-        assertThrows(NullPointerException.class, () -> {
-            JsonValue.EMPTY_JSON_OBJECT.getInt("hledej cislo");
-        });
+        Assertions.assertThrows(NullPointerException.class, () -> JsonValue.EMPTY_JSON_OBJECT.getInt("hledej cislo"));
     }
 
     @Test
     void objectGetBoolean() {
-        assertThrows(NullPointerException.class, () -> {
-            JsonValue.EMPTY_JSON_OBJECT.getBoolean("booo");
-        });
+        Assertions.assertThrows(NullPointerException.class, () -> JsonValue.EMPTY_JSON_OBJECT.getBoolean("booo"));
     }
 
     @Test
     void objectIsNull() {
-        assertThrows(NullPointerException.class, () -> {
-            JsonValue.EMPTY_JSON_OBJECT.isNull("???");
-        });
+        Assertions.assertThrows(NullPointerException.class, () -> JsonValue.EMPTY_JSON_OBJECT.isNull("???"));
     }
 
     @Test
@@ -147,16 +119,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);
-        });
+        Assertions.assertThrows(UnsupportedOperationException.class, () -> JsonValue.EMPTY_JSON_OBJECT.put("klauni", JsonValue.EMPTY_JSON_ARRAY));
     }
 
     @Test
@@ -192,6 +162,7 @@ private byte[] serialize(Object o) {
         return baos.toByteArray();
     }
 
+    @SuppressWarnings("unchecked")
     private <T> T deserialize(Class<T> 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..082df784 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/JsonWriterTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/JsonWriterTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024 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
@@ -16,9 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.StringWriter;
@@ -29,6 +26,7 @@
 import jakarta.json.JsonValue;
 import jakarta.json.JsonWriter;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -44,7 +42,7 @@ void testObject() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("{}", writer.toString());
+        Assertions.assertEquals("{}", writer.toString());
     }
 
     @Test
@@ -55,7 +53,7 @@ void testEmptyObject() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("{}", writer.toString());
+        Assertions.assertEquals("{}", writer.toString());
     }
 
     @Test
@@ -66,7 +64,7 @@ void testArray() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("[]", writer.toString());
+        Assertions.assertEquals("[]", writer.toString());
     }
 
     @Test
@@ -77,7 +75,7 @@ void testEmptyArray() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("[]", writer.toString());
+        Assertions.assertEquals("[]", writer.toString());
     }
 
     @Test
@@ -88,7 +86,7 @@ void testNumber() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("[10]", writer.toString());
+        Assertions.assertEquals("[10]", writer.toString());
     }
 
     @Test
@@ -99,7 +97,7 @@ void testDoubleNumber() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("[10.5]", writer.toString());
+        Assertions.assertEquals("[10.5]", writer.toString());
     }
 
     @Test
@@ -110,7 +108,7 @@ void testArrayString() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("[\"string\"]", writer.toString());
+        Assertions.assertEquals("[\"string\"]", writer.toString());
     }
 
     @Test
@@ -121,7 +119,7 @@ void testObjectAsValue() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("{}", writer.toString());
+        Assertions.assertEquals("{}", writer.toString());
     }
 
     @Test
@@ -132,7 +130,7 @@ void testNullValue() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("null", writer.toString());
+        Assertions.assertEquals("null", writer.toString());
     }
 
     @Test
@@ -143,7 +141,7 @@ void testTrueValue() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("true", writer.toString());
+        Assertions.assertEquals("true", writer.toString());
     }
 
     @Test
@@ -154,11 +152,11 @@ void testFalseValue() throws Exception {
         jsonWriter.close();
         writer.close();
 
-        assertEquals("false", writer.toString());
+        Assertions.assertEquals("false", writer.toString());
     }
 
     @Test
-    void testIllegalStateExcepton() throws Exception {
+    void testIllegalStateExcepton() {
         JsonObject obj = Json.createObjectBuilder().build();
         JsonArray array = Json.createArrayBuilder().build();
 
@@ -196,16 +194,16 @@ void testNoCloseWriteObjectToStream() throws Exception {
         JsonWriter writer = Json.createWriter(baos);
         writer.write(Json.createObjectBuilder().build());
         // not calling writer.close() intentionally
-        assertEquals("{}", baos.toString("UTF-8"));
+        Assertions.assertEquals("{}", baos.toString("UTF-8"));
     }
 
     @Test
-    void testNoCloseWriteObjectToWriter() throws Exception {
+    void testNoCloseWriteObjectToWriter() {
         StringWriter sw = new StringWriter();
         JsonWriter writer = Json.createWriter(sw);
         writer.write(Json.createObjectBuilder().build());
         // not calling writer.close() intentionally
-        assertEquals("{}", sw.toString());
+        Assertions.assertEquals("{}", sw.toString());
     }
 
     @Test
@@ -214,16 +212,16 @@ void testNoCloseWriteArrayToStream() throws Exception {
         JsonWriter writer = Json.createWriter(baos);
         writer.write(Json.createArrayBuilder().build());
         // not calling writer.close() intentionally
-        assertEquals("[]", baos.toString("UTF-8"));
+        Assertions.assertEquals("[]", baos.toString("UTF-8"));
     }
 
     @Test
-    void testNoCloseWriteArrayToWriter() throws Exception {
+    void testNoCloseWriteArrayToWriter() {
         StringWriter sw = new StringWriter();
         JsonWriter writer = Json.createWriter(sw);
         writer.write(Json.createArrayBuilder().build());
         // not calling writer.close() intentionally
-        assertEquals("[]", sw.toString());
+        Assertions.assertEquals("[]", sw.toString());
     }
 
     @Test
@@ -232,8 +230,8 @@ void testClose() throws Exception {
         JsonWriter writer = Json.createWriter(baos);
         writer.write(Json.createObjectBuilder().build());
         writer.close();
-        assertEquals("{}", baos.toString("UTF-8"));
-        assertTrue(baos.isClosed());
+        Assertions.assertEquals("{}", baos.toString("UTF-8"));
+        Assertions.assertTrue(baos.isClosed());
     }
 
     private static final class MyByteStream extends ByteArrayOutputStream {
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/RFC7159Test.java b/impl/src/test/java/org/eclipse/parsson/tests/RFC7159Test.java
index 85bfeca2..754620ed 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/RFC7159Test.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/RFC7159Test.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,8 +16,6 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 import java.io.StringReader;
 import java.io.StringWriter;
 
@@ -28,6 +26,7 @@
 import jakarta.json.JsonWriter;
 import jakarta.json.stream.JsonGenerator;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -47,7 +46,7 @@ void testCreatValues() {
                                     .add(100)
                                     .add(12345.6789)
                                     .build();
-        assertEquals(expected, array);
+        Assertions.assertEquals(expected, array);
     }
 
     @Test
@@ -65,7 +64,7 @@ void testReadValues() {
                                     .add(100)
                                     .add(12345.6789)
                                     .build();
-        assertEquals(expected, array);
+        Assertions.assertEquals(expected, array);
     }
 
     @Test
@@ -73,17 +72,17 @@ void testWriteValues() {
         StringWriter stringWriter = new StringWriter();
         JsonWriter writer = Json.createWriter(stringWriter);
         writer.write(Json.createValue("someString"));
-        assertEquals("\"someString\"", stringWriter.toString());
+        Assertions.assertEquals("\"someString\"", stringWriter.toString());
 
         stringWriter = new StringWriter();
         writer = Json.createWriter(stringWriter);
         writer.write(Json.createValue(100));
-        assertEquals("100", stringWriter.toString());
+        Assertions.assertEquals("100", stringWriter.toString());
 
         stringWriter = new StringWriter();
         writer = Json.createWriter(stringWriter);
         writer.write(Json.createValue(12345.6789));
-        assertEquals("12345.6789", stringWriter.toString());
+        Assertions.assertEquals("12345.6789", stringWriter.toString());
     }
 
     @Test
@@ -91,16 +90,16 @@ void testGeneratorValues() {
         StringWriter stringWriter = new StringWriter();
         JsonGenerator generator = Json.createGenerator(stringWriter);
         generator.write("someString").close();
-        assertEquals("\"someString\"", stringWriter.toString());
+        Assertions.assertEquals("\"someString\"", stringWriter.toString());
 
         stringWriter = new StringWriter();
         generator = Json.createGenerator(stringWriter);
         generator.write(100).close();
-        assertEquals("100", stringWriter.toString());
+        Assertions.assertEquals("100", stringWriter.toString());
 
         stringWriter = new StringWriter();
         generator = Json.createGenerator(stringWriter);
         generator.write(12345.6789).close();
-        assertEquals("12345.6789", stringWriter.toString());
+        Assertions.assertEquals("12345.6789", stringWriter.toString());
     }
 }
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/ToJsonTest.java b/impl/src/test/java/org/eclipse/parsson/tests/ToJsonTest.java
index 4a65ed20..1aab836c 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/ToJsonTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/ToJsonTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2023 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2024 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
@@ -16,14 +16,13 @@
 
 package org.eclipse.parsson.tests;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 import jakarta.json.Json;
 import jakarta.json.JsonArray;
 import jakarta.json.JsonArrayBuilder;
 import jakarta.json.JsonValue;
 
 import org.eclipse.parsson.TestUtils;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -33,9 +32,9 @@ public class ToJsonTest {
 
     @Test
     void testToJson() {
-        assertEquals(Json.createValue("someString"), TestUtils.toJson("'someString'"));
-        assertEquals(Json.createValue("some'thing"), TestUtils.toJson("'some\\'thing'"));
-        assertEquals(Json.createValue("some\"thing"), TestUtils.toJson("'some\\\"thing'"));
+        Assertions.assertEquals(Json.createValue("someString"), TestUtils.toJson("'someString'"));
+        Assertions.assertEquals(Json.createValue("some'thing"), TestUtils.toJson("'some\\'thing'"));
+        Assertions.assertEquals(Json.createValue("some\"thing"), TestUtils.toJson("'some\\\"thing'"));
         JsonArrayBuilder builder = Json.createArrayBuilder();
         JsonArray array = builder
             .add(Json.createObjectBuilder()
@@ -55,7 +54,7 @@ void testToJson() {
                  "'educations': ['Gunn High', 'UC Berkeley'] }, " +
               " { 'name': 'Jane', " +
                  "'educations': ['Oxford']}]");
-          assertEquals(expected, array);
+          Assertions.assertEquals(expected, array);
     }
 }
 
diff --git a/impl/src/test/java/org/eclipse/parsson/tests/TwitterSearchTest.java b/impl/src/test/java/org/eclipse/parsson/tests/TwitterSearchTest.java
index 1d859171..b1085e3f 100644
--- a/impl/src/test/java/org/eclipse/parsson/tests/TwitterSearchTest.java
+++ b/impl/src/test/java/org/eclipse/parsson/tests/TwitterSearchTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2024 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
diff --git a/pom.xml b/pom.xml
index 02dc20c4..df1a0ebe 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2011, 2023 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2011, 2024 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
@@ -94,12 +94,12 @@
         <spotbugs.exclude>${config.dir}/exclude.xml</spotbugs.exclude>
         <spotbugs.skip>false</spotbugs.skip>
         <spotbugs.threshold>Low</spotbugs.threshold>
-        <spotbugs.version>4.8.1.0</spotbugs.version>
+        <spotbugs.version>4.8.3.1</spotbugs.version>
 
         <jakarta.json-api.version>2.1.3</jakarta.json-api.version>
 
-        <jakarta.annotation-api.version>2.1.1</jakarta.annotation-api.version>
-        <jakarta.xml.bind-api.version>4.0.1</jakarta.xml.bind-api.version>
+        <jakarta.annotation-api.version>3.0.0</jakarta.annotation-api.version>
+        <jakarta.xml.bind-api.version>4.0.2</jakarta.xml.bind-api.version>
         <jakarta.ws.rs-api.version>3.1.0</jakarta.ws.rs-api.version>
     </properties>
 
@@ -297,7 +297,7 @@
                 <plugin>
                     <groupId>org.glassfish.build</groupId>
                     <artifactId>spec-version-maven-plugin</artifactId>
-                    <version>2.1</version>
+                    <version>2.2</version>
                 </plugin>
                 <plugin>
                     <groupId>org.glassfish.copyright</groupId>
@@ -318,12 +318,12 @@
                 <plugin>
                     <groupId>org.codehaus.mojo</groupId>
                     <artifactId>build-helper-maven-plugin</artifactId>
-                    <version>3.4.0</version>
+                    <version>3.5.0</version>
                 </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-javadoc-plugin</artifactId>
-                    <version>3.6.2</version>
+                    <version>3.6.3</version>
                 </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
@@ -333,7 +333,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-compiler-plugin</artifactId>
-                    <version>3.11.0</version>
+                    <version>3.12.1</version>
                 </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
@@ -368,7 +368,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-surefire-plugin</artifactId>
-                    <version>3.2.2</version>
+                    <version>3.2.5</version>
                 </plugin>
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
@@ -487,7 +487,7 @@
                         <plugin>
                             <groupId>org.codehaus.mojo</groupId>
                             <artifactId>exec-maven-plugin</artifactId>
-                            <version>3.1.0</version>
+                            <version>3.2.0</version>
                         </plugin>
                     </plugins>
                 </pluginManagement>