|| PRIORITY_ELEMENT.equals(qName)) {
                buf = new StringBuilder();
            }
        }

        @Override
        public void characters(final char[] ch, final int offset, final int length) {
            if (buf != null) {
                buf.append(new String(ch, offset, length));
            }
        }

        @Override

        // Test that all methods return the builder instance for chaining
        String id = "chain-test";
        SuggestSettings settings = builder.setSettingsIndexName("CHAINED_INDEX")
                .addInitialSettings("chain.key1", "chainValue1")
                .addInitialSettings("chain.key2", "chainValue2")
                .scrollTimeout("11s")
                .searchTimeout("12s")

        final ReadingConverterChain chain = new ReadingConverterChain();
        chain.addConverter(new AnalyzerConverter(client, settings));
        chain.addConverter(new KatakanaToAlphabetConverter());
        return chain;
    }

    /**
     * Creates a default ReadingConverterChain with a KatakanaToAlphabetConverter.
     *

    private final BytesRef scratchBytes = new BytesRef();

    private final CharsRef scratchChars = new CharsRef();

    private int longestMatchEndOffset;

    private int ch;

    private final char[] readBuffer;

    private int readBufferIndex;

    private int readBufferLen;

    StringBuilder block;

    int blkStart;

    int nextBlkStart;

    private int finalOffset;

 * </ul>
 *
 * <p>Timeout settings can be accessed via:</p>
 * <ul>
 *   <li>{@link #getScrollTimeout()}</li>
 *   <li>{@link #getSearchTimeout()}</li>
 *   <li>{@link #getIndexTimeout()}</li>
 *   <li>{@link #getIndicesTimeout()}</li>
 *   <li>{@link #getBulkTimeout()}</li>
 *   <li>{@link #getClusterTimeout()}</li>
 * </ul>
 *
 * <p>Default settings and array settings can be customized using:</p>
 * <ul>

         * - Symbol characters (!-/, :-@, [-`, {-~) are appended to the buffer.
         * - Duplicate terms can be removed based on the `duplicateTermRemoved` flag.
         * - The maximum size of alphanumeric and symbol terms can be limited by `maxAlphanumTermSize` and `maxSymbolTermSize` respectively.
         *

        assertEquals("concurrentRule", testRule.getRuleId());
        assertSame(processor, testRule.getResponseProcessor());
    }

    /**
     * Test rule chain with AbstractRule
     */
    public void test_ruleChain() {
        // Create chain of rules
        TestAbstractRule rule1 = new TestAbstractRule();
        rule1.crawlerContainer = container;
        rule1.setRuleId("rule1");

        final StringBuilder buf = new StringBuilder(100);
        boolean singleQuote = false;
        boolean doubleQuote = false;
        char prevChar = ' ';
        for (int i = 0; i < cmd.length(); i++) {
            final char c = cmd.charAt(i);
            if (c == ' ' && !singleQuote && !doubleQuote && buf.length() > 0) {
                cmdList.add(getCommandValue(buf.toString(), params));

 *   <li>Dependency injection using {@code @Resource} annotation</li>
 *   <li>Lifecycle management using {@code @PostConstruct} and {@code @PreDestroy} annotations</li>
 * </ul>
 *
 * <p>Components can be registered in two ways:
 * <ul>
 *   <li>As singletons, where one instance is shared throughout the container's lifecycle</li>
 *   <li>As prototypes, where a new instance is created each time the component is requested</li>

        String[][] readings = { { "test" } };

        // Test with boost less than 1
        SuggestItem item = new SuggestItem(text, readings, null, 0L, 0L, 0.5f, null, null, null, SuggestItem.Kind.QUERY);
        assertEquals(1.0f, item.getUserBoost(), 0.001f); // Should be set to 1

        // Test with boost greater than 1