diff --git a/src/main/java/org/json/JSONParserConfiguration.java b/src/main/java/org/json/JSONParserConfiguration.java
index 0d8706c..fc16f61 100644
--- a/src/main/java/org/json/JSONParserConfiguration.java
+++ b/src/main/java/org/json/JSONParserConfiguration.java
@@ -30,22 +30,50 @@ public class JSONParserConfiguration extends ParserConfiguration {
 
     @Override
     protected JSONParserConfiguration clone() {
-        return new JSONParserConfiguration();
+        JSONParserConfiguration clone = new JSONParserConfiguration(overwriteDuplicateKey);
+        clone.maxNestingDepth = maxNestingDepth;
+        return clone;
     }
 
+    /**
+     * Defines the maximum nesting depth that the parser will descend before throwing an exception
+     * when parsing a map into JSONObject or parsing a {@link java.util.Collection} instance into
+     * JSONArray. The default max nesting depth is 512, which means the parser will throw a JsonException
+     * if the maximum depth is reached.
+     *
+     * @param maxNestingDepth the maximum nesting depth allowed to the JSON parser
+     * @return The existing configuration will not be modified. A new configuration is returned.
+     */
     @SuppressWarnings("unchecked")
     @Override
     public JSONParserConfiguration withMaxNestingDepth(final int maxNestingDepth) {
-        return super.withMaxNestingDepth(maxNestingDepth);
+        JSONParserConfiguration clone = this.clone();
+        clone.maxNestingDepth = maxNestingDepth;
+
+        return clone;
     }
 
+    /**
+     * Controls the parser's behavior when meeting duplicate keys.
+     * If set to false, the parser will throw a JSONException when meeting a duplicate key.
+     * Or the duplicate key's value will be overwritten.
+     *
+     * @param overwriteDuplicateKey defines should the parser overwrite duplicate keys.
+     * @return The existing configuration will not be modified. A new configuration is returned.
+     */
     public JSONParserConfiguration withOverwriteDuplicateKey(final boolean overwriteDuplicateKey) {
-        JSONParserConfiguration newConfig = this.clone();
-        newConfig.overwriteDuplicateKey = overwriteDuplicateKey;
+        JSONParserConfiguration clone = this.clone();
+        clone.overwriteDuplicateKey = overwriteDuplicateKey;
 
-        return newConfig;
+        return clone;
     }
 
+    /**
+     * The parser's behavior when meeting duplicate keys, controls whether the parser should
+     * overwrite duplicate keys or not.
+     *
+     * @return The <code>overwriteDuplicateKey</code> configuration value.
+     */
     public boolean isOverwriteDuplicateKey() {
         return this.overwriteDuplicateKey;
     }
diff --git a/src/main/java/org/json/ParserConfiguration.java b/src/main/java/org/json/ParserConfiguration.java
index 5cdc10d..06cc443 100644
--- a/src/main/java/org/json/ParserConfiguration.java
+++ b/src/main/java/org/json/ParserConfiguration.java
@@ -20,12 +20,12 @@ public class ParserConfiguration {
 
     /**
      * Specifies if values should be kept as strings (<code>true</code>), or if
-     * they should try to be guessed into JSON values (numeric, boolean, string)
+     * they should try to be guessed into JSON values (numeric, boolean, string).
      */
     protected boolean keepStrings;
 
     /**
-     * The maximum nesting depth when parsing a document.
+     * The maximum nesting depth when parsing an object.
      */
     protected int maxNestingDepth;
 
@@ -59,14 +59,14 @@ public class ParserConfiguration {
         // map should be cloned as well. If the values of the map are known to also
         // be immutable, then a shallow clone of the map is acceptable.
         return new ParserConfiguration(
-            this.keepStrings,
-            this.maxNestingDepth
+                this.keepStrings,
+                this.maxNestingDepth
         );
     }
 
     /**
      * When parsing the XML into JSONML, specifies if values should be kept as strings (<code>true</code>), or if
-     * they should try to be guessed into JSON values (numeric, boolean, string)
+     * they should try to be guessed into JSON values (numeric, boolean, string).
      *
      * @return The <code>keepStrings</code> configuration value.
      */
@@ -78,22 +78,21 @@ public class ParserConfiguration {
      * When parsing the XML into JSONML, specifies if values should be kept as strings (<code>true</code>), or if
      * they should try to be guessed into JSON values (numeric, boolean, string)
      *
-     * @param newVal
-     *      new value to use for the <code>keepStrings</code> configuration option.
-     * @param <T> the type of the configuration object
-     * 
+     * @param newVal new value to use for the <code>keepStrings</code> configuration option.
+     * @param <T>    the type of the configuration object
      * @return The existing configuration will not be modified. A new configuration is returned.
      */
     @SuppressWarnings("unchecked")
     public <T extends ParserConfiguration> T withKeepStrings(final boolean newVal) {
-        T newConfig = (T)this.clone();
+        T newConfig = (T) this.clone();
         newConfig.keepStrings = newVal;
         return newConfig;
     }
 
     /**
      * The maximum nesting depth that the parser will descend before throwing an exception
-     * when parsing the XML into JSONML.
+     * when parsing an object (e.g. Map, Collection) into JSON-related objects.
+     *
      * @return the maximum nesting depth set for this configuration
      */
     public int getMaxNestingDepth() {
@@ -102,18 +101,19 @@ public class ParserConfiguration {
 
     /**
      * Defines the maximum nesting depth that the parser will descend before throwing an exception
-     * when parsing the XML into JSONML. The default max nesting depth is 512, which means the parser
-     * will throw a JsonException if the maximum depth is reached.
+     * when parsing an object (e.g. Map, Collection) into JSON-related objects.
+     * The default max nesting depth is 512, which means the parser will throw a JsonException if
+     * the maximum depth is reached.
      * Using any negative value as a parameter is equivalent to setting no limit to the nesting depth,
      * which means the parses will go as deep as the maximum call stack size allows.
+     *
      * @param maxNestingDepth the maximum nesting depth allowed to the XML parser
-     * @param <T> the type of the configuration object
-     * 
+     * @param <T>             the type of the configuration object
      * @return The existing configuration will not be modified. A new configuration is returned.
      */
     @SuppressWarnings("unchecked")
     public <T extends ParserConfiguration> T withMaxNestingDepth(int maxNestingDepth) {
-        T newConfig = (T)this.clone();
+        T newConfig = (T) this.clone();
 
         if (maxNestingDepth > UNDEFINED_MAXIMUM_NESTING_DEPTH) {
             newConfig.maxNestingDepth = maxNestingDepth;
diff --git a/src/test/java/org/json/junit/JSONObjectDuplicateKeyTest.java b/src/test/java/org/json/junit/JSONObjectDuplicateKeyTest.java
deleted file mode 100644
index 1a3525b..0000000
--- a/src/test/java/org/json/junit/JSONObjectDuplicateKeyTest.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package org.json.junit;
-
-import org.json.*;
-
-import static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class JSONObjectDuplicateKeyTest {
-    private static final String TEST_SOURCE = "{\"key\": \"value1\", \"key\": \"value2\"}";
-
-    @Test(expected = JSONException.class)
-    public void testThrowException() {
-        new JSONObject(TEST_SOURCE);
-    }
-
-    @Test
-    public void testOverwrite() {
-        JSONObject jsonObject = new JSONObject(TEST_SOURCE, new JSONParserConfiguration(true));
-
-        assertEquals("duplicate key should be overwritten", "value2", jsonObject.getString("key"));
-    }
-}
diff --git a/src/test/java/org/json/junit/JSONParserConfigurationTest.java b/src/test/java/org/json/junit/JSONParserConfigurationTest.java
new file mode 100644
index 0000000..0e80d77
--- /dev/null
+++ b/src/test/java/org/json/junit/JSONParserConfigurationTest.java
@@ -0,0 +1,45 @@
+package org.json.junit;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONParserConfiguration;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class JSONParserConfigurationTest {
+    private static final String TEST_SOURCE = "{\"key\": \"value1\", \"key\": \"value2\"}";
+
+    @Test(expected = JSONException.class)
+    public void testThrowException() {
+        new JSONObject(TEST_SOURCE);
+    }
+
+    @Test
+    public void testOverwrite() {
+        JSONObject jsonObject = new JSONObject(TEST_SOURCE, new JSONParserConfiguration(true));
+
+        assertEquals("duplicate key should be overwritten", "value2", jsonObject.getString("key"));
+    }
+
+    @Test
+    public void verifyDuplicateKeyThenMaxDepth() {
+        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+                .withOverwriteDuplicateKey(true)
+                .withMaxNestingDepth(42);
+
+        assertEquals(42, jsonParserConfiguration.getMaxNestingDepth());
+        assertTrue(jsonParserConfiguration.isOverwriteDuplicateKey());
+    }
+
+    @Test
+    public void verifyMaxDepthThenDuplicateKey() {
+        JSONParserConfiguration jsonParserConfiguration = new JSONParserConfiguration()
+                .withMaxNestingDepth(42)
+                .withOverwriteDuplicateKey(true);
+
+        assertTrue(jsonParserConfiguration.isOverwriteDuplicateKey());
+        assertEquals(42, jsonParserConfiguration.getMaxNestingDepth());
+    }
+}