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

        // 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);

    }

    /**
     * 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);
    }

    /**

        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
    }

import org.codelibs.fess.suggest.normalizer.ICUNormalizer;

// Configure custom settings
SuggestSettings settings = SuggestSettings.builder()
    .analyzer(analyzers -> {
        // Configure custom analyzers
        analyzers.addAnalyzer("custom", customAnalyzerSettings);
    })
    .build();

Suggester customSuggester = Suggester.builder()
    .settings(settings)

 *
 * <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>

**Example for Swedish:**
```json
{
  "analysis": {
    "filter": {
      "swedish_stop": {
        "type": "stop",
        "stopwords": "_swedish_"
      },
      "swedish_stemmer": {
        "type": "stemmer",
        "language": "swedish"
      }
    },
    "analyzer": {
      "sv_analyzer": {
        "type": "custom",

        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.
     *

     * @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

          }
        }
      },
      {
        "lang_cs": {
          "match": "*_cs",
          "mapping": {
            "type": "text",
            "analyzer": "czech_analyzer"
          }
        }
      },
      {
        "lang_da": {
          "match": "*_da",
          "mapping": {
            "type": "text",
            "analyzer": "danish_analyzer"
          }