*/
class JavaHttpClientTest {
  @JvmField @RegisterExtension
  val platform = PlatformRule()

  @StartStop
  private val server = MockWebServer()

  @Test fun get() {
    // Not available
    platform.expectFailureOnJdkVersion(8)

    val httpClient =
      HttpClient
        .newBuilder()
        .followRedirects(NORMAL)
        .build()

        // In this case, we simply put the elements into these buckets evenly.
        return list.chunked(list.size / expectedBucketNumber, smallElementAggregateFunction)
    }

    val largestElement = list.removeFirst()!!

    val largestElementSize = toIntFunction(largestElement)

    if (largestElementSize >= roughSizeOfEachBucket) {
        var bucketNumberOfFirstElement =
            determineBucketNumberForLargeElment(

abstract class UpdateSmokeTestedPluginsVersions : AbstractVersionsUpdateTask() {

    @TaskAction
    fun update() {
        val pluginIds = getPluginIds()
        val fetchedVersions = fetchLatestVersions(pluginIds)
        updateProperties(fetchedVersions)
    }

    private
    fun getPluginIds(): List<String> {
        val props = Properties()
        propertiesFile.get().asFile.reader().use { input ->
            props.load(input)
        }

import model.Stage

open class BaseGradleBuildType(
    open val stage: Stage? = null,
    open val failStage: Boolean = true,
    init: BaseGradleBuildType.() -> Unit = {},
) : BuildType() {
    init {
        this.init()
    }
}

open class OsAwareBaseGradleBuildType(
    val os: Os,
    override val stage: Stage? = null,
    override val failStage: Boolean = true,
    init: OsAwareBaseGradleBuildType.() -> Unit = {},

open class DelegatingServerSocketFactory(
  private val delegate: ServerSocketFactory,
) : ServerSocketFactory() {
  @Throws(IOException::class)
  override fun createServerSocket(): ServerSocket {
    val serverSocket = delegate.createServerSocket()
    return configureServerSocket(serverSocket)
  }

  @Throws(IOException::class)
  override fun createServerSocket(port: Int): ServerSocket {
    val serverSocket = delegate.createServerSocket(port)

    }

    @get:InputFiles
    @get:PathSensitive(PathSensitivity.RELATIVE)
    abstract val packageInfoFiles: ConfigurableFileCollection

    @get:OutputFile
    abstract val outputFile: RegularFileProperty

    private val baseDir = project.layout.settingsDirectory.asFile

    @TaskAction
    fun action() {
        val results = mutableListOf<Pair<String, String>>()

        for (packageInfoFile in packageInfoFiles.files) {

 * a stale [EventListener] in a field or local variable.
 */
class EventListenerRelay(
  val call: Call,
  val eventRecorder: EventRecorder,
) {
  private val eventListenerAdapter =
    EventListenerAdapter()
      .apply {
        listeners += ::onEvent
      }

  val eventListener: EventListener
    get() = eventListenerAdapter

  var eventCount = 0

  companion object {
    private val activeLoggers = mutableListOf<Logger>()

    fun configureLogging(
      debug: Boolean,
      showHttp2Frames: Boolean,
      sslDebug: Boolean,
    ) {
      if (debug || showHttp2Frames || sslDebug) {
        if (sslDebug) {
          System.setProperty("javax.net.debug", "")
        }
        LogManager.getLogManager().reset()
        val handler =

  @Test fun testDoubleQuotesAreSpecial() {
    val mediaType = parse("text/plain;a=\";charset=utf-8;b=\"")
    assertNull(mediaType.charsetName())
  }

  @Test fun testSingleQuotesAreNotSpecial() {
    val mediaType = parse("text/plain;a=';charset=utf-8;b='")
    assertEquals("UTF-8", mediaType.charsetName())
  }

  @Test fun testParseWithSpecialCharacters() {

```

### Usage

```
  val appCache = Cache(File("cacheDir", "okhttpcache"), 10 * 1024 * 1024)
  val bootstrapClient = OkHttpClient.Builder().cache(appCache).build()

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())
    .bootstrapDnsHosts(InetAddress.getByName("8.8.4.4"), InetAddress.getByName("8.8.8.8"))
    .build()