* Z. B. würde `await myfile.seek(0)` zum Anfang der Datei gehen.
    * Das ist besonders dann nützlich, wenn Sie `await myfile.read()` einmal ausführen und dann diese Inhalte erneut auslesen müssen.
* `close()`: Schließt die Datei.

Da alle diese Methoden `async`hron sind, müssen Sie sie `await`en („erwarten“).

Zum Beispiel können Sie innerhalb einer `async` *Pfadoperation-Funktion* den Inhalt wie folgt auslesen:

    * E.g., `await myfile.seek(0)` navegaria para o ínicio do arquivo.
    * Isso é especialmente útil se você executar `await myfile.read()` uma vez e depois precisar ler os conteúdos do arquivo de novo.
* `close()`: Fecha o arquivo.

Como todos esses métodos são assíncronos (`async`) você precisa esperar ("await") por eles.

Por exemplo, dentro de uma *função de operação de rota* assíncrona você pode obter os conteúdos com:

                      SmbTransportInternal trans = session.getTransport().unwrap(SmbTransportInternal.class) ) {
                    t = trans;
                }
                f.close();

                Thread.sleep(2 * soTimeout);

                // connection should be closed by now
                assertTrue("Transport is still connected", t.isDisconnected());

                logger.debug("Failed to validate a file.", e);
            }
        }
        return false;
    }

    /**
     * Generates SitemapSet instance.
     *
     * This method does not close the input stream.
     *
     * @param in Input stream for a sitemap
     * @return a sitemap set
     */
    public SitemapSet parse(final InputStream in) {
        return parse(in, true);
    }

	public final fun boundary ()Ljava/lang/String;
	public fun close ()V
	public final fun nextPart ()Lokhttp3/MultipartReader$Part;
}

public final class okhttp3/MultipartReader$Part : java/io/Closeable {
	public fun <init> (Lokhttp3/Headers;Lokio/BufferedSource;)V
	public final fun body ()Lokio/BufferedSource;
	public fun close ()V
	public final fun headers ()Lokhttp3/Headers;
}

    call =
      clientTestRule.newClient().newCall(
        Request.Builder()
          .url("https://$uriHost:$uriPort/")
          .build(),
      ) as RealCall
  }

  @AfterEach fun tearDown() {
    factory.close()
  }

  @Test fun singleRoute() {
    val address = factory.newAddress()
    val routeSelector = newRouteSelector(address)
    assertThat(routeSelector.hasNext()).isTrue()
    dns[uriHost] = dns.allocate(1)

					if !cache.Info.LastUpdate.IsZero() && cache.Info.LastUpdate.After(before) {
						scannerLogIf(ctx, cache.save(ctx, er, cacheName))
					} else {
						scannerLogIf(ctx, err)
					}
					// This ensures that we don't close
					// bucketResults channel while the
					// updates-collector goroutine still
					// holds a reference to this.
					wg.Wait()
					continue
				}

				wg.Wait()

			batchLogIf(ctx, ri.updateAfter(ctx, api, after, job))
			cancel()
		}
	}()

	expireCh := make(chan []expireObjInfo, workerSize)
	expireDoneCh := make(chan struct{})
	go func() {
		defer close(expireDoneCh)
		batchObjsForDelete(ctx, r, ri, job, api, wk, expireCh)
	}()

	var (
		prevObj       ObjectInfo
		matchedFilter BatchJobExpireFilter
		versionsCount int
		toDel         []expireObjInfo

	file := os.Stdin
	if filename != "-" {
		var err error
		file, err = os.Open(filename)
		if err != nil {
			return nil, err
		}
	}
	defer func() {
		if err := file.Close(); err != nil {
			log.Errorf("failed to close %s: %s", filename, err)
		}
	}()
	return io.ReadAll(file)
}

func extractZtunnelConfigDump(kubeClient kube.CLIClient, podName, podNamespace string) ([]byte, error) {

	}

	return fi.ToObjectInfo(srcBucket, srcObject, srcOpts.Versioned || srcOpts.VersionSuspended), nil
}

// GetObjectNInfo - returns object info and an object
// Read(Closer). When err != nil, the returned reader is always nil.
func (er erasureObjects) GetObjectNInfo(ctx context.Context, bucket, object string, rs *HTTPRangeSpec, h http.Header, opts ObjectOptions) (gr *GetObjectReader, err error) {