.setMessage("Malformed POM " + modelSource.getLocation() + ": " + e.getMessage())
                            .setException(e));
                } else {
                    problems.add(new ModelProblemCollectorRequest(Severity.WARNING, Version.V20)
                            .setMessage("Malformed POM " + modelSource.getLocation() + ": " + e.getMessage())

	// Verify if the parent claim matches the parentUser.
	p, ok := args.Claims[parentClaim]
	if ok {
		parentInClaim, ok := p.(string)
		if !ok {
			// Reject malformed/malicious requests.
			return false
		}
		// The parent claim in the session token should be equal
		// to the parent detected in the backend
		if parentInClaim != parentUser {
			return false
		}

    ```

 *  Fix: Don't miss cancels when sending HTTP/2 request headers.
 *  Fix: Don't miss whole operation timeouts when calls redirect.
 *  Fix: Don't leak connections if web sockets have malformed responses or if `onOpen()` throws.
 *  Fix: Don't retry when request bodies fail due to `FileNotFoundException`.
 *  Fix: Don't crash when URLs have IPv4-mapped IPv6 addresses.

	}
	if region := globalSite.Region(); region != "" {
		if errCode == ErrAuthorizationHeaderMalformed {
			apiErr.Description = fmt.Sprintf("The authorization header is malformed; the region is wrong; expecting '%s'.", region)
			return apiErr
		}
	}
	return apiErr
}

func (e errorCodeMap) ToAPIErr(errCode APIErrorCode) APIError {
	return e.ToAPIErrWithErr(errCode, nil)
}

     *
     * @param currentUrl the current URL
     * @param baseHref the base href value from HTML
     * @return the base URL
     * @throws MalformedURLException if the URL is malformed
     */
    protected URL getBaseUrl(final String currentUrl, final String baseHref) throws MalformedURLException {
        if (baseHref != null) {
            return getURL(currentUrl, baseHref);
        }

                // Empty context consumer
            });
            // Some invalid queries might be handled gracefully
        } catch (InvalidQueryException e) {
            // This is expected for malformed queries
            assertNotNull(e.getMessage());
            assertTrue(e.getMessage().contains("Invalid query"));
        }
    }

    @Test
    public void test_build_emptyQuery() {

    }

    @Test
    public void test_normalizeCanonicalUrl_withMalformedRelative() throws Exception {
        final FessXpathTransformer transformer = new FessXpathTransformer();
        // Valid base URL with malformed relative: java.net.URL is lenient, resolves anyway
        final String value = transformer.normalizeCanonicalUrl("http://example.com/", "://");
        // java.net.URL(base, "://") prepends protocol, result may vary

	// Ignore errors here to preserve the S3 error behavior of GetBucketInfo()
	checkRequestAuthType(ctx, r, policy.DeleteObjectAction, bucket, "")

	deleteObjectsFn := objectAPI.DeleteObjects

	// Return Malformed XML as S3 spec if the number of objects is empty
	if len(deleteObjectsReq.Objects) == 0 || len(deleteObjectsReq.Objects) > maxDeleteList {
		writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMalformedXML), r.URL)
		return
	}

 * Instances of [HttpUrl] are well-formed and always have a scheme, host, and path. With
 * `java.net.URL` it's possible to create an awkward URL like `http:/` with scheme and path but no
 * hostname. Building APIs that consume such malformed values is difficult!
 *
 * This class has a modern API. It avoids punitive checked exceptions: [toHttpUrl] throws
 * [IllegalArgumentException] on invalid input or [toHttpUrlOrNull] returns null if the input is an

		},
		{
			// Contains a base64 padding character
			bucketNames[0], "asia", "asia/europe", "abc=", "", 0,
			ListMultipartsInfo{},
			fmt.Errorf("Malformed upload id %s", "abc="), false,
		},

		// Setting up valid case of ListMultiPartUploads.
		// Test case with multiple parts for a single uploadID (Test number 13).