/** Sets the results for `hostname`.  */
  operator fun set(
    hostname: String,
    addresses: List<InetAddress>,
  ): FakeDns {
    hostAddresses[hostname] = addresses
    return this
  }

  /** Clears the results for `hostname`.  */
  fun clear(hostname: String): FakeDns {
    hostAddresses.remove(hostname)
    return this
  }

  @Throws(UnknownHostException::class)
  fun lookup(

// 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)
  }

  @AfterEach

    server.enqueue(
      MockResponse(
        code = 301,
        headers = headersOf("Location", "http://www.fakeurl:" + server.port),
      ),
    )
    server.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server.hostName)
    client =
      client
        .newBuilder()
        .dns(dns)
        .build()

import java.net.Proxy
import java.net.ProxySelector
import java.net.SocketAddress
import java.net.URI
import java.net.UnknownHostException
import kotlin.test.assertFailsWith
import okhttp3.Address
import okhttp3.FakeDns
import okhttp3.OkHttpClientTestRule
import okhttp3.Request
import okhttp3.Route
import okhttp3.TestValueFactory
import okhttp3.internal.connection.RouteSelector.Companion.socketHost

  @StartStop
  val server2 = MockWebServer()

  private var eventRecorder = EventRecorder()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  val dns = FakeDns()

  val ipv4 = InetAddress.getByName("203.0.113.1")
  val ipv6 = InetAddress.getByName("2001:db8:ffff:ffff:ffff:ffff:ffff:1")

  val refusedStream =
    MockResponse
      .Builder()

  @StartStop
  private val server = MockWebServer()

  private lateinit var client: OkHttpClient
  private lateinit var rootCa: HeldCertificate
  private lateinit var certificate: HeldCertificate
  private val dns = FakeDns()
  private lateinit var url: HttpUrl
  private lateinit var serverIps: List<InetAddress>

  @BeforeEach
  fun setUp() {
    platform.assumeHttp2Support()
    platform.assumeNotBouncyCastle()
    rootCa =

      MockResponse
        .Builder()
        .code(301)
        .setHeader("Location", "http://www.fakeurl:" + server.port)
        .build(),
    )
    server.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server.hostName)
    client =
      client
        .newBuilder()
        .dns(dns)
        .build()

    executeSynchronously("/")
      .assertCode(200)
      .assertBody("A")

    // Attempt conditional cache validation and a DNS miss.
    client =
      client
        .newBuilder()
        .dns(FakeDns())
        .build()
    executeSynchronously("/").assertFailure(UnknownHostException::class.java)
  }

  @Test
  fun redirect() {
    server.enqueue(
      MockResponse(
        code = 301,

    )
  }

  @Test
  fun invalidHost() {
    // Note that 1234.1.1.1 is an invalid host in a URI, but URL isn't as strict.
    client =
      client
        .newBuilder()
        .dns(FakeDns())
        .build()
    assertFailsWith<UnknownHostException> {
      getResponse(
        Request
          .Builder()
          .url("http://1234.1.1.1/index.html".toHttpUrl())
          .build(),

    interface will make your code easier to test. When you test code that makes
    HTTP requests, you can use this interface to replace the real `OkHttpClient`
    with your own mocks or fakes.

    The interface will also let you use OkHttp's API with another HTTP client's
    implementation. This is useful in sandboxed environments like Google App
    Engine.