// will implicitly flush out the file's padding.
func (tw *Writer) Flush() error {
	if tw.err != nil {
		return tw.err
	}
	if nb := tw.curr.logicalRemaining(); nb > 0 {
		return fmt.Errorf("archive/tar: missed writing %d bytes", nb)
	}
	if _, tw.err = tw.w.Write(zeroBlock[:tw.pad]); tw.err != nil {
		return tw.err
	}
	tw.pad = 0
	return nil
}

	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 {

	}
	if _, err := tw.Write(data); err != nil {
		t.Fatalf("tw.Write: %v", err)
	}
	if err := tw.Close(); err != nil {
		t.Fatalf("tw.Close: %v", err)
	}

	// Read it back.
	tr := NewReader(&b)
	rHdr, err := tr.Next()
	if err != nil {
		t.Fatalf("tr.Next: %v", err)
	}
	if !reflect.DeepEqual(rHdr, hdr) {
		t.Errorf("Header mismatch.\n got %+v\nwant %+v", rHdr, hdr)
	}
	rData, err := io.ReadAll(tr)

          "mapping": {
            "type": "text",
            "analyzer": "simplified_chinese_analyzer"
          }
        }
      },
      {
        "lang_zh-tw": {
          "match": "*_zh-tw",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      }
    ],
    "properties": {
      "anchor": {

          "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": {

        assertArrays(new String[] { "zh-tw" }, fessConfig.normalizeQueryLanguages(new String[] { "zh_TW" }));
    }

    public void test_getQueryLocaleFromName() {
        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";
            }
        };

          "mapping": {
            "type": "text",
            "analyzer": "simplified_chinese_analyzer"
          }
        }
      },
      {
        "lang_zh-tw": {
          "match": "*_zh-tw",
          "mapping": {
            "type": "text",
            "analyzer": "traditional_chinese_analyzer"
          }
        }
      }
    ],
    "properties": {
      "anchor": {

          "mapping": {
            "type": "text",
            "analyzer": "simplified_chinese_analyzer"
          }
        }
      },
      {
        "lang_zh-tw": {
          "match": "*_zh-tw",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      }
    ],
    "properties": {
      "anchor": {

	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 {

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