throw afe;
      }
    }
  }

  void checkEmpty(BlockingQueue<?> q) {
    try {
      assertTrue(q.isEmpty());
      assertEquals(0, q.size());
      assertThat(q.peek()).isNull();
      assertThat(q.poll()).isNull();
      assertThat(q.poll(0, MILLISECONDS)).isNull();
      assertEquals("[]", q.toString());
      assertThat(q.toArray()).isEmpty();

		}
		if contextCanceled(ctx) {
			return ctx.Err()
		}
		for i, r := range readers {
			if errs[i] != nil {
				hasErr++
				continue
			}
			entry, err := r.peek()
			switch err {
			case io.EOF:
				atEOF++
				continue
			case nil:
			default:
				switch err.Error() {
				case errFileNotFound.Error():
					atEOF++
					fnf++
					continue

	public static final field EMPTY Lokhttp3/TrailersSource;
	public abstract fun get ()Lokhttp3/Headers;
	public fun peek ()Lokhttp3/Headers;
}

public final class okhttp3/TrailersSource$Companion {
}

public final class okhttp3/TrailersSource$DefaultImpls {
	public static fun peek (Lokhttp3/TrailersSource;)Lokhttp3/Headers;
}

public abstract interface class okhttp3/WebSocket {

## Version 5.1.0

_2025-07-07_

 *  New: `Response.peekTrailers()`. When we changed `Response.trailers()` to block instead of
    throwing in 5.0.0, we inadvertently removed the ability for callers to peek the trailers
    (by catching the `IllegalStateException` if they weren't available). This new API restores that
    capability.

		{bucketNames[2], "minio-object", objectNames[1], "", "", 10, listMultipartResults[34], nil, true},
	}

	for i, testCase := range testCases {
		// fmt.Println(i+1, testCase) // uncomment to peek into the test cases.
		actualResult, actualErr := obj.ListMultipartUploads(context.Background(), testCase.bucket, testCase.prefix, testCase.keyMarker, testCase.uploadIDMarker, testCase.delimiter, testCase.maxUploads)

    val requestFinished = CountDownLatch(2)
    val dispatcher: QueueDispatcher =
      object : QueueDispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {
          if (peek().onResponseStart is CloseSocket) {
            requestFinished.await()
          }
          return super.dispatch(request)
        }
      }
    dispatcher.enqueue(MockResponse(body = "seed connection pool"))

		{seek: io.SeekCurrent, off: 1, wantpos: 1<<33 + 1, readerr: io.EOF},
		{seek: io.SeekStart, n: 5, want: "01234"},
		{seek: io.SeekCurrent, n: 5, want: "56789"},
		{seek: io.SeekEnd, off: -1, n: 1, wantpos: 9, want: "9"},
	}

	for i, tt := range tests {
		pos, err := r.Seek(tt.off, tt.seek)
		if err == nil && tt.seekerr != "" {
			t.Errorf("%d. want seek error %q", i, tt.seekerr)
			continue
		}

    /**
     * Current position in file
     *
     * @return current position
     */
    long getFilePointer();

    /**
     * Seek to new position
     *
     * @param pos the new position to seek to
     */
    void seek(long pos);

    /**
     * Get the current file length
     *
     * @return file length
     * @throws SmbException if an I/O error occurs
     */

import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Seek command response implementation.
 * Handles server responses to file seek operations, returning the new file
 * position after a seek request in SMB1 protocol file operations.
 *
 * @author mbechler
 */
public class SmbComSeekResponse extends ServerMessageBlock {

    private long offset;

    /**
     * Constructs a seek response.
     *

		// io.Seeker, but calling Seek always returns an error and performs
		// no action. Thus, we try an innocent seek to the current position
		// to see if Seek is really supported.
		pos1, err := sr.Seek(0, io.SeekCurrent)
		if pos1 >= 0 && err == nil {
			// Seek seems supported, so perform the real Seek.
			pos2, err := sr.Seek(n-1, io.SeekCurrent)
			if pos2 < 0 || err != nil {
				return err