try {
      for (i in 1..2) {
        // Space out traffic to make it easier to demarcate.
        sendTestRequest(fbRequest)
        Thread.sleep(1000)
        sendTestRequest(twitterRequest)
        Thread.sleep(1000)
        sendTestRequest(googleRequest)
        Thread.sleep(2000)
      }
    } finally {
      client.connectionPool.evictAll()
      client.dispatcher.executorService.shutdownNow()

        // Open the circuit
        circuitBreaker.tripBreaker();
        assertEquals(SimpleCircuitBreaker.State.OPEN, circuitBreaker.getState());

        // Wait for timeout
        Thread.sleep(150);

        // Next call should transition to HALF_OPEN
        String result = circuitBreaker.call(() -> "success");
        assertEquals("success", result);

      this.everyMillis = everyMillis;
      this.interruptee = interruptee;
    }

    @Override
    public void run() {
      while (true) {
        try {
          Thread.sleep(everyMillis);
        } catch (InterruptedException e) {
          // ok. just stop sleeping.
        }
        if (shouldStop) {
          break;
        }
        interruptee.interrupt();
      }
    }

        .Builder()
        .url(server.url("/"))
        .build()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    val response = call.execute()
    Thread.sleep(500)
    assertFailsWith<IOException> {
      response.body.source().readUtf8()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
      assertThat(call.isCanceled()).isTrue()
    }

                connected = true;
                break;
            } catch (final Exception e) {
                logger.info("[{}] {}", i + 1, e.getMessage());
            }
            ThreadUtil.sleep(200L);
        }
        if (!connected) {
            throw new IllegalStateException("Could not connect to the Samba server");
        }
    }

    @Override

    }

    @Test
    void testActivityTracking() {
        long initialTime = channelInfo.getLastActivityTime();

        // Wait a bit and update activity
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        channelInfo.updateActivity();
        assertTrue(channelInfo.getLastActivityTime() > initialTime);

/**
 * @author shinsuke
 *
 */
public class ThreadUtilTest {

    /**
     * @throws Exception
     */
    @Test
    public void test_sleep() throws Exception {
        ThreadUtil.sleep(1L);
        assertTrue(true);
        ThreadUtil.sleepQuietly(1L);
    }

    /**
     * @throws Exception
     */
    @Test
    public void test_sleepQuietly() throws Exception {

      yieldUntil(ResumePriority.BeforeOtherTasks) {
        contextSwitchCount > contextSwitchCountBefore
      }
    }
  }

  /** Sleep until [durationNanos] elapses. For use by the task threads. */
  fun sleep(durationNanos: Long) {
    taskRunner.withLock {
      val sleepUntil = nanoTime + durationNanos
      yieldUntil { nanoTime >= sleepUntil }
    }
  }

  /**

   *
   * Even if no other references to classes from the application class loader remain, the Finalizer
   * thread keeps an indirect strong reference to the queue in ReferenceMap, which keeps the
   * Finalizer running, and as a result, the application class loader can never be reclaimed.
   *
   * This means that dynamically loaded web applications and OSGi bundles can't be unloaded.

import java.util.concurrent.TimeUnit.SECONDS
import okhttp3.MediaType
import okhttp3.RequestBody
import okio.BufferedSink
import org.junit.jupiter.api.Assertions.assertTrue

/** A duplex request body that keeps the provided sinks so they can be written to later.  */
class AsyncRequestBody : RequestBody() {
  private val requestBodySinks: BlockingQueue<BufferedSink> = LinkedBlockingQueue()

  override fun contentType(): MediaType? = null