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

import java.io.IOException
import java.net.ProtocolException
import okhttp3.Headers
import okhttp3.Interceptor
import okhttp3.Response
import okhttp3.TrailersSource
import okhttp3.internal.UnreadableResponseBody

                }
            })
        }

        @Throws(IOException::class)
        private
        fun processEntry(zipEntry: ZipEntry, builder: Trie.Builder) {
            val name = zipEntry.name
            if (name.endsWith(".class")) {
                processClassFile(zipEntry, builder)
            }
        }

        @Throws(IOException::class)
        private

    TO_BYTE_ARRAY_NEW_STRING {
      @Override
      String read(ByteSource byteSource, Charset cs) throws IOException {
        return new String(byteSource.read(), cs);
      }
    },
    USING_CHARSTREAMS_COPY {
      @Override
      String read(ByteSource byteSource, Charset cs) throws IOException {
        StringBuilder sb = new StringBuilder();

        }
      } catch (e: Exception) {
        val exception =
          when {
            canceled -> IOException("canceled", e)
            else -> e
          }
        listener.onFailure(this, exception, response)
        return
      }
      if (canceled) {
        listener.onFailure(this, IOException("canceled"), response)
      } else {
        listener.onClosed(this)
      }
    }
  }

        .build()

    val request = Request(server.url("/"))
    assertFailsWith<IOException> {
      client.newCall(request).execute()
    }.also { expected ->
      expected.assertSuppressed {
        val suppressed = it.single()
        assertThat(suppressed).isInstanceOf(IOException::class.java)
        assertThat(suppressed).isNotSameAs(expected)
      }
    }
  }

internal infix fun Int.and(mask: Long): Long = toLong() and mask

@Throws(IOException::class)
internal fun BufferedSink.writeMedium(medium: Int) {
  writeByte(medium.ushr(16) and 0xff)
  writeByte(medium.ushr(8) and 0xff)
  writeByte(medium and 0xff)
}

@Throws(IOException::class)
internal fun BufferedSource.readMedium(): Int =
  (
    readByte() and 0xff shl 16

 * limitations under the License.
 */
package okhttp3

import okio.IOException

/**
 * Returns the trailers that follow an HTTP response, blocking if they aren't ready yet.
 * Implementations of this interface should respond to [Call.cancel] by immediately throwing an
 * [IOException].
 *
 * Most callers won't need this interface, and should use [Response.trailers] instead.
 *

    this.inetSocketAddress = address;
  }

  @Override public void connect(SocketAddress endpoint) throws IOException {
    this.inetSocketAddress = (InetSocketAddress) endpoint;
    super.connect(new UnixSocketAddress(path), 0);
  }

  @Override public void connect(SocketAddress endpoint, int timeout) throws IOException {
    this.inetSocketAddress = (InetSocketAddress) endpoint;
    super.connect(new UnixSocketAddress(path), timeout);

    val plan0 = routePlanner.addPlan()
    plan0.tcpConnectThrowable = IOException("boom 0!")
    val plan1 = routePlanner.addPlan()
    plan1.tcpConnectThrowable = IOException("boom 1!")

    taskRunner.newQueue().execute("connect") {
      assertFailsWith<IOException> {
        finder.find()
      }.also { expected ->
        assertThat(expected).hasMessage("boom 0!")

 * under the License.
 */
package org.apache.maven.settings.crypto;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.maven.settings.Proxy;
import org.apache.maven.settings.Server;
import org.apache.maven.settings.building.DefaultSettingsProblem;