return source.timeout().intersectWith(timeout) {
          when (val limit = currentPartBytesRemaining(maxByteCount = byteCount)) {
            0L -> -1L

            // No more bytes in this part.
            else -> source.read(sink, limit)
          }
        }
      }

      override fun timeout(): Timeout = timeout
    }

    /**

// Lock - block until write lock is taken or timeout has occurred.
func (di *distLockInstance) GetLock(ctx context.Context, timeout *dynamicTimeout) (LockContext, error) {
	lockSource := getSource(2)
	start := UTCNow()

	newCtx, cancel := context.WithCancel(ctx)
	if !di.rwMutex.GetLock(newCtx, cancel, di.opsID, lockSource, dsync.Options{
		Timeout:       timeout.Timeout(),
		RetryInterval: timeout.RetryInterval(),
	}) {

  }

  /**
   * Test to ensure we throw a read timeout on responses that are progressing too slowly.  For this
   * case, we take a 2KiB body and throttle it to 1KiB/second.  We set the read timeout to half a
   * second.  If our implementation is acting correctly, it will throw, as a byte doesn't arrive in
   * time.
   */
  @Test
  fun readTimeoutOnSlowConnection() {
    val body = repeat('y', 2048)

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.mockito.Mockito;

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.Credentials;

/**
 * Simple memory management tests to validate basic resource cleanup functionality
 */

            testRequest.setOverrideTimeout(timeout);
            assertEquals(timeout, testRequest.getOverrideTimeout());
        }

        @Test
        @DisplayName("setOverrideTimeout should handle null value")
        void testSetOverrideTimeoutNull() {
            testRequest.setOverrideTimeout(5000);
            testRequest.setOverrideTimeout(null);
            assertNull(testRequest.getOverrideTimeout());

   * ({@code this}) will be cancelled and interrupted.
   *
   * @param timeout when to time out the future
   * @param unit the time unit of the time parameter
   * @param scheduledExecutor The executor service to enforce the timeout.
   */
  @J2ktIncompatible
  @GwtIncompatible // ScheduledExecutorService
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public final FluentFuture<V> withTimeout(

     *
     * @param name the pipe name to wait for
     * @param timeout the timeout value in milliseconds
     */
    public FsctlPipeWaitRequest(final String name, final long timeout) {
        this.nameBytes = name.getBytes(StandardCharsets.UTF_16LE);
        this.timeoutSpecified = true;
        this.timeout = timeout;
    }

    /**
     * {@inheritDoc}
     *

     * Returns a new chain with the specified read timeout.
     */
    fun withReadTimeout(
      timeout: Int,
      unit: TimeUnit,
    ): Chain

    /**
     * Returns the write timeout in milliseconds.
     */
    fun writeTimeoutMillis(): Int

    /**
     * Returns a new chain with the specified write timeout.
     */
    fun withWriteTimeout(
      timeout: Int,
      unit: TimeUnit,
    ): Chain

	"context"
	"fmt"
	"runtime"
	"sync/atomic"
	"testing"
	"time"
)

const (
	id     = "1234-5678"
	source = "main.go"
)

func testSimpleWriteLock(t *testing.T, duration time.Duration) (locked bool) {
	drwm1 := NewDRWMutex(ds, "simplelock")
	ctx1, cancel1 := context.WithCancel(t.Context())
	if !drwm1.GetRLock(ctx1, cancel1, id, source, Options{Timeout: time.Second}) {
		panic("Failed to acquire read lock")
	}

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          check(!closed)
          return data.read(sink, byteCount)
        }

        override fun timeout(): Timeout = Timeout.NONE
      }
    return source.buffer().asResponseBody(null, -1)
  }

  private fun newResponse(
    responseBody: ResponseBody,
    code: Int = 200,
    fn: Response.Builder.() -> Unit = {},