}

    /**
     * Analyze text.
     * @param analyzer Analyzer
     * @param field Field
     * @param text Text
     * @param lang Language
     * @return List of tokens
     */
    protected List<AnalyzeToken> analyzeText(final SuggestAnalyzer analyzer, final String field, final String text, final String lang) {
        return analyzeTextInternal(analyzer, field, text, lang, false);
    }

    /**

        protected final String contentsAnalyzer;
        /** Contents reading analyzer name. */
        protected final String contentsReadingAnalyzer;

        /**
         * Constructor.
         * @param readingAnalyzer Reading analyzer name
         * @param readingTermAnalyzer Reading term analyzer name
         * @param normalizeAnalyzer Normalize analyzer name
         * @param contentsAnalyzer Contents analyzer name

        SuggestAnalyzer analyzer = suggester.settings().analyzer().new DefaultContentsAnalyzer();
        String text = "これはテストです。検索エンジン。";

        List<AnalyzeToken> tokens = defaultContentsParser.analyzeTextByReading(analyzer, "content", text, null);

        assertNotNull(tokens);
        // analyzeAndReading may return null for some analyzers
        // Just verify it doesn't throw an exception
    }

        this.defaultField = defaultField;
    }

    /**
     * Sets the analyzer used to analyze query terms.
     *
     * @param analyzer the analyzer to use
     */
    public void setAnalyzer(final Analyzer analyzer) {
        this.analyzer = analyzer;
    }

    /**
     * Sets whether to allow leading wildcards in query terms.
     *

        runner.ensureYellow();
        suggester = Suggester.builder().build(runner.client(), "DefaultContentsParserEdgeCaseTest");
        analyzer = suggester.settings().analyzer().new DefaultContentsAnalyzer();
        defaultReadingConverter = createDefaultReadingConverter();
        defaultNormalizer = createDefaultNormalizer();
    }

    @AfterClass

                .put("analysis.analyzer.test_reading_analyzer_ja.type", "custom")
                .put("analysis.analyzer.test_reading_analyzer_ja.tokenizer", "keyword")
                .put("analysis.analyzer.test_reading_term_analyzer_ja.type", "custom")
                .put("analysis.analyzer.test_reading_term_analyzer_ja.tokenizer", "keyword")
                .build();

 *
 * <p>Usage example:</p>
 * <pre>
 * PomMemoryAnalyzer analyzer = new PomMemoryAnalyzer();
 * Model model = reader.read(Files.newInputStream(pomPath));
 * analyzer.analyzePom(model);
 * analyzer.printAnalysis();
 * </pre>
 *
 * <p>The analysis output includes:</p>
 * <ul>
 *   <li>Total memory usage per POM path</li>

        operationsStale = true;
        return this;
    }

    /**
     * Sets the analyzer.
     * @param analyzer The analyzer.
     * @return This SuggestIndexer instance.
     */
    public SuggestIndexer setAnalyzer(final SuggestAnalyzer analyzer) {
        this.analyzer = analyzer;
        operationsStale = true;
        return this;
    }

    /**
     * Sets the contents parser.

     * @param threadPool The executor service for async operations
     * @param indexingOps The indexing operations for writing items
     * @param contentsParser The contents parser for parsing documents
     * @param analyzer The suggest analyzer
     * @param readingConverter The reading converter
     * @param contentsReadingConverter The contents reading converter
     * @param normalizer The normalizer

        // Test that multiple analyzer instances work independently
        SuggestAnalyzer analyzer1 = new TestSuggestAnalyzer();
        SuggestAnalyzer analyzer2 = new TestSuggestAnalyzer();

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

        List<AnalyzeToken> tokens1 = analyzer1.analyze(text, field, lang);