`
	var err error
	dir := t.TempDir()

	mountsPath := filepath.Join(dir, "mounts")
	if err = os.WriteFile(mountsPath, []byte(successCase), 0o666); err != nil {
		t.Fatal(err)
	}
	// Verifies if reading each line worked properly.
	{
		var mounts mountInfos
		mounts, err = readProcMounts(mountsPath)
		if err != nil {
			t.Fatal(err)
		}
		if len(mounts) != 3 {

    /*
     * We overload this because we want readAndXWireFormat to
     * read the parameter words and bytes. This is so when
     * commands are batched together we can recursivly call
     * readAndXWireFormat without reading the non-existent header.
     */

    int decode( byte[] buffer, int bufferIndex ) {
        int start = headerStart = bufferIndex;

        bufferIndex += readHeaderWireFormat( buffer, bufferIndex );

                    final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(con.getOutputStream(), Constants.CHARSET_UTF_8))) {
                String line;
                while ((line = br.readLine()) != null) {
                    if (StringUtil.isNotBlank(line)) {
                        final Map<String, Map<String, String>> dataObj;
                        if (line.contains("\"_index\"") || line.contains("\"_type\"")) {

labels.labelTypeIds=Надписи
labels.lang=язык
labels.outputs=Цель
labels.pos=POS
labels.purgeJobLogDay=Предварительная очистка журнала работы
labels.purgeUserInfoDay=Предварительная очистка пользователя
labels.reading=Чтение
labels.roleTypeIds=ID роль
labels.scriptData=Скрипт
labels.scriptResult=Результат
labels.scriptType=Исполнитель
labels.segmentation=Сегментация
labels.startTime=Время начала
labels.target=Цель

	}
	r := new(ReadCloser)
	if err = r.init(f, fi.Size()); err != nil && err != ErrInsecurePath {
		f.Close()
		return nil, err
	}
	r.f = f
	return r, err
}

// NewReader returns a new [Reader] reading from r, which is assumed to
// have the given size in bytes.
//
// If any file inside the archive uses a non-local name
// (as defined by [filepath.IsLocal]) or a name containing backslashes

### Asynchronous Get ([.kt][AsynchronousGetKotlin], [.java][AsynchronousGetJava])

Download a file on a worker thread, and get called back when the response is readable. The callback is made after the response headers are ready. Reading the response body may still block. OkHttp doesn't currently offer asynchronous APIs to receive a response body in parts.

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val client = OkHttpClient()

	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "id":
			z.ID, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "cl":
			z.CmdLine, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "CmdLine")
				return

  @GwtIncompatible // java.io.ObjectInputStream
  @J2ktIncompatible
  private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
    stream.defaultReadObject();
    int keyCount = stream.readInt();
    if (keyCount < 0) {
      throw new InvalidObjectException("Invalid key count " + keyCount);
    }
    ImmutableMap.Builder<Object, ImmutableList<Object>> builder = ImmutableMap.builder();
    int tmpSize = 0;

    // Append 10 more bytes to the source.
    source.append(newPreFilledByteArray(5, 10));

    // The stream reports no bytes... importantly, it doesn't read the byte at index 5 when it
    // should be reading the byte at index 10.
    // We could use a custom InputStream instead to make the read start at index 10, but since this
    // is a racy situation anyway, this behavior seems reasonable.
    assertEquals(-1, in.read());
  }

                        try {
                            while (!reader.ready()) {
                                ThreadUtil.sleep(1000L);
                            }
                            command = reader.readLine().trim();
                            if (logger.isDebugEnabled()) {
                                logger.debug("Process command: {}", command);
                            }