*/
        val taskPathToReports: MapProperty<String, List<File>>

        /**
         * Key is the path of the test, value is Test.binaryResultsDir
         */
        val testPathToBinaryResultsDirs: MapProperty<String, File>
    }

    private
    val projectPathToFailedTaskPaths: MutableMap<String, MutableList<String>> = mutableMapOf()

    private

    val addressD = decodeIpv6("abcd:ef01:2345:6789:abcd:ef01:2345:6789")!!
    assertThat(canonicalizeInetAddress(addressD)).isEqualTo(addressD)

    val addressE = decodeIpv6("2001:db8::1:0:0:1")!!
    assertThat(canonicalizeInetAddress(addressE)).isEqualTo(addressE)

    val addressF = decodeIpv6("0:0:0:0:0:ffff:7f00:1")!!
    assertThat(canonicalizeInetAddress(addressF)).isEqualTo(addressB)

      var pos = cookiePairEnd + 1
      val limit = setCookie.length
      while (pos < limit) {
        val attributePairEnd = setCookie.delimiterOffset(';', pos, limit)

        val attributeEqualsSign = setCookie.delimiterOffset('=', pos, attributePairEnd)
        val attributeName = setCookie.trimSubstring(pos, attributeEqualsSign)
        val attributeValue =
          if (attributeEqualsSign < attributePairEnd) {

    address: Address,
    policy: ConnectionPool.AddressPolicy,
  ) {
    val state = AddressState(address, taskRunner.newQueue(), policy)
    val newConnectionsNeeded: Int

    while (true) {
      val oldMap = this.addressStates
      val newMap = oldMap + (address to state)
      if (addressStatesUpdater.compareAndSet(this, oldMap, newMap)) {
        val oldPolicyMinimumConcurrentCalls = oldMap[address]?.policy?.minimumConcurrentCalls ?: 0

class ClassGraph(
    private val keepPackages: PackagePatterns,
    private val unshadedPackages: PackagePatterns,
    private val ignorePackages: PackagePatterns,
    shadowPackage: String
) {

    private
    val classes: MutableMap<String, ClassDetails> = linkedMapOf()

    val entryPoints: MutableSet<ClassDetails> = linkedSetOf()

    val shadowPackagePrefix =

            }
            if( val != 0 ) {
                val >>>= 4;
            }
            size--;
        }
    }
    public static void toHexChars( long val, char dst[], int dstIndex, int size ) {
        while( size > 0 ) {
            dst[dstIndex + size - 1] = HEX_DIGITS[(int)( val & 0x000FL )];
            if( val != 0 ) {
                val >>>= 4;
            }

      apply {
        val keyStoreFactory = KeyStoreFactory(Configuration.configuration(), MockServerLogger())

        val socketFactory = keyStoreFactory.sslContext().socketFactory

        val trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
        trustManagerFactory.init(keyStoreFactory.loadOrCreateKeyStore())

  }

  @Test fun addDate() {
    val expected = Date(0L)
    val headers =
      Headers.Builder()
        .add("testDate", expected)
        .build()
    assertThat(headers["testDate"]).isEqualTo("Thu, 01 Jan 1970 00:00:00 GMT")
    assertThat(headers.getDate("testDate")).isEqualTo(Date(0L))
  }

  @Test fun addInstant() {
    val expected = Instant.ofEpochMilli(0L)
    val headers =
      Headers.Builder()

      )
    }
  }

  @Test
  fun byteStringEmpty() {
    val body = body("")
    assertThat(body.byteString()).isEqualTo(ByteString.EMPTY)
  }

  @Test
  fun byteStringSeesBom() {
    val body = body("efbbbf68656c6c6f")
    val actual = body.byteString()
    val expected: ByteString = "efbbbf68656c6c6f".decodeHex()
    assertThat(actual).isEqualTo(expected)
  }

import okhttp3.internal.connection.RoutePlanner.ConnectResult

class FakeRoutePlanner(
  val factory: TestValueFactory = TestValueFactory(),
  val taskFaker: TaskFaker = factory.taskFaker,
) : RoutePlanner, Closeable {
  val pool = factory.newConnectionPool(routePlanner = this)
  val events = LinkedBlockingDeque<String>()
  var canceled = false
  var autoGeneratePlans = false