</project>"""
        )
    }

    private boolean assertXmlEquals(String toTest, String expected) {
        def diff = DiffBuilder.compare(Input.fromString(expected))
                .ignoreWhitespace()
                .ignoreComments()
                .normalizeWhitespace()
                .withTest(Input.fromString(toTest))
                .build()
        diff.differences.each { difference ->

import org.gradle.api.Project

val Project.platform: String
  get() = findProperty("okhttp.platform")?.toString() ?: "jdk9"

val Project.testJavaVersion: Int
  get() = findProperty("test.java.version")?.toString()?.toInt() ?: 21

val Project.androidBuild: Boolean
  get() = findProperty("androidBuild")?.toString()?.toBoolean() ?: false

val Project.alpnBootVersion: String?

    in '0'..'9' -> this - '0'
    in 'a'..'f' -> this - 'a' + 10
    in 'A'..'F' -> this - 'A' + 10
    else -> -1
  }

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

internal infix fun Short.and(mask: Int): Int = toInt() and mask

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

@Throws(IOException::class)
internal fun BufferedSink.writeMedium(medium: Int) {

 */
package okhttp3.testing

object PlatformVersion {
  val majorVersion: Int by lazy {
    when (val jvmSpecVersion = getJvmSpecVersion()) {
      "1.8" -> 8
      else -> jvmSpecVersion.toInt()
    }
  }

  fun getJvmSpecVersion(): String = System.getProperty("java.specification.version", "unknown")

}[data-bs-theme=dark] .btn-close{filter:var(--bs-btn-close-white-filter)}.toast{--bs-toast-zindex:1090;--bs-toast-padding-x:0.75rem;--bs-toast-padding-y:0.5rem;--bs-toast-spacing:1.5rem;--bs-toast-max-width:350px;--bs-toast-font-size:0.875rem;--bs-toast-color: ;--bs-toast-bg:rgba(var(--bs-body-bg-rgb), 0.85);--bs-toast-border-width:var(--bs-border-width);--bs-toast-border-color:var(--bs-border-color-translucent);--bs-toast-border-radius:var(--bs-border-radius);--bs-toast-box-shadow:var(--bs-box-...

internal inline fun Lockable.awaitNanos(nanos: Long) {
  val ms = nanos / 1_000_000L
  val ns = nanos - (ms * 1_000_000L)
  if (ms > 0L || nanos > 0) {
    (this as Object).wait(ms, ns.toInt())
  }
}

internal inline fun Lockable.assertLockNotHeld() {
  if (assertionsEnabled && Thread.holdsLock(this)) {
    throw AssertionError("Thread ${Thread.currentThread().name} MUST NOT hold lock on $this")
  }
}

    val from = nextAddress
    nextAddress += count
    return (from until nextAddress)
      .map {
        return@map InetAddress.getByAddress(
          Buffer().writeInt(it.toInt()).readByteArray(),
        )
      }
  }

  /** Allocates and returns `count` fake IPv6 addresses like [::ff00:64, ::ff00:65].  */
  fun allocateIpv6(count: Int): List<InetAddress> {
    val from = nextAddress

  }

  val javaVersion = System.getProperty("java.version")
  val match = "1\\.8\\.0_(\\d+)(-.*)?".toRegex().find(javaVersion) ?: return null

  return alpnBootVersionForPatchVersion(match.groupValues.first().toInt())

    val parts = version.split(".")
    require(parts.size == 3 && parts.all { it.toIntOrNull() != null }) {
        "Version '$version' is not a valid x.y.z version."
    }
    return "${parts[0]}.${parts[1]}.${parts[2].toInt() + 1}"
}


fun updateReleasedVersionFile(releasedVersionsFile: File, currentReleasedVersion: ReleasedVersion) {
    val releasedVersions = releasedVersionsFile.reader().use {

    val unlimitedSource =
      object : Source {
        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          sink.writeUtf8("a".repeat(byteCount.toInt()))
          return byteCount
        }

        override fun close() {
        }

        override fun timeout() = Timeout.NONE
      }