List<AnalyzeToken> tokensContent = analyzer.analyze(text, "content", lang);
        assertNotNull(tokensContent);
        assertEquals(2, tokensContent.size());

        List<AnalyzeToken> tokensTitle = analyzer.analyze(text, "title", lang);
        assertNotNull(tokensTitle);
        assertEquals(2, tokensTitle.size());

        // Test with null field
        List<AnalyzeToken> tokensNull = analyzer.analyze(text, null, lang);

        converter1.init();
        converter2.init();

        String text = "test";
        String field = "content";

        List<String> readings1 = converter1.convert(text, field, "en");
        List<String> readings2 = converter2.convert(text, field, "ja");

        assertNotNull(readings1);
        assertNotNull(readings2);
        assertEquals("TEST", readings1.get(0));

        TestComponent.resetCounter();
        factory.setComponentName("testComponent");

        final int threadCount = 10;
        final int objectsPerThread = 10;
        final List<TestComponent> createdComponents = new ArrayList<>();
        final List<Exception> exceptions = new ArrayList<>();

        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {

        List<String> results = converter.convert(text, field, "en", "ja");

        assertNotNull(results);
        // With multiple languages, should use ReadingConverterChain
    }

    @Test
    public void testConvertWithEmptyText() throws IOException {
        // Test convert with empty text
        String text = "";
        String field = "content";

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

import org.codelibs.fess.crawler.container.StandardCrawlerContainer;
import org.codelibs.fess.crawler.entity.ResponseData;

     *
     * @param accessResult the access result to update
     */
    void update(RESULT accessResult);

    /**
     * Updates the given list of access results.
     *
     * @param accessResult the list of access results to update
     */
    void update(List<RESULT> accessResult);

    /**
     * Returns the count of access results for the given session ID.
     *
     * @param sessionId the session ID

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.
 * It maintains a list of ReadingConverter instances and iterates through them, applying each converter to the input text and accumulating the results.

                    offset += term.length();
                }
            }

            final List<String> list = new ArrayList<>(1);
            if (readingBuf.length() > 0) {
                list.add(readingBuf.toString());
            }
            return list;
        }
    }

     * @param name The name of the field.
     * @param values The list of values for the field.
     * @return The result data body.
     */
    protected String getResultDataBody(final String name, final List<String> values) {
        final StringBuilder buf = new StringBuilder();
        buf.append("<list>");
        if (values != null && !values.isEmpty()) {
            for (final String value : values) {

        // Test with List
        List<String> originalList = Arrays.asList("one", "two", "three");
        List<String> resultList = SuggestUtil.getAsList(originalList);
        assertNotNull(resultList);
        assertEquals(3, resultList.size());
        assertEquals(originalList, resultList);
    }

    @Test(expected = IllegalArgumentException.class)