},
		// Test Case - 7.
		// Test case with invalid region.
		{
			inputCredentialStr: generateCredentialStr(
				"Z7IXGOO6BZ0REAN1Q26I",
				UTCNow().Format(yyyymmdd),
				"us-west-2",
				"s3",
				"aws4_request"),
			expectedCredentials: credentialHeader{},
			expectedErrCode:     ErrAuthorizationHeaderMalformed,
		},
		// Test Case - 8.
		// Test case with invalid request version.

    }

    /**
     * Gets the pattern for matching invalid URLs.
     *
     * @return the invalid URL pattern
     */
    public Pattern getInvalidUrlPattern() {
        return invalidUrlPattern;
    }

    /**
     * Sets the pattern for matching invalid URLs.
     *
     * @param invalidUrlPattern the invalid URL pattern to set
     */

        });
        assertTrue(e.getMessage().contains("PAC"));
    }

    // Test exception for invalid version
    @Test
    void testConstructorInvalidVersion() throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

        // Write header with invalid version
        dos.writeInt(Integer.reverseBytes(1)); // 1 buffer

    }

    // Edge/Invalid: empty string is invalid for valueOf
    @ParameterizedTest
    @EmptySource
    @DisplayName("valueOf(\"\") throws IllegalArgumentException for empty input")
    void valueOfRejectsEmpty(String empty) {
        assertThrows(IllegalArgumentException.class, () -> RequestParam.valueOf(empty));
    }

    // Invalid: null is not allowed for valueOf
    @ParameterizedTest

        // Protocol errors
        INVALID_PARAMETER("Invalid parameter", ErrorCategory.PROTOCOL, false), NOT_SUPPORTED("Operation not supported",
                ErrorCategory.PROTOCOL, false), INVALID_PROTOCOL("Invalid protocol", ErrorCategory.PROTOCOL,
                        false), MESSAGE_TOO_LARGE("Message too large", ErrorCategory.PROTOCOL, false),

    "output": "x..xn--zca"
  },
  {
    "comment": "Invalid Punycode",
    "input": "xn--a",
    "output": null
  },
  {
    "input": "xn--a.xn--zca",
    "output": null
  },
  {
    "input": "xn--a.ß",
    "output": null
  },
  {
    "input": "xn--ls8h=",
    "output": null
  },
  {
    "comment": "Invalid Punycode (contains non-ASCII character)",
    "input": "xn--tešla",

     * @return an {@code ArtifactCoordinates}, never {@code null}
     * @throws IllegalArgumentException if {@code request} is null or {@code request.session} is null or invalid
     */
    @Nonnull
    ArtifactCoordinates create(@Nonnull ArtifactCoordinatesFactoryRequest request);

    /**
     * Creates coordinates out of string that is formatted like:

        assertActivationWithProblems(profile, newContext(null, newProperties("rubbish")), "invalid JDK version");
        assertActivationWithProblems(profile, newContext(null, newProperties("1.a.0_09")), "invalid JDK version");
        assertActivationWithProblems(profile, newContext(null, newProperties("1.a.2.b")), "invalid JDK version");
    }

						if _, ok := first[dbName].(string); !ok {
							t.Errorf("invalid data type for %v, got %#v", dbName, first[dbName])
						}
					case "Age":
						if _, ok := first[dbName].(uint); !ok {
							t.Errorf("invalid data type for %v, got %#v", dbName, first[dbName])
						}
					case "Birthday":
						if _, ok := first[dbName].(*time.Time); !ok {
							t.Errorf("invalid data type for %v, got %#v", dbName, first[dbName])
						}
					}

			want:    nil,
			wantErr: true,
		},
		{
			name:    "nil pointer",
			value:   (*int)(nil),
			want:    nil,
			wantErr: false,
		},
		{
			name:    "invalid type",
			value:   "invalid",
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {