import assertk.assertThat
import assertk.assertions.isEqualTo
import okhttp3.internal.http2.hpackjson.HpackJsonUtil
import okhttp3.internal.http2.hpackjson.Story
import okio.Buffer

/**
 * Tests Hpack implementation using https://github.com/http2jp/hpack-test-case/
 */
open class HpackDecodeTestBase {
  private val bytesIn = Buffer()
  private val hpackReader = Hpack.Reader(bytesIn, 4096)

}

project.applyOsgi(
  "Export-Package: okhttp3.tls",
  "Automatic-Module-Name: okhttp3.tls",
  "Bundle-SymbolicName: com.squareup.okhttp3.tls"
)

dependencies {
  api(libs.squareup.okio)
  implementation(projects.okhttp)
  compileOnly(libs.findbugs.jsr305)
  compileOnly(libs.animalsniffer.annotations)

  testImplementation(projects.okhttpTestingSupport)
  testImplementation(projects.mockwebserver3Junit5)

 * limitations under the License.
 */
package okhttp3.dnsoverhttps

import java.net.InetAddress
import java.net.UnknownHostException
import okhttp3.Dns

/**
 * Internal Bootstrap DNS implementation for handling initial connection to DNS over HTTPS server.
 *
 * Returns hardcoded results for the known host.
 */
internal class BootstrapDns(
  private val dnsHostname: String,

import okio.IOException

/**
 * An async domain name service that resolves IP addresses for host names.
 *
 * The main implementations will typically be implemented using specific DNS libraries such as
 *  * Android DnsResolver
 *  * OkHttp DnsOverHttps
 *  * dnsjava Resolver
 *
 * Implementations of this interface must be safe for concurrent use.
 */
@ExperimentalOkHttpApi
interface AsyncDns {
  /**

    KOqkqm57TH2H3eDJAkSnh6/DNFu0Qg==
    -----END CERTIFICATE-----
    """.trimIndent().decodeCertificatePem()

  private val client: OkHttpClient

  init {
    // This implementation just embeds the PEM files in Java strings; most applications will
    // instead read this from a resource file that gets bundled with the application.
    val certificates =
      HandshakeCertificates.Builder()

   * [WindowCounter] generally carries the client view of total and acked bytes.
   */
  fun receivingConnectionWindowChanged(windowCounter: WindowCounter)

  /** Noop implementation */
  object None : FlowControlListener {
    override fun receivingStreamWindowChanged(
      streamId: Int,
      windowCounter: WindowCounter,
      bufferSize: Long,
    ) {
    }

 *  Breaking: Drop support for Kotlin Multiplatform.

    We planned to support multiplatform in OkHttp 5.0, but after building it, we weren't happy with
    the implementation trade-offs. We can't use our HTTP client engine on Kotlin/JS, and we weren't
    prepared to build a TLS API for Kotlin/Native.

    We'd prefer a multiplatform HTTP client API that's backed by OkHttp on Android and JVM, and

      resources.srcDir(copyResourcesTemplates.get().outputs)
    }
  }
}

dependencies {
  api(libs.kotlin.stdlib)
  api(projects.okhttp)
  api(projects.loggingInterceptor)
  api(libs.squareup.okio)
  implementation(libs.clikt)
  api(libs.guava.jre)

  testImplementation(projects.okhttpTestingSupport)
  testApi(libs.assertk)
  testImplementation(kotlin("test"))
}

animalsniffer {
  isIgnoreFailures = true
}

    // ideographic space
    assertThat(parse("http://h/\u3000").encodedPath).isEqualTo("/%E3%80%80")
  }

  @Test
  fun newBuilderResolve() {
    // Non-exhaustive tests because implementation is the same as resolve.
    val base = parse("http://host/a/b")
    assertThat(base.newBuilder("https://host2")!!.build())
      .isEqualTo(parse("https://host2/"))
    assertThat(base.newBuilder("//host2")!!.build())

import okio.BufferedSource
import okio.ByteString
import okio.ByteString.Companion.encodeUtf8
import okio.Options

/**
 * A decoded [mapping table] that can perform the [mapping step] of IDNA processing.
 *
 * This implementation is optimized for readability over efficiency.
 *
 * This implements non-transitional processing by preserving deviation characters.
 *
 * This implementation's STD3 rules are configured to `UseSTD3ASCIIRules=false`. This is