/**
     * Creates a <code>URL</code> by parsing the specified spec within the specified context.
     *
     * @param context
     *            The context in which to parse the spec. Must not be {@literal null}.
     * @param spec
     *            A string to be parsed as a <code>URL</code>. Must not be {@literal null} or empty.
     * @return A <code>URL</code>.
     */
    public static URL create(final URL context, final String spec) {

     */
    public static void parse(final SAXParser parser, final InputSource inputSource, final DefaultHandler handler) {
        assertArgumentNotNull("parser", parser);
        assertArgumentNotNull("inputSource", inputSource);
        assertArgumentNotNull("handler", handler);

        try {
            parser.parse(inputSource, handler);
        } catch (final SAXException e) {

 * the License.
 */

package com.google.common.primitives;

import com.google.common.annotations.GwtCompatible;

/** A string to be parsed as a number and the radix to interpret it in. */
@GwtCompatible
final class ParseRequest {
  final String rawValue;
  final int radix;

  private ParseRequest(String rawValue, int radix) {

 */
package jcifs.internal;

import jcifs.CIFSException;

/**
 * Exception thrown when errors occur during SMB protocol message decoding.
 * Indicates that an SMB message could not be properly parsed or decoded due to
 * malformed data, protocol violations, or unsupported message formats.
 *
 * @author mbechler
 */
public class SMBProtocolDecodingException extends CIFSException {

    /**
     *
     */

            throws VersionResolverException;

    /**
     * Parses the specified version string, for example "1.0".
     * <p>
     * Shortcut for {@code getService(VersionParser.class).parseVersion(...)}.
     *
     * @param version the version string to parse
     * @return the version parsed from the given string
     * @throws org.apache.maven.api.services.VersionParserException if the parsing failed

    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
     */

        System.arraycopy(err, 0, buf, bodyStart + 8, bc);

        int decoded = resp.decode(buf, headerStart);
        assertTrue(decoded > 0);

        // When error path is taken, no blob should be parsed
        assertNull(resp.getBlob(), "Blob should be null on error path");
        assertNotNull(resp.getErrorData(), "Error data should be present");
        assertArrayEquals(err, resp.getErrorData());
    }

     * @return a list of suggest items parsed from the query log
     */
    List<SuggestItem> parseQueryLog(QueryLog queryLog, String[] fields, String[] tagFieldNames, String roleFieldName,
            ReadingConverter readingConverter, Normalizer normalizer);

    /**
     * Parses a document and extracts suggest items based on the provided fields and converters.
     *

    @classmethod
    def fromstring(cls, root_name, data):
        """Initialize STSElement from name and XML string data.

        :param name: Name for XML data. Used in XML errors.
        :param data: string data to be parsed.
        :return: Returns an STSElement.
        """
        try:
            return cls(root_name, cElementTree.fromstring(data))
        except _ETREE_EXCEPTIONS as error:
            raise InvalidXMLError(

     * argument will be returned.
     *
     * @param key the property key to look up
     * @param def the default value to return if the property is not found or cannot be parsed
     * @return the property value as an int, or the default value
     */

    public static int getInt(final String key, int def) {
        final String s = prp.getProperty(key);
        if (s != null) {