runner.ensureYellow();

        suggester = Suggester.builder().build(runner.client(), "SuggesterTest");
    }

    @AfterClass
    public static void afterClass() throws Exception {
        runner.close();
        runner.clean();
    }

    @Test
    public void test_normalize() throws Exception {
        Normalizer normalizer = SuggestUtil.createDefaultNormalizer(runner.client(), suggester.settings());

    assertFailsWith<IOException> {
      while (responseBody.read(buffer) != -1) {
      }
    }.also { expected ->
      assertEquals(cancelMode == INTERRUPT, Thread.interrupted())
    }
    responseBody.close()
    assertEquals(if (connectionType == H2) 1 else 0, client.connectionPool.connectionCount())
  }

  @ParameterizedTest
  @ArgumentsSource(CancelModelParamProvider::class)

func (p *parallelReader) Done() {
	if p.stashBuffer != nil {
		globalBytePoolCap.Load().Put(p.stashBuffer)
		p.stashBuffer = nil
	}
}

// preferReaders can mark readers as preferred.
// These will be chosen before others.
func (p *parallelReader) preferReaders(prefer []bool) {
	if len(prefer) != len(p.orgReaders) {
		return
	}
	// Copy so we don't change our input.
	tmp := make([]io.ReaderAt, len(p.orgReaders))

    val socket = Socket()
    socket.connect(serverSocket.localSocketAddress)
    val socketSource = socket.source().buffer()

    assertThat(socket.isHealthy(socketSource)).isTrue()

    serverSocket.close()
    assertThat(socket.isHealthy(socketSource)).isFalse()
  }

  @Test
  fun testDurationTimeUnit() {
    assertThat(checkDuration("timeout", 0, TimeUnit.MILLISECONDS)).isEqualTo(0)

        dns = fakeDns
      }

  @BeforeEach
  fun setup() {
    Authenticator.setDefault(recordingAuthenticator)
  }

  @AfterEach
  fun tearDown() {
    Authenticator.setDefault(null)
    factory.close()
  }

  @Test
  fun testBasicAuth() {
    fakeDns["server"] = listOf(InetAddress.getLocalHost())

    val route = factory.newRoute()

    val request =
      Request.Builder()

      if (!other.isSet(i)) continue
      set(i, other[i])
    }
  }

  companion object {
    /**
     * From the HTTP/2 specs, the default initial window size for all streams is 64 KiB. (Chrome 25
     * uses 10 MiB).
     */
    const val DEFAULT_INITIAL_WINDOW_SIZE = 65535

    /** HTTP/2: Size in bytes of the table used to decode the sender's header blocks. */
    const val HEADER_TABLE_SIZE = 1

 * **Exchange** carries a single HTTP request/response pair.

 * **ExchangeFinder** chooses which connection carries each exchange. Where possible it will use the same connection for all exchanges in a single call. It prefers reusing pooled connections over establishing new connections.      

#### Per-Connection Locks

        try ( SmbFileHandleImpl fh = ensureOpen() ) {}
    }


    @Override
    public synchronized void close () throws SmbException {
        try {
            if ( this.handle != null ) {
                try {
                    this.handle.close();
                }
                catch ( CIFSException e ) {
                    throw SmbException.wrap(e);
                }

   */
  private fun responseBody(content: String): ResponseBody {
    val data = Buffer().writeUtf8(content)
    val source: Source =
      object : Source {
        var closed = false

        override fun close() {
          closed = true
        }

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

      stream.responseBody.writeUtf8(s)
      stream.responseBody.flush()
      responseSent.countDown()
    }
  }

  fun exhaustResponse() =
    apply {
      actions += { stream -> stream.responseBody.close() }
    }

  fun sleep(
    duration: Long,
    unit: TimeUnit,
  ) = apply {
    actions += { Thread.sleep(unit.toMillis(duration)) }
  }

  override fun handle(stream: Stream) {