var current metacacheBlock
		var n int

		buf := bytebufferpool.Get()
		defer func() {
			buf.Reset()
			bytebufferpool.Put(buf)
		}()

		block := newMetacacheWriter(buf, 1<<20)
		defer block.Close()
		finishBlock := func() {
			if err := block.Close(); err != nil {
				w.streamErr = err
				return
			}
			current.data = buf.Bytes()
			w.streamErr = nextBlock(&current)

                            final Map<String, String> map = new HashMap<>();
                            map.put(ExtractData.RESOURCE_NAME_KEY, filename);
                            buf.append(extractor.getText(new IgnoreCloseInputStream(ais), map).getContent());
                            buf.append('\n');
                        } catch (final Exception e) {
                            if (logger.isDebugEnabled()) {

                            final StringBuilder buf = new StringBuilder(1000);
                            buf.append("[SEARCH TIMEOUT] {\"exec_time\":").append(execTime)//
                                    .append(",\"request\":").append(searchRequestBuilder.toString())//
                                    .append(",\"response\":").append(r.toString()).append('}');
                            logger.warn(buf.toString());
                        }

		} else {
			versions = append(versions, fi)
			allVersionIDs = append(allVersionIDs, fi.VersionID)
		}
	}
	buf, err := xl.AppendTo(nil)
	if err != nil {
		t.Fatalf("Failed to serialize xlmeta %v", err)
	}
	fivs, err := getFileInfoVersions(buf, basefi.Volume, basefi.Name, false)
	if err != nil {
		t.Fatalf("getFileInfoVersions failed: %v", err)
	}

    for (i in s.indices) {
      assertRoundTrip(s.substring(0, i).encodeUtf8())
    }
    val random = Random(123456789L)
    val buf = ByteArray(4096)
    random.nextBytes(buf)
    assertRoundTrip(buf.toByteString())
  }

  private fun assertRoundTrip(data: ByteString) {
    val encodeBuffer = Buffer()
    encode(data, encodeBuffer)

			b.Run("ToFileInfoNew", func(b *testing.B) {
				b.SetBytes(int64(size))
				b.ResetTimer()
				b.ReportAllocs()
				for i := 0; i < b.N; i++ {
					buf, _, _ := isIndexedMetaV2(enc)
					if buf == nil {
						b.Fatal("buf == nil")
					}
					_, err = buf.ToFileInfo("volume", "path", ids[rng.Intn(size)], true)
					if err != nil {
						b.Fatal(err)
					}
				}
			})

                            final Map<String, String> map = new HashMap<>();
                            map.put(ExtractData.RESOURCE_NAME_KEY, filename);
                            buf.append(extractor.getText(new IgnoreCloseInputStream(ais), map).getContent());
                            buf.append('\n');
                        } catch (final Exception e) {
                            if (logger.isDebugEnabled()) {

        // content
        final StringBuilder buf = new StringBuilder(content.length() + 1000);
        if (fessConfig.isCrawlerDocumentFileAppendBodyContent()) {
            buf.append(content);
        }
        if (fessConfig.isCrawlerDocumentFileAppendMetaContent()) {
            if (buf.length() > 0) {
                buf.append(' ');
            }
            buf.append(contentMeta);
        }

                    if (StringUtil.isNotBlank(normalizePath)) {
                        buf.append(normalizePath);
                    }
                }
                this.includedPaths = Pattern.compile(buf.toString());
            }

            if (StringUtil.isNotBlank(excludedPaths)) {
                final StringBuilder buf = new StringBuilder(100);
                char split = 0;

}

// AppendFile - append to a file.
func (client *storageRESTClient) AppendFile(ctx context.Context, volume string, path string, buf []byte) error {
	values := make(url.Values)
	values.Set(storageRESTVolume, volume)
	values.Set(storageRESTFilePath, path)
	reader := bytes.NewReader(buf)
	respBody, err := client.call(ctx, storageRESTMethodAppendFile, values, reader, -1)
	defer xhttp.DrainBody(respBody)
	return err
}