}

    /**
     * Parses project properties from the given path.
     *
     * @param propPath The path to the project properties file.
     * @throws FessSystemException if the properties file cannot be parsed.
     */
    protected void parseProjectProperties(final Path propPath) {

        // Mock the parse method to return two different objects based on input
        // Must use matchers for all arguments when using any matcher
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(1), eq(new byte[] { 0x01 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData1));
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(2), eq(new byte[] { 0x02 }), any(Map.class)))

                    accessTimeoutTask.cancel();
                }
            }
        }
    }

    /**
     * Parses a storage path into bucket name and object path components.
     * @param path the storage path to parse (format: bucket/object/path)
     * @return an array containing the bucket name and object path
     * @throws CrawlingAccessException if the path format is invalid
     */

        when(sitemapsHelper.parse(any(InputStream.class))).thenThrow(new RuntimeException("Parse error"));

        // Execute and verify RuntimeException is thrown
        try {
            processor.process(responseData);
            fail("Should throw RuntimeException");
        } catch (RuntimeException e) {
            // Expected exception
            assertEquals("Parse error", e.getMessage());
        }
    }

        private String name;

        /**
         * Constructs a new FtpInfo from a URL string.
         * This constructor parses the URL and extracts the host, port, parent directory,
         * and file name components.
         *
         * @param s The URL string to parse
         * @param c The character encoding (not currently used)
         * @throws CrawlingAccessException If the URL is invalid or malformed

            throw new DictionaryException("Failed to parse " + path, e);
        }
    }

    /**
     * Reloads the synonym dictionary from an input stream.
     *
     * @param updater An optional updater to apply changes.
     * @param in      The input stream to read the dictionary from.
     * @throws DictionaryException if the input stream cannot be parsed.
     */

 */
package org.codelibs.core.xml;

import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import javax.xml.XMLConstants;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.codelibs.core.exception.ParserConfigurationRuntimeException;
import org.codelibs.core.exception.SAXRuntimeException;
import org.xml.sax.SAXException;

			<!-- Supported MIME type -->
			<arg>
  "(application/xml"
+ "|application/xhtml+xml"
+ "|application/rdf+xml"
+ "|application/pdf"
+ "|application/x-freemind"
+ "|text/xml"
+ "|text/xml-external-parsed-entity)"
			</arg>
		</postConstruct>
	</component>

	<component name="fsFileRule" class="org.codelibs.fess.crawler.rule.impl.RegexRule" >
		<property name="ruleId">"fsFileRule"</property>

    //                                                                           Attribute
    //                                                                           =========
    // keeping parsed request parameters, normal texts or uploaded files
    // keys are requested parameter names (treated as field name here)
    protected Map<String, Object> elementsAll; // lazy-loaded, then after not null

        // GIVEN an unknown auth type
        int unknownAuthType = -1;
        byte[] emptyToken = new byte[0];

        // WHEN parsing the auth data
        List<KerberosAuthData> result = KerberosAuthData.parse(unknownAuthType, emptyToken, mockKeys);

        // THEN the result should be an empty list
        assertNotNull(result, "The result should not be null.");