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

        "com.squareup.okhttp3.urlconnection",
      )

    /** Equinox must also be on the testing classpath.  */
    private const val RESOLVE_OSGI_FRAMEWORK = "org.eclipse.osgi"
    private const val RESOLVE_JAVA_VERSION = "JavaSE-1.8"
    private const val REPO_NAME = "OsgiTest"
  }

  }

  @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()

 *
 * Typical use loops over the parts in sequence:
 *
 * ```kotlin
 * val response: Response = call.execute()
 * val multipartReader = MultipartReader(response.body!!)
 *
 * multipartReader.use {
 *   while (true) {
 *     val part = multipartReader.nextPart() ?: break
 *     process(part.headers, part.body)
 *   }
 * }
 * ```
 *

          .build(),
      )
    val response = call.execute()
    interruptLater(500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {
      while (responseBody.read(buffer) != -1) {
      }
    }
    responseBody.close()
  }

  private fun sleep(delayMillis: Int) {
    try {
      Thread.sleep(delayMillis.toLong())

const val MAX_TEST_PROJECTS_PER_BUCKET = 10

data class PerformanceTestSpec(val performanceTestType: PerformanceTestType, val os: Os)

class StatisticsBasedPerformanceTestBucketProvider(private val model: CIBuildModel, performanceTestDurationsJson: File, performanceTestsCiJson: File) : PerformanceTestBucketProvider {
    private

     */
    val dogfoodTimestamp1 = "19800101010101+0000"
    val dogfoodTimestamp2 = "19800202020202+0000"
    val buildScanTagForType = buildScanTagParam("Gradleception")
    val buildScanTagForGroovy4 = buildScanTagParam("Groovy4")
    val buildScanTags =
        if (bundleGroovy4) listOf(buildScanTagForType, buildScanTagForGroovy4) else listOf(buildScanTagForType)
    val extraSysProp = mutableListOf<String>()

import org.junit.jupiter.api.Test

// Most tests from URLConnectionTest
class JavaNetAuthenticatorTest {
  private var authenticator = JavaNetAuthenticator()
  private val fakeDns = FakeDns()
  private val recordingAuthenticator = RecordingAuthenticator()
  private val factory =
    TestValueFactory()
      .apply {
        dns = fakeDns
      }

  @BeforeEach
  fun setup() {
    Authenticator.setDefault(recordingAuthenticator)

    interface Parameters : ValueSourceParameters {

        @get:Optional
        val buildTimestampFromBuildReceipt: Property<String>

        @get:Optional
        val buildTimestampFromGradleProperty: Property<String>

        val runningOnCi: Property<Boolean>

        val runningInstallTask: Property<Boolean>
        val runningDocsTestTask: Property<Boolean>
    }

 */
class KotlinInternalFilteringTest : AbstractBinaryCompatibilityTest() {

    private
    val internalMembers = """

        internal fun foo() {}

        internal val bar = "bar"

        internal var bazar = "bazar"

        internal fun String.fooExt() {}

        internal fun Int.fooExt() {}

        internal val String.barExt: String
            get() = "bar"

        internal var Int.bazarExt: String