override fun contentType(): MediaType? = null

  override fun writeTo(sink: BufferedSink) {
    requestBodySinks.add(sink)
  }

  override fun isDuplex(): Boolean = true

  @Throws(InterruptedException::class)
  fun takeSink(): BufferedSink = requestBodySinks.poll(5, SECONDS) ?: throw AssertionError("no sink to take")

  fun assertNoMoreSinks() {
    assertTrue(requestBodySinks.isEmpty())
  }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.mockwebserver

abstract class Dispatcher {
  @Throws(InterruptedException::class)
  abstract fun dispatch(request: RecordedRequest): MockResponse

  open fun peek(): MockResponse = MockResponse().apply { this.socketPolicy = SocketPolicy.KEEP_OPEN }

  open fun shutdown() {}

            @Override
            protected ResponseData getResponseData(final String uri, final boolean includeContent) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new CrawlingAccessException(e);
                }
                return null;
            }
        };
        client.setAccessTimeout(1);
        try {

      aboutToAcquire(this);
      try {
        super.lock();
      } finally {
        lockStateChanged(this);
      }
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
      aboutToAcquire(this);
      try {
        super.lockInterruptibly();
      } finally {
        lockStateChanged(this);
      }
    }

    @Override
    public boolean tryLock() {

            ReactorContext reactorContext,
            ProjectBuildList projectBuilds,
            List<TaskSegment> taskSegments,
            ReactorBuildStatus reactorBuildStatus)
            throws ExecutionException, InterruptedException;

  public void testSuccess() throws ExecutionException, InterruptedException {
    Object value = new Object();
    assertSame(
        value,
        new AbstractFuture<Object>() {
          {
            set(value);
          }
        }.get());
  }

  public void testException() throws InterruptedException {
    Throwable failure = new Throwable();
    AbstractFuture<String> future =

        }

        @Test
        @DisplayName("Should be thread-safe with optimized locking")
        void testSignThreadSafety() throws InterruptedException {
            int threadCount = 10;
            Thread[] threads = new Thread[threadCount];
            byte[][] dataArrays = new byte[threadCount][128];

            for (int i = 0; i < threadCount; i++) {

          proxy: Proxy,
        ) {
          try {
            // Wait for request2 to guarantee we make 2 separate connections to the server.
            latch1.await()
          } catch (e: InterruptedException) {
            throw AssertionError(e)
          }
        }

        override fun connectionAcquired(
          call: Call,
          connection: Connection,
        ) {

        assertFalse(entry.isExpired());
        assertFalse(entry.needsRefresh());

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            // Ignore
        }

        assertTrue(entry.isExpired());
        assertTrue(entry.needsRefresh());
    }

    @Test
    public void testNeedsRefresh() {

    verifyTimedGetOnPendingFuture(future);
  }

  private static void assertSuccessful(
      AbstractFuture<Integer> future, @Nullable Integer expectedResult)
      throws InterruptedException, TimeoutException, ExecutionException {
    assertDone(future);
    assertThat(future.isCancelled()).isFalse();

    assertThat(getDone(future)).isEqualTo(expectedResult);