Fix Bug 6456: Handle malformed percent-encoded URLs gracefully

When recording HTTP traffic via the HTTP(S) Test Script Recorder, JMeter
would crash with IllegalArgumentException when encountering malformed
percent-encoded parameters (e.g., "%u2", "%ZZ", "text%") from real-world
web applications.

Changes:
- HTTPArgument constructor now catches IllegalArgumentException from
  URLDecoder.decode() in addition to UnsupportedEncodingException
- When malformed encoding is detected, the original encoded value is
  preserved and a warning is logged instead of crashing
- Added comprehensive test cases covering various malformed encoding
  scenarios: incomplete hex sequences, invalid hex characters, truncated
  percent signs, and mixed valid/invalid encoding

This allows JMeter to successfully record and test applications with
encoding bugs, which is a legitimate use case for a testing tool.

Author: claude

src/protocol/http/src/main/java/org/apache/jmeter/protocol/http/util/HTTPArgument.java

@@ -161,6 +161,13 @@ public HTTPArgument(String name, String value, boolean alreadyEncoded, String co
             } catch (UnsupportedEncodingException e) {
                 log.error("{} encoding not supported!", contentEncoding);
                 throw new Error(e.toString(), e);
+            } catch (IllegalArgumentException e) {
+                // Handle malformed percent-encoded strings (e.g., "%u2", "%ZZ", "text%")
+                // This can occur when recording real-world web traffic with encoding bugs
+                // See Bug 6456
+                log.warn("Malformed percent-encoded parameter detected - using original value. " +
+                        "Name: '{}', Value: '{}', Error: {}", name, value, e.getMessage());
+                // Keep the original encoded values as-is
             }
         }
         setName(name);

src/protocol/http/src/test/java/org/apache/jmeter/protocol/http/util/TestHTTPArgument.java

@@ -93,4 +93,37 @@ public void testEncoding() throws Exception {
         assertEquals("", arg.getEncodedName());
         assertEquals("\00\01\07", arg.getEncodedValue());
     }
+
+    @Test
+    public void testMalformedPercentEncoding() throws Exception {
+        // Test case for Bug 6456: Handle malformed percent-encoded strings gracefully
+        // These are real-world cases that can occur when recording web application traffic
+
+        // Case 1: Incomplete hex sequence "%u2" - reported in the issue
+        HTTPArgument arg1 = new HTTPArgument("param", "value%u2", true);
+        // Should preserve the original malformed value instead of throwing IllegalArgumentException
+        assertEquals("param", arg1.getName());
+        assertEquals("value%u2", arg1.getValue());
+
+        // Case 2: Invalid hex character in encoding
+        HTTPArgument arg2 = new HTTPArgument("name", "test%ZZ", true);
+        assertEquals("name", arg2.getName());
+        assertEquals("test%ZZ", arg2.getValue());
+
+        // Case 3: Truncated percent at end of string
+        HTTPArgument arg3 = new HTTPArgument("data", "some%", true);
+        assertEquals("data", arg3.getName());
+        assertEquals("some%", arg3.getValue());
+
+        // Case 4: Percent followed by single hex digit
+        HTTPArgument arg4 = new HTTPArgument("field", "text%2", true);
+        assertEquals("field", arg4.getName());
+        assertEquals("text%2", arg4.getValue());
+
+        // Case 5: Mix of valid and invalid encoding
+        HTTPArgument arg5 = new HTTPArgument("mixed", "hello%20world%u2", true);
+        assertEquals("mixed", arg5.getName());
+        // Valid %20 should decode to space, but %u2 is malformed
+        assertEquals("hello%20world%u2", arg5.getValue());
+    }
 }