* governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.exception;

/**
 * MimeTypeException is a custom exception class that extends CrawlerSystemException.
 * It is used to indicate exceptions related to MIME type handling during the crawling process.
 * This exception can be thrown with a message, a cause, or both.
 */

        assertNotNull(tokens);
        assertEquals(2, tokens.size());
        assertEquals("test", tokens.get(0).getTerm());
        assertEquals("text", tokens.get(1).getTerm());
        // Check that readings are added
        assertEquals("TEST", ((TestAnalyzeToken) tokens.get(0)).getReading());
        assertEquals("TEXT", ((TestAnalyzeToken) tokens.get(1)).getReading());
    }

    @Test

 * It keeps track of any failures that occur during the operation.
 */
public class SuggestWriterResult {
    /**
     * Constructs a new {@link SuggestWriterResult}.
     */
    public SuggestWriterResult() {
        // nothing
    }

    /**
     * A list of Throwables representing failures that occurred during the operation.
     */

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.log;

/**
 * LogType defines the different types of log messages that can be generated during the crawling process.
 * Each enum constant represents a specific event or state in the crawler's execution.
 */
public enum LogType {
    /** Indicates the start of a crawling process. */

 * String normalized = normalizer.normalize("ｶﾞｷﾞｸﾞｹﾞｺﾞ", "field");
 * System.out.println(normalized); // Outputs: ガギグゲゴ
 * }
 * </pre>
 *
 * <p>Note: This class assumes that the input string contains valid Hankaku Kana characters
 * and does not perform any validation on the input.</p>
 *
 * @see Normalizer
 */
public class HankakuKanaToZenkakuKana implements Normalizer {
    /**

import org.codelibs.fess.suggest.exception.SuggesterException;
import org.opensearch.core.common.Strings;
import org.opensearch.transport.client.Client;

/**
 * Abstract class representing a request that can be executed to produce a response.
 *
 * @param <T> the type of response produced by this request
 */
public abstract class Request<T extends Response> {
    /**
     * Constructs a new request.
     */

        } catch (IOException e) {
            assertEquals("Convert failed", e.getMessage());
        }
    }

    @Test
    public void testConvertWithMaxReadingLimit() throws IOException {
        // Test that readings respect max reading limit
        TestReadingConverterWithLimit limitConverter = new TestReadingConverterWithLimit();
        limitConverter.init();

        assertEquals(5, limitConverter.getMaxReadingNum());

/**
 * <p>
 *   Deferred is a class that represents a deferred computation.
 *   It is similar to a Promise in JavaScript.
 *   It allows you to register callbacks that will be executed when the computation is complete,
 *   either successfully (resolve) or with an error (reject).
 * </p>
 *
 * <p>
 *   The Deferred class has a Promise inner class that allows you to register callbacks

import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.exception.CrawlingAccessException;
import org.codelibs.fess.crawler.helper.SitemapsHelper;

/**
 * SitemapsRule is a rule implementation that extends RegexRule to determine if a given response data
 * represents a valid sitemap. It uses a SitemapsHelper to validate the response body as an InputStream.

import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * A chain of {@link ReadingConverter} implementations that applies each converter in sequence to generate possible reading variations of a given text.