*/
  fun timeout(): Timeout

  /**
   * Configure this call to publish all future events to [eventListener], in addition to the
   * listeners configured by [OkHttpClient.Builder.eventListener] and other calls to this function.
   *
   * If this call is later [cloned][clone], [eventListener] will not be notified of its events.
   *
   * There is no mechanism to remove an event listener. Implementations should instead ignore events

   *
   * <p><b>Warning:</b> using a bounded executor may be counterproductive! If the thread pool fills
   * up, any time callers spend waiting for a thread may count toward their time limit, and in this
   * case the call may even time out before the target method is ever invoked.
   *
   * @param executor the ExecutorService that will execute the method calls on the target objects;

    assertTrue(Thread.holdsLock(mutex));
    return super.isEmpty();
  }

  /*
   * We don't assert that the lock is held during calls to iterator(), stream(), and spliterator:
   * `Synchronized` doesn't guarantee that it will hold the mutex for those calls because callers
   * are responsible for taking the mutex themselves:

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.Deque;
import java.util.Iterator;
import org.jspecify.annotations.Nullable;

/**
 * A deque which forwards all its method calls to another deque. Subclasses should override one or
 * more methods to modify the behavior of the backing deque as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.NoSuchElementException;
import java.util.Queue;
import org.jspecify.annotations.Nullable;

/**
 * A queue which forwards all its method calls to another queue. Subclasses should override one or
 * more methods to modify the behavior of the backing queue as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

    throw new UnsupportedOperationException();
  }

  /**
   * Not supported. <b>You are attempting to create a set that may contain a non-{@code Comparable}
   * element.</b> Proper calls will resolve to the version in {@code ImmutableSortedSet}, not this
   * dummy version.
   *
   * @throws UnsupportedOperationException always
   * @deprecated <b>Pass a parameter of type {@code Comparable} to use {@link

    }

    /**
     * Helper method to create a DcerpcPipeHandle with injected mocks
     * Uses mock to avoid constructor issues while allowing real method calls
     */
    private DcerpcPipeHandle createMockedDcerpcPipeHandle() throws Exception {
        // Create a mock without calling the constructor
        DcerpcPipeHandle handle = mock(DcerpcPipeHandle.class);

      return this.value == that.value;
    }
    return false;
  }

  @Override
  public int hashCode() {
    throw new UnsupportedOperationException();
  }

  // needed because otherwise Object.toString() calls hashCode()
  @Override
  public String toString() {
    return "DontHashMe" + value;
  }

  @Override
  public int compareTo(UnhashableObject o) {
    return Integer.compare(this.value, o.value);
  }

    assertTrue(Thread.holdsLock(mutex));
    return super.isEmpty();
  }

  /*
   * We don't assert that the lock is held during calls to iterator(), stream(), and spliterator:
   * `Synchronized` doesn't guarantee that it will hold the mutex for those calls because callers
   * are responsible for taking the mutex themselves:

import java.util.Collection;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.TimeUnit;
import org.jspecify.annotations.Nullable;

/**
 * A {@link BlockingDeque} which forwards all its method calls to another {@code BlockingDeque}.
 * Subclasses should override one or more methods to modify the behavior of the backing deque as
 * desired per the <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *