}

  private fun newEmptyKeyStore(keyStoreType: String?): KeyStore =
    KeyStore.getInstance(keyStoreType ?: KeyStore.getDefaultType()).apply {
      val inputStream: InputStream? = null // By convention, 'null' creates an empty key store.
      load(inputStream, password)
    }

 * limitations under the License.
 */
package okhttp3.slack;

import java.io.IOException;
import java.io.InterruptedIOException;
import okhttp3.HttpUrl;
import okio.Timeout;

/** A connection to Slack as a single user. */
public final class SlackClient {
  private final SlackApi slackApi;
  private OAuthSessionFactory sessionFactory;

  /** Guarded by this. */
  private OAuthSession session;

ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

interface ExchangeFinder {
  val routePlanner: RoutePlanner

  fun find(): RealConnection

import java.net.InetAddress
import java.net.Socket
import java.util.concurrent.CountDownLatch
import javax.net.ssl.SSLSocket
import okhttp3.Handshake
import okhttp3.Handshake.Companion.handshake
import okhttp3.internal.connection.BufferedSocket
import okhttp3.internal.platform.Platform
import okio.BufferedSink
import okio.BufferedSource
import okio.ForwardingSink
import okio.ForwardingSource
import okio.asOkioSocket
import okio.buffer

    val request2 = Request.Builder().url(server.url("/")).build()
    val response2 = client.newCall(request2).execute()
    assertThat(response2.body.string()).isEqualTo("def")

    // The HTTP calls should share a single connection.
    assertThat(socksProxy.connectionCount()).isEqualTo(1)
  }

  @Test
  fun proxySelector() {
    server.enqueue(MockResponse.Builder().body("abc").build())
    val proxySelector: ProxySelector =

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

import java.net.Socket as JavaNetSocket
import okio.BufferedSink
import okio.BufferedSource
import okio.Socket as OkioSocket
import okio.asOkioSocket
import okio.buffer

  }

  @Test
  fun trailersWithServerTruncatedResponseHttp2() {
    trailersWithServerTruncatedResponse(Protocol.HTTP_2)
  }

  /**
   * If the server closes the connection while the client is consuming the response body, attempts
   * to peek or read the trailers should throw.
   */
  private fun trailersWithServerTruncatedResponse(protocol: Protocol) {

        Protocol protocol, IOException ioe) {
      printEvent("connectFailed");
    }

    @Override public void connectionAcquired(Call call, Connection connection) {
      printEvent("connectionAcquired");
    }

    @Override public void connectionReleased(Call call, Connection connection) {
      printEvent("connectionReleased");
    }

    @Override public void requestHeadersStart(Call call) {

   */
  fun receivingStreamWindowChanged(
    streamId: Int,
    windowCounter: WindowCounter,
    bufferSize: Long,
  )

  /**
   * Notification that the receiving connection flow control window has changed.
   * [WindowCounter] generally carries the client view of total and acked bytes.
   */
  fun receivingConnectionWindowChanged(windowCounter: WindowCounter)

  /** Noop implementation */