// Parse the first token as a decimal integer.
	n, perr := strconv.ParseInt(nStr, 10, 0) // Intentionally parse as native int
	if perr != nil || n < 5 || n > int64(len(s)) {
		return "", "", s, ErrHeader
	}
	n -= int64(len(nStr) + 1) // convert from index in s to index in rest
	if n <= 0 {
		return "", "", s, ErrHeader
	}

	// Extract everything between the space and the final newline.

    }

    /**
     * Returns whether space trimming is enabled.
     * @return True if space trimming is enabled, false otherwise.
     */
    public boolean isTrimSpace() {
        return trimSpaceEnabled;
    }

    /**
     * Sets whether space trimming is enabled.
     * @param trimSpace The trim space flag to set.
     */
    public void setTrimSpace(final boolean trimSpace) {

     * @return the encoded token bytes
     */
    public abstract byte[] toByteArray();

    /**
     * Parses the provided token bytes to populate this SPNEGO token
     * @param token the token bytes to parse
     * @throws IOException if parsing fails
     */
    protected abstract void parse(byte[] token) throws IOException;

    protected KerberosAuthData() {
        // Default constructor
    }

    /**
     * Parse Kerberos authorization data based on the authorization type.
     *
     * @param authType the type of authorization data
     * @param token the authorization data token
     * @param keys the Kerberos keys for decryption
     * @return a list of parsed authorization data
     * @throws PACDecodingException if the data cannot be decoded
     */

     */
    protected DocumentBuilderUtil() {
    }

    /**
     * Parses the XML.
     *
     * @param builder
     *            {@link DocumentBuilder}; must not be {@literal null}.
     * @param is
     *            Input stream; must not be {@literal null}.
     * @return {@link Document}
     */
    public static Document parse(final DocumentBuilder builder, final InputStream is) {

        CommonsCliUpgradeOptions options = CommonsCliUpgradeOptions.parse(args);
        assertNotNull(options);

        // We can't easily test the help output directly, but we can verify
        // that the option is properly configured by checking if it parses
        String[] pluginsArgs = {"apply", "--plugins"};
        CommonsCliUpgradeOptions pluginsOptions = CommonsCliUpgradeOptions.parse(pluginsArgs);

	for i, test := range tests {
		arch, ctxt := setArch(goarch)
		tokenizer := lex.NewTokenizer("", strings.NewReader(test.input+"\n"), nil)
		parser := NewParser(ctxt, arch, tokenizer)

		err := tryParse(t, func() {
			parser.Parse()
		})

		switch {
		case err == nil:
			t.Errorf("#%d: %q: want error %q; have none", i, test.input, test.error)
		case !strings.Contains(err.Error(), test.error):

import jakarta.annotation.Resource;

/**
 * A response processor implementation that handles sitemaps.
 * It parses the response body as a SitemapSet, extracts URLs from the sitemaps,
 * and adds them as child URLs to be crawled.
 *
 * <p>
 * This class uses a {@link SitemapsHelper} to parse the sitemap XML or text.
 * It then iterates through the sitemaps in the SitemapSet, extracts the URL

        MIEName expected = new MIEName(testOid(), name);
        assertEquals(expected, parsed, "Parsed object should equal expected");
        assertEquals(name, parsed.toString(), "toString should return the name");
        assertEquals(testOid().hashCode(), parsed.hashCode(), "hashCode should derive from OID");
    }

    @Test
    @DisplayName("Parses empty name length (NAME_LEN=0) as empty string")
    void parseEmptyName() {

	if err = json.NewDecoder(resp.Body).Decode(&idpToken); err != nil {
		return nil, err
	}

	return &credentials.ClientGrantsToken{Token: idpToken.AccessToken, Expiry: idpToken.Expiry}, nil
}

func main() {
	flag.Parse()
	if clientID == "" || clientSecret == "" {
		flag.PrintDefaults()
		return
	}

	sts, err := credentials.NewSTSClientGrants(stsEndpoint, getTokenExpiry)
	if err != nil {
		log.Fatal(err)
	}