diff --git a/.github/workflows/release-publish.yml b/.github/workflows/release-publish.yml
new file mode 100644
index 0000000..90facb9
--- /dev/null
+++ b/.github/workflows/release-publish.yml
@@ -0,0 +1,62 @@
+name: Release and Publish to Maven Central
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Release version'
+        required: true
+        type: string
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+      
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: 'maven'
+          server-id: ossrh
+          server-username: MAVEN_USERNAME
+          server-password: MAVEN_PASSWORD
+          gpg-private-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          gpg-passphrase: GPG_PASSPHRASE
+
+      - name: Import GPG key
+        run: |
+          echo "${{ secrets.GPG_PRIVATE_KEY }}" | gpg --dearmor > ~/.gnupg/secring.gpg
+          gpg --import ~/.gnupg/secring.gpg
+
+      - name: Release accessors-smart
+        run: |
+          cd accessors-smart
+          ./mvnw clean deploy -P release-sign-artifacts
+        env:
+          MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          MAVEN_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
+          GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
+
+      - name: Release json-smart
+        run: |
+          cd json-smart
+          ./mvnw clean deploy -P release-sign-artifacts
+        env:
+          MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          MAVEN_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
+          GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
+
+      - name: Release json-smart-action
+        run: |
+          cd json-smart-action
+          ./mvnw clean deploy -P release-sign-artifacts
+        env:
+          MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          MAVEN_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
+          GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }}
\ No newline at end of file
diff --git a/README.md b/README.md
index 9d9b3d4..60d95cb 100644
--- a/README.md
+++ b/README.md
@@ -25,6 +25,7 @@ So I do not use my json-smart anymore. I had fun with this project. If you want
 
 * JSONObject merge support overwrite as parameter. [PR 238](https://github.com/netplex/json-smart-v2/pull/238)
 * Add `JSONParser.ACCEPT_INCOMPLETE` to allow parsing partial and incomplete JSON without error [PR 254](https://github.com/netplex/json-smart-v2/pull/254)
+* Add multiple JSON syntax blocks in a single input [PR 272](https://github.com/netplex/json-smart-v2/pull/272)
 
 ### *V 2.5.2* (2025-02-12)
 
diff --git a/accessors-smart/pom.xml b/accessors-smart/pom.xml
index 98621d7..7305547 100644
--- a/accessors-smart/pom.xml
+++ b/accessors-smart/pom.xml
@@ -1,5 +1,5 @@
 <!--
-Copyright 2011-2024 JSON-SMART authors
+Copyright 2011-2025 JSON-SMART authors
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -278,6 +278,16 @@ limitations under the License.
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-install-plugin</artifactId>
+                <version>3.1.4</version>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-deploy-plugin</artifactId>
+                <version>3.1.4</version>
+            </plugin>
         </plugins>
     </build>
     <dependencies>
diff --git a/accessors-smart/src/main/java/net/minidev/asm/ASMUtil.java b/accessors-smart/src/main/java/net/minidev/asm/ASMUtil.java
index 7c1cd35..b33f6c6 100644
--- a/accessors-smart/src/main/java/net/minidev/asm/ASMUtil.java
+++ b/accessors-smart/src/main/java/net/minidev/asm/ASMUtil.java
@@ -1,7 +1,7 @@
 package net.minidev.asm;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/accessors-smart/src/main/java/net/minidev/asm/Accessor.java b/accessors-smart/src/main/java/net/minidev/asm/Accessor.java
index c050410..d449acc 100644
--- a/accessors-smart/src/main/java/net/minidev/asm/Accessor.java
+++ b/accessors-smart/src/main/java/net/minidev/asm/Accessor.java
@@ -1,7 +1,7 @@
 package net.minidev.asm;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/accessors-smart/src/main/java/net/minidev/asm/BeansAccess.java b/accessors-smart/src/main/java/net/minidev/asm/BeansAccess.java
index 21ef4ef..fcafb0a 100644
--- a/accessors-smart/src/main/java/net/minidev/asm/BeansAccess.java
+++ b/accessors-smart/src/main/java/net/minidev/asm/BeansAccess.java
@@ -1,7 +1,7 @@
 package net.minidev.asm;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/accessors-smart/src/main/java/net/minidev/asm/DynamicClassLoader.java b/accessors-smart/src/main/java/net/minidev/asm/DynamicClassLoader.java
index edf58bd..ea662b1 100644
--- a/accessors-smart/src/main/java/net/minidev/asm/DynamicClassLoader.java
+++ b/accessors-smart/src/main/java/net/minidev/asm/DynamicClassLoader.java
@@ -1,7 +1,7 @@
 package net.minidev.asm;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/accessors-smart/src/test/java/net/minidev/asm/ASMTest.java b/accessors-smart/src/test/java/net/minidev/asm/ASMTest.java
index af94f8b..ca9566e 100644
--- a/accessors-smart/src/test/java/net/minidev/asm/ASMTest.java
+++ b/accessors-smart/src/test/java/net/minidev/asm/ASMTest.java
@@ -114,7 +114,6 @@ public void testGet() throws Exception {
     // T1 = System.currentTimeMillis() - T1;
   }
 
-  @Test
   private void subtext(BeansAccess<BTest> acc) {
     BTest t = new BTest();
     acc.set(t, "pubBoolValue", true);
diff --git a/accessors-smart/src/test/java/net/minidev/asm/ex/ConvertExceptionTest.java b/accessors-smart/src/test/java/net/minidev/asm/ex/ConvertExceptionTest.java
new file mode 100644
index 0000000..f5f9465
--- /dev/null
+++ b/accessors-smart/src/test/java/net/minidev/asm/ex/ConvertExceptionTest.java
@@ -0,0 +1,43 @@
+package net.minidev.asm.ex;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class ConvertExceptionTest {
+
+  @Test
+  public void testDefaultConstructor() {
+    ConvertException exception = new ConvertException();
+    assertNotNull(exception);
+    assertNull(exception.getMessage());
+    assertTrue(exception instanceof RuntimeException);
+  }
+
+  @Test
+  public void testConstructorWithMessage() {
+    String message = "Test conversion error";
+    ConvertException exception = new ConvertException(message);
+    assertNotNull(exception);
+    assertEquals(message, exception.getMessage());
+    assertTrue(exception instanceof RuntimeException);
+  }
+
+  @Test
+  public void testConstructorWithNullMessage() {
+    ConvertException exception = new ConvertException(null);
+    assertNotNull(exception);
+    assertNull(exception.getMessage());
+  }
+
+  @Test
+  public void testConstructorWithEmptyMessage() {
+    String message = "";
+    ConvertException exception = new ConvertException(message);
+    assertNotNull(exception);
+    assertEquals(message, exception.getMessage());
+  }
+}
diff --git a/accessors-smart/src/test/java/net/minidev/asm/ex/NoSuchFieldExceptionTest.java b/accessors-smart/src/test/java/net/minidev/asm/ex/NoSuchFieldExceptionTest.java
new file mode 100644
index 0000000..f1a13dc
--- /dev/null
+++ b/accessors-smart/src/test/java/net/minidev/asm/ex/NoSuchFieldExceptionTest.java
@@ -0,0 +1,43 @@
+package net.minidev.asm.ex;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class NoSuchFieldExceptionTest {
+
+  @Test
+  public void testDefaultConstructor() {
+    NoSuchFieldException exception = new NoSuchFieldException();
+    assertNotNull(exception);
+    assertNull(exception.getMessage());
+    assertTrue(exception instanceof RuntimeException);
+  }
+
+  @Test
+  public void testConstructorWithMessage() {
+    String message = "Test field not found error";
+    NoSuchFieldException exception = new NoSuchFieldException(message);
+    assertNotNull(exception);
+    assertEquals(message, exception.getMessage());
+    assertTrue(exception instanceof RuntimeException);
+  }
+
+  @Test
+  public void testConstructorWithNullMessage() {
+    NoSuchFieldException exception = new NoSuchFieldException(null);
+    assertNotNull(exception);
+    assertNull(exception.getMessage());
+  }
+
+  @Test
+  public void testConstructorWithEmptyMessage() {
+    String message = "";
+    NoSuchFieldException exception = new NoSuchFieldException(message);
+    assertNotNull(exception);
+    assertEquals(message, exception.getMessage());
+  }
+}
diff --git a/json-smart-action/pom.xml b/json-smart-action/pom.xml
index 13dc87a..378eace 100644
--- a/json-smart-action/pom.xml
+++ b/json-smart-action/pom.xml
@@ -250,6 +250,16 @@
                     </java>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-install-plugin</artifactId>
+                <version>3.1.4</version>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-deploy-plugin</artifactId>
+                <version>3.1.4</version>
+            </plugin>
         </plugins>
     </build>
     <dependencies>
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/ElementRemover.java b/json-smart-action/src/main/java/net/minidev/json/actions/ElementRemover.java
index 5fda519..c76417c 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/ElementRemover.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/ElementRemover.java
@@ -31,16 +31,19 @@
 public class ElementRemover {
   private Map<String, Object> elementsToRemove;
 
+  /** Creates an element remover with the specified elements to remove */
   public ElementRemover(Map<String, Object> elementsToRemove) {
     this.elementsToRemove =
         elementsToRemove == null ? Collections.<String, Object>emptyMap() : elementsToRemove;
   }
 
+  /** Creates an element remover with the specified JSON object elements to remove */
   public ElementRemover(JSONObject elementsToRemove) {
     this.elementsToRemove =
         elementsToRemove == null ? Collections.<String, Object>emptyMap() : elementsToRemove;
   }
 
+  /** Removes the specified elements from the given JSON object */
   public JSONObject remove(JSONObject objectToClean) {
     JSONTraverseAction strategy = new RemoveElementsJsonAction(this.elementsToRemove);
     JSONTraverser traversal = new JSONTraverser(strategy);
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/PathLocator.java b/json-smart-action/src/main/java/net/minidev/json/actions/PathLocator.java
index c0e1840..758dd8e 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/PathLocator.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/PathLocator.java
@@ -23,8 +23,6 @@
  * A key to the right of a dot is a direct child of a key to the left of a dot. Keys with a dot in
  * their name are not supported.
  *
- * <p>
- *
  * @author adoneitan@gmail.com
  */
 public class PathLocator {
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/navigate/CopyPathsAction.java b/json-smart-action/src/main/java/net/minidev/json/actions/navigate/CopyPathsAction.java
index f292bc9..a757169 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/navigate/CopyPathsAction.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/navigate/CopyPathsAction.java
@@ -26,8 +26,13 @@
  * @since 15 March 2016.
  */
 public class CopyPathsAction implements JSONNavigateAction {
+  /** The destination tree for copied paths */
   protected JSONObject destTree;
+
+  /** The current destination branch */
   protected JSONObject destBranch;
+
+  /** Stack for tracking destination nodes */
   protected Stack<Object> destNodeStack;
 
   @Override
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/navigate/JSONNavigator.java b/json-smart-action/src/main/java/net/minidev/json/actions/navigate/JSONNavigator.java
index 79fab41..64f4c99 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/navigate/JSONNavigator.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/navigate/JSONNavigator.java
@@ -5,15 +5,19 @@
 import net.minidev.json.JSONObject;
 
 /**
+ * A navigator that operates on JSON objects and arrays for path-based navigation.
+ *
  * @author adoneitan@gmail.com
  * @since 15 June 2016.
  */
 public class JSONNavigator extends TreeNavigator<JSONObject, JSONArray> {
 
+  /** Creates a navigator with the specified action and paths */
   public JSONNavigator(JSONNavigateAction action, List<String> pathsToNavigate) {
     super(action, pathsToNavigate);
   }
 
+  /** Creates a navigator with the specified action and paths */
   public JSONNavigator(JSONNavigateAction action, String... pathsToNavigate) {
     super(action, pathsToNavigate);
   }
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/navigate/NavigateAction.java b/json-smart-action/src/main/java/net/minidev/json/actions/navigate/NavigateAction.java
index 592b700..298e098 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/navigate/NavigateAction.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/navigate/NavigateAction.java
@@ -10,6 +10,8 @@
  *
  * <p>See package-info for more details
  *
+ * @param <M> the map type that extends Map&lt;String, Object&gt;
+ * @param <L> the list type that extends List&lt;Object&gt;
  * @author adoneitan@gmail.com
  * @since 15 June 2016
  */
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/navigate/TreeNavigator.java b/json-smart-action/src/main/java/net/minidev/json/actions/navigate/TreeNavigator.java
index 6363679..b39aa93 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/navigate/TreeNavigator.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/navigate/TreeNavigator.java
@@ -23,14 +23,22 @@
  * <p>To navigate the branch k1.k2 of the object {"k1":{"k2":"v1"}, "k3":{"k4":"v2"}} instantiate
  * the navigator like so: new JSONNavigator("k1.k2")
  *
+ * @param <M> the map type that extends Map&lt;String, Object&gt;
+ * @param <L> the list type that extends List&lt;Object&gt;
  * @author adoneitan@gmail.com
  * @since 15 June 2016.
  */
 public class TreeNavigator<M extends Map<String, Object>, L extends List<Object>> {
+  /** The list of paths to navigate */
   protected List<String> pathsToNavigate;
+
+  /** The navigation action to execute */
   protected NavigateAction<M, L> action;
+
+  /** The path prefix to use */
   protected String pathPrefix = "";
 
+  /** Creates a tree navigator with the specified action and paths */
   public TreeNavigator(NavigateAction<M, L> action, List<String> pathsToNavigate) {
     if (action == null) {
       throw new IllegalArgumentException("NavigateAction cannot be null");
@@ -39,15 +47,18 @@ public TreeNavigator(NavigateAction<M, L> action, List<String> pathsToNavigate)
     this.pathsToNavigate = pathsToNavigate;
   }
 
+  /** Sets a path prefix for this navigator */
   public TreeNavigator<M, L> with(String pathPrefix) {
     this.pathPrefix = pathPrefix;
     return this;
   }
 
+  /** Creates a tree navigator with the specified action and paths */
   public TreeNavigator(NavigateAction<M, L> action, String... pathsToNavigate) {
     this(action, Arrays.asList(pathsToNavigate));
   }
 
+  /** Navigates the specified object using the configured paths */
   public void nav(M object) throws Exception {
     if (action.start(object, pathsToNavigate)) {
       for (String path : pathsToNavigate) {
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/path/DotDelimiter.java b/json-smart-action/src/main/java/net/minidev/json/actions/path/DotDelimiter.java
index dc4c519..38e59c3 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/path/DotDelimiter.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/path/DotDelimiter.java
@@ -8,8 +8,10 @@
  * @since 31 May2016
  */
 public class DotDelimiter extends PathDelimiter {
+  /** The dot delimiter character */
   protected static final char DELIM_CHAR = '.';
 
+  /** Creates a new dot delimiter */
   public DotDelimiter() {
     super(DELIM_CHAR);
   }
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/path/PathDelimiter.java b/json-smart-action/src/main/java/net/minidev/json/actions/path/PathDelimiter.java
index db8e495..0cf5b2d 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/path/PathDelimiter.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/path/PathDelimiter.java
@@ -7,32 +7,43 @@
  * @since 31 May 2016
  */
 public abstract class PathDelimiter {
+  /** The delimiter character */
   protected char delimChar;
+
+  /** The delimiter as a string */
   protected String delimStr;
+
+  /** Whether to accept delimiter characters in keys */
   protected boolean acceptDelimInKey;
 
+  /** Creates a path delimiter with the specified character */
   public PathDelimiter(char delim) {
     this.delimChar = delim;
     this.delimStr = String.valueOf(delim);
   }
 
+  /** Configures whether to accept delimiter characters in node names */
   public PathDelimiter withAcceptDelimiterInNodeName(boolean acceptDelimInKey) {
     this.acceptDelimInKey = acceptDelimInKey;
     return this;
   }
 
+  /** Checks if the given key is acceptable based on delimiter rules */
   public boolean accept(String key) {
     if (!acceptDelimInKey && key.contains(delimStr)) return false;
     return true;
   }
 
+  /** Returns the delimiter as a string */
   public String str() {
     return delimStr;
   }
 
+  /** Returns the delimiter character */
   public char chr() {
     return delimChar;
   }
 
+  /** Returns the regex pattern for this delimiter */
   public abstract String regex();
 }
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/traverse/KeysPrintAction.java b/json-smart-action/src/main/java/net/minidev/json/actions/traverse/KeysPrintAction.java
index 70825de..c1e224a 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/traverse/KeysPrintAction.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/traverse/KeysPrintAction.java
@@ -5,6 +5,8 @@
 import net.minidev.json.JSONObject;
 
 /**
+ * A traverse action that prints keys during JSON traversal.
+ *
  * @author adoneitan@gmail.com
  * @since 5/24/16.
  */
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/traverse/LocatePathsJsonAction.java b/json-smart-action/src/main/java/net/minidev/json/actions/traverse/LocatePathsJsonAction.java
index 8ee6e4f..5b338a1 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/traverse/LocatePathsJsonAction.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/traverse/LocatePathsJsonAction.java
@@ -20,14 +20,21 @@
  * @author adoneitan@gmail.com
  */
 public class LocatePathsJsonAction implements JSONTraverseAction {
+  /** The list of paths found during traversal */
   protected List<String> pathsFound;
+
+  /** The list of paths to search for */
   protected List<String> pathsToFind;
+
+  /** The path delimiter to use */
   protected PathDelimiter delim;
 
   /**
+   * Creates a new locate paths action.
+   *
    * @param pathsToFind A path to a field in the {@link JSONObject} should be specified in n-gram
    *     format where keys are chained: k0[[[.k1].k2]...]
-   * @param delim -
+   * @param delim the path delimiter to use
    */
   public LocatePathsJsonAction(List<String> pathsToFind, PathDelimiter delim) {
     this.pathsToFind = pathsToFind;
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/traverse/TreeTraverseAction.java b/json-smart-action/src/main/java/net/minidev/json/actions/traverse/TreeTraverseAction.java
index 2aee21c..26e4e69 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/traverse/TreeTraverseAction.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/traverse/TreeTraverseAction.java
@@ -11,6 +11,8 @@
  *
  * <p>See package-info for more details
  *
+ * @param <M> the map type that extends Map&lt;String, Object&gt;
+ * @param <L> the list type that extends List&lt;Object&gt;
  * @author adoneitan@gmail.com
  */
 public interface TreeTraverseAction<M extends Map<String, Object>, L extends List<Object>> {
diff --git a/json-smart-action/src/main/java/net/minidev/json/actions/traverse/TreeTraverser.java b/json-smart-action/src/main/java/net/minidev/json/actions/traverse/TreeTraverser.java
index 6ad703f..e88f802 100644
--- a/json-smart-action/src/main/java/net/minidev/json/actions/traverse/TreeTraverser.java
+++ b/json-smart-action/src/main/java/net/minidev/json/actions/traverse/TreeTraverser.java
@@ -14,6 +14,8 @@
  *
  * <p>See package-info for more details
  *
+ * @param <M> the map type that extends Map&lt;String, Object&gt;
+ * @param <L> the list type that extends List&lt;Object&gt;
  * @author adoneitan@gmail.com
  */
 public class TreeTraverser<M extends Map<String, Object>, L extends List<Object>> {
diff --git a/json-smart/pom.xml b/json-smart/pom.xml
index 6fc3938..a1fafc6 100644
--- a/json-smart/pom.xml
+++ b/json-smart/pom.xml
@@ -1,5 +1,5 @@
 <!--
-Copyright 2011-2024 JSON-SMART authors
+Copyright 2011-2025 JSON-SMART authors
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -289,6 +289,16 @@ limitations under the License.
 					</execution>
 				</executions>
 			</plugin>
+			<plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-install-plugin</artifactId>
+        <version>3.1.4</version>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-deploy-plugin</artifactId>
+        <version>3.1.4</version>
+      </plugin>
 		</plugins>
 	</build>
 	<dependencies>
diff --git a/json-smart/src/main/java/net/minidev/json/JSONArray.java b/json-smart/src/main/java/net/minidev/json/JSONArray.java
index 41c5413..2e76c05 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONArray.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONArray.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/JSONAware.java b/json-smart/src/main/java/net/minidev/json/JSONAware.java
index 9bc5e74..74a3f3e 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONAware.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONAware.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,8 @@
  */
 public interface JSONAware {
   /**
+   * Converts this object to JSON string representation.
+   *
    * @return JSON text
    */
   String toJSONString();
diff --git a/json-smart/src/main/java/net/minidev/json/JSONAwareEx.java b/json-smart/src/main/java/net/minidev/json/JSONAwareEx.java
index 1fef8f6..c9ceee3 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONAwareEx.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONAwareEx.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,6 +24,9 @@
  */
 public interface JSONAwareEx extends JSONAware {
   /**
+   * Converts this object to JSON string representation with specified compression style.
+   *
+   * @param compression the JSON style for formatting
    * @return JSON text
    */
   String toJSONString(JSONStyle compression);
diff --git a/json-smart/src/main/java/net/minidev/json/JSONNavi.java b/json-smart/src/main/java/net/minidev/json/JSONNavi.java
index 5c7fc3c..cafbfee 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONNavi.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONNavi.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,6 +24,7 @@
 /**
  * A JQuery like Json editor, accessor.
  *
+ * @param <T> the type of the root object
  * @since 1.0.9
  * @author Uriel Chemouni &lt;uchemouni@gmail.com&gt;
  */
diff --git a/json-smart/src/main/java/net/minidev/json/JSONObject.java b/json-smart/src/main/java/net/minidev/json/JSONObject.java
index ebab072..a0556e9 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONObject.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONObject.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/JSONStreamAware.java b/json-smart/src/main/java/net/minidev/json/JSONStreamAware.java
index 447351d..ffa0321 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONStreamAware.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONStreamAware.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,6 +23,11 @@
  * @author FangYidong &lt;fangyidong@yahoo.com.cn&gt;
  */
 public interface JSONStreamAware {
-  /** write JSON string to out. */
+  /**
+   * write JSON string to out.
+   *
+   * @param out the output to write to
+   * @throws IOException if I/O error occurs
+   */
   void writeJSONString(Appendable out) throws IOException;
 }
diff --git a/json-smart/src/main/java/net/minidev/json/JSONStreamAwareEx.java b/json-smart/src/main/java/net/minidev/json/JSONStreamAwareEx.java
index 16f20c9..26b6a2b 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONStreamAwareEx.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONStreamAwareEx.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,6 +23,12 @@
  * @author FangYidong &lt;fangyidong@yahoo.com.cn&gt;
  */
 public interface JSONStreamAwareEx extends JSONStreamAware {
-  /** write JSON string to out. */
+  /**
+   * write JSON string to out.
+   *
+   * @param out the output to write to
+   * @param compression the JSON style for formatting
+   * @throws IOException if I/O error occurs
+   */
   void writeJSONString(Appendable out, JSONStyle compression) throws IOException;
 }
diff --git a/json-smart/src/main/java/net/minidev/json/JSONStyle.java b/json-smart/src/main/java/net/minidev/json/JSONStyle.java
index 86ae8f8..a5fcb3e 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONStyle.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONStyle.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/JSONUtil.java b/json-smart/src/main/java/net/minidev/json/JSONUtil.java
index 8a1fe4e..ca8a361 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONUtil.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONUtil.java
@@ -6,7 +6,7 @@
 import net.minidev.json.annotate.JsonIgnore;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/JSONValue.java b/json-smart/src/main/java/net/minidev/json/JSONValue.java
index 95fdee1..a2e7c02 100644
--- a/json-smart/src/main/java/net/minidev/json/JSONValue.java
+++ b/json-smart/src/main/java/net/minidev/json/JSONValue.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/JStylerObj.java b/json-smart/src/main/java/net/minidev/json/JStylerObj.java
index b176465..0378575 100644
--- a/json-smart/src/main/java/net/minidev/json/JStylerObj.java
+++ b/json-smart/src/main/java/net/minidev/json/JStylerObj.java
@@ -1,7 +1,7 @@
 package net.minidev.json;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/parser/JSONParser.java b/json-smart/src/main/java/net/minidev/json/parser/JSONParser.java
index 013e740..5f1405f 100644
--- a/json-smart/src/main/java/net/minidev/json/parser/JSONParser.java
+++ b/json-smart/src/main/java/net/minidev/json/parser/JSONParser.java
@@ -1,7 +1,7 @@
 package net.minidev.json.parser;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/parser/JSONParserBase.java b/json-smart/src/main/java/net/minidev/json/parser/JSONParserBase.java
index 227dbb9..76a2274 100644
--- a/json-smart/src/main/java/net/minidev/json/parser/JSONParserBase.java
+++ b/json-smart/src/main/java/net/minidev/json/parser/JSONParserBase.java
@@ -1,7 +1,7 @@
 package net.minidev.json.parser;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -197,12 +197,36 @@ private boolean compareDoublePrecision(String convert, String origin) {
     return j == originArray.length;
   }
 
+  protected boolean hasNext() {
+    return c != EOI;
+  }
+
   /**
+   * parse from the first position <br>
    * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
    * ContainerFactory
    */
   protected <T> T parse(JsonReaderI<T> mapper) throws ParseException {
     this.pos = -1;
+    return parseInner(mapper);
+  }
+
+  /**
+   * parse from the current position <br>
+   * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
+   * ContainerFactory
+   */
+  protected <T> T parseNext(JsonReaderI<T> mapper) throws ParseException {
+    this.pos = this.pos > 0 ? this.pos : -1;
+    return parseInner(mapper);
+  }
+
+  /**
+   * parse from the last position <br>
+   * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
+   * ContainerFactory
+   */
+  private <T> T parseInner(JsonReaderI<T> mapper) throws ParseException {
     T result;
     try {
       read();
diff --git a/json-smart/src/main/java/net/minidev/json/parser/JSONParserByteArray.java b/json-smart/src/main/java/net/minidev/json/parser/JSONParserByteArray.java
index 29121dc..683f3f2 100644
--- a/json-smart/src/main/java/net/minidev/json/parser/JSONParserByteArray.java
+++ b/json-smart/src/main/java/net/minidev/json/parser/JSONParserByteArray.java
@@ -1,7 +1,7 @@
 package net.minidev.json.parser;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,6 +33,12 @@ public JSONParserByteArray(int permissiveMode) {
     super(permissiveMode);
   }
 
+  public JSONParserByteArray(byte[] in, int permissiveMode) {
+    super(permissiveMode);
+    this.in = in;
+    this.len = in.length;
+  }
+
   /**
    * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
    * ContainerFactory
@@ -41,14 +47,6 @@ public Object parse(byte[] in) throws ParseException {
     return parse(in, JSONValue.defaultReader.DEFAULT);
   }
 
-  //
-  //
-  //
-  //
-  //
-  //
-  //
-
   /**
    * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
    * ContainerFactory
diff --git a/json-smart/src/main/java/net/minidev/json/parser/JSONParserInputStream.java b/json-smart/src/main/java/net/minidev/json/parser/JSONParserInputStream.java
index 076b302..8e6e443 100644
--- a/json-smart/src/main/java/net/minidev/json/parser/JSONParserInputStream.java
+++ b/json-smart/src/main/java/net/minidev/json/parser/JSONParserInputStream.java
@@ -1,7 +1,7 @@
 package net.minidev.json.parser;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,6 +33,10 @@ public JSONParserInputStream(int permissiveMode) {
     super(permissiveMode);
   }
 
+  public JSONParserInputStream(InputStream in, int permissiveMode) {
+    super(new InputStreamReader(in, StandardCharsets.UTF_8), permissiveMode);
+  }
+
   /**
    * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
    * ContainerFactory
@@ -54,13 +58,4 @@ public <T> T parse(InputStream in, JsonReaderI<T> mapper)
     //
     return super.parse(i2, mapper);
   }
-
-  //
-  //
-  //
-  //
-  //
-  //
-  //
-  //
 }
diff --git a/json-smart/src/main/java/net/minidev/json/parser/JSONParserMemory.java b/json-smart/src/main/java/net/minidev/json/parser/JSONParserMemory.java
index bb19984..bec5808 100644
--- a/json-smart/src/main/java/net/minidev/json/parser/JSONParserMemory.java
+++ b/json-smart/src/main/java/net/minidev/json/parser/JSONParserMemory.java
@@ -1,7 +1,7 @@
 package net.minidev.json.parser;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -41,6 +41,7 @@ protected void readNQString(boolean[] stop) throws IOException {
     extractStringTrim(start, pos);
   }
 
+  /** this function must be sync with JSONParserStream.readNumber */
   protected Object readNumber(boolean[] stop) throws ParseException, IOException {
     int start = pos;
     // accept first char digit or -
@@ -129,6 +130,7 @@ protected void readString() throws ParseException, IOException {
       return;
     }
     sb.clear();
+
     readString2();
   }
 
diff --git a/json-smart/src/main/java/net/minidev/json/parser/JSONParserReader.java b/json-smart/src/main/java/net/minidev/json/parser/JSONParserReader.java
index 20f624e..f12df0a 100644
--- a/json-smart/src/main/java/net/minidev/json/parser/JSONParserReader.java
+++ b/json-smart/src/main/java/net/minidev/json/parser/JSONParserReader.java
@@ -1,7 +1,7 @@
 package net.minidev.json.parser;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -30,11 +30,15 @@
 class JSONParserReader extends JSONParserStream {
   private Reader in;
 
-  // len
   public JSONParserReader(int permissiveMode) {
     super(permissiveMode);
   }
 
+  public JSONParserReader(Reader in, int permissiveMode) {
+    super(permissiveMode);
+    this.in = in;
+  }
+
   /**
    * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
    * ContainerFactory
@@ -54,19 +58,10 @@ public <T> T parse(Reader in, JsonReaderI<T> mapper) throws ParseException {
     return super.parse(mapper);
   }
 
-  //
-  //
-  //
-  //
-  //
-  //
-  //
-
   protected void read() throws IOException {
     int i = in.read();
     c = (i == -1) ? (char) EOI : (char) i;
     pos++;
-    //
   }
 
   protected void readS() throws IOException {
diff --git a/json-smart/src/main/java/net/minidev/json/parser/JSONParserStream.java b/json-smart/src/main/java/net/minidev/json/parser/JSONParserStream.java
index dbcc938..4f5d0f2 100644
--- a/json-smart/src/main/java/net/minidev/json/parser/JSONParserStream.java
+++ b/json-smart/src/main/java/net/minidev/json/parser/JSONParserStream.java
@@ -1,7 +1,7 @@
 package net.minidev.json.parser;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@
  * limitations under the License.
  */
 import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_CHAR;
+// import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_EOF;
 import static net.minidev.json.parser.ParseException.ERROR_UNEXPECTED_TOKEN;
 
 import java.io.IOException;
@@ -28,8 +29,8 @@
  * @see JSONParserReader
  */
 abstract class JSONParserStream extends JSONParserBase {
-  // len
-  //
+  // no protected int len field
+
   public JSONParserStream(int permissiveMode) {
     super(permissiveMode);
   }
@@ -40,6 +41,7 @@ protected void readNQString(boolean[] stop) throws IOException {
     xs = sb.toString().trim();
   }
 
+  /** this function must be sync with JSONParserMemory.readNumber */
   protected Object readNumber(boolean[] stop) throws ParseException, IOException {
     sb.clear();
     sb.append(c); // accept first char digit or -
@@ -111,27 +113,24 @@ protected void readString() throws ParseException, IOException {
       }
       throw new ParseException(pos, ERROR_UNEXPECTED_CHAR, c);
     }
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
+    // acceptIncomplete not implemented for stream
     sb.clear();
-    //
-    //
-    //
-    //
-    //
-    //
-    //
-    //
-    //
-    //
     /* assert (c == '\"' || c == '\'') */
     readString2();
   }
-
-  //
-  //
-  //
-  //
-  //
-  //
-  //
-  //
 }
diff --git a/json-smart/src/main/java/net/minidev/json/parser/JSONParserString.java b/json-smart/src/main/java/net/minidev/json/parser/JSONParserString.java
index 94a4c78..ed1c44c 100644
--- a/json-smart/src/main/java/net/minidev/json/parser/JSONParserString.java
+++ b/json-smart/src/main/java/net/minidev/json/parser/JSONParserString.java
@@ -1,7 +1,7 @@
 package net.minidev.json.parser;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,6 +32,12 @@ public JSONParserString(int permissiveMode) {
     super(permissiveMode);
   }
 
+  public JSONParserString(String in, int permissiveMode) {
+    super(permissiveMode);
+    this.in = in;
+    this.len = in.length();
+  }
+
   /**
    * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
    * ContainerFactory
diff --git a/json-smart/src/main/java/net/minidev/json/parser/MultipleJsonParser.java b/json-smart/src/main/java/net/minidev/json/parser/MultipleJsonParser.java
new file mode 100644
index 0000000..76a1c68
--- /dev/null
+++ b/json-smart/src/main/java/net/minidev/json/parser/MultipleJsonParser.java
@@ -0,0 +1,67 @@
+package net.minidev.json.parser;
+
+import java.io.InputStream;
+import java.io.Reader;
+import net.minidev.json.JSONValue;
+import net.minidev.json.writer.JsonReaderI;
+
+/**
+ * json-smart will parse multiple json separated by blank or line break character.
+ *
+ * <p>multiple json example: <br>
+ * {"json1": "value1"} {"json2": "value2"} <br>
+ * or <br>
+ * [{"json1-key1": "value1"}] [{"json2": "value2"}]
+ */
+public class MultipleJsonParser {
+
+  private final JSONParserBase jsonParser;
+
+  public MultipleJsonParser(byte[] in, int permissiveMode) {
+    this.jsonParser = new JSONParserByteArray(in, permissiveMode);
+  }
+
+  public MultipleJsonParser(InputStream in, int permissiveMode) {
+    this.jsonParser = new JSONParserInputStream(in, permissiveMode);
+  }
+
+  public MultipleJsonParser(Reader in, int permissiveMode) {
+    this.jsonParser = new JSONParserReader(in, permissiveMode);
+  }
+
+  public MultipleJsonParser(String in, int permissiveMode) {
+    this.jsonParser = new JSONParserString(in, permissiveMode);
+  }
+
+  /**
+   * Parse next json with defaultReader <br>
+   * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
+   * ContainerFactory
+   */
+  public Object parseNext() throws ParseException {
+    return jsonParser.parseNext(JSONValue.defaultReader.DEFAULT);
+  }
+
+  /**
+   * Parse next json with target JsonReaderI <br>
+   * use to return Primitive Type, or String, Or JsonObject or JsonArray generated by a
+   * ContainerFactory
+   */
+  public <T> T parseNext(JsonReaderI<T> mapper) throws ParseException {
+    return this.jsonParser.parseNext(mapper);
+  }
+
+  /** Parse next json with target Class */
+  public <T> T parseNext(Class<T> mapTo) throws ParseException {
+    return this.jsonParser.parseNext(JSONValue.defaultReader.getMapper(mapTo));
+  }
+
+  /**
+   * Checks if there is another JSON value available in the input.
+   *
+   * @return true if another JSON value exists, false otherwise
+   */
+  public boolean hasNext() {
+    return this.jsonParser.hasNext();
+  }
+}
diff --git a/json-smart/src/main/java/net/minidev/json/parser/ParseException.java b/json-smart/src/main/java/net/minidev/json/parser/ParseException.java
index b8cf012..6ff2f49 100644
--- a/json-smart/src/main/java/net/minidev/json/parser/ParseException.java
+++ b/json-smart/src/main/java/net/minidev/json/parser/ParseException.java
@@ -1,7 +1,7 @@
 package net.minidev.json.parser;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/writer/ArraysMapper.java b/json-smart/src/main/java/net/minidev/json/writer/ArraysMapper.java
index 04db8e9..84ccab5 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/ArraysMapper.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/ArraysMapper.java
@@ -1,7 +1,7 @@
 package net.minidev.json.writer;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/writer/BeansMapper.java b/json-smart/src/main/java/net/minidev/json/writer/BeansMapper.java
index 446b1b7..3a53b41 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/BeansMapper.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/BeansMapper.java
@@ -1,7 +1,7 @@
 package net.minidev.json.writer;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/writer/CollectionMapper.java b/json-smart/src/main/java/net/minidev/json/writer/CollectionMapper.java
index 83b7821..06e4df3 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/CollectionMapper.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/CollectionMapper.java
@@ -1,7 +1,7 @@
 package net.minidev.json.writer;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/writer/CompessorMapper.java b/json-smart/src/main/java/net/minidev/json/writer/CompessorMapper.java
index 0140077..e26a9e9 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/CompessorMapper.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/CompessorMapper.java
@@ -1,7 +1,7 @@
 package net.minidev.json.writer;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/writer/DefaultMapper.java b/json-smart/src/main/java/net/minidev/json/writer/DefaultMapper.java
index 976b38a..e47eba0 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/DefaultMapper.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/DefaultMapper.java
@@ -22,8 +22,8 @@
 /**
  * Simple Reader Class for generic Map
  *
+ * @param <T> the type of object to map
  * @author uriel
- * @param <T>
  */
 public class DefaultMapper<T> extends JsonReaderI<T> {
   protected DefaultMapper(JsonReader base) {
diff --git a/json-smart/src/main/java/net/minidev/json/writer/DefaultMapperCollection.java b/json-smart/src/main/java/net/minidev/json/writer/DefaultMapperCollection.java
index e0c5217..746549d 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/DefaultMapperCollection.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/DefaultMapperCollection.java
@@ -1,7 +1,7 @@
 package net.minidev.json.writer;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/writer/DefaultMapperOrdered.java b/json-smart/src/main/java/net/minidev/json/writer/DefaultMapperOrdered.java
index 75b931a..6f59c3e 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/DefaultMapperOrdered.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/DefaultMapperOrdered.java
@@ -1,7 +1,7 @@
 package net.minidev.json.writer;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/writer/FakeMapper.java b/json-smart/src/main/java/net/minidev/json/writer/FakeMapper.java
index c0b8b31..e1d9fbb 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/FakeMapper.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/FakeMapper.java
@@ -1,7 +1,7 @@
 package net.minidev.json.writer;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/writer/JsonReader.java b/json-smart/src/main/java/net/minidev/json/writer/JsonReader.java
index ec6b725..0395663 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/JsonReader.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/JsonReader.java
@@ -1,7 +1,7 @@
 package net.minidev.json.writer;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/json-smart/src/main/java/net/minidev/json/writer/JsonReaderI.java b/json-smart/src/main/java/net/minidev/json/writer/JsonReaderI.java
index a456e5c..3b0ff1c 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/JsonReaderI.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/JsonReaderI.java
@@ -1,7 +1,7 @@
 package net.minidev.json.writer;
 
 /*
- *    Copyright 2011-2024 JSON-SMART authors
+ *    Copyright 2011-2025 JSON-SMART authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,6 +43,9 @@ public JsonReaderI(JsonReader base) {
    * called when json-smart parser meet an object key
    *
    * @param key key name
+   * @return a JsonReaderI to handle the object parsing
+   * @throws ParseException if parsing fails
+   * @throws IOException if I/O error occurs
    */
   public JsonReaderI<?> startObject(String key) throws ParseException, IOException {
     throw new RuntimeException(
@@ -53,41 +56,78 @@ public JsonReaderI<?> startObject(String key) throws ParseException, IOException
    * called when json-smart parser start an array.
    *
    * @param key the destination key name, or null.
+   * @return a JsonReaderI to handle the array parsing
+   * @throws ParseException if parsing fails
+   * @throws IOException if I/O error occurs
    */
   public JsonReaderI<?> startArray(String key) throws ParseException, IOException {
     throw new RuntimeException(ERR_MSG + " startArray in " + this.getClass() + " key=" + key);
   }
 
-  /** called when json-smart done parsing a value */
+  /**
+   * called when json-smart done parsing a value
+   *
+   * @param current the current object being built
+   * @param key the key for the value
+   * @param value the parsed value
+   * @throws ParseException if parsing fails
+   * @throws IOException if I/O error occurs
+   */
   public void setValue(Object current, String key, Object value)
       throws ParseException, IOException {
     throw new RuntimeException(ERR_MSG + " setValue in " + this.getClass() + " key=" + key);
   }
 
-  /** ------------- */
+  /**
+   * Gets a value from the current object
+   *
+   * @param current the current object
+   * @param key the key to get the value for
+   * @return the value associated with the key
+   */
   public Object getValue(Object current, String key) {
     throw new RuntimeException(
         ERR_MSG + " getValue(Object current, String key) in " + this.getClass() + " key=" + key);
   }
 
-  // Object current,
+  /**
+   * Gets the type for the specified key
+   *
+   * @param key the key to get the type for
+   * @return the Type associated with the key
+   */
   public Type getType(String key) {
     throw new RuntimeException(
         ERR_MSG + " getType(String key) in " + this.getClass() + " key=" + key);
   }
 
-  /** add a value in an array json object. */
+  /**
+   * add a value in an array json object.
+   *
+   * @param current the current array object
+   * @param value the value to add
+   * @throws ParseException if parsing fails
+   * @throws IOException if I/O error occurs
+   */
   public void addValue(Object current, Object value) throws ParseException, IOException {
     throw new RuntimeException(
         ERR_MSG + " addValue(Object current, Object value) in " + this.getClass());
   }
 
-  /** use to instantiate a new object that will be used as an object */
+  /**
+   * use to instantiate a new object that will be used as an object
+   *
+   * @return a new object instance
+   */
   public Object createObject() {
     throw new RuntimeException(ERR_MSG + " createObject() in " + this.getClass());
   }
 
-  /** use to instantiate a new object that will be used as an array */
+  /**
+   * use to instantiate a new object that will be used as an array
+   *
+   * @return a new array instance
+   */
   public Object createArray() {
     throw new RuntimeException(ERR_MSG + " createArray() in " + this.getClass());
   }
@@ -96,6 +136,9 @@ public Object createArray() {
    * Allow a mapper to convert a temporary structure to the final data format.
    *
    * <p>example: convert an List&lt;Integer&gt; to an int[]
+   *
+   * @param current the current object to convert
+   * @return the converted object
    */
   @SuppressWarnings("unchecked")
   public T convert(Object current) {
diff --git a/json-smart/src/main/java/net/minidev/json/writer/MapperRemapped.java b/json-smart/src/main/java/net/minidev/json/writer/MapperRemapped.java
index 40e712d..e8067d5 100644
--- a/json-smart/src/main/java/net/minidev/json/writer/MapperRemapped.java
+++ b/json-smart/src/main/java/net/minidev/json/writer/MapperRemapped.java
@@ -9,8 +9,8 @@
 /**
  * Simple solution to support on read field renaming
  *
+ * @param <T> the type of object to map
  * @author uriel
- * @param <T>
  */
 public class MapperRemapped<T> extends JsonReaderI<T> {
   private Map<String, String> rename;
diff --git a/json-smart/src/test/java/net/minidev/json/JStylerObjTest.java b/json-smart/src/test/java/net/minidev/json/JStylerObjTest.java
new file mode 100644
index 0000000..7b6a25c
--- /dev/null
+++ b/json-smart/src/test/java/net/minidev/json/JStylerObjTest.java
@@ -0,0 +1,321 @@
+package net.minidev.json;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.StringWriter;
+import org.junit.jupiter.api.Test;
+
+public class JStylerObjTest {
+
+  @Test
+  public void testIsSpace() {
+    assertTrue(JStylerObj.isSpace(' '));
+    assertTrue(JStylerObj.isSpace('\t'));
+    assertTrue(JStylerObj.isSpace('\n'));
+    assertTrue(JStylerObj.isSpace('\r'));
+
+    assertFalse(JStylerObj.isSpace('a'));
+    assertFalse(JStylerObj.isSpace('1'));
+    assertFalse(JStylerObj.isSpace(':'));
+  }
+
+  @Test
+  public void testIsSpecialChar() {
+    assertTrue(JStylerObj.isSpecialChar('\b'));
+    assertTrue(JStylerObj.isSpecialChar('\f'));
+    assertTrue(JStylerObj.isSpecialChar('\n'));
+
+    assertFalse(JStylerObj.isSpecialChar('a'));
+    assertFalse(JStylerObj.isSpecialChar('\t'));
+    assertFalse(JStylerObj.isSpecialChar('\r'));
+  }
+
+  @Test
+  public void testIsSpecialOpen() {
+    assertTrue(JStylerObj.isSpecialOpen('{'));
+    assertTrue(JStylerObj.isSpecialOpen('['));
+    assertTrue(JStylerObj.isSpecialOpen(','));
+    assertTrue(JStylerObj.isSpecialOpen(':'));
+
+    assertFalse(JStylerObj.isSpecialOpen('}'));
+    assertFalse(JStylerObj.isSpecialOpen(']'));
+    assertFalse(JStylerObj.isSpecialOpen('a'));
+  }
+
+  @Test
+  public void testIsSpecialClose() {
+    assertTrue(JStylerObj.isSpecialClose('}'));
+    assertTrue(JStylerObj.isSpecialClose(']'));
+    assertTrue(JStylerObj.isSpecialClose(','));
+    assertTrue(JStylerObj.isSpecialClose(':'));
+
+    assertFalse(JStylerObj.isSpecialClose('{'));
+    assertFalse(JStylerObj.isSpecialClose('['));
+    assertFalse(JStylerObj.isSpecialClose('a'));
+  }
+
+  @Test
+  public void testIsSpecial() {
+    assertTrue(JStylerObj.isSpecial('{'));
+    assertTrue(JStylerObj.isSpecial('['));
+    assertTrue(JStylerObj.isSpecial('}'));
+    assertTrue(JStylerObj.isSpecial(']'));
+    assertTrue(JStylerObj.isSpecial(','));
+    assertTrue(JStylerObj.isSpecial(':'));
+    assertTrue(JStylerObj.isSpecial('\''));
+    assertTrue(JStylerObj.isSpecial('"'));
+
+    assertFalse(JStylerObj.isSpecial('a'));
+    assertFalse(JStylerObj.isSpecial('1'));
+    assertFalse(JStylerObj.isSpecial(' '));
+  }
+
+  @Test
+  public void testIsUnicode() {
+    assertTrue(JStylerObj.isUnicode('\u0000'));
+    assertTrue(JStylerObj.isUnicode('\u001F'));
+    assertTrue(JStylerObj.isUnicode('\u007F'));
+    assertTrue(JStylerObj.isUnicode('\u009F'));
+    assertTrue(JStylerObj.isUnicode('\u2000'));
+    assertTrue(JStylerObj.isUnicode('\u20FF'));
+
+    assertFalse(JStylerObj.isUnicode('a'));
+    assertFalse(JStylerObj.isUnicode('Z'));
+    assertFalse(JStylerObj.isUnicode('1'));
+    assertFalse(JStylerObj.isUnicode(' '));
+  }
+
+  @Test
+  public void testIsKeyword() {
+    assertTrue(JStylerObj.isKeyword("null"));
+    assertTrue(JStylerObj.isKeyword("true"));
+    assertTrue(JStylerObj.isKeyword("false"));
+    assertTrue(JStylerObj.isKeyword("NaN"));
+
+    assertFalse(JStylerObj.isKeyword("NULL"));
+    assertFalse(JStylerObj.isKeyword("TRUE"));
+    assertFalse(JStylerObj.isKeyword("FALSE"));
+    assertFalse(JStylerObj.isKeyword("hello"));
+    assertFalse(JStylerObj.isKeyword("a"));
+    assertFalse(JStylerObj.isKeyword("ab"));
+    assertFalse(JStylerObj.isKeyword(""));
+  }
+
+  @Test
+  public void testMPSimpleMustBeProtect() {
+    JStylerObj.MustProtect mp = JStylerObj.MP_SIMPLE;
+
+    assertFalse(mp.mustBeProtect(null));
+
+    assertTrue(mp.mustBeProtect(""));
+    assertTrue(mp.mustBeProtect(" text"));
+    assertTrue(mp.mustBeProtect("text "));
+    assertTrue(mp.mustBeProtect(" text "));
+
+    assertTrue(mp.mustBeProtect("123"));
+    assertTrue(mp.mustBeProtect("-456"));
+    assertTrue(mp.mustBeProtect("0"));
+
+    assertTrue(mp.mustBeProtect("null"));
+    assertTrue(mp.mustBeProtect("true"));
+    assertTrue(mp.mustBeProtect("false"));
+    assertTrue(mp.mustBeProtect("NaN"));
+
+    assertTrue(mp.mustBeProtect("text{"));
+    assertTrue(mp.mustBeProtect("text["));
+    assertTrue(mp.mustBeProtect("text\""));
+    assertTrue(mp.mustBeProtect("text'"));
+
+    assertTrue(mp.mustBeProtect("text\n"));
+    assertTrue(mp.mustBeProtect("text\t"));
+    assertTrue(mp.mustBeProtect("text "));
+
+    assertTrue(mp.mustBeProtect("text\u0001"));
+
+    assertFalse(mp.mustBeProtect("hello"));
+    assertFalse(mp.mustBeProtect("world"));
+    assertFalse(mp.mustBeProtect("test"));
+    assertFalse(mp.mustBeProtect("a"));
+  }
+
+  @Test
+  public void testMPTrueMustBeProtect() {
+    JStylerObj.MustProtect mp = JStylerObj.MP_TRUE;
+
+    assertTrue(mp.mustBeProtect("anything"));
+    assertTrue(mp.mustBeProtect(""));
+    assertTrue(mp.mustBeProtect("hello"));
+    assertTrue(mp.mustBeProtect("123"));
+    assertTrue(mp.mustBeProtect(null));
+  }
+
+  @Test
+  public void testMPAggressiveMustBeProtect() {
+    JStylerObj.MustProtect mp = JStylerObj.MP_AGGRESIVE;
+
+    assertFalse(mp.mustBeProtect(null));
+
+    assertTrue(mp.mustBeProtect(""));
+    assertTrue(mp.mustBeProtect(" text"));
+    assertTrue(mp.mustBeProtect("text "));
+
+    assertTrue(mp.mustBeProtect("null"));
+    assertTrue(mp.mustBeProtect("true"));
+    assertTrue(mp.mustBeProtect("false"));
+    assertTrue(mp.mustBeProtect("NaN"));
+
+    assertTrue(mp.mustBeProtect("123"));
+    assertTrue(mp.mustBeProtect("-456"));
+    assertTrue(mp.mustBeProtect("3.14"));
+    assertTrue(mp.mustBeProtect("1.23e5"));
+    assertTrue(mp.mustBeProtect("1.23E-5"));
+    assertTrue(mp.mustBeProtect("1.23e+5"));
+
+    assertTrue(mp.mustBeProtect("{text"));
+    assertTrue(mp.mustBeProtect("text}"));
+    assertTrue(mp.mustBeProtect("text,"));
+
+    assertTrue(mp.mustBeProtect("text\u0001"));
+
+    assertFalse(mp.mustBeProtect("hello"));
+    assertFalse(mp.mustBeProtect("world"));
+    assertFalse(mp.mustBeProtect("a"));
+    assertFalse(mp.mustBeProtect("abc123def"));
+  }
+
+  @Test
+  public void testMPAggressiveNumberLike() {
+    JStylerObj.MustProtect mp = JStylerObj.MP_AGGRESIVE;
+
+    assertTrue(mp.mustBeProtect("0"));
+    assertTrue(mp.mustBeProtect("123"));
+    assertTrue(mp.mustBeProtect("-456"));
+    assertTrue(mp.mustBeProtect("3.14"));
+    assertTrue(mp.mustBeProtect("1e5"));
+    assertTrue(mp.mustBeProtect("1E5"));
+    assertTrue(mp.mustBeProtect("1e+5"));
+    assertTrue(mp.mustBeProtect("1e-5"));
+    assertTrue(mp.mustBeProtect("1.23e5"));
+    assertTrue(mp.mustBeProtect("1.23E-5"));
+
+    assertFalse(mp.mustBeProtect("1e"));
+    assertFalse(mp.mustBeProtect("1E"));
+    assertFalse(mp.mustBeProtect("123abc"));
+    assertFalse(mp.mustBeProtect("12.34.56"));
+  }
+
+  @Test
+  public void testEscapeLTStringProtector() {
+    JStylerObj.StringProtector protector = JStylerObj.ESCAPE_LT;
+    StringWriter writer = new StringWriter();
+
+    protector.escape("hello\"world", writer);
+    assertTrue(writer.toString().contains("hello\\\"world"));
+
+    writer = new StringWriter();
+    protector.escape("line1\nline2", writer);
+    assertTrue(writer.toString().contains("line1\\nline2"));
+
+    writer = new StringWriter();
+    protector.escape("tab\there", writer);
+    assertTrue(writer.toString().contains("tab\\there"));
+
+    writer = new StringWriter();
+    protector.escape("back\\slash", writer);
+    assertTrue(writer.toString().contains("back\\\\slash"));
+
+    writer = new StringWriter();
+    protector.escape("backspace\b", writer);
+    assertTrue(writer.toString().contains("backspace\\b"));
+
+    writer = new StringWriter();
+    protector.escape("formfeed\f", writer);
+    assertTrue(writer.toString().contains("formfeed\\f"));
+
+    writer = new StringWriter();
+    protector.escape("carriage\rreturn", writer);
+    assertTrue(writer.toString().contains("carriage\\rreturn"));
+
+    writer = new StringWriter();
+    protector.escape("unicode\u0001char", writer);
+    assertTrue(writer.toString().contains("unicode\\u0001char"));
+  }
+
+  @Test
+  public void testEscape4WebStringProtector() {
+    JStylerObj.StringProtector protector = JStylerObj.ESCAPE4Web;
+    StringWriter writer = new StringWriter();
+
+    protector.escape("hello/world", writer);
+    assertTrue(writer.toString().contains("hello\\/world"));
+
+    writer = new StringWriter();
+    protector.escape("hello\"world", writer);
+    assertTrue(writer.toString().contains("hello\\\"world"));
+
+    writer = new StringWriter();
+    protector.escape("line1\nline2", writer);
+    assertTrue(writer.toString().contains("line1\\nline2"));
+
+    writer = new StringWriter();
+    protector.escape("unicode\u0001char", writer);
+    assertTrue(writer.toString().contains("unicode\\u0001char"));
+  }
+
+  @Test
+  public void testEscapeUnicodeCharacters() {
+    JStylerObj.StringProtector protector = JStylerObj.ESCAPE_LT;
+    StringWriter writer = new StringWriter();
+
+    protector.escape("\u0000\u001F\u007F\u009F", writer);
+    String result = writer.toString();
+    assertTrue(result.contains("\\u0000"));
+    assertTrue(result.contains("\\u001F"));
+    assertTrue(result.contains("\\u007F"));
+    assertTrue(result.contains("\\u009F"));
+  }
+
+  @Test
+  public void testEscapeUnicodeRange2000() {
+    JStylerObj.StringProtector protector = JStylerObj.ESCAPE_LT;
+    StringWriter writer = new StringWriter();
+
+    protector.escape("\u2000\u20FF", writer);
+    String result = writer.toString();
+    assertTrue(result.contains("\\u2000"));
+    assertTrue(result.contains("\\u20FF"));
+  }
+
+  @Test
+  public void testEscapeNormalCharacters() {
+    JStylerObj.StringProtector protector = JStylerObj.ESCAPE_LT;
+    StringWriter writer = new StringWriter();
+
+    protector.escape("Hello World 123!", writer);
+    String result = writer.toString();
+    assertTrue(result.equals("Hello World 123!"));
+  }
+
+  @Test
+  public void testMPSimpleDigitStarting() {
+    JStylerObj.MustProtect mp = JStylerObj.MP_SIMPLE;
+
+    assertTrue(mp.mustBeProtect("0abc"));
+    assertTrue(mp.mustBeProtect("1test"));
+    assertTrue(mp.mustBeProtect("9xyz"));
+    assertTrue(mp.mustBeProtect("-5abc"));
+
+    assertFalse(mp.mustBeProtect("a123"));
+    assertFalse(mp.mustBeProtect("test"));
+  }
+
+  @Test
+  public void testConstants() {
+    assertTrue(JStylerObj.MP_SIMPLE instanceof JStylerObj.MustProtect);
+    assertTrue(JStylerObj.MP_TRUE instanceof JStylerObj.MustProtect);
+    assertTrue(JStylerObj.MP_AGGRESIVE instanceof JStylerObj.MustProtect);
+    assertTrue(JStylerObj.ESCAPE_LT instanceof JStylerObj.StringProtector);
+    assertTrue(JStylerObj.ESCAPE4Web instanceof JStylerObj.StringProtector);
+  }
+}
diff --git a/json-smart/src/test/java/net/minidev/json/test/JSONNaviExtendedTest.java b/json-smart/src/test/java/net/minidev/json/test/JSONNaviExtendedTest.java
new file mode 100644
index 0000000..3bef710
--- /dev/null
+++ b/json-smart/src/test/java/net/minidev/json/test/JSONNaviExtendedTest.java
@@ -0,0 +1,404 @@
+package net.minidev.json.test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Collection;
+import net.minidev.json.JSONArray;
+import net.minidev.json.JSONAwareEx;
+import net.minidev.json.JSONNavi;
+import net.minidev.json.JSONObject;
+import net.minidev.json.JSONStyle;
+import org.junit.jupiter.api.Test;
+
+public class JSONNaviExtendedTest {
+
+  @Test
+  public void testNewInstance() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    assertNotNull(navi);
+    assertFalse(navi.hasFailure());
+  }
+
+  @Test
+  public void testNewInstanceObject() {
+    JSONNavi<JSONObject> navi = JSONNavi.newInstanceObject();
+    assertNotNull(navi);
+    assertTrue(navi.isObject());
+    assertFalse(navi.hasFailure());
+  }
+
+  @Test
+  public void testNewInstanceArray() {
+    JSONNavi<JSONArray> navi = JSONNavi.newInstanceArray();
+    assertNotNull(navi);
+    assertTrue(navi.isArray());
+    assertFalse(navi.hasFailure());
+  }
+
+  @Test
+  public void testConstructorWithJson() {
+    String json = "{\"name\":\"John\", \"age\":30}";
+    JSONNavi<?> navi = new JSONNavi<>(json);
+    assertNotNull(navi);
+    assertEquals("John", navi.getString("name"));
+    assertEquals(30, navi.getInt("age"));
+  }
+
+  @Test
+  public void testConstructorWithJsonAndClass() {
+    String json = "{\"name\":\"John\", \"age\":30}";
+    JSONNavi<JSONObject> navi = new JSONNavi<>(json, JSONObject.class);
+    assertNotNull(navi);
+    assertEquals("John", navi.getString("name"));
+    assertEquals(30, navi.getInt("age"));
+  }
+
+  @Test
+  public void testSetAndGetString() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("name", "John");
+
+    assertEquals("John", navi.getString("name"));
+    assertTrue(navi.hasKey("name"));
+  }
+
+  @Test
+  public void testSetAndGetNumbers() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("intValue", 42)
+        .set("longValue", 1000L)
+        .set("doubleValue", 3.14)
+        .set("floatValue", 2.5f);
+
+    assertEquals(42, navi.getInt("intValue"));
+    assertEquals(Integer.valueOf(42), navi.getInteger("intValue"));
+    assertEquals(3.14, navi.getDouble("doubleValue"), 0.001);
+  }
+
+  @Test
+  public void testAtAndUp() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("name", "root").at("child").set("name", "child1").up().set("age", 30);
+
+    assertEquals("root", navi.getString("name"));
+    assertEquals(30, navi.getInt("age"));
+
+    navi.at("child");
+    assertEquals("child1", navi.getString("name"));
+  }
+
+  @Test
+  public void testArrayOperations() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.at("numbers").add(1, 2, 3, 4, 5);
+
+    assertTrue(navi.isArray());
+    assertEquals(5, navi.getSize());
+
+    navi.at(0);
+    assertEquals(1, navi.asInt());
+
+    navi.up().at(-1);
+    assertEquals(5, navi.asInt());
+  }
+
+  @Test
+  public void testAtNext() {
+    JSONNavi<JSONArray> navi = JSONNavi.newInstanceArray();
+    navi.add("first", "second").atNext().set("third").root();
+
+    assertEquals(3, navi.getSize());
+    navi.at(2);
+    assertEquals("third", navi.asString());
+  }
+
+  @Test
+  public void testNestedStructures() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("user", "John")
+        .at("address")
+        .set("street", "123 Main St")
+        .set("city", "Boston")
+        .up()
+        .at("phones")
+        .add("555-1234", "555-5678")
+        .root();
+
+    assertEquals("John", navi.getString("user"));
+
+    navi.at("address");
+    assertEquals("123 Main St", navi.getString("street"));
+    assertEquals("Boston", navi.getString("city"));
+
+    navi.up().at("phones");
+    assertEquals(2, navi.getSize());
+    navi.at(0);
+    assertEquals("555-1234", navi.asString());
+  }
+
+  @Test
+  public void testGetKeys() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("name", "John").set("age", 30).set("city", "Boston");
+
+    Collection<String> keys = navi.getKeys();
+    assertNotNull(keys);
+    assertEquals(3, keys.size());
+    assertTrue(keys.contains("name"));
+    assertTrue(keys.contains("age"));
+    assertTrue(keys.contains("city"));
+  }
+
+  @Test
+  public void testGetKeysForArray() {
+    JSONNavi<JSONArray> navi = JSONNavi.newInstanceArray();
+    navi.add(1, 2, 3);
+
+    Collection<String> keys = navi.getKeys();
+    assertNull(keys);
+  }
+
+  @Test
+  public void testAsTypes() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("stringVal", "hello")
+        .set("intVal", 42)
+        .set("doubleVal", 3.14)
+        .at("boolVal")
+        .set(Boolean.TRUE)
+        .up()
+        .set("nullVal", (String) null);
+
+    navi.at("stringVal");
+    assertEquals("hello", navi.asString());
+
+    navi.up().at("intVal");
+    assertEquals(42, navi.asInt());
+    assertEquals(Integer.valueOf(42), navi.asIntegerObj());
+    assertEquals(42.0, navi.asDouble(), 0.001);
+    assertEquals(Double.valueOf(42.0), navi.asDoubleObj());
+
+    navi.up().at("doubleVal");
+    assertEquals(3.14, navi.asDouble(), 0.001);
+
+    navi.up().at("boolVal");
+    assertTrue(navi.asBoolean());
+    assertEquals(Boolean.TRUE, navi.asBooleanObj());
+
+    navi.up().at("nullVal");
+    assertNull(navi.asString());
+    assertNull(navi.asIntegerObj());
+    assertNull(navi.asDoubleObj());
+    assertNull(navi.asBooleanObj());
+  }
+
+  @Test
+  public void testSetDirectValues() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.at("text").set("hello").up().at("number").set(42).up().at("bool").set(Boolean.TRUE).root();
+
+    assertEquals("hello", navi.getString("text"));
+    assertEquals(42, navi.getInt("number"));
+
+    navi.at("bool");
+    assertTrue(navi.asBoolean());
+  }
+
+  @Test
+  public void testRootNavigation() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("rootValue", "test").at("nested").set("childValue", "child").root();
+
+    assertEquals("test", navi.getString("rootValue"));
+    assertFalse(navi.hasFailure());
+  }
+
+  @Test
+  public void testUpMultipleLevels() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("level0", "root")
+        .at("level1")
+        .set("name", "first")
+        .at("level2")
+        .set("name", "second")
+        .at("level3")
+        .set("name", "third")
+        .up(3);
+
+    assertEquals("root", navi.getString("level0"));
+  }
+
+  @Test
+  public void testGetCurrentObject() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("test", "value");
+
+    Object current = navi.getCurrentObject();
+    assertNotNull(current);
+  }
+
+  @Test
+  public void testGetRoot() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("test", "value");
+
+    Object root = navi.getRoot();
+    assertNotNull(root);
+  }
+
+  @Test
+  public void testJPath() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.at("user").at("address").at("street");
+
+    assertEquals("/user/address/street", navi.getJPath());
+  }
+
+  @Test
+  public void testJPathWithArrays() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.at("users").add("user1", "user2").at(0);
+
+    assertEquals("/users[0]", navi.getJPath());
+  }
+
+  @Test
+  public void testToString() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("name", "John").set("age", 30);
+
+    String json = navi.toString();
+    assertNotNull(json);
+    assertTrue(json.contains("\"name\":\"John\""));
+    assertTrue(json.contains("\"age\":30"));
+  }
+
+  @Test
+  public void testToStringWithStyle() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("name", "John");
+
+    String compressed = navi.toString(JSONStyle.MAX_COMPRESS);
+    String uncompressed = navi.toString(JSONStyle.NO_COMPRESS);
+
+    assertNotNull(compressed);
+    assertNotNull(uncompressed);
+    assertTrue(compressed.length() <= uncompressed.length());
+  }
+
+  @Test
+  public void testFailureHandling() {
+    String json = "{\"name\":\"John\"}";
+    JSONNavi<?> navi = new JSONNavi<>(json);
+
+    navi.at("nonexistent");
+    assertTrue(navi.hasFailure());
+
+    String errorString = navi.toString();
+    assertTrue(errorString.contains("Error"));
+  }
+
+  @Test
+  public void testArrayFailure() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("notArray", "value");
+
+    navi.at("notArray").at(0);
+    assertTrue(navi.hasFailure());
+  }
+
+  @Test
+  public void testSimpleFailure() {
+    String json = "{\"name\":\"John\"}";
+    JSONNavi<?> navi = new JSONNavi<>(json);
+
+    navi.at("nonexistent");
+    assertTrue(navi.hasFailure());
+  }
+
+  @Test
+  public void testHasKey() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("existing", "value");
+
+    assertTrue(navi.hasKey("existing"));
+    assertFalse(navi.hasKey("nonexistent"));
+  }
+
+  @Test
+  public void testHasKeyOnArray() {
+    JSONNavi<JSONArray> navi = JSONNavi.newInstanceArray();
+    navi.add(1, 2, 3);
+
+    assertFalse(navi.hasKey("anykey"));
+  }
+
+  @Test
+  public void testGetWithKey() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("test", "value");
+
+    Object value = navi.get("test");
+    assertEquals("value", value);
+
+    Object missing = navi.get("missing");
+    assertNull(missing);
+  }
+
+  @Test
+  public void testGetWithIndex() {
+    JSONNavi<JSONArray> navi = JSONNavi.newInstanceArray();
+    navi.add("first", "second", "third");
+
+    Object value = navi.get(1);
+    assertEquals("second", value);
+  }
+
+  @Test
+  public void testSizeCalculations() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    assertEquals(0, navi.getSize());
+
+    navi.set("key1", "value1").set("key2", "value2");
+    assertEquals(2, navi.getSize());
+
+    navi.at("array").add(1, 2, 3, 4);
+    assertEquals(4, navi.getSize());
+  }
+
+  @Test
+  public void testNegativeArrayIndex() {
+    JSONNavi<JSONArray> navi = JSONNavi.newInstanceArray();
+    navi.add("first", "second", "third");
+
+    navi.at(-1);
+    assertEquals("third", navi.asString());
+
+    navi.up().at(-2);
+    assertEquals("second", navi.asString());
+  }
+
+  @Test
+  public void testReadonlyMode() {
+    String json = "{\"name\":\"John\"}";
+    JSONNavi<?> navi = new JSONNavi<>(json);
+
+    navi.at("newkey");
+    assertTrue(navi.hasFailure());
+  }
+
+  @Test
+  public void testComplexNestedStructure() {
+    JSONNavi<JSONAwareEx> navi = JSONNavi.newInstance();
+    navi.set("company", "TechCorp").at("employees").add("John", "Jane").root();
+
+    String json = navi.toString();
+    assertTrue(json.contains("TechCorp"));
+    assertTrue(json.contains("John"));
+    assertTrue(json.contains("Jane"));
+  }
+}
diff --git a/json-smart/src/test/java/net/minidev/json/test/parser/MultipleJsonParserTest.java b/json-smart/src/test/java/net/minidev/json/test/parser/MultipleJsonParserTest.java
new file mode 100644
index 0000000..7cecb8a
--- /dev/null
+++ b/json-smart/src/test/java/net/minidev/json/test/parser/MultipleJsonParserTest.java
@@ -0,0 +1,206 @@
+package net.minidev.json.test.parser;
+
+import static net.minidev.json.parser.JSONParser.DEFAULT_PERMISSIVE_MODE;
+
+import java.io.ByteArrayInputStream;
+import java.io.StringReader;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Field;
+import java.nio.charset.StandardCharsets;
+import net.minidev.json.JSONArray;
+import net.minidev.json.JSONObject;
+import net.minidev.json.JSONValue;
+import net.minidev.json.parser.JSONParser;
+import net.minidev.json.parser.MultipleJsonParser;
+import net.minidev.json.parser.ParseException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class MultipleJsonParserTest {
+
+  @Test
+  public void testMultipleJsonsFromSingleJsonArraySuccess()
+      throws ParseException, UnsupportedEncodingException {
+    String json =
+        "[{\"friends\":[{\"id\":0,\"name\":\"test1\"},{\"id\":1,\"name\":\"test2\"}]}] other data";
+    MultipleJsonParser parser = new MultipleJsonParser(json, DEFAULT_PERMISSIVE_MODE);
+    JSONArray root = (JSONArray) parser.parseNext();
+    JSONObject rootObj = (JSONObject) root.get(0);
+    JSONArray array = (JSONArray) rootObj.get("friends");
+    for (int idx = 0; idx < array.size(); idx++) {
+      JSONObject cap = (JSONObject) array.get(idx);
+      String first = (String) cap.get("name");
+      Assertions.assertEquals("test" + (idx + 1), first);
+    }
+  }
+
+  @Test
+  public void testMultipleJsonsFromMultipleJsonArraySuccess()
+      throws ParseException, UnsupportedEncodingException {
+    String json =
+        "[{\"friends\":[{\"id\":0,\"name\":\"test1\"},{\"id\":1,\"name\":\"test2\"}]}] "
+            + "[{\"friends\":[{\"id\":2,\"name\":\"test3\"},{\"id\":3,\"name\":\"test4\"}]}]";
+    MultipleJsonParser parser = new MultipleJsonParser(json, DEFAULT_PERMISSIVE_MODE);
+
+    // first
+    JSONArray root = (JSONArray) parser.parseNext();
+    JSONObject rootObj = (JSONObject) root.get(0);
+    JSONArray array = (JSONArray) rootObj.get("friends");
+    for (int idx = 0; idx < array.size(); idx++) {
+      JSONObject cap = (JSONObject) array.get(idx);
+      String first = (String) cap.get("name");
+      Assertions.assertEquals("test" + (idx + 1), first);
+    }
+
+    // second
+    JSONArray root2 = (JSONArray) parser.parseNext();
+    JSONObject rootObj2 = (JSONObject) root2.get(0);
+    JSONArray array2 = (JSONArray) rootObj2.get("friends");
+    for (int idx = 0; idx < array2.size(); idx++) {
+      JSONObject cap = (JSONObject) array2.get(idx);
+      String first = (String) cap.get("name");
+      Assertions.assertEquals("test" + (idx + 3), first);
+    }
+  }
+
+  @Test
+  public void testMultipleJsonsFromByteSuccess() throws Exception {
+    String json =
+        "{tranid:\"1212\", \"user\":{\"name\":\"123\",\"addr\":\"786 rt\"}}"
+            + "\n{tranid:\"1213\", \"user\":{\"name\":\"345\",\"addr\":\"4234 iu\"}}";
+    MultipleJsonParser parser =
+        new MultipleJsonParser(json.getBytes(StandardCharsets.UTF_8), DEFAULT_PERMISSIVE_MODE);
+
+    JSONObject root1 = (JSONObject) parser.parseNext();
+    Assertions.assertEquals("1212", root1.get("tranid"));
+
+    Assertions.assertTrue(parser.hasNext());
+    JSONObject root2 = (JSONObject) parser.parseNext();
+    Assertions.assertEquals("1213", root2.get("tranid"));
+
+    Assertions.assertFalse(parser.hasNext());
+  }
+
+  @Test
+  public void testMultipleJsonsFromInputStreamSuccess() throws Exception {
+    String json =
+        "{tranid:\"1212\", \"user\":{\"name\":\"123\",\"addr\":\"786 rt\"}}"
+            + "\n{tranid:\"1213\", \"user\":{\"name\":\"345\",\"addr\":\"4234 iu\"}}";
+    ByteArrayInputStream stream = new ByteArrayInputStream(json.getBytes(StandardCharsets.UTF_8));
+    MultipleJsonParser parser = new MultipleJsonParser(stream, DEFAULT_PERMISSIVE_MODE);
+
+    JSONObject root1 = (JSONObject) parser.parseNext();
+    Assertions.assertEquals("1212", root1.get("tranid"));
+
+    Assertions.assertTrue(parser.hasNext());
+    JSONObject root2 = (JSONObject) parser.parseNext();
+    Assertions.assertEquals("1213", root2.get("tranid"));
+
+    Assertions.assertFalse(parser.hasNext());
+  }
+
+  @Test
+  public void testMultipleJsonsFromInputStreamReaderSuccess() throws Exception {
+    String json =
+        "{tranid:\"1212\", \"user\":{\"name\":\"123\",\"addr\":\"786 rt\"}}"
+            + "\n{tranid:\"1213\", \"user\":{\"name\":\"345\",\"addr\":\"4234 iu\"}}";
+    StringReader reader = new StringReader(json);
+    MultipleJsonParser parser = new MultipleJsonParser(reader, DEFAULT_PERMISSIVE_MODE);
+
+    JSONObject root1 = (JSONObject) parser.parseNext();
+    Assertions.assertEquals("1212", root1.get("tranid"));
+
+    Assertions.assertTrue(parser.hasNext());
+    JSONObject root2 = (JSONObject) parser.parseNext();
+    Assertions.assertEquals("1213", root2.get("tranid"));
+
+    Assertions.assertFalse(parser.hasNext());
+  }
+
+  @Test
+  public void testMultipleJsonsFromStringSuccess() throws Exception {
+    String json =
+        "{tranid:\"1212\", \"user\":{\"name\":\"123\",\"addr\":\"786 rt\"}}"
+            + " {tranid:\"1213\", \"user\":{\"name\":\"343\",\"addr\":\"4233 iu\"}}"
+            + "\r{tranid:\"1214\", \"user\":{\"name\":\"344\",\"addr\":\"4234 iu\"}}"
+            + "\t{tranid:\"1215\", \"user\":{\"name\":\"345\",\"addr\":\"4235 iu\"}}"
+            + "\n{tranid:\"1216\", \"user\":{\"name\":\"346\",\"addr\":\"4236 iu\"}}";
+    MultipleJsonParser parser = new MultipleJsonParser(json, DEFAULT_PERMISSIVE_MODE);
+    JSONObject root1 = (JSONObject) parser.parseNext(JSONValue.defaultReader.DEFAULT);
+    Assertions.assertEquals("1212", root1.get("tranid"));
+
+    int count = 3;
+    while (parser.hasNext()) {
+      JSONObject root2 = (JSONObject) parser.parseNext(JSONValue.defaultReader.DEFAULT);
+      Assertions.assertEquals("121" + count, root2.get("tranid"));
+      count++;
+    }
+    Assertions.assertEquals(7, count);
+  }
+
+  @Test
+  public void testMultipleJsonsParseClassFromStringSuccess() throws Exception {
+    String json =
+        "{tranid:\"1212\", \"user\":{\"name\":\"123\",\"addr\":\"786 rt\"}}"
+            + " {tranid:\"1213\", \"user\":{\"name\":\"343\",\"addr\":\"4233 iu\"}}"
+            + "\r{tranid:\"1214\", \"user\":{\"name\":\"344\",\"addr\":\"4234 iu\"}}"
+            + "\t{tranid:\"1215\", \"user\":{\"name\":\"345\",\"addr\":\"4235 iu\"}}"
+            + "\n{tranid:\"1216\", \"user\":{\"name\":\"346\",\"addr\":\"4236 iu\"}}";
+    MultipleJsonParser parser = new MultipleJsonParser(json, DEFAULT_PERMISSIVE_MODE);
+    JSONObject root1 = (JSONObject) parser.parseNext(JSONValue.defaultReader.DEFAULT);
+    Assertions.assertEquals("1212", root1.get("tranid"));
+
+    int count = 3;
+    while (parser.hasNext()) {
+      Transaction root2 = parser.parseNext(Transaction.class);
+      Assertions.assertEquals("121" + count, root2.getTranid());
+      Assertions.assertEquals("34" + count, root2.getUser().getName());
+      count++;
+    }
+    Assertions.assertEquals(7, count);
+  }
+
+  @Test
+  public void testMultipleJsonsFromInvalidStringFailed() throws Exception {
+    String json =
+        "{tranid:\"1212\", \"user\":{\"name\":\"123\",\"addr\":\"786 rt\"}} bbb "
+            + "\n{tranid:\"1213\", \"user\":{\"name\":\"343\",\"addr\":\"4233 iu\"}} ";
+    MultipleJsonParser parser = new MultipleJsonParser(json, DEFAULT_PERMISSIVE_MODE);
+    JSONObject root1 = (JSONObject) parser.parseNext(JSONValue.defaultReader.DEFAULT);
+    Assertions.assertEquals("1212", root1.get("tranid"));
+
+    int count = 3;
+    while (parser.hasNext()) {
+      // return invalid input when parse failed
+      Object root2 = parser.parseNext(JSONValue.defaultReader.DEFAULT);
+      Assertions.assertEquals(
+          "bbb \n" + "{tranid:\"1213\", \"user\":{\"name\":\"343\",\"addr\":\"4233 iu\"}}", root2);
+      count++;
+    }
+    Assertions.assertEquals(4, count);
+  }
+
+  @Test
+  public void testMultipleJsonsWithJsonParserBySubStringSuccess() throws Exception {
+    String json =
+        "{tranid:\"1212\", \"user\":{\"name\":\"123\",\"addr\":\"786 rt\"}}"
+            + "\n{tranid:\"1213\", \"user\":{\"name\":\"345\",\"addr\":\"4234 iu\"}}";
+    JSONParser parser = new JSONParser(DEFAULT_PERMISSIVE_MODE);
+    JSONObject root1 = (JSONObject) parser.parse(json, JSONValue.defaultReader.DEFAULT);
+    Assertions.assertEquals("1212", root1.get("tranid"));
+
+    Field field = Class.forName("net.minidev.json.parser.JSONParserBase").getDeclaredField("pos");
+    field.setAccessible(true);
+    Field pStringField = JSONParser.class.getDeclaredField("pString");
+    pStringField.setAccessible(true);
+    Object parser2 = pStringField.get(parser);
+    Integer ipos = (Integer) field.get(parser2);
+    Assertions.assertEquals(54, ipos);
+
+    JSONObject root2 =
+        (JSONObject) parser.parse(json.substring(ipos), JSONValue.defaultReader.DEFAULT);
+    Assertions.assertEquals("1213", root2.get("tranid"));
+    ipos = (Integer) field.get(parser2);
+    Assertions.assertEquals(56, ipos);
+  }
+}
diff --git a/json-smart/src/test/java/net/minidev/json/test/parser/Transaction.java b/json-smart/src/test/java/net/minidev/json/test/parser/Transaction.java
new file mode 100644
index 0000000..e8c9db1
--- /dev/null
+++ b/json-smart/src/test/java/net/minidev/json/test/parser/Transaction.java
@@ -0,0 +1,77 @@
+package net.minidev.json.test.parser;
+
+import java.util.List;
+import java.util.Map;
+
+/** Represents a transaction data structure parsed from JSON. */
+public class Transaction {
+  private String tranid;
+  private User user;
+  private List<Map<String, Object>> friends;
+
+  // Getters and Setters
+  public String getTranid() {
+    return tranid;
+  }
+
+  public void setTranid(String tranid) {
+    this.tranid = tranid;
+  }
+
+  public User getUser() {
+    return user;
+  }
+
+  public void setUser(User user) {
+    this.user = user;
+  }
+
+  public List<Map<String, Object>> getFriends() {
+    return friends;
+  }
+
+  public void setFriends(List<Map<String, Object>> friends) {
+    this.friends = friends;
+  }
+
+  @Override
+  public String toString() {
+    return "Transaction{"
+        + "tranid='"
+        + tranid
+        + '\''
+        + ", user="
+        + user
+        + ", friends="
+        + friends
+        + '}';
+  }
+
+  /** Represents the user object within the transaction. */
+  public static class User {
+    private String name;
+    private String addr;
+
+    // Getters and Setters
+    public String getName() {
+      return name;
+    }
+
+    public void setName(String name) {
+      this.name = name;
+    }
+
+    public String getAddr() {
+      return addr;
+    }
+
+    public void setAddr(String addr) {
+      this.addr = addr;
+    }
+
+    @Override
+    public String toString() {
+      return "User{" + "name='" + name + '\'' + ", addr='" + addr + '\'' + '}';
+    }
+  }
+}
diff --git a/json-smart/src/test/java/net/minidev/json/test/reader/BeansWriterTest.java b/json-smart/src/test/java/net/minidev/json/test/reader/BeansWriterTest.java
new file mode 100644
index 0000000..19691ed
--- /dev/null
+++ b/json-smart/src/test/java/net/minidev/json/test/reader/BeansWriterTest.java
@@ -0,0 +1,200 @@
+package net.minidev.json.test.reader;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import net.minidev.json.JSONStyle;
+import net.minidev.json.reader.BeansWriter;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class BeansWriterTest {
+
+  private BeansWriter beansWriter;
+
+  @BeforeEach
+  public void setUp() {
+    beansWriter = new BeansWriter();
+  }
+
+  public static class SimpleBean {
+    public String name;
+    public int age;
+    private String city;
+
+    public SimpleBean() {}
+
+    public SimpleBean(String name, int age, String city) {
+      this.name = name;
+      this.age = age;
+      this.city = city;
+    }
+
+    public String getCity() {
+      return city;
+    }
+
+    public void setCity(String city) {
+      this.city = city;
+    }
+  }
+
+  public static class BooleanBean {
+    private boolean active;
+    private Boolean enabled;
+
+    public BooleanBean(boolean active, Boolean enabled) {
+      this.active = active;
+      this.enabled = enabled;
+    }
+
+    public boolean isActive() {
+      return active;
+    }
+
+    public Boolean getEnabled() {
+      return enabled;
+    }
+  }
+
+  public static class BeanWithStaticFields {
+    public static final String CONSTANT = "test";
+    public static int staticField = 42;
+    public String normalField = "normal";
+    private transient String transientField = "transient";
+  }
+
+  public static class BeanWithNullValues {
+    public String name;
+    public String nullField;
+
+    public BeanWithNullValues(String name, String nullField) {
+      this.name = name;
+      this.nullField = nullField;
+    }
+  }
+
+  public static class InheritedBean extends SimpleBean {
+    public double salary;
+
+    public InheritedBean(String name, int age, String city, double salary) {
+      super(name, age, city);
+      this.salary = salary;
+    }
+  }
+
+  @Test
+  public void testWriteSimpleBean() throws IOException {
+    SimpleBean bean = new SimpleBean("John", 30, "New York");
+    StringWriter writer = new StringWriter();
+
+    beansWriter.writeJSONString(bean, writer, JSONStyle.NO_COMPRESS);
+
+    String result = writer.toString();
+    assertTrue(result.contains("\"name\":\"John\""));
+    assertTrue(result.contains("\"age\":30"));
+    assertTrue(result.contains("\"city\":\"New York\""));
+  }
+
+  @Test
+  public void testWriteBooleanBean() throws IOException {
+    BooleanBean bean = new BooleanBean(true, false);
+    StringWriter writer = new StringWriter();
+
+    beansWriter.writeJSONString(bean, writer, JSONStyle.NO_COMPRESS);
+
+    String result = writer.toString();
+    assertTrue(result.contains("\"active\":true"));
+    assertTrue(result.contains("\"enabled\":false"));
+  }
+
+  @Test
+  public void testWriteBeanWithStaticAndTransientFields() throws IOException {
+    BeanWithStaticFields bean = new BeanWithStaticFields();
+    StringWriter writer = new StringWriter();
+
+    beansWriter.writeJSONString(bean, writer, JSONStyle.NO_COMPRESS);
+
+    String result = writer.toString();
+    assertTrue(result.contains("\"normalField\":\"normal\""));
+    assertTrue(!result.contains("CONSTANT"));
+    assertTrue(!result.contains("staticField"));
+    assertTrue(!result.contains("transientField"));
+  }
+
+  @Test
+  public void testWriteBeanWithNullValuesIgnoreNull() throws IOException {
+    BeanWithNullValues bean = new BeanWithNullValues("Test", null);
+    StringWriter writer = new StringWriter();
+
+    beansWriter.writeJSONString(bean, writer, JSONStyle.MAX_COMPRESS);
+
+    String result = writer.toString();
+    assertTrue(result.contains("name:Test"));
+    assertTrue(!result.contains("nullField"));
+  }
+
+  @Test
+  public void testWriteBeanWithNullValuesIncludeNull() throws IOException {
+    BeanWithNullValues bean = new BeanWithNullValues("Test", null);
+    StringWriter writer = new StringWriter();
+
+    beansWriter.writeJSONString(bean, writer, JSONStyle.NO_COMPRESS);
+
+    String result = writer.toString();
+    assertTrue(result.contains("\"name\":\"Test\""));
+    assertTrue(result.contains("\"nullField\":null"));
+  }
+
+  @Test
+  public void testWriteInheritedBean() throws IOException {
+    InheritedBean bean = new InheritedBean("Alice", 25, "Boston", 75000.0);
+    StringWriter writer = new StringWriter();
+
+    beansWriter.writeJSONString(bean, writer, JSONStyle.NO_COMPRESS);
+
+    String result = writer.toString();
+    assertTrue(result.contains("\"name\":\"Alice\""));
+    assertTrue(result.contains("\"age\":25"));
+    assertTrue(result.contains("\"city\":\"Boston\""));
+    assertTrue(result.contains("\"salary\":75000.0"));
+  }
+
+  @Test
+  public void testWriteEmptyBean() throws IOException {
+    SimpleBean bean = new SimpleBean();
+    StringWriter writer = new StringWriter();
+
+    beansWriter.writeJSONString(bean, writer, JSONStyle.NO_COMPRESS);
+
+    String result = writer.toString();
+    assertTrue(result.contains("\"name\":null"));
+    assertTrue(result.contains("\"age\":0"));
+    assertTrue(result.contains("\"city\":null"));
+  }
+
+  @Test
+  public void testWriteCompressed() throws IOException {
+    SimpleBean bean = new SimpleBean("John", 30, "New York");
+    StringWriter writer = new StringWriter();
+
+    beansWriter.writeJSONString(bean, writer, JSONStyle.MAX_COMPRESS);
+
+    String result = writer.toString();
+    assertTrue(result.contains("name:John"));
+    assertTrue(result.contains("age:30"));
+    assertTrue(result.contains("city:New York"));
+    assertTrue(!result.contains("\"name\""));
+  }
+
+  @Test
+  public void testWriteNullObject() {
+    assertThrows(
+        RuntimeException.class,
+        () -> {
+          beansWriter.writeJSONString(null, new StringWriter(), JSONStyle.NO_COMPRESS);
+        });
+  }
+}
diff --git a/json-smart/src/test/java/net/minidev/json/test/unit/JSONValueExtendedTest.java b/json-smart/src/test/java/net/minidev/json/test/unit/JSONValueExtendedTest.java
new file mode 100644
index 0000000..292883a
--- /dev/null
+++ b/json-smart/src/test/java/net/minidev/json/test/unit/JSONValueExtendedTest.java
@@ -0,0 +1,328 @@
+package net.minidev.json.test.unit;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import net.minidev.json.JSONArray;
+import net.minidev.json.JSONObject;
+import net.minidev.json.JSONStyle;
+import net.minidev.json.JSONValue;
+import net.minidev.json.parser.ParseException;
+import org.junit.jupiter.api.Test;
+
+public class JSONValueExtendedTest {
+
+  @Test
+  public void testParseSimpleTypes() {
+    assertEquals("hello", JSONValue.parse("\"hello\""));
+    assertEquals(42, JSONValue.parse("42"));
+    assertEquals(3.14, JSONValue.parse("3.14"));
+    assertEquals(true, JSONValue.parse("true"));
+    assertEquals(false, JSONValue.parse("false"));
+    assertNull(JSONValue.parse("null"));
+  }
+
+  @Test
+  public void testParseArray() {
+    Object result = JSONValue.parse("[1, 2, 3]");
+    assertInstanceOf(JSONArray.class, result);
+    JSONArray array = (JSONArray) result;
+    assertEquals(3, array.size());
+    assertEquals(1, array.get(0));
+    assertEquals(2, array.get(1));
+    assertEquals(3, array.get(2));
+  }
+
+  @Test
+  public void testParseObject() {
+    Object result = JSONValue.parse("{\"name\":\"John\", \"age\":30}");
+    assertInstanceOf(JSONObject.class, result);
+    JSONObject obj = (JSONObject) result;
+    assertEquals("John", obj.get("name"));
+    assertEquals(30, obj.get("age"));
+  }
+
+  @Test
+  public void testParseKeepingOrder() {
+    Object result = JSONValue.parseKeepingOrder("{\"c\":3, \"a\":1, \"b\":2}");
+    assertInstanceOf(LinkedHashMap.class, result);
+    LinkedHashMap<?, ?> map = (LinkedHashMap<?, ?>) result;
+
+    String[] keys = map.keySet().toArray(new String[0]);
+    assertEquals("c", keys[0]);
+    assertEquals("a", keys[1]);
+    assertEquals("b", keys[2]);
+  }
+
+  @Test
+  public void testParseKeepingOrderFromReader() throws IOException {
+    StringReader reader = new StringReader("{\"z\":26, \"x\":24, \"y\":25}");
+    Object result = JSONValue.parseKeepingOrder(reader);
+    assertInstanceOf(LinkedHashMap.class, result);
+    LinkedHashMap<?, ?> map = (LinkedHashMap<?, ?>) result;
+
+    String[] keys = map.keySet().toArray(new String[0]);
+    assertEquals("z", keys[0]);
+    assertEquals("x", keys[1]);
+    assertEquals("y", keys[2]);
+  }
+
+  @Test
+  public void testParseWithException() throws ParseException {
+    Object result = JSONValue.parseWithException("{\"valid\":true}");
+    assertInstanceOf(JSONObject.class, result);
+    assertEquals(true, ((JSONObject) result).get("valid"));
+  }
+
+  @Test
+  public void testParseWithExceptionThrows() {
+    assertThrows(
+        ParseException.class,
+        () -> {
+          JSONValue.parseWithException("{\"invalid\"");
+        });
+  }
+
+  @Test
+  public void testParseStrict() throws ParseException {
+    Object result = JSONValue.parseStrict("{\"key\":\"value\"}");
+    assertInstanceOf(JSONObject.class, result);
+    assertEquals("value", ((JSONObject) result).get("key"));
+  }
+
+  @Test
+  public void testParseStrictThrows() {
+    assertThrows(
+        ParseException.class,
+        () -> {
+          JSONValue.parseStrict("{key:value}");
+        });
+  }
+
+  @Test
+  public void testIsValidJson() {
+    assertTrue(JSONValue.isValidJson("{\"valid\":true}"));
+    assertTrue(JSONValue.isValidJson("[1,2,3]"));
+    assertTrue(JSONValue.isValidJson("\"string\""));
+    assertTrue(JSONValue.isValidJson("42"));
+    assertFalse(JSONValue.isValidJson("{invalid"));
+  }
+
+  @Test
+  public void testIsValidJsonStrict() {
+    assertTrue(JSONValue.isValidJsonStrict("{\"valid\":true}"));
+    assertFalse(JSONValue.isValidJsonStrict("{key:value}"));
+    assertFalse(JSONValue.isValidJsonStrict("{invalid"));
+  }
+
+  @Test
+  public void testIsValidJsonWithReader() throws IOException {
+    StringReader validReader = new StringReader("{\"valid\":true}");
+    assertTrue(JSONValue.isValidJson(validReader));
+
+    StringReader invalidReader = new StringReader("{invalid");
+    assertFalse(JSONValue.isValidJson(invalidReader));
+  }
+
+  @Test
+  public void testToJSONString() {
+    Map<String, Object> map = new HashMap<>();
+    map.put("name", "John");
+    map.put("age", 30);
+
+    String json = JSONValue.toJSONString(map);
+    assertNotNull(json);
+    assertTrue(json.contains("\"name\""));
+    assertTrue(json.contains("\"John\""));
+    assertTrue(json.contains("\"age\""));
+    assertTrue(json.contains("30"));
+  }
+
+  @Test
+  public void testToJSONStringWithStyle() {
+    Map<String, Object> map = new HashMap<>();
+    map.put("name", "John");
+
+    String compressed = JSONValue.toJSONString(map, JSONStyle.MAX_COMPRESS);
+    String uncompressed = JSONValue.toJSONString(map, JSONStyle.NO_COMPRESS);
+
+    assertNotNull(compressed);
+    assertNotNull(uncompressed);
+    assertTrue(compressed.length() <= uncompressed.length());
+  }
+
+  @Test
+  public void testWriteJSONString() throws IOException {
+    StringWriter writer = new StringWriter();
+    Map<String, Object> map = new HashMap<>();
+    map.put("test", "value");
+
+    JSONValue.writeJSONString(map, writer);
+
+    String result = writer.toString();
+    assertTrue(result.contains("\"test\""));
+    assertTrue(result.contains("\"value\""));
+  }
+
+  @Test
+  public void testWriteJSONStringWithStyle() throws IOException {
+    StringWriter writer = new StringWriter();
+    Map<String, Object> map = new HashMap<>();
+    map.put("test", "value");
+
+    JSONValue.writeJSONString(map, writer, JSONStyle.MAX_COMPRESS);
+
+    String result = writer.toString();
+    assertTrue(result.contains("test:value"));
+  }
+
+  @Test
+  public void testWriteJSONStringNull() throws IOException {
+    StringWriter writer = new StringWriter();
+    JSONValue.writeJSONString(null, writer);
+    assertEquals("null", writer.toString());
+  }
+
+  @Test
+  public void testCompress() {
+    String input = "{ \"name\" : \"John\" , \"age\" : 30 }";
+    String compressed = JSONValue.compress(input);
+    assertNotNull(compressed);
+    assertFalse(compressed.contains(" "));
+  }
+
+  @Test
+  public void testCompressWithStyle() {
+    String input = "{ \"name\" : \"John\" }";
+    String compressed = JSONValue.compress(input, JSONStyle.MAX_COMPRESS);
+    String uncompressed = JSONValue.compress(input, JSONStyle.NO_COMPRESS);
+
+    assertNotNull(compressed);
+    assertNotNull(uncompressed);
+    assertTrue(compressed.length() <= uncompressed.length());
+  }
+
+  @Test
+  public void testUncompress() {
+    String input = "{name:John}";
+    String uncompressed = JSONValue.uncompress(input);
+    assertNotNull(uncompressed);
+    assertTrue(uncompressed.contains("\"name\""));
+    assertTrue(uncompressed.contains("\"John\""));
+  }
+
+  @Test
+  public void testParseToClass() {
+    String json = "\"Hello World\"";
+    String result = JSONValue.parse(json, String.class);
+    assertEquals("Hello World", result);
+  }
+
+  @Test
+  public void testParseToClassWithByteArray() {
+    String json = "42";
+    byte[] bytes = json.getBytes();
+    Integer result = JSONValue.parse(bytes, Integer.class);
+    assertEquals(Integer.valueOf(42), result);
+  }
+
+  @Test
+  public void testParseToClassWithInputStream() {
+    String json = "true";
+    ByteArrayInputStream stream = new ByteArrayInputStream(json.getBytes());
+    Boolean result = JSONValue.parse(stream, Boolean.class);
+    assertEquals(Boolean.TRUE, result);
+  }
+
+  @Test
+  public void testParseToClassWithReader() {
+    String json = "3.14";
+    StringReader reader = new StringReader(json);
+    Double result = JSONValue.parse(reader, Double.class);
+    assertEquals(Double.valueOf(3.14), result);
+  }
+
+  @Test
+  public void testParseWithExceptionToClass() throws ParseException {
+    String json = "\"test\"";
+    String result = JSONValue.parseWithException(json, String.class);
+    assertEquals("test", result);
+  }
+
+  @Test
+  public void testParseToUpdate() {
+    TestBean bean = new TestBean();
+    bean.name = "original";
+    bean.value = 0;
+
+    String json = "{\"name\":\"updated\", \"value\":42}";
+    TestBean result = JSONValue.parse(json, bean);
+
+    assertEquals("updated", result.name);
+    assertEquals(42, result.value);
+  }
+
+  @Test
+  public void testParseToUpdateWithReader() {
+    TestBean bean = new TestBean();
+    bean.name = "original";
+
+    StringReader reader = new StringReader("{\"name\":\"updated\"}");
+    TestBean result = JSONValue.parse(reader, bean);
+
+    assertEquals("updated", result.name);
+  }
+
+  @Test
+  public void testParseToUpdateWithInputStream() {
+    TestBean bean = new TestBean();
+    bean.value = 0;
+
+    ByteArrayInputStream stream = new ByteArrayInputStream("{\"value\":100}".getBytes());
+    TestBean result = JSONValue.parse(stream, bean);
+
+    assertEquals(100, result.value);
+  }
+
+  @Test
+  public void testParseInvalidInputReturnsNull() {
+    assertNull(JSONValue.parse("{invalid json"));
+    Object result1 = JSONValue.parse(new byte[] {1, 2, 3});
+    assertTrue(result1 == null || "".equals(result1));
+    assertNull(JSONValue.parse(new StringReader("{invalid")));
+    assertNull(JSONValue.parse(new ByteArrayInputStream("{invalid".getBytes())));
+  }
+
+  @Test
+  public void testParseInvalidInputWithClassReturnsNull() {
+    assertNull(JSONValue.parse("{invalid", String.class));
+    Object result1 = JSONValue.parse(new byte[] {1, 2, 3}, String.class);
+    assertTrue(result1 == null || "".equals(result1));
+    assertNull(JSONValue.parse(new StringReader("{invalid"), String.class));
+    assertNull(JSONValue.parse(new ByteArrayInputStream("{invalid".getBytes()), String.class));
+  }
+
+  @Test
+  public void testCompressInvalidInputReturnsOriginal() {
+    String invalid = "{invalid json";
+    String result = JSONValue.compress(invalid);
+    assertEquals(invalid, result);
+  }
+
+  public static class TestBean {
+    public String name;
+    public int value;
+  }
+}
diff --git a/json-smart/src/test/java/net/minidev/json/test/writer/DefaultMapperOrderedTest.java b/json-smart/src/test/java/net/minidev/json/test/writer/DefaultMapperOrderedTest.java
new file mode 100644
index 0000000..5dbf64d
--- /dev/null
+++ b/json-smart/src/test/java/net/minidev/json/test/writer/DefaultMapperOrderedTest.java
@@ -0,0 +1,176 @@
+package net.minidev.json.test.writer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import net.minidev.json.JSONArray;
+import net.minidev.json.JSONAwareEx;
+import net.minidev.json.parser.ParseException;
+import net.minidev.json.writer.DefaultMapperOrdered;
+import net.minidev.json.writer.JsonReader;
+import net.minidev.json.writer.JsonReaderI;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class DefaultMapperOrderedTest {
+
+  private JsonReaderI<JSONAwareEx> mapper;
+  private JsonReader jsonReader;
+
+  @BeforeEach
+  public void setUp() {
+    jsonReader = new JsonReader();
+    mapper = jsonReader.DEFAULT_ORDERED;
+  }
+
+  @Test
+  public void testStartObject() throws ParseException, IOException {
+    JsonReaderI<?> result = mapper.startObject("testKey");
+    assertSame(jsonReader.DEFAULT_ORDERED, result);
+  }
+
+  @Test
+  public void testStartArray() throws ParseException, IOException {
+    JsonReaderI<?> result = mapper.startArray("testKey");
+    assertSame(jsonReader.DEFAULT_ORDERED, result);
+  }
+
+  @Test
+  public void testMapperInstanceType() {
+    assertInstanceOf(DefaultMapperOrdered.class, mapper);
+  }
+
+  @Test
+  public void testCreateObject() {
+    Object result = mapper.createObject();
+    assertInstanceOf(LinkedHashMap.class, result);
+  }
+
+  @Test
+  public void testCreateArray() {
+    Object result = mapper.createArray();
+    assertInstanceOf(JSONArray.class, result);
+  }
+
+  @Test
+  public void testSetValue() throws ParseException, IOException {
+    Map<String, Object> current = new LinkedHashMap<>();
+    mapper.setValue(current, "testKey", "testValue");
+
+    assertEquals(1, current.size());
+    assertEquals("testValue", current.get("testKey"));
+  }
+
+  @Test
+  public void testSetValueWithMultipleEntries() throws ParseException, IOException {
+    LinkedHashMap<String, Object> current = new LinkedHashMap<>();
+
+    mapper.setValue(current, "key1", "value1");
+    mapper.setValue(current, "key2", "value2");
+    mapper.setValue(current, "key3", "value3");
+
+    assertEquals(3, current.size());
+    assertEquals("value1", current.get("key1"));
+    assertEquals("value2", current.get("key2"));
+    assertEquals("value3", current.get("key3"));
+
+    String[] keys = current.keySet().toArray(new String[0]);
+    assertEquals("key1", keys[0]);
+    assertEquals("key2", keys[1]);
+    assertEquals("key3", keys[2]);
+  }
+
+  @Test
+  public void testAddValue() throws ParseException, IOException {
+    JSONArray current = new JSONArray();
+
+    mapper.addValue(current, "value1");
+    mapper.addValue(current, "value2");
+    mapper.addValue(current, 42);
+
+    assertEquals(3, current.size());
+    assertEquals("value1", current.get(0));
+    assertEquals("value2", current.get(1));
+    assertEquals(42, current.get(2));
+  }
+
+  @Test
+  public void testSetValueWithNullKey() throws ParseException, IOException {
+    Map<String, Object> current = new LinkedHashMap<>();
+    mapper.setValue(current, null, "testValue");
+
+    assertEquals(1, current.size());
+    assertTrue(current.containsKey(null));
+    assertEquals("testValue", current.get(null));
+  }
+
+  @Test
+  public void testSetValueWithNullValue() throws ParseException, IOException {
+    Map<String, Object> current = new LinkedHashMap<>();
+    mapper.setValue(current, "testKey", null);
+
+    assertEquals(1, current.size());
+    assertEquals(null, current.get("testKey"));
+  }
+
+  @Test
+  public void testAddValueWithNullValue() throws ParseException, IOException {
+    JSONArray current = new JSONArray();
+    mapper.addValue(current, null);
+
+    assertEquals(1, current.size());
+    assertEquals(null, current.get(0));
+  }
+
+  @Test
+  public void testOrderPreservation() throws ParseException, IOException {
+    LinkedHashMap<String, Object> current = new LinkedHashMap<>();
+
+    mapper.setValue(current, "first", 1);
+    mapper.setValue(current, "second", 2);
+    mapper.setValue(current, "third", 3);
+    mapper.setValue(current, "fourth", 4);
+
+    String[] expectedOrder = {"first", "second", "third", "fourth"};
+    String[] actualOrder = current.keySet().toArray(new String[0]);
+
+    for (int i = 0; i < expectedOrder.length; i++) {
+      assertEquals(expectedOrder[i], actualOrder[i]);
+    }
+  }
+
+  @Test
+  public void testComplexObjectStructure() throws ParseException, IOException {
+    LinkedHashMap<String, Object> root = new LinkedHashMap<>();
+
+    mapper.setValue(root, "name", "test");
+    mapper.setValue(root, "age", 25);
+
+    JSONArray array = new JSONArray();
+    mapper.addValue(array, "item1");
+    mapper.addValue(array, "item2");
+    mapper.setValue(root, "items", array);
+
+    LinkedHashMap<String, Object> nested = new LinkedHashMap<>();
+    mapper.setValue(nested, "nestedKey", "nestedValue");
+    mapper.setValue(root, "nested", nested);
+
+    assertEquals(4, root.size());
+    assertEquals("test", root.get("name"));
+    assertEquals(25, root.get("age"));
+    assertEquals(array, root.get("items"));
+    assertEquals(nested, root.get("nested"));
+
+    assertEquals(2, array.size());
+    assertEquals("item1", array.get(0));
+    assertEquals("item2", array.get(1));
+
+    assertEquals(1, nested.size());
+    assertEquals("nestedValue", nested.get("nestedKey"));
+  }
+}
diff --git a/json-smart/src/test/java/net/minidev/json/test/writer/FakeMapperTest.java b/json-smart/src/test/java/net/minidev/json/test/writer/FakeMapperTest.java
new file mode 100644
index 0000000..0b0f13b
--- /dev/null
+++ b/json-smart/src/test/java/net/minidev/json/test/writer/FakeMapperTest.java
@@ -0,0 +1,63 @@
+package net.minidev.json.test.writer;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+import java.io.IOException;
+import net.minidev.json.parser.ParseException;
+import net.minidev.json.writer.FakeMapper;
+import net.minidev.json.writer.JsonReaderI;
+import org.junit.jupiter.api.Test;
+
+/** Test for FakeMapper class */
+public class FakeMapperTest {
+
+  @Test
+  public void testDefaultInstance() {
+    assertNotNull(FakeMapper.DEFAULT);
+    assertSame(FakeMapper.DEFAULT, FakeMapper.DEFAULT);
+  }
+
+  @Test
+  public void testStartObject() throws ParseException, IOException {
+    JsonReaderI<Object> mapper = FakeMapper.DEFAULT;
+    JsonReaderI<?> result = mapper.startObject("testKey");
+    assertSame(mapper, result);
+  }
+
+  @Test
+  public void testStartArray() throws ParseException, IOException {
+    JsonReaderI<Object> mapper = FakeMapper.DEFAULT;
+    JsonReaderI<?> result = mapper.startArray("testKey");
+    assertSame(mapper, result);
+  }
+
+  @Test
+  public void testSetValue() throws ParseException, IOException {
+    JsonReaderI<Object> mapper = FakeMapper.DEFAULT;
+    Object current = new Object();
+    mapper.setValue(current, "key", "value");
+  }
+
+  @Test
+  public void testAddValue() throws ParseException, IOException {
+    JsonReaderI<Object> mapper = FakeMapper.DEFAULT;
+    Object current = new Object();
+    mapper.addValue(current, "value");
+  }
+
+  @Test
+  public void testCreateObject() {
+    JsonReaderI<Object> mapper = FakeMapper.DEFAULT;
+    Object result = mapper.createObject();
+    assertNull(result);
+  }
+
+  @Test
+  public void testCreateArray() {
+    JsonReaderI<Object> mapper = FakeMapper.DEFAULT;
+    Object result = mapper.createArray();
+    assertNull(result);
+  }
+}