return Collections.emptyList();
            }
            final AnalyzeAction.Response analyzeResponse = client.admin().indices().prepareAnalyze(analyzerSettingsIndexName, text)
                    .setAnalyzer(getContentsAnalyzerName(field, lang)).execute().actionGet(settings.getIndicesTimeout());
            return analyzeResponse.getTokens();
        }

        @Override

	for _, r := range ctx.Resources {
		fn(r)
	}
}

// Canceled implements analysis.Context
func (ctx *Context) Canceled() bool { return false }

                    .setAnalyzer(analyzerSettings.getReadingAnalyzerName(field, lang)).execute().actionGet(settings.getIndicesTimeout());

            final AnalyzeAction.Response termResponse =
                    client.admin().indices().prepareAnalyze(analyzerSettings.getAnalyzerSettingsIndexName(), text)
                            .setAnalyzer(analyzerSettings.getReadingTermAnalyzerName(field, lang)).execute()

            final AnalyzeAction.Response termResponse = client.admin().indices()
                    .prepareAnalyze(analyzerSettings.getAnalyzerSettingsIndexName(), text)
                    .setAnalyzer(analyzerSettings.getNormalizeAnalyzerName(field, lang)).execute().actionGet(settings.getIndicesTimeout());

            final List<AnalyzeToken> termTokenList = termResponse.getTokens();
            if (termTokenList.isEmpty()) {

	ForEach(c config.GroupVersionKind, fn IteratorFn)

	// Canceled indicates that the context has been canceled. The analyzer should stop executing as soon as possible.
	Canceled() bool

	SetAnalyzer(analyzerName string)

func (ctx *context) ForEach(config.GroupVersionKind, IteratorFn)                        {}
func (ctx *context) Canceled() bool                                                     { return false }
func (ctx *context) SetAnalyzer(_ string)                                               {}

func TestCombinedAnalyzer(t *testing.T) {
	g := NewWithT(t)

	col1 := newSchema("col1")
	col2 := newSchema("col2")
	col3 := newSchema("col3")

        parser.setDefaultOperator(defaultOperator);
        return parser;
    }

    public void setDefaultField(final String defaultField) {
        this.defaultField = defaultField;
    }

    public void setAnalyzer(final Analyzer analyzer) {
        this.analyzer = analyzer;
    }

    public void setAllowLeadingWildcard(final boolean allowLeadingWildcard) {
        this.allowLeadingWildcard = allowLeadingWildcard;
    }

		scope.Analysis.Debugf("Started analyzer %q...", a.Metadata().Name)
		if ctx.Canceled() {
			scope.Analysis.Debugf("Analyzer %q has been cancelled...", c.Metadata().Name)
			return
		}
		ctx.SetAnalyzer(a.Metadata().Name)
		a.Analyze(ctx)
		scope.Analysis.Debugf("Completed analyzer %q...", a.Metadata().Name)
	}
}

	msgs := i.messages[i.currentAnalyzer]
	if msgs == nil {
		msgs = &diag.Messages{}
		i.messages[i.currentAnalyzer] = msgs
	}
	msgs.Add(m)
}

func (i *istiodContext) SetAnalyzer(analyzerName string) {
	i.currentAnalyzer = analyzerName
}

func (i *istiodContext) GetMessages(analyzerNames ...string) diag.Messages {
	result := diag.Messages{}
	if len(analyzerNames) == 0 {

        return this;
    }

    public SuggestIndexer setNormalizer(final Normalizer normalizer) {
        this.normalizer = normalizer;
        return this;
    }

    public SuggestIndexer setAnalyzer(final SuggestAnalyzer analyzer) {
        this.analyzer = analyzer;
        return this;
    }

    public SuggestIndexer setContentsParser(final ContentsParser contentsParser) {