t.Run("NegativeSize", func(t *testing.T) {
		tw := NewWriter(new(bytes.Buffer))
		hdr := &Header{Name: "small.txt", Size: -1}
		if err := tw.WriteHeader(hdr); err == nil {
			t.Fatalf("WriteHeader() = nil, want non-nil error")
		}
	})

	t.Run("BeforeHeader", func(t *testing.T) {
		tw := NewWriter(new(bytes.Buffer))
		if _, err := tw.Write([]byte("Kilts")); err != ErrWriteTooLong {

          "keywords_path": "${fess.dictionary.path}th/protwords.txt"
        },
        "traditional_chinese_stop": {
          "type":       "stop",
          "stopwords_path": "${fess.dictionary.path}zh-tw/stopwords.txt"
        },
        "turkish_stop": {
          "type":       "stop",
          "stopwords_path": "${fess.dictionary.path}tr/stopwords.txt"
        },
        "turkish_lowercase": {

        FessProp.propMap.clear();
        FessConfig fessConfig = new FessConfig.SimpleImpl() {
            @Override
            public String getQueryLanguageMapping() {
                return "ja=ja\nzh_cn=zh-cn\nzh_TW=zh-tw\nzh=zh-cn";
            }
        };

        assertArrays(new String[] {}, fessConfig.normalizeQueryLanguages(new String[] {}));

        assertTrue(AnalyzerSettings.isSupportedLanguage("ja"));
        assertTrue(AnalyzerSettings.isSupportedLanguage("zh-cn"));
        assertTrue(AnalyzerSettings.isSupportedLanguage("zh-tw"));

        // Test unsupported languages
        assertFalse(AnalyzerSettings.isSupportedLanguage("xyz"));
        assertFalse(AnalyzerSettings.isSupportedLanguage(""));

func (t *transitionState) Init(objAPI ObjectLayer) {
	n := globalAPIConfig.getTransitionWorkers()
	// Prefer ilm.transition_workers over now deprecated api.transition_workers
	if tw := globalILMConfig.getTransitionWorkers(); tw > 0 {
		n = tw
	}
	t.mu.Lock()
	defer t.mu.Unlock()

	t.objAPI = objAPI
	t.updateWorkers(n)
}

// PendingTasks returns the number of ILM transition tasks waiting for a worker

        .Builder()
        .url("https://graph.facebook.com/robots.txt?s=fb")
        .build()
    val twitterRequest =
      Request
        .Builder()
        .url("https://api.twitter.com/robots.txt?s=tw")
        .build()
    val googleRequest =
      Request
        .Builder()
        .url("https://www.google.com/robots.txt?s=g")
        .build()

    try {
      for (i in 1..2) {

	for _, path := range []string{
		"../foo",
		"/foo",
		"a/b/../../../c",
	} {
		var buf bytes.Buffer
		tw := NewWriter(&buf)
		tw.WriteHeader(&Header{
			Name: path,
		})
		const securePath = "secure"
		tw.WriteHeader(&Header{
			Name: securePath,
		})
		tw.Close()

		tr := NewReader(&buf)
		h, err := tr.Next()
		if err != ErrInsecurePath {

		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"zh-cn/stopwords.txt"</arg>
		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"zh-tw/stopwords.txt"</arg>
		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"ar/stemmer_override.txt"</arg>
		</postConstruct>
		<postConstruct name="addConfigFile">

        value = "zh-cn";
        assertEquals("zh_CN", systemHelper.normalizeLang(value));

        value = "zh_CN";
        assertEquals("zh_CN", systemHelper.normalizeLang(value));

        value = "zh-tw";
        assertEquals("zh_TW", systemHelper.normalizeLang(value));

        value = "zh_TW";
        assertEquals("zh_TW", systemHelper.normalizeLang(value));
    }

    @Test

            "fr", "gu", "he", "hi", "hr", "hu", "id", "it", "ja", "ko", "lt", "lv", "mk", "ml", "nl", "no", "pa", "pl", "pt", "ro", "ru",
            "si", "sq", "sv", "ta", "te", "th", "tl", "tr", "uk", "ur", "vi", "zh-cn", "zh-tw" };

    /**
     * Constructor for AnalyzerSettings.
     * @param client The OpenSearch client.
     * @param settings The SuggestSettings instance.
     * @param settingsIndexName The name of the settings index.