Switch to a Builder for mockwebserver3.MockResponse (#7578)

* Switch to a Builder for mockwebserver3.MockResponse

* Migrate lots of tests to MockResponse.Builder

* Improve some code style

* Follow naming conventions in MockResponse.Builder

* Apply side-effects for inTunnel=true

* Update the API

mockwebserver-deprecated/src/main/kotlin/okhttp3/mockwebserver/bridge.kt

@@ -39,23 +39,23 @@ internal fun Dispatcher.wrap(): mockwebserver3.Dispatcher {
 }
 
 internal fun MockResponse.wrap(): mockwebserver3.MockResponse {
-  val result = mockwebserver3.MockResponse()
+  val result = mockwebserver3.MockResponse.Builder()
   val copyFromWebSocketListener = webSocketListener
   if (copyFromWebSocketListener != null) {
-    result.withWebSocketUpgrade(copyFromWebSocketListener)
+    result.webSocketUpgrade(copyFromWebSocketListener)
   }
 
   val body = getBody()
-  if (body != null) result.setBody(body)
+  if (body != null) result.body(body)
 
   for (pushPromise in pushPromises) {
-    result.withPush(pushPromise.wrap())
+    result.addPush(pushPromise.wrap())
   }
 
-  result.withSettings(settings)
+  result.settings(settings)
   result.status = status
-  result.headers = headers
+  result.headers(headers)
-  result.trailers = trailers
+  result.trailers(trailers)
   result.socketPolicy = when (socketPolicy) {
     SocketPolicy.EXPECT_CONTINUE, SocketPolicy.CONTINUE_ALWAYS -> {
       result.add100Continue()
@@ -69,9 +69,9 @@ internal fun MockResponse.wrap(): mockwebserver3.MockResponse {
   }
   result.http2ErrorCode = http2ErrorCode
   result.throttleBody(throttleBytesPerPeriod, getThrottlePeriod(MILLISECONDS), MILLISECONDS)
-  result.setBodyDelay(getBodyDelay(MILLISECONDS), MILLISECONDS)
+  result.bodyDelay(getBodyDelay(MILLISECONDS), MILLISECONDS)
-  result.setHeadersDelay(getHeadersDelay(MILLISECONDS), MILLISECONDS)
+  result.headersDelay(getHeadersDelay(MILLISECONDS), MILLISECONDS)
-  return result
+  return result.build()
 }
 
 private fun PushPromise.wrap(): mockwebserver3.PushPromise {

mockwebserver-junit5/src/test/java/mockwebserver3/junit5/internal/ExtensionLifecycleTest.kt

@@ -37,14 +37,14 @@ class ExtensionLifecycleTest {
   fun setup(server: MockWebServer) {
     _server = server
     assertThat(server.started).isTrue()
-    server.enqueue(MockResponse().setResponseCode(200))
+    server.enqueue(MockResponse())
   }
 
   @AfterEach
   fun tearDown(server: MockWebServer) {
     assertThat(_server).isSameAs(server)
     assertThat(server.started).isTrue()
-    server.enqueue(MockResponse().setResponseCode(200))
+    server.enqueue(MockResponse())
   }
 
   @Test

mockwebserver/api/mockwebserver3.api

@@ -5,22 +5,17 @@ public abstract class mockwebserver3/Dispatcher {
 	public fun shutdown ()V
 }
 
-public final class mockwebserver3/MockResponse : java/lang/Cloneable {
+public final class mockwebserver3/MockResponse {
 	public static final field Companion Lmockwebserver3/MockResponse$Companion;
-	public final fun -deprecated_getHeaders ()Lokhttp3/Headers;
-	public final fun -deprecated_getHttp2ErrorCode ()I
-	public final fun -deprecated_getSocketPolicy ()Lmockwebserver3/SocketPolicy;
-	public final fun -deprecated_getStatus ()Ljava/lang/String;
-	public final fun -deprecated_getTrailers ()Lokhttp3/Headers;
 	public fun <init> ()V
-	public final fun add100Continue ()Lmockwebserver3/MockResponse;
+	public fun <init> (I)V
-	public final fun addHeader (Ljava/lang/String;)Lmockwebserver3/MockResponse;
+	public fun <init> (ILokhttp3/Headers;)V
-	public final fun addHeader (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse;
+	public fun <init> (ILokhttp3/Headers;Ljava/lang/String;)V
-	public final fun addHeaderLenient (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse;
+	public fun <init> (ILokhttp3/Headers;Ljava/lang/String;Z)V
-	public final fun addInformationalResponse (Lmockwebserver3/MockResponse;)Lmockwebserver3/MockResponse;
+	public fun <init> (ILokhttp3/Headers;Ljava/lang/String;ZLmockwebserver3/SocketPolicy;)V
-	public final fun clearHeaders ()Lmockwebserver3/MockResponse;
+	public fun <init> (ILokhttp3/Headers;Ljava/lang/String;ZLmockwebserver3/SocketPolicy;I)V
-	public synthetic fun clone ()Ljava/lang/Object;
+	public synthetic fun <init> (ILokhttp3/Headers;Ljava/lang/String;ZLmockwebserver3/SocketPolicy;IILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public fun clone ()Lmockwebserver3/MockResponse;
+	public synthetic fun <init> (Lmockwebserver3/MockResponse$Builder;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public final fun getBody ()Lokio/Buffer;
 	public final fun getBodyDelay (Ljava/util/concurrent/TimeUnit;)J
 	public final fun getCode ()I
@@ -39,33 +34,57 @@ public final class mockwebserver3/MockResponse : java/lang/Cloneable {
 	public final fun getThrottlePeriod (Ljava/util/concurrent/TimeUnit;)J
 	public final fun getTrailers ()Lokhttp3/Headers;
 	public final fun getWebSocketListener ()Lokhttp3/WebSocketListener;
-	public final fun headers (Lokhttp3/Headers;)V
-	public final fun http2ErrorCode (I)V
-	public final fun inTunnel ()Lmockwebserver3/MockResponse;
 	public final fun isDuplex ()Z
-	public final fun removeHeader (Ljava/lang/String;)Lmockwebserver3/MockResponse;
+	public final fun newBuilder ()Lmockwebserver3/MockResponse$Builder;
-	public final fun setBody (Ljava/lang/String;)Lmockwebserver3/MockResponse;
-	public final fun setBody (Lmockwebserver3/internal/duplex/DuplexResponseBody;)Lmockwebserver3/MockResponse;
-	public final fun setBody (Lokio/Buffer;)Lmockwebserver3/MockResponse;
-	public final fun setBodyDelay (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse;
-	public final fun setChunkedBody (Ljava/lang/String;I)Lmockwebserver3/MockResponse;
-	public final fun setChunkedBody (Lokio/Buffer;I)Lmockwebserver3/MockResponse;
-	public final fun setHeader (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse;
-	public final fun setHeaders (Lokhttp3/Headers;)Lmockwebserver3/MockResponse;
-	public final fun setHeadersDelay (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse;
-	public final fun setHttp2ErrorCode (I)Lmockwebserver3/MockResponse;
-	public final fun setResponseCode (I)Lmockwebserver3/MockResponse;
-	public final fun setSocketPolicy (Lmockwebserver3/SocketPolicy;)Lmockwebserver3/MockResponse;
-	public final fun setStatus (Ljava/lang/String;)Lmockwebserver3/MockResponse;
-	public final fun setTrailers (Lokhttp3/Headers;)Lmockwebserver3/MockResponse;
-	public final fun socketPolicy (Lmockwebserver3/SocketPolicy;)V
-	public final fun status (Ljava/lang/String;)V
-	public final fun throttleBody (JJLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse;
 	public fun toString ()Ljava/lang/String;
-	public final fun trailers (Lokhttp3/Headers;)V
+}
-	public final fun withPush (Lmockwebserver3/PushPromise;)Lmockwebserver3/MockResponse;
+
-	public final fun withSettings (Lokhttp3/internal/http2/Settings;)Lmockwebserver3/MockResponse;
+public final class mockwebserver3/MockResponse$Builder : java/lang/Cloneable {
-	public final fun withWebSocketUpgrade (Lokhttp3/WebSocketListener;)Lmockwebserver3/MockResponse;
+	public fun <init> ()V
+	public final fun add100Continue ()Lmockwebserver3/MockResponse$Builder;
+	public final fun addHeader (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
+	public final fun addHeader (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse$Builder;
+	public final fun addHeaderLenient (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse$Builder;
+	public final fun addInformationalResponse (Lmockwebserver3/MockResponse;)Lmockwebserver3/MockResponse$Builder;
+	public final fun addPush (Lmockwebserver3/PushPromise;)Lmockwebserver3/MockResponse$Builder;
+	public final fun body (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
+	public final fun body (Lmockwebserver3/internal/duplex/DuplexResponseBody;)Lmockwebserver3/MockResponse$Builder;
+	public final fun body (Lokio/Buffer;)Lmockwebserver3/MockResponse$Builder;
+	public final fun bodyDelay (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse$Builder;
+	public final fun build ()Lmockwebserver3/MockResponse;
+	public final fun chunkedBody (Ljava/lang/String;I)Lmockwebserver3/MockResponse$Builder;
+	public final fun chunkedBody (Lokio/Buffer;I)Lmockwebserver3/MockResponse$Builder;
+	public final fun clearHeaders ()Lmockwebserver3/MockResponse$Builder;
+	public synthetic fun clone ()Ljava/lang/Object;
+	public fun clone ()Lmockwebserver3/MockResponse$Builder;
+	public final fun code (I)Lmockwebserver3/MockResponse$Builder;
+	public final fun getCode ()I
+	public final fun getDuplexResponseBody ()Lmockwebserver3/internal/duplex/DuplexResponseBody;
+	public final fun getHttp2ErrorCode ()I
+	public final fun getInTunnel ()Z
+	public final fun getInformationalResponses ()Ljava/util/List;
+	public final fun getPushPromises ()Ljava/util/List;
+	public final fun getSettings ()Lokhttp3/internal/http2/Settings;
+	public final fun getSocketPolicy ()Lmockwebserver3/SocketPolicy;
+	public final fun getStatus ()Ljava/lang/String;
+	public final fun getThrottleBytesPerPeriod ()J
+	public final fun getWebSocketListener ()Lokhttp3/WebSocketListener;
+	public final fun headers (Lokhttp3/Headers;)Lmockwebserver3/MockResponse$Builder;
+	public final fun headersDelay (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse$Builder;
+	public final fun http2ErrorCode (I)Lmockwebserver3/MockResponse$Builder;
+	public final fun inTunnel ()Lmockwebserver3/MockResponse$Builder;
+	public final fun removeHeader (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
+	public final fun setCode (I)V
+	public final fun setHeader (Ljava/lang/String;Ljava/lang/Object;)Lmockwebserver3/MockResponse$Builder;
+	public final fun setHttp2ErrorCode (I)V
+	public final fun setSocketPolicy (Lmockwebserver3/SocketPolicy;)V
+	public final fun setStatus (Ljava/lang/String;)V
+	public final fun settings (Lokhttp3/internal/http2/Settings;)Lmockwebserver3/MockResponse$Builder;
+	public final fun socketPolicy (Lmockwebserver3/SocketPolicy;)Lmockwebserver3/MockResponse$Builder;
+	public final fun status (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
+	public final fun throttleBody (JJLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse$Builder;
+	public final fun trailers (Lokhttp3/Headers;)Lmockwebserver3/MockResponse$Builder;
+	public final fun webSocketUpgrade (Lokhttp3/WebSocketListener;)Lmockwebserver3/MockResponse$Builder;
 }
 
 public final class mockwebserver3/MockResponse$Companion {

mockwebserver/src/main/kotlin/mockwebserver3/Dispatcher.kt

@@ -31,7 +31,7 @@ abstract class Dispatcher {
    * request bodies.
    */
   open fun peek(): MockResponse {
-    return MockResponse().apply { this.socketPolicy = SocketPolicy.KEEP_OPEN }
+    return MockResponse(socketPolicy = SocketPolicy.KEEP_OPEN)
   }
 
   /**

mockwebserver/src/main/kotlin/mockwebserver3/MockResponse.kt

@@ -18,22 +18,17 @@ package mockwebserver3
 import java.util.concurrent.TimeUnit
 import mockwebserver3.internal.duplex.DuplexResponseBody
 import okhttp3.Headers
+import okhttp3.Headers.Companion.headersOf
 import okhttp3.WebSocketListener
 import okhttp3.internal.addHeaderLenient
 import okhttp3.internal.http2.Settings
 import okio.Buffer
 
 /** A scripted response to be replayed by the mock web server. */
-class MockResponse : Cloneable {
+class MockResponse {
-  var inTunnel = false
-    private set
-
-  var informationalResponses: List<MockResponse> = listOf()
-    private set
 
   /** Returns the HTTP response line, such as "HTTP/1.1 200 OK". */
-  @set:JvmName("status")
+  val status: String
-  var status: String = ""
 
   val code: Int
     get() {
@@ -49,352 +44,397 @@ class MockResponse : Cloneable {
       return statusParts[2]
     }
 
-  private var headersBuilder = Headers.Builder()
+  val headers: Headers
-  private var trailersBuilder = Headers.Builder()
+  val trailers: Headers
 
-  /** The HTTP headers, such as "Content-Length: 0". */
+  val body: Buffer?
-  @set:JvmName("headers")
+    get() { return field?.clone() }
-  var headers: Headers
-    get() = headersBuilder.build()
-    set(value) {
-      this.headersBuilder = value.newBuilder()
-    }
 
-  @set:JvmName("trailers")
+  val inTunnel: Boolean
-  var trailers: Headers
+  val informationalResponses: List<MockResponse>
-    get() = trailersBuilder.build()
-    set(value) {
-      this.trailersBuilder = value.newBuilder()
-    }
 
-  private var body: Buffer? = null
+  val throttleBytesPerPeriod: Long
+  private val throttlePeriodAmount: Long
+  private val throttlePeriodUnit: TimeUnit
 
-  var throttleBytesPerPeriod: Long = Long.MAX_VALUE
+  val socketPolicy: SocketPolicy
-    private set
-  private var throttlePeriodAmount = 1L
-  private var throttlePeriodUnit = TimeUnit.SECONDS
-
-  @set:JvmName("socketPolicy")
-  var socketPolicy: SocketPolicy = SocketPolicy.KEEP_OPEN
 
   /**
    * Sets the [HTTP/2 error code](https://tools.ietf.org/html/rfc7540#section-7) to be
-   * returned when resetting the stream.
+   * returned when resetting the stream. This is only valid with
-   * This is only valid with [SocketPolicy.RESET_STREAM_AT_START] and
+   * [SocketPolicy.RESET_STREAM_AT_START] and [SocketPolicy.DO_NOT_READ_REQUEST_BODY].
-   * [SocketPolicy.DO_NOT_READ_REQUEST_BODY].
    */
-  @set:JvmName("http2ErrorCode")
+  val http2ErrorCode: Int
-  var http2ErrorCode: Int = -1
 
-  private var bodyDelayAmount = 0L
+  private val bodyDelayAmount: Long
-  private var bodyDelayUnit = TimeUnit.MILLISECONDS
+  private val bodyDelayUnit: TimeUnit
 
-  private var headersDelayAmount = 0L
+  private val headersDelayAmount: Long
-  private var headersDelayUnit = TimeUnit.MILLISECONDS
+  private var headersDelayUnit: TimeUnit
+
+  val pushPromises: List<PushPromise>
+
+  val settings: Settings
+
+  val webSocketListener: WebSocketListener?
+  val duplexResponseBody: DuplexResponseBody?
 
-  private var promises = mutableListOf<PushPromise>()
-  var settings: Settings = Settings()
-    private set
-  var webSocketListener: WebSocketListener? = null
-    private set
-  var duplexResponseBody: DuplexResponseBody? = null
-    private set
   val isDuplex: Boolean
     get() = duplexResponseBody != null
 
-  /** Returns the streams the server will push with this response. */
+  @JvmOverloads
-  val pushPromises: List<PushPromise>
+  constructor(
-    get() = promises
+    code: Int = 200,
-
+    headers: Headers = headersOf(),
-  /** Creates a new mock response with an empty body. */
+    body: String = "",
-  init {
+    inTunnel: Boolean = false,
-    setResponseCode(200)
+    socketPolicy: SocketPolicy = SocketPolicy.KEEP_OPEN,
-    setHeader("Content-Length", 0L)
+    http2ErrorCode: Int = -1,
-  }
+  ) : this(Builder()
-
+    .apply {
-  public override fun clone(): MockResponse {
+      this.code = code
-    val result = super.clone() as MockResponse
+      this.headers.addAll(headers)
-    result.headersBuilder = headersBuilder.build().newBuilder()
+      if (inTunnel) inTunnel()
-    result.promises = promises.toMutableList()
+      this.body(body)
-    return result
+      this.socketPolicy = socketPolicy
-  }
+      this.http2ErrorCode = http2ErrorCode
-
-  @JvmName("-deprecated_getStatus")
-  @Deprecated(
-      message = "moved to var",
-      replaceWith = ReplaceWith(expression = "status"),
-      level = DeprecationLevel.ERROR)
-  fun getStatus(): String = status
-
-  /**
-   * Sets the status and returns this.
-   *
-   * This was deprecated in OkHttp 4.0 in favor of the [status] val. In OkHttp 4.3 it is
-   * un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
-   * deprecated).
-   */
-  fun setStatus(status: String) = apply {
-    this.status = status
-  }
-
-  fun setResponseCode(code: Int): MockResponse {
-    val reason = when (code) {
-      in 100..199 -> "Informational"
-      in 200..299 -> "OK"
-      in 300..399 -> "Redirection"
-      in 400..499 -> "Client Error"
-      in 500..599 -> "Server Error"
-      else -> "Mock Response"
     }
-    return apply { status = "HTTP/1.1 $code $reason" }
+  )
-  }
 
-  /**
+  private constructor(builder: Builder) {
-   * Removes all HTTP headers including any "Content-Length" and "Transfer-encoding" headers that
+    this.status = builder.status
-   * were added by default.
+    this.headers = builder.headers.build()
-   */
+    this.trailers = builder.trailers.build()
-  fun clearHeaders() = apply {
+    this.body = builder.body?.clone()
-    headersBuilder = Headers.Builder()
+    this.inTunnel = builder.inTunnel
-  }
+    this.informationalResponses = builder.informationalResponses.toList()
-
+    this.throttleBytesPerPeriod = builder.throttleBytesPerPeriod
-  /**
+    this.throttlePeriodAmount = builder.throttlePeriodAmount
-   * Adds [header] as an HTTP header. For well-formed HTTP [header] should contain a
+    this.throttlePeriodUnit = builder.throttlePeriodUnit
-   * name followed by a colon and a value.
+    this.socketPolicy = builder.socketPolicy
-   */
+    this.http2ErrorCode = builder.http2ErrorCode
-  fun addHeader(header: String) = apply {
+    this.bodyDelayAmount = builder.bodyDelayAmount
-    headersBuilder.add(header)
+    this.bodyDelayUnit = builder.bodyDelayUnit
-  }
+    this.headersDelayAmount = builder.headersDelayAmount
-
+    this.headersDelayUnit = builder.headersDelayUnit
-  /**
+    this.pushPromises = builder.pushPromises.toList()
-   * Adds a new header with the name and value. This may be used to add multiple headers with the
+    this.settings = Settings().apply {
-   * same name.
+      merge(builder.settings)
-   */
-  fun addHeader(name: String, value: Any) = apply {
-    headersBuilder.add(name, value.toString())
-  }
-
-  /**
-   * Adds a new header with the name and value. This may be used to add multiple headers with the
-   * same name. Unlike [addHeader] this does not validate the name and
-   * value.
-   */
-  fun addHeaderLenient(name: String, value: Any) = apply {
-    addHeaderLenient(headersBuilder, name, value.toString())
-  }
-
-  /**
-   * Removes all headers named [name], then adds a new header with the name and value.
-   */
-  fun setHeader(name: String, value: Any) = apply {
-    removeHeader(name)
-    addHeader(name, value)
-  }
-
-  /** Removes all headers named [name]. */
-  fun removeHeader(name: String) = apply {
-    headersBuilder.removeAll(name)
-  }
-
-  /** Returns a copy of the raw HTTP payload. */
-  fun getBody(): Buffer? = body?.clone()
-
-  fun setBody(body: Buffer) = apply {
-    setHeader("Content-Length", body.size)
-    this.body = body.clone() // Defensive copy.
-  }
-
-  /** Sets the response body to the UTF-8 encoded bytes of [body]. */
-  fun setBody(body: String): MockResponse = setBody(Buffer().writeUtf8(body))
-
-  fun setBody(duplexResponseBody: DuplexResponseBody) = apply {
-    this.duplexResponseBody = duplexResponseBody
-  }
-
-  /**
-   * Sets the response body to [body], chunked every [maxChunkSize] bytes.
-   */
-  fun setChunkedBody(body: Buffer, maxChunkSize: Int) = apply {
-    removeHeader("Content-Length")
-    headersBuilder.add(CHUNKED_BODY_HEADER)
-
-    val bytesOut = Buffer()
-    while (!body.exhausted()) {
-      val chunkSize = minOf(body.size, maxChunkSize.toLong())
-      bytesOut.writeHexadecimalUnsignedLong(chunkSize)
-      bytesOut.writeUtf8("\r\n")
-      bytesOut.write(body, chunkSize)
-      bytesOut.writeUtf8("\r\n")
     }
-    bytesOut.writeUtf8("0\r\n") // Last chunk. Trailers follow!
+    this.webSocketListener = builder.webSocketListener
-    this.body = bytesOut
+    this.duplexResponseBody = builder.duplexResponseBody
-  }
-
-  /**
-   * Sets the response body to the UTF-8 encoded bytes of [body],
-   * chunked every [maxChunkSize] bytes.
-   */
-  fun setChunkedBody(body: String, maxChunkSize: Int): MockResponse =
-    setChunkedBody(Buffer().writeUtf8(body), maxChunkSize)
-
-  @JvmName("-deprecated_getHeaders")
-  @Deprecated(
-      message = "moved to var",
-      replaceWith = ReplaceWith(expression = "headers"),
-      level = DeprecationLevel.ERROR)
-  fun getHeaders(): Headers = headers
-
-  /**
-   * Sets the headers and returns this.
-   *
-   * This was deprecated in OkHttp 4.0 in favor of the [headers] val. In OkHttp 4.3 it is
-   * un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
-   * deprecated).
-   */
-  fun setHeaders(headers: Headers) = apply { this.headers = headers }
-
-  @JvmName("-deprecated_getTrailers")
-  @Deprecated(
-      message = "moved to var",
-      replaceWith = ReplaceWith(expression = "trailers"),
-      level = DeprecationLevel.ERROR)
-  fun getTrailers(): Headers = trailers
-
-  /**
-   * Sets the trailers and returns this.
-   *
-   * This was deprecated in OkHttp 4.0 in favor of the [trailers] val. In OkHttp 4.3 it is
-   * un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
-   * deprecated).
-   */
-  fun setTrailers(trailers: Headers) = apply { this.trailers = trailers }
-
-  @JvmName("-deprecated_getSocketPolicy")
-  @Deprecated(
-      message = "moved to var",
-      replaceWith = ReplaceWith(expression = "socketPolicy"),
-      level = DeprecationLevel.ERROR)
-  fun getSocketPolicy(): SocketPolicy = socketPolicy
-
-  /**
-   * Sets the socket policy and returns this.
-   *
-   * This was deprecated in OkHttp 4.0 in favor of the [socketPolicy] val. In OkHttp 4.3 it is
-   * un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
-   * deprecated).
-   */
-  fun setSocketPolicy(socketPolicy: SocketPolicy) = apply {
-    this.socketPolicy = socketPolicy
-  }
-
-  @JvmName("-deprecated_getHttp2ErrorCode")
-  @Deprecated(
-      message = "moved to var",
-      replaceWith = ReplaceWith(expression = "http2ErrorCode"),
-      level = DeprecationLevel.ERROR)
-  fun getHttp2ErrorCode(): Int = http2ErrorCode
-
-  /**
-   * Sets the HTTP/2 error code and returns this.
-   *
-   * This was deprecated in OkHttp 4.0 in favor of the [http2ErrorCode] val. In OkHttp 4.3 it is
-   * un-deprecated because Java callers can't chain when assigning Kotlin vals. (The getter remains
-   * deprecated).
-   */
-  fun setHttp2ErrorCode(http2ErrorCode: Int) = apply {
-    this.http2ErrorCode = http2ErrorCode
-  }
-
-  /**
-   * Throttles the request reader and response writer to sleep for the given period after each
-   * series of [bytesPerPeriod] bytes are transferred. Use this to simulate network behavior.
-   */
-  fun throttleBody(bytesPerPeriod: Long, period: Long, unit: TimeUnit) = apply {
-    throttleBytesPerPeriod = bytesPerPeriod
-    throttlePeriodAmount = period
-    throttlePeriodUnit = unit
   }
 
   fun getThrottlePeriod(unit: TimeUnit): Long =
     unit.convert(throttlePeriodAmount, throttlePeriodUnit)
 
-  /**
-   * Set the delayed time of the response body to [delay]. This applies to the response body
-   * only; response headers are not affected.
-   */
-  fun setBodyDelay(delay: Long, unit: TimeUnit) = apply {
-    bodyDelayAmount = delay
-    bodyDelayUnit = unit
-  }
-
   fun getBodyDelay(unit: TimeUnit): Long =
     unit.convert(bodyDelayAmount, bodyDelayUnit)
 
-  fun setHeadersDelay(delay: Long, unit: TimeUnit) = apply {
-    headersDelayAmount = delay
-    headersDelayUnit = unit
-  }
-
   fun getHeadersDelay(unit: TimeUnit): Long =
     unit.convert(headersDelayAmount, headersDelayUnit)
 
-  /**
+  fun newBuilder(): Builder = Builder(this)
-   * When [protocols][MockWebServer.protocols] include [HTTP_2][okhttp3.Protocol], this attaches a
-   * pushed stream to this response.
-   */
-  fun withPush(promise: PushPromise) = apply {
-    promises.add(promise)
-  }
-
-  /**
-   * When [protocols][MockWebServer.protocols] include [HTTP_2][okhttp3.Protocol], this pushes
-   * [settings] before writing the response.
-   */
-  fun withSettings(settings: Settings) = apply {
-    this.settings = settings
-  }
-
-  /**
-   * Attempts to perform a web socket upgrade on the connection.
-   * This will overwrite any previously set status or body.
-   */
-  fun withWebSocketUpgrade(listener: WebSocketListener) = apply {
-    status = "HTTP/1.1 101 Switching Protocols"
-    setHeader("Connection", "Upgrade")
-    setHeader("Upgrade", "websocket")
-    body = null
-    webSocketListener = listener
-  }
-
-  /**
-   * Configures this response to be served as a response to an HTTP CONNECT request, either for
-   * doing HTTPS through an HTTP proxy, or HTTP/2 prior knowledge through an HTTP proxy.
-   *
-   * When a new connection is received, all in-tunnel responses are served before the connection is
-   * upgraded to HTTPS or HTTP/2.
-   */
-  fun inTunnel() = apply {
-    removeHeader("Content-Length")
-    inTunnel = true
-  }
-
-  /**
-   * Adds an HTTP 1xx response to precede this response. Note that this response's
-   * [headers delay][setHeadersDelay] applies after this response is transmitted. Set a
-   * headers delay on that response to delay its transmission.
-   */
-  fun addInformationalResponse(response: MockResponse) = apply {
-    informationalResponses += response
-  }
-
-  fun add100Continue() = apply {
-    addInformationalResponse(
-      MockResponse()
-        .setResponseCode(100)
-    )
-  }
 
   override fun toString(): String = status
 
+  class Builder : Cloneable {
+    var inTunnel: Boolean
+      internal set
+
+    val informationalResponses: MutableList<MockResponse>
+
+    var status: String
+
+    var code: Int
+      get() {
+        val statusParts = status.split(' ', limit = 3)
+        require(statusParts.size >= 2) { "Unexpected status: $status" }
+        return statusParts[1].toInt()
+      }
+      set(value) {
+        val reason = when (value) {
+          in 100..199 -> "Informational"
+          in 200..299 -> "OK"
+          in 300..399 -> "Redirection"
+          in 400..499 -> "Client Error"
+          in 500..599 -> "Server Error"
+          else -> "Mock Response"
+        }
+        status = "HTTP/1.1 $value $reason"
+      }
+
+    internal var headers: Headers.Builder
+
+    internal var trailers: Headers.Builder
+
+    internal var body: Buffer?
+
+    var throttleBytesPerPeriod: Long
+      private set
+    internal var throttlePeriodAmount: Long
+    internal var throttlePeriodUnit: TimeUnit
+
+    var socketPolicy: SocketPolicy
+
+    var http2ErrorCode: Int
+
+    internal var bodyDelayAmount: Long
+    internal var bodyDelayUnit: TimeUnit
+
+    internal var headersDelayAmount: Long
+    internal var headersDelayUnit: TimeUnit
+
+    /** The streams the server will push with this response. */
+    val pushPromises: MutableList<PushPromise>
+
+    val settings: Settings
+    var webSocketListener: WebSocketListener?
+      private set
+    var duplexResponseBody: DuplexResponseBody?
+      private set
+
+    constructor() {
+      this.inTunnel = false
+      this.informationalResponses = mutableListOf()
+      this.status = "HTTP/1.1 200 OK"
+      this.body = null
+      this.headers = Headers.Builder()
+        .add("Content-Length", "0")
+      this.trailers = Headers.Builder()
+      this.throttleBytesPerPeriod = Long.MAX_VALUE
+      this.throttlePeriodAmount = 1L
+      this.throttlePeriodUnit = TimeUnit.SECONDS
+      this.socketPolicy = SocketPolicy.KEEP_OPEN
+      this.http2ErrorCode = -1
+      this.bodyDelayAmount = 0L
+      this.bodyDelayUnit = TimeUnit.MILLISECONDS
+      this.headersDelayAmount = 0L
+      this.headersDelayUnit = TimeUnit.MILLISECONDS
+      this.pushPromises = mutableListOf()
+      this.settings = Settings()
+      this.webSocketListener = null
+      this.duplexResponseBody = null
+    }
+
+    internal constructor(mockResponse: MockResponse) {
+      this.inTunnel = mockResponse.inTunnel
+      this.informationalResponses = mockResponse.informationalResponses.toMutableList()
+      this.status = mockResponse.status
+      this.headers = mockResponse.headers.newBuilder()
+      this.trailers = mockResponse.trailers.newBuilder()
+      this.body = mockResponse.body
+      this.throttleBytesPerPeriod = mockResponse.throttleBytesPerPeriod
+      this.throttlePeriodAmount = mockResponse.throttlePeriodAmount
+      this.throttlePeriodUnit = mockResponse.throttlePeriodUnit
+      this.socketPolicy = mockResponse.socketPolicy
+      this.http2ErrorCode = mockResponse.http2ErrorCode
+      this.bodyDelayAmount = mockResponse.bodyDelayAmount
+      this.bodyDelayUnit = mockResponse.bodyDelayUnit
+      this.headersDelayAmount = mockResponse.headersDelayAmount
+      this.headersDelayUnit = mockResponse.headersDelayUnit
+      this.pushPromises = mockResponse.pushPromises.toMutableList()
+      this.settings = Settings().apply {
+        merge(mockResponse.settings)
+      }
+      this.webSocketListener = mockResponse.webSocketListener
+      this.duplexResponseBody = mockResponse.duplexResponseBody
+    }
+
+    fun code(code: Int) = apply {
+      this.code = code
+    }
+
+    /** Sets the status and returns this. */
+    fun status(status: String) = apply {
+      this.status = status
+    }
+
+    /**
+     * Removes all HTTP headers including any "Content-Length" and "Transfer-encoding" headers that
+     * were added by default.
+     */
+    fun clearHeaders() = apply {
+      headers = Headers.Builder()
+    }
+
+    /**
+     * Adds [header] as an HTTP header. For well-formed HTTP [header] should contain a name followed
+     * by a colon and a value.
+     */
+    fun addHeader(header: String) = apply {
+      headers.add(header)
+    }
+
+    /**
+     * Adds a new header with the name and value. This may be used to add multiple headers with the
+     * same name.
+     */
+    fun addHeader(name: String, value: Any) = apply {
+      headers.add(name, value.toString())
+    }
+
+    /**
+     * Adds a new header with the name and value. This may be used to add multiple headers with the
+     * same name. Unlike [addHeader] this does not validate the name and
+     * value.
+     */
+    fun addHeaderLenient(name: String, value: Any) = apply {
+      addHeaderLenient(headers, name, value.toString())
+    }
+
+    /** Removes all headers named [name], then adds a new header with the name and value. */
+    fun setHeader(name: String, value: Any) = apply {
+      removeHeader(name)
+      addHeader(name, value)
+    }
+
+    /** Removes all headers named [name]. */
+    fun removeHeader(name: String) = apply {
+      headers.removeAll(name)
+    }
+
+    fun body(body: Buffer) = apply {
+      setHeader("Content-Length", body.size)
+      this.body = body.clone() // Defensive copy.
+    }
+
+    /** Sets the response body to the UTF-8 encoded bytes of [body]. */
+    fun body(body: String): Builder = body(Buffer().writeUtf8(body))
+
+    fun body(duplexResponseBody: DuplexResponseBody) = apply {
+      this.duplexResponseBody = duplexResponseBody
+    }
+
+    /**
+     * Sets the response body to [body], chunked every [maxChunkSize] bytes.
+     */
+    fun chunkedBody(body: Buffer, maxChunkSize: Int) = apply {
+      removeHeader("Content-Length")
+      headers.add(CHUNKED_BODY_HEADER)
+
+      val bytesOut = Buffer()
+      while (!body.exhausted()) {
+        val chunkSize = minOf(body.size, maxChunkSize.toLong())
+        bytesOut.writeHexadecimalUnsignedLong(chunkSize)
+        bytesOut.writeUtf8("\r\n")
+        bytesOut.write(body, chunkSize)
+        bytesOut.writeUtf8("\r\n")
+      }
+      bytesOut.writeUtf8("0\r\n") // Last chunk. Trailers follow!
+      this.body = bytesOut
+    }
+
+    /**
+     * Sets the response body to the UTF-8 encoded bytes of [body],
+     * chunked every [maxChunkSize] bytes.
+     */
+    fun chunkedBody(body: String, maxChunkSize: Int): Builder =
+      chunkedBody(Buffer().writeUtf8(body), maxChunkSize)
+
+    /** Sets the headers and returns this. */
+    fun headers(headers: Headers) = apply {
+      this.headers = headers.newBuilder()
+    }
+
+    /** Sets the trailers and returns this. */
+    fun trailers(trailers: Headers) = apply {
+      this.trailers = trailers.newBuilder()
+    }
+
+    /** Sets the socket policy and returns this. */
+    fun socketPolicy(socketPolicy: SocketPolicy) = apply {
+      this.socketPolicy = socketPolicy
+    }
+
+    /** Sets the HTTP/2 error code and returns this. */
+    fun http2ErrorCode(http2ErrorCode: Int) = apply {
+      this.http2ErrorCode = http2ErrorCode
+    }
+
+    /**
+     * Throttles the request reader and response writer to sleep for the given period after each
+     * series of [bytesPerPeriod] bytes are transferred. Use this to simulate network behavior.
+     */
+    fun throttleBody(bytesPerPeriod: Long, period: Long, unit: TimeUnit) = apply {
+      throttleBytesPerPeriod = bytesPerPeriod
+      throttlePeriodAmount = period
+      throttlePeriodUnit = unit
+    }
+
+    /**
+     * Set the delayed time of the response body to [delay]. This applies to the response body
+     * only; response headers are not affected.
+     */
+    fun bodyDelay(delay: Long, unit: TimeUnit) = apply {
+      bodyDelayAmount = delay
+      bodyDelayUnit = unit
+    }
+
+    fun headersDelay(delay: Long, unit: TimeUnit) = apply {
+      headersDelayAmount = delay
+      headersDelayUnit = unit
+    }
+
+    /**
+     * When [protocols][MockWebServer.protocols] include [HTTP_2][okhttp3.Protocol], this attaches a
+     * pushed stream to this response.
+     */
+    fun addPush(promise: PushPromise) = apply {
+      this.pushPromises += promise
+    }
+
+    /**
+     * When [protocols][MockWebServer.protocols] include [HTTP_2][okhttp3.Protocol], this pushes
+     * [settings] before writing the response.
+     */
+    fun settings(settings: Settings) = apply {
+      this.settings.clear()
+      this.settings.merge(settings)
+    }
+
+    /**
+     * Attempts to perform a web socket upgrade on the connection.
+     * This will overwrite any previously set status or body.
+     */
+    fun webSocketUpgrade(listener: WebSocketListener) = apply {
+      status = "HTTP/1.1 101 Switching Protocols"
+      setHeader("Connection", "Upgrade")
+      setHeader("Upgrade", "websocket")
+      body = null
+      webSocketListener = listener
+    }
+
+    /**
+     * Configures this response to be served as a response to an HTTP CONNECT request, either for
+     * doing HTTPS through an HTTP proxy, or HTTP/2 prior knowledge through an HTTP proxy.
+     *
+     * When a new connection is received, all in-tunnel responses are served before the connection is
+     * upgraded to HTTPS or HTTP/2.
+     */
+    fun inTunnel() = apply {
+      removeHeader("Content-Length")
+      inTunnel = true
+    }
+
+    /**
+     * Adds an HTTP 1xx response to precede this response. Note that this response's
+     * [headers delay][headersDelay] applies after this response is transmitted. Set a
+     * headers delay on that response to delay its transmission.
+     */
+    fun addInformationalResponse(response: MockResponse) = apply {
+      informationalResponses += response
+    }
+
+    fun add100Continue() = apply {
+      addInformationalResponse(MockResponse(code = 100))
+    }
+
+    public override fun clone(): Builder = build().newBuilder()
+
+    fun build(): MockResponse = MockResponse(this)
+  }
+
   companion object {
     private const val CHUNKED_BODY_HEADER = "Transfer-encoding: chunked"
   }

mockwebserver/src/main/kotlin/mockwebserver3/MockWebServer.kt

@@ -357,7 +357,7 @@ class MockWebServer : Closeable {
    * replaced with [setDispatcher][dispatcher].
    */
   fun enqueue(response: MockResponse) =
-    (dispatcher as QueueDispatcher).enqueueResponse(response.clone())
+    (dispatcher as QueueDispatcher).enqueueResponse(response)
 
   /**
    * Starts the server on the loopback interface for the given port.
@@ -795,9 +795,10 @@ class MockWebServer : Closeable {
     response: MockResponse
   ) {
     val key = request.getHeader("Sec-WebSocket-Key")
-    response.setHeader("Sec-WebSocket-Accept", WebSocketProtocol.acceptHeader(key!!))
+    val webSocketResponse = response.newBuilder()
-
+      .setHeader("Sec-WebSocket-Accept", WebSocketProtocol.acceptHeader(key!!))
-    writeHttpResponse(socket, sink, response)
+      .build()
+    writeHttpResponse(socket, sink, webSocketResponse)
 
     // Adapt the request and response into our Request and Response domain model.
     val scheme = if (request.tlsVersion != null) "https" else "http"
@@ -807,9 +808,9 @@ class MockWebServer : Closeable {
       .headers(request.headers)
       .build()
     val fancyResponse = Response.Builder()
-      .code(response.code)
+      .code(webSocketResponse.code)
-      .message(response.message)
+      .message(webSocketResponse.message)
-      .headers(response.headers)
+      .headers(webSocketResponse.headers)
       .request(fancyRequest)
       .protocol(Protocol.HTTP_1_1)
       .build()
@@ -821,13 +822,13 @@ class MockWebServer : Closeable {
     val webSocket = RealWebSocket(
       taskRunner = taskRunner,
       originalRequest = fancyRequest,
-      listener = response.webSocketListener!!,
+      listener = webSocketResponse.webSocketListener!!,
       random = SecureRandom(),
       pingIntervalMillis = 0,
-      extensions = WebSocketExtensions.parse(response.headers),
+      extensions = WebSocketExtensions.parse(webSocketResponse.headers),
       minimumDeflateSize = 0L // Compress all messages if compression is enabled.
     )
-    response.webSocketListener!!.onOpen(webSocket, fancyResponse)
+    webSocketResponse.webSocketListener!!.onOpen(webSocket, fancyResponse)
     val name = "MockWebServer WebSocket ${request.path!!}"
     webSocket.initReaderAndWriter(name, streams)
     try {
@@ -850,7 +851,7 @@ class MockWebServer : Closeable {
 
     writeHeaders(sink, response.headers)
 
-    val body = response.getBody() ?: return
+    val body = response.body ?: return
     sleepIfDelayed(response.getBodyDelay(TimeUnit.MILLISECONDS))
     throttledTransfer(response, socket, body, sink, body.size, false)
 
@@ -1116,7 +1117,7 @@ class MockWebServer : Closeable {
 
       val bodyDelayMs = response.getBodyDelay(TimeUnit.MILLISECONDS)
       val trailers = response.trailers
-      val body = response.getBody()
+      val body = response.body
       val outFinished = (body == null &&
         response.pushPromises.isEmpty() &&
         !response.isDuplex)
@@ -1173,7 +1174,7 @@ class MockWebServer : Closeable {
             socket = socket
           )
         )
-        val hasBody = pushPromise.response.getBody() != null
+        val hasBody = pushPromise.response.body != null
         val pushedStream = stream.connection.pushStream(stream.id, pushedHeaders, hasBody)
         writeResponse(pushedStream, request, pushPromise.response)
       }
@@ -1184,10 +1185,10 @@ class MockWebServer : Closeable {
     init {
       MwsDuplexAccess.instance = object : MwsDuplexAccess() {
         override fun setBody(
-          mockResponse: MockResponse,
+          mockResponseBuilder: MockResponse.Builder,
-          duplexResponseBody: DuplexResponseBody
+          duplexResponseBody: DuplexResponseBody,
         ) {
-          mockResponse.setBody(duplexResponseBody)
+          mockResponseBuilder.body(duplexResponseBody)
         }
       }
     }

mockwebserver/src/main/kotlin/mockwebserver3/QueueDispatcher.kt

@@ -34,7 +34,7 @@ open class QueueDispatcher : Dispatcher() {
     val requestLine = request.requestLine
     if (requestLine == "GET /favicon.ico HTTP/1.1") {
       logger.info("served $requestLine")
-      return MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_FOUND)
+      return MockResponse(code = HttpURLConnection.HTTP_NOT_FOUND)
     }
 
     if (failFastResponse != null && responseQueue.peek() == null) {
@@ -69,7 +69,7 @@ open class QueueDispatcher : Dispatcher() {
 
   open fun setFailFast(failFast: Boolean) {
     val failFastResponse = if (failFast) {
-      MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_FOUND)
+      MockResponse(code = HttpURLConnection.HTTP_NOT_FOUND)
     } else {
       null
     }
@@ -85,9 +85,7 @@ open class QueueDispatcher : Dispatcher() {
      * Enqueued on shutdown to release threads waiting on [dispatch]. Note that this response
      * isn't transmitted because the connection is closed before this response is returned.
      */
-    private val DEAD_LETTER = MockResponse().apply {
+    private val DEAD_LETTER = MockResponse(code = HTTP_UNAVAILABLE)
-      this.status = "HTTP/1.1 $HTTP_UNAVAILABLE shutting down"
-    }
 
     private val logger = Logger.getLogger(QueueDispatcher::class.java.name)
   }

mockwebserver/src/main/kotlin/okhttp3/internal/duplex/MwsDuplexAccess.kt

@@ -24,7 +24,10 @@ import mockwebserver3.internal.duplex.DuplexResponseBody
  */
 abstract class MwsDuplexAccess {
 
-  abstract fun setBody(mockResponse: MockResponse, duplexResponseBody: DuplexResponseBody)
+  abstract fun setBody(
+    mockResponseBuilder: MockResponse.Builder,
+    duplexResponseBody: DuplexResponseBody,
+  )
 
   companion object {
     @JvmField var instance: MwsDuplexAccess? = null

mockwebserver/src/test/java/mockwebserver3/MockWebServerTest.java

@@ -51,7 +51,6 @@ import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.api.extension.RegisterExtension;
-
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Arrays.asList;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
@@ -83,9 +82,9 @@ public final class MockWebServerTest {
   }
 
   @Test public void defaultMockResponse() {
-    MockResponse response = new MockResponse();
+    MockResponse.Builder builder = new MockResponse.Builder();
-    assertThat(headersToList(response)).containsExactly("Content-Length: 0");
+    assertThat(headersToList(builder)).containsExactly("Content-Length: 0");
-    assertThat(response.getStatus()).isEqualTo("HTTP/1.1 200 OK");
+    assertThat(builder.getStatus()).isEqualTo("HTTP/1.1 200 OK");
   }
 
   @Test public void setResponseMockReason() {
@@ -99,56 +98,57 @@ public final class MockWebServerTest {
         "Mock Response"
     };
     for (int i = 0; i < 600; i++) {
-      MockResponse response = new MockResponse().setResponseCode(i);
+      MockResponse.Builder builder = new MockResponse.Builder().code(i);
       String expectedReason = reasons[i / 100];
-      assertThat(response.getStatus()).isEqualTo(("HTTP/1.1 " + i + " " + expectedReason));
+      assertThat(builder.getStatus()).isEqualTo(("HTTP/1.1 " + i + " " + expectedReason));
-      assertThat(headersToList(response)).containsExactly("Content-Length: 0");
+      assertThat(headersToList(builder)).containsExactly("Content-Length: 0");
     }
   }
 
   @Test public void setStatusControlsWholeStatusLine() {
-    MockResponse response = new MockResponse().setStatus("HTTP/1.1 202 That'll do pig");
+    MockResponse.Builder builder = new MockResponse.Builder().status("HTTP/1.1 202 That'll do pig");
-    assertThat(headersToList(response)).containsExactly("Content-Length: 0");
+    assertThat(headersToList(builder)).containsExactly("Content-Length: 0");
-    assertThat(response.getStatus()).isEqualTo("HTTP/1.1 202 That'll do pig");
+    assertThat(builder.getStatus()).isEqualTo("HTTP/1.1 202 That'll do pig");
   }
 
   @Test public void setBodyAdjustsHeaders() throws IOException {
-    MockResponse response = new MockResponse().setBody("ABC");
+    MockResponse.Builder builder = new MockResponse.Builder().body("ABC");
-    assertThat(headersToList(response)).containsExactly("Content-Length: 3");
+    assertThat(headersToList(builder)).containsExactly("Content-Length: 3");
+    MockResponse response = builder.build();
     assertThat(response.getBody().readUtf8()).isEqualTo("ABC");
   }
 
   @Test public void mockResponseAddHeader() {
-    MockResponse response = new MockResponse()
+    MockResponse.Builder builder = new MockResponse.Builder()
         .clearHeaders()
         .addHeader("Cookie: s=square")
         .addHeader("Cookie", "a=android");
-    assertThat(headersToList(response)).containsExactly("Cookie: s=square", "Cookie: a=android");
+    assertThat(headersToList(builder)).containsExactly("Cookie: s=square", "Cookie: a=android");
   }
 
   @Test public void mockResponseSetHeader() {
-    MockResponse response = new MockResponse()
+    MockResponse.Builder builder = new MockResponse.Builder()
         .clearHeaders()
         .addHeader("Cookie: s=square")
         .addHeader("Cookie: a=android")
         .addHeader("Cookies: delicious");
-    response.setHeader("cookie", "r=robot");
+    builder.setHeader("cookie", "r=robot");
-    assertThat(headersToList(response)).containsExactly("Cookies: delicious", "cookie: r=robot");
+    assertThat(headersToList(builder)).containsExactly("Cookies: delicious", "cookie: r=robot");
   }
 
   @Test public void mockResponseSetHeaders() {
-    MockResponse response = new MockResponse()
+    MockResponse.Builder builder = new MockResponse.Builder()
         .clearHeaders()
         .addHeader("Cookie: s=square")
         .addHeader("Cookies: delicious");
 
-    response.setHeaders(new Headers.Builder().add("Cookie", "a=android").build());
+    builder.headers(new Headers.Builder().add("Cookie", "a=android").build());
 
-    assertThat(headersToList(response)).containsExactly("Cookie: a=android");
+    assertThat(headersToList(builder)).containsExactly("Cookie: a=android");
   }
 
   @Test public void regularResponse() throws Exception {
-    server.enqueue(new MockResponse().setBody("hello world"));
+    server.enqueue(new MockResponse.Builder().body("hello world").build());
 
     URL url = server.url("/").url();
     HttpURLConnection connection = (HttpURLConnection) url.openConnection();
@@ -167,11 +167,14 @@ public final class MockWebServerTest {
   }
 
   @Test public void redirect() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+        .code(HttpURLConnection.HTTP_MOVED_TEMP)
         .addHeader("Location: " + server.url("/new-path"))
-        .setBody("This page has moved!"));
+        .body("This page has moved!")
-    server.enqueue(new MockResponse().setBody("This is the new location!"));
+        .build());
+    server.enqueue(new MockResponse.Builder()
+        .body("This is the new location!")
+        .build());
 
     URLConnection connection = server.url("/").url().openConnection();
     InputStream in = connection.getInputStream();
@@ -194,7 +197,9 @@ public final class MockWebServerTest {
         Thread.sleep(1000);
       } catch (InterruptedException ignored) {
       }
-      server.enqueue(new MockResponse().setBody("enqueued in the background"));
+      server.enqueue(new MockResponse.Builder()
+          .body("enqueued in the background")
+          .build());
     }).start();
 
     URLConnection connection = server.url("/").url().openConnection();
@@ -204,10 +209,11 @@ public final class MockWebServerTest {
   }
 
   @Test public void nonHexadecimalChunkSize() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("G\r\nxxxxxxxxxxxxxxxx\r\n0\r\n\r\n")
+        .body("G\r\nxxxxxxxxxxxxxxxx\r\n0\r\n\r\n")
         .clearHeaders()
-        .addHeader("Transfer-encoding: chunked"));
+        .addHeader("Transfer-encoding: chunked")
+        .build());
 
     URLConnection connection = server.url("/").url().openConnection();
     InputStream in = connection.getInputStream();
@@ -219,11 +225,14 @@ public final class MockWebServerTest {
   }
 
   @Test public void responseTimeout() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("ABC")
+        .body("ABC")
         .clearHeaders()
-        .addHeader("Content-Length: 4"));
+        .addHeader("Content-Length: 4")
-    server.enqueue(new MockResponse().setBody("DEF"));
+        .build());
+    server.enqueue(new MockResponse.Builder()
+        .body("DEF")
+        .build());
 
     URLConnection urlConnection = server.url("/").url().openConnection();
     urlConnection.setReadTimeout(1000);
@@ -250,7 +259,9 @@ public final class MockWebServerTest {
 
   @Disabled("Not actually failing where expected")
   @Test public void disconnectAtStart() throws Exception {
-    server.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AT_START));
+    server.enqueue(new MockResponse.Builder()
+        .socketPolicy(SocketPolicy.DISCONNECT_AT_START)
+        .build());
     server.enqueue(new MockResponse()); // The jdk's HttpUrlConnection is a bastard.
     server.enqueue(new MockResponse());
     try {
@@ -262,9 +273,13 @@ public final class MockWebServerTest {
   }
 
   @Test public void clearDispatcherQueue() throws Exception {
-    server.enqueue(new MockResponse().setBody("A"));
+    server.enqueue(new MockResponse.Builder()
+        .body("A")
+        .build());
     ((QueueDispatcher) server.getDispatcher()).clear();
-    server.enqueue(new MockResponse().setBody("B"));
+    server.enqueue(new MockResponse.Builder()
+        .body("B")
+        .build());
 
     InputStream in = server.url("/a").url().openConnection().getInputStream();
     assertThat(in.read()).isEqualTo('B');
@@ -277,8 +292,9 @@ public final class MockWebServerTest {
   @Test public void throttleRequest() throws Exception {
     TestUtil.assumeNotWindows();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .throttleBody(3, 500, TimeUnit.MILLISECONDS));
+        .throttleBody(3, 500, TimeUnit.MILLISECONDS)
+        .build());
 
     long startNanos = System.nanoTime();
     URLConnection connection = server.url("/").url().openConnection();
@@ -298,9 +314,10 @@ public final class MockWebServerTest {
   @Test public void throttleResponse() throws Exception {
     TestUtil.assumeNotWindows();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("ABCDEF")
+        .body("ABCDEF")
-        .throttleBody(3, 500, TimeUnit.MILLISECONDS));
+        .throttleBody(3, 500, TimeUnit.MILLISECONDS)
+        .build());
 
     long startNanos = System.nanoTime();
     URLConnection connection = server.url("/").url().openConnection();
@@ -321,9 +338,10 @@ public final class MockWebServerTest {
   @Test public void delayResponse() throws IOException {
     TestUtil.assumeNotWindows();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("ABCDEF")
+        .body("ABCDEF")
-        .setBodyDelay(1, SECONDS));
+        .bodyDelay(1, SECONDS)
+        .build());
 
     long startNanos = System.nanoTime();
     URLConnection connection = server.url("/").url().openConnection();
@@ -337,7 +355,9 @@ public final class MockWebServerTest {
   }
 
   @Test public void disconnectRequestHalfway() throws Exception {
-    server.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY));
+    server.enqueue(new MockResponse.Builder()
+        .socketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY)
+        .build());
     // Limit the size of the request body that the server holds in memory to an arbitrary
     // 3.5 MBytes so this test can pass on devices with little memory.
     server.setBodyLimit(7 * 512 * 1024);
@@ -368,9 +388,10 @@ public final class MockWebServerTest {
   }
 
   @Test public void disconnectResponseHalfway() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("ab")
+        .body("ab")
-        .setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
+        .socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
+        .build());
 
     URLConnection connection = server.url("/").url().openConnection();
     assertThat(connection.getContentLength()).isEqualTo(2);
@@ -386,8 +407,8 @@ public final class MockWebServerTest {
     }
   }
 
-  private List<String> headersToList(MockResponse response) {
+  private List<String> headersToList(MockResponse.Builder response) {
-    Headers headers = response.getHeaders();
+    Headers headers = response.build().getHeaders();
     int size = headers.size();
     List<String> headerList = new ArrayList<>(size);
     for (int i = 0; i < size; i++) {
@@ -445,7 +466,9 @@ public final class MockWebServerTest {
   }
 
   @Test public void requestUrlReconstructed() throws Exception {
-    server.enqueue(new MockResponse().setBody("hello world"));
+    server.enqueue(new MockResponse.Builder()
+        .body("hello world")
+        .build());
 
     URL url = server.url("/a/deep/path?key=foo%20bar").url();
     HttpURLConnection connection = (HttpURLConnection) url.openConnection();
@@ -467,7 +490,9 @@ public final class MockWebServerTest {
   }
 
   @Test public void shutdownServerAfterRequest() throws Exception {
-    server.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.SHUTDOWN_SERVER_AFTER_RESPONSE));
+    server.enqueue(new MockResponse.Builder()
+        .socketPolicy(SocketPolicy.SHUTDOWN_SERVER_AFTER_RESPONSE)
+        .build());
 
     URL url = server.url("/").url();
 
@@ -485,7 +510,9 @@ public final class MockWebServerTest {
   }
 
   @Test public void http100Continue() throws Exception {
-    server.enqueue(new MockResponse().setBody("response"));
+    server.enqueue(new MockResponse.Builder()
+        .body("response")
+        .build());
 
     URL url = server.url("/").url();
     HttpURLConnection connection = (HttpURLConnection) url.openConnection();
@@ -502,10 +529,11 @@ public final class MockWebServerTest {
   }
 
   @Test public void multiple1xxResponses() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
       .add100Continue()
       .add100Continue()
-      .setBody("response"));
+      .body("response")
+      .build());
 
     URL url = server.url("/").url();
     HttpURLConnection connection = (HttpURLConnection) url.openConnection();
@@ -553,7 +581,9 @@ public final class MockWebServerTest {
   @Test public void https() throws Exception {
     HandshakeCertificates handshakeCertificates = localhost();
     server.useHttps(handshakeCertificates.sslSocketFactory());
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder()
+        .body("abc")
+        .build());
 
     HttpUrl url = server.url("/");
     HttpsURLConnection connection = (HttpsURLConnection) url.url().openConnection();
@@ -595,7 +625,9 @@ public final class MockWebServerTest {
         .build();
 
     server.useHttps(serverHandshakeCertificates.sslSocketFactory());
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder()
+        .body("abc")
+        .build());
     server.requestClientAuth();
 
     HeldCertificate clientCertificate = new HeldCertificate.Builder()
@@ -628,7 +660,9 @@ public final class MockWebServerTest {
   }
 
   @Test public void proxiedRequestGetsCorrectRequestUrl() throws Exception {
-    server.enqueue(new MockResponse().setBody("Result"));
+    server.enqueue(new MockResponse.Builder()
+        .body("Result")
+        .build());
 
     OkHttpClient proxiedClient = new OkHttpClient.Builder()
       .proxy(server.toProxyAddress())

okhttp-coroutines/src/jvmTest/kotlin/okhttp3/SuspendCallTest.kt

@@ -39,7 +39,6 @@ import org.junit.jupiter.api.fail
 import java.io.IOException
 import java.util.concurrent.TimeUnit
 import kotlin.time.Duration.Companion.seconds
-import kotlin.time.ExperimentalTime
 import org.junit.jupiter.api.BeforeEach
 
 @ExtendWith(MockWebServerExtension::class)
@@ -61,7 +60,7 @@ class SuspendCallTest {
   @Test
   fun suspendCall() {
     runTest {
-      server.enqueue(MockResponse().setBody("abc"))
+      server.enqueue(MockResponse(body = "abc"))
 
       val call = client.newCall(request)
 
@@ -77,9 +76,10 @@ class SuspendCallTest {
   fun timeoutCall() {
     runTest {
       server.enqueue(
-        MockResponse()
+        MockResponse.Builder()
-          .setBodyDelay(5, TimeUnit.SECONDS)
+          .bodyDelay(5, TimeUnit.SECONDS)
-          .setBody("abc")
+          .body("abc")
+          .build()
       )
 
       val call = client.newCall(request)
@@ -105,9 +105,10 @@ class SuspendCallTest {
   fun cancelledCall() {
     runTest {
       server.enqueue(
-        MockResponse()
+        MockResponse.Builder()
-          .setBodyDelay(5, TimeUnit.SECONDS)
+          .bodyDelay(5, TimeUnit.SECONDS)
-          .setBody("abc")
+          .body("abc")
+          .build()
       )
 
       val call = client.newCall(request)
@@ -132,9 +133,10 @@ class SuspendCallTest {
   fun failedCall() {
     runTest {
       server.enqueue(
-        MockResponse()
+        MockResponse(
-          .setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST)
+          body = "abc",
-          .setBody("abc")
+          socketPolicy = SocketPolicy.DISCONNECT_AFTER_REQUEST,
+        )
       )
 
       val call = client.newCall(request)

okhttp-dnsoverhttps/src/test/java/okhttp3/dnsoverhttps/DnsOverHttpsTest.java

@@ -178,7 +178,10 @@ public class DnsOverHttpsTest {
     server.enqueue(dnsResponse(
         "0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c00050001"
             + "00000a6d000603617069c012c0300005000100000cde000c04737461720463313072c012c04200010"
-            + "0010000003b00049df00112").setHeader("cache-control", "private, max-age=298"));
+            + "0010000003b00049df00112")
+        .newBuilder()
+        .setHeader("cache-control", "private, max-age=298")
+        .build());
 
     List<InetAddress> result = cachedDns.lookup("google.com");
 
@@ -201,7 +204,10 @@ public class DnsOverHttpsTest {
     server.enqueue(dnsResponse(
         "0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c00050001"
             + "00000a6d000603617069c012c0300005000100000cde000c04737461720463313072c012c04200010"
-            + "0010000003b00049df00112").setHeader("cache-control", "max-age=1"));
+            + "0010000003b00049df00112")
+        .newBuilder()
+        .setHeader("cache-control", "max-age=1")
+        .build());
 
     List<InetAddress> result = cachedDns.lookup("google.com");
 
@@ -217,7 +223,10 @@ public class DnsOverHttpsTest {
     server.enqueue(dnsResponse(
         "0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c00050001"
             + "00000a6d000603617069c012c0300005000100000cde000c04737461720463313072c012c04200010"
-            + "0010000003b00049df00112").setHeader("cache-control", "max-age=1"));
+            + "0010000003b00049df00112")
+        .newBuilder()
+        .setHeader("cache-control", "max-age=1")
+        .build());
 
     result = cachedDns.lookup("google.com");
     assertThat(result).isEqualTo(singletonList(address("157.240.1.18")));
@@ -229,9 +238,11 @@ public class DnsOverHttpsTest {
   }
 
   private MockResponse dnsResponse(String s) {
-    return new MockResponse().setBody(new Buffer().write(ByteString.decodeHex(s)))
+    return new MockResponse.Builder()
+        .body(new Buffer().write(ByteString.decodeHex(s)))
         .addHeader("content-type", "application/dns-message")
-        .addHeader("content-length", s.length() / 2);
+        .addHeader("content-length", s.length() / 2)
+        .build();
   }
 
   private DnsOverHttps buildLocalhost(OkHttpClient bootstrapClient, boolean includeIPv6) {

okhttp-logging-interceptor/src/test/java/okhttp3/logging/HttpLoggingInterceptorTest.java

@@ -167,9 +167,10 @@ public final class HttpLoggingInterceptorTest {
   @Test public void basicResponseBody() throws IOException {
     setLevel(Level.BASIC);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("Hello!")
+        .body("Hello!")
-        .setHeader("Content-Type", PLAIN));
+        .setHeader("Content-Type", PLAIN)
+        .build());
     Response response = client.newCall(request().build()).execute();
     response.body().close();
 
@@ -187,9 +188,10 @@ public final class HttpLoggingInterceptorTest {
   @Test public void basicChunkedResponseBody() throws IOException {
     setLevel(Level.BASIC);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setChunkedBody("Hello!", 2)
+        .chunkedBody("Hello!", 2)
-        .setHeader("Content-Type", PLAIN));
+        .setHeader("Content-Type", PLAIN)
+        .build());
     Response response = client.newCall(request().build()).execute();
     response.body().close();
 
@@ -378,9 +380,10 @@ public final class HttpLoggingInterceptorTest {
   @Test public void headersResponseBody() throws IOException {
     setLevel(Level.HEADERS);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("Hello!")
+        .body("Hello!")
-        .setHeader("Content-Type", PLAIN));
+        .setHeader("Content-Type", PLAIN)
+        .build());
     Response response = client.newCall(request().build()).execute();
     response.body().close();
 
@@ -446,8 +449,9 @@ public final class HttpLoggingInterceptorTest {
   }
 
   private void bodyGetNoBody(int code) throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setStatus("HTTP/1.1 " + code + " No Content"));
+        .status("HTTP/1.1 " + code + " No Content")
+        .build());
     Response response = client.newCall(request().build()).execute();
     response.body().close();
 
@@ -512,9 +516,10 @@ public final class HttpLoggingInterceptorTest {
   @Test public void bodyResponseBody() throws IOException {
     setLevel(Level.BODY);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("Hello!")
+        .body("Hello!")
-        .setHeader("Content-Type", PLAIN));
+        .setHeader("Content-Type", PLAIN)
+        .build());
     Response response = client.newCall(request().build()).execute();
     response.body().close();
 
@@ -548,9 +553,10 @@ public final class HttpLoggingInterceptorTest {
   @Test public void bodyResponseBodyChunked() throws IOException {
     setLevel(Level.BODY);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setChunkedBody("Hello!", 2)
+        .chunkedBody("Hello!", 2)
-        .setHeader("Content-Type", PLAIN));
+        .setHeader("Content-Type", PLAIN)
+        .build());
     Response response = client.newCall(request().build()).execute();
     response.body().close();
 
@@ -584,9 +590,10 @@ public final class HttpLoggingInterceptorTest {
   @Test public void bodyRequestGzipEncoded() throws IOException {
     setLevel(Level.BODY);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-      .setHeader("Content-Type", PLAIN)
+        .setHeader("Content-Type", PLAIN)
-      .setBody(new Buffer().writeUtf8("Uncompressed")));
+        .body(new Buffer().writeUtf8("Uncompressed"))
+        .build());
 
     Response response = client.newCall(request()
         .addHeader("Content-Encoding", "gzip")
@@ -620,11 +627,12 @@ public final class HttpLoggingInterceptorTest {
   @Test public void bodyResponseGzipEncoded() throws IOException {
     setLevel(Level.BODY);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
         .setHeader("Content-Encoding", "gzip")
         .setHeader("Content-Type", PLAIN)
-        .setBody(new Buffer().write(ByteString.decodeBase64(
+        .body(new Buffer().write(ByteString.decodeBase64(
-            "H4sIAAAAAAAAAPNIzcnJ11HwQKIAdyO+9hMAAAA="))));
+            "H4sIAAAAAAAAAPNIzcnJ11HwQKIAdyO+9hMAAAA=")))
+        .build());
     Response response = client.newCall(request().build()).execute();
 
     ResponseBody responseBody = response.body();
@@ -662,12 +670,13 @@ public final class HttpLoggingInterceptorTest {
   @Test public void bodyResponseUnknownEncoded() throws IOException {
       setLevel(Level.BODY);
 
-      server.enqueue(new MockResponse()
+      server.enqueue(new MockResponse.Builder()
           // It's invalid to return this if not requested, but the server might anyway
           .setHeader("Content-Encoding", "br")
           .setHeader("Content-Type", PLAIN)
-          .setBody(new Buffer().write(ByteString.decodeBase64(
+          .body(new Buffer().write(ByteString.decodeBase64(
-              "iwmASGVsbG8sIEhlbGxvLCBIZWxsbwoD"))));
+              "iwmASGVsbG8sIEhlbGxvLCBIZWxsbwoD")))
+          .build());
       Response response = client.newCall(request().build()).execute();
       response.body().close();
 
@@ -699,9 +708,9 @@ public final class HttpLoggingInterceptorTest {
   @Test public void bodyResponseIsStreaming() throws IOException {
     setLevel(Level.BODY);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
       .setHeader("Content-Type", "text/event-stream")
-      .setChunkedBody(""
+      .chunkedBody(""
         + "event: add\n"
         + "data: 73857293\n"
         + "\n"
@@ -711,6 +720,7 @@ public final class HttpLoggingInterceptorTest {
         + "event: add\n"
         + "data: 113411\n"
         + "\n", 8)
+      .build()
     );
     Response response = client.newCall(request().build()).execute();
     response.body().close();
@@ -741,9 +751,10 @@ public final class HttpLoggingInterceptorTest {
   @Test public void bodyGetMalformedCharset() throws IOException {
     setLevel(Level.BODY);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
         .setHeader("Content-Type", "text/html; charset=0")
-        .setBody("Body with unknown charset"));
+        .body("Body with unknown charset")
+        .build());
     Response response = client.newCall(request().build()).execute();
     response.body().close();
 
@@ -785,9 +796,10 @@ public final class HttpLoggingInterceptorTest {
     buffer.writeUtf8CodePoint(0x0a);
     buffer.writeUtf8CodePoint(0x1a);
     buffer.writeUtf8CodePoint(0x0a);
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody(buffer)
+        .body(buffer)
-        .setHeader("Content-Type", "image/png; charset=utf-8"));
+        .setHeader("Content-Type", "image/png; charset=utf-8")
+        .build());
     Response response = client.newCall(request().build()).execute();
     response.body().close();
 
@@ -874,8 +886,9 @@ public final class HttpLoggingInterceptorTest {
             .addInterceptor(applicationInterceptor)
             .build();
 
-    server.enqueue(
+    server.enqueue(new MockResponse.Builder()
-        new MockResponse().addHeader("SeNsItIvE", "Value").addHeader("Not-Sensitive", "Value"));
+        .addHeader("SeNsItIvE", "Value").addHeader("Not-Sensitive", "Value")
+        .build());
     Response response =
         client
             .newCall(
@@ -924,8 +937,9 @@ public final class HttpLoggingInterceptorTest {
 
     setLevel(Level.BODY);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("Hello response!"));
+        .body("Hello response!")
+        .build());
 
     RequestBody asyncRequestBody = new RequestBody() {
       @Override public @Nullable MediaType contentType() {
@@ -966,8 +980,9 @@ public final class HttpLoggingInterceptorTest {
 
     setLevel(Level.BODY);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-                           .setBody("Hello response!"));
+        .body("Hello response!")
+        .build());
 
     RequestBody asyncRequestBody = new RequestBody() {
       @Override public @Nullable MediaType contentType() {

okhttp-logging-interceptor/src/test/java/okhttp3/logging/LoggingEventListenerTest.java

@@ -77,7 +77,10 @@ public final class LoggingEventListenerTest {
   public void get() throws Exception {
     TestUtil.assumeNotWindows();
 
-    server.enqueue(new MockResponse().setBody("Hello!").setHeader("Content-Type", PLAIN));
+    server.enqueue(new MockResponse.Builder()
+        .body("Hello!")
+        .setHeader("Content-Type", PLAIN)
+        .build());
     Response response = client.newCall(request().build()).execute();
     assertThat(response.body()).isNotNull();
     response.body().bytes();
@@ -223,7 +226,9 @@ public final class LoggingEventListenerTest {
 
     server.useHttps(handshakeCertificates.sslSocketFactory());
     server.setProtocols(asList(HTTP_2, HTTP_1_1));
-    server.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
+    server.enqueue(new MockResponse.Builder()
+        .socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
+        .build());
     url = server.url("/");
 
     try {

okhttp-sse/src/test/java/okhttp3/sse/internal/EventSourceHttpTest.java

@@ -56,9 +56,11 @@ public final class EventSourceHttpTest {
   }
 
   @Test public void event() {
-    server.enqueue(new MockResponse().setBody(""
+    server.enqueue(new MockResponse.Builder()
-        + "data: hey\n"
+        .body(""
-        + "\n").setHeader("content-type", "text/event-stream"));
+            + "data: hey\n"
+            + "\n").setHeader("content-type", "text/event-stream")
+        .build());
 
     EventSource source = newEventSource();
 
@@ -70,9 +72,11 @@ public final class EventSourceHttpTest {
   }
 
   @Test public void cancelInEventShortCircuits() throws IOException {
-    server.enqueue(new MockResponse().setBody(""
+    server.enqueue(new MockResponse.Builder()
-      + "data: hey\n"
+        .body(""
-      + "\n").setHeader("content-type", "text/event-stream"));
+            + "data: hey\n"
+            + "\n").setHeader("content-type", "text/event-stream")
+        .build());
     listener.enqueueCancel(); // Will cancel in onOpen().
 
     newEventSource();
@@ -81,18 +85,24 @@ public final class EventSourceHttpTest {
   }
 
   @Test public void badContentType() {
-    server.enqueue(new MockResponse().setBody(""
+    server.enqueue(new MockResponse.Builder()
-        + "data: hey\n"
+        .body(""
-        + "\n").setHeader("content-type", "text/plain"));
+            + "data: hey\n"
+            + "\n").setHeader("content-type", "text/plain")
+        .build());
 
     newEventSource();
     listener.assertFailure("Invalid content-type: text/plain");
   }
 
   @Test public void badResponseCode() {
-    server.enqueue(new MockResponse().setBody(""
+    server.enqueue(new MockResponse.Builder()
-        + "data: hey\n"
+        .body(""
-        + "\n").setHeader("content-type", "text/event-stream").setResponseCode(401));
+          + "data: hey\n"
+          + "\n")
+        .setHeader("content-type", "text/event-stream")
+        .code(401)
+        .build());
 
     newEventSource();
     listener.assertFailure(null);
@@ -103,10 +113,11 @@ public final class EventSourceHttpTest {
         .callTimeout(250, TimeUnit.MILLISECONDS)
         .build();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBodyDelay(500, TimeUnit.MILLISECONDS)
+        .bodyDelay(500, TimeUnit.MILLISECONDS)
         .setHeader("content-type", "text/event-stream")
-        .setBody("data: hey\n\n"));
+        .body("data: hey\n\n")
+        .build());
 
     EventSource source = newEventSource();
 
@@ -122,19 +133,22 @@ public final class EventSourceHttpTest {
         .callTimeout(250, TimeUnit.MILLISECONDS)
         .build();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setHeadersDelay(500, TimeUnit.MILLISECONDS)
+        .headersDelay(500, TimeUnit.MILLISECONDS)
         .setHeader("content-type", "text/event-stream")
-        .setBody("data: hey\n\n"));
+        .body("data: hey\n\n")
+        .build());
 
     newEventSource();
     listener.assertFailure("timeout");
   }
 
   @Test public void retainsAccept() throws InterruptedException {
-    server.enqueue(new MockResponse().setBody(""
+    server.enqueue(new MockResponse.Builder()
-        + "data: hey\n"
+        .body(""
-        + "\n").setHeader("content-type", "text/event-stream"));
+            + "data: hey\n"
+            + "\n").setHeader("content-type", "text/event-stream")
+        .build());
 
     EventSource source = newEventSource("text/plain");
 
@@ -146,9 +160,11 @@ public final class EventSourceHttpTest {
   }
 
   @Test public void setsMissingAccept() throws InterruptedException {
-    server.enqueue(new MockResponse().setBody(""
+    server.enqueue(new MockResponse.Builder()
-        + "data: hey\n"
+        .body(""
-        + "\n").setHeader("content-type", "text/event-stream"));
+            + "data: hey\n"
+            + "\n").setHeader("content-type", "text/event-stream")
+        .build());
 
     EventSource source = newEventSource();
 

okhttp-sse/src/test/java/okhttp3/sse/internal/EventSourcesHttpTest.java

@@ -52,9 +52,11 @@ public final class EventSourcesHttpTest {
   }
 
   @Test public void processResponse() throws IOException {
-    server.enqueue(new MockResponse().setBody(""
+    server.enqueue(new MockResponse.Builder()
-        + "data: hey\n"
+      .body(""
-        + "\n").setHeader("content-type", "text/event-stream"));
+          + "data: hey\n"
+          + "\n").setHeader("content-type", "text/event-stream")
+      .build());
 
     Request request = new Request.Builder()
         .url(server.url("/"))
@@ -68,9 +70,11 @@ public final class EventSourcesHttpTest {
   }
 
   @Test public void cancelShortCircuits() throws IOException {
-    server.enqueue(new MockResponse().setBody(""
+    server.enqueue(new MockResponse.Builder()
-      + "data: hey\n"
+      .body(""
-      + "\n").setHeader("content-type", "text/event-stream"));
+          + "data: hey\n"
+          + "\n").setHeader("content-type", "text/event-stream")
+      .build());
     listener.enqueueCancel(); // Will cancel in onOpen().
 
     Request request = new Request.Builder()

okhttp/src/jvmTest/java/okhttp3/CacheCorruptionTest.kt

@@ -15,8 +15,19 @@
  */
 package okhttp3
 
+import java.net.CookieManager
+import java.net.ResponseCache
+import java.text.DateFormat
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+import java.util.concurrent.TimeUnit
+import javax.net.ssl.HostnameVerifier
+import javax.net.ssl.SSLSession
 import mockwebserver3.MockResponse
 import mockwebserver3.MockWebServer
+import okhttp3.Headers.Companion.headersOf
 import okhttp3.internal.buildCache
 import okhttp3.okio.LoggingFilesystem
 import okhttp3.testing.PlatformRule
@@ -28,16 +39,6 @@ import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.RegisterExtension
-import java.net.CookieManager
-import java.net.ResponseCache
-import java.text.DateFormat
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-import java.util.TimeZone
-import java.util.concurrent.TimeUnit
-import javax.net.ssl.HostnameVerifier
-import javax.net.ssl.SSLSession
 
 class CacheCorruptionTest {
   var fileSystem = FakeFileSystem()
@@ -145,16 +146,22 @@ class CacheCorruptionTest {
   private fun testCorruptingCache(corruptor: () -> Unit): Response {
     server.useHttps(handshakeCertificates.sslSocketFactory())
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
+        headers = headersOf(
-        .addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
+          "Last-Modified", formatDate(-1, TimeUnit.HOURS)!!,
-        .setBody("ABC.1")
+          "Expires", formatDate(1, TimeUnit.HOURS)!!,
+        ),
+        body = "ABC.1",
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .addHeader("Last-Modified: " + formatDate(-1, TimeUnit.HOURS))
+        headers = headersOf(
-        .addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
+          "Last-Modified", formatDate(-1, TimeUnit.HOURS)!!,
-        .setBody("ABC.2")
+          "Expires", formatDate(1, TimeUnit.HOURS)!!,
+        ),
+        body = "ABC.2",
+      )
     )
     client = client.newBuilder()
       .sslSocketFactory(
@@ -162,7 +169,7 @@ class CacheCorruptionTest {
       )
       .hostnameVerifier(NULL_HOSTNAME_VERIFIER)
       .build()
-    val request: Request = Request(server.url("/"))
+    val request = Request(server.url("/"))
     val response1: Response = client.newCall(request).execute()
     val bodySource = response1.body.source()
     assertThat(bodySource.readUtf8()).isEqualTo("ABC.1")

okhttp/src/jvmTest/java/okhttp3/CallHandshakeTest.kt

@@ -15,6 +15,7 @@
  */
 package okhttp3
 
+import javax.net.ssl.SSLSocket
 import mockwebserver3.MockResponse
 import mockwebserver3.MockWebServer
 import okhttp3.CipherSuite.Companion.TLS_AES_128_GCM_SHA256
@@ -35,7 +36,6 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.RegisterExtension
-import javax.net.ssl.SSLSocket
 
 class CallHandshakeTest {
   private lateinit var client: OkHttpClient
@@ -62,7 +62,7 @@ class CallHandshakeTest {
   fun setup(server: MockWebServer) {
     this.server = server
 
-    server.enqueue(MockResponse().setResponseCode(200))
+    server.enqueue(MockResponse())
 
     client = clientTestRule.newClientBuilder()
       .sslSocketFactory(

okhttp/src/jvmTest/java/okhttp3/CallKotlinTest.kt

@@ -63,8 +63,8 @@ class CallKotlinTest {
 
   @Test
   fun legalToExecuteTwiceCloning() {
-    server.enqueue(MockResponse().setBody("abc"))
+    server.enqueue(MockResponse(body = "abc"))
-    server.enqueue(MockResponse().setBody("def"))
+    server.enqueue(MockResponse(body = "def"))
 
     val request = Request(server.url("/"))
 
@@ -83,7 +83,7 @@ class CallKotlinTest {
   fun testMockWebserverRequest() {
     enableTls()
 
-    server.enqueue(MockResponse().setBody("abc"))
+    server.enqueue(MockResponse(body = "abc"))
 
     val request = Request.Builder().url(server.url("/")).build()
 
@@ -130,15 +130,9 @@ class CallKotlinTest {
       }
     }
 
-    server.enqueue(MockResponse().apply {
+    server.enqueue(MockResponse(code = 201))
-      setResponseCode(201)
+    server.enqueue(MockResponse(code = 204))
-    })
+    server.enqueue(MockResponse(code = 204))
-    server.enqueue(MockResponse().apply {
-      setResponseCode(204)
-    })
-    server.enqueue(MockResponse().apply {
-      setResponseCode(204)
-    })
 
     val endpointUrl = server.url("/endpoint")
 
@@ -192,9 +186,13 @@ class CallKotlinTest {
         })
         .build()
 
-    server.enqueue(MockResponse().setBody("a")
+    server.enqueue(
-        .setSocketPolicy(SocketPolicy.SHUTDOWN_OUTPUT_AT_END))
+      MockResponse(
-    server.enqueue(MockResponse().setBody("b"))
+        body = "a",
+        socketPolicy = SocketPolicy.SHUTDOWN_OUTPUT_AT_END
+      )
+    )
+    server.enqueue(MockResponse(body = "b"))
 
     val requestA = Request(server.url("/"))
     val responseA = client.newCall(requestA).execute()
@@ -243,8 +241,8 @@ class CallKotlinTest {
 
   /** Confirm suppressed exceptions that occur after connecting are returned. */
   @Test fun httpExceptionsAreReturnedAsSuppressed() {
-    server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AT_START))
+    server.enqueue(MockResponse(socketPolicy = SocketPolicy.DISCONNECT_AT_START))
-    server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AT_START))
+    server.enqueue(MockResponse(socketPolicy = SocketPolicy.DISCONNECT_AT_START))
 
     client = client.newBuilder()
         .dns(DoubleInetAddressDns()) // Two routes so we get two failures.
@@ -266,9 +264,10 @@ class CallKotlinTest {
   @Test
   fun responseRequestIsLastRedirect() {
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setResponseCode(302)
+        code = 302,
-        .addHeader("Location: /b")
+        headers = headersOf("Location", "/b"),
+      )
     )
     server.enqueue(MockResponse())
 

okhttp/src/jvmTest/java/okhttp3/ConnectionCoalescingTest.java

@@ -276,11 +276,13 @@ public final class ConnectionCoalescingTest {
   }
 
   @Test public void skipsOnRedirectWhenDnsDontMatch() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(301)
+        .code(301)
-        .addHeader("Location", url.newBuilder().host("differentdns.com").build()));
+        .addHeader("Location", url.newBuilder().host("differentdns.com").build())
-    server.enqueue(new MockResponse()
+        .build());
-        .setBody("unexpected call"));
+    server.enqueue(new MockResponse.Builder()
+        .body("unexpected call")
+        .build());
 
     try {
       Response response = execute(url);
@@ -307,9 +309,10 @@ public final class ConnectionCoalescingTest {
   }
 
   @Test public void skipsOnRedirectWhenNotSubjectAltName() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(301)
+        .code(301)
-        .addHeader("Location", url.newBuilder().host("nonsan.com").build()));
+        .addHeader("Location", url.newBuilder().host("nonsan.com").build())
+        .build());
     server.enqueue(new MockResponse());
 
     try {
@@ -365,9 +368,10 @@ public final class ConnectionCoalescingTest {
         .build();
     client = client.newBuilder().certificatePinner(pinner).build();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(301)
+        .code(301)
-        .addHeader("Location", url.newBuilder().host("san.com").build()));
+        .addHeader("Location", url.newBuilder().host("san.com").build())
+        .build());
     server.enqueue(new MockResponse());
 
     try {
@@ -401,9 +405,10 @@ public final class ConnectionCoalescingTest {
     HostnameVerifier verifier = (name, session) -> true;
     client = client.newBuilder().hostnameVerifier(verifier).build();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(301)
+        .code(301)
-        .addHeader("Location", url.newBuilder().host("san.com").build()));
+        .addHeader("Location", url.newBuilder().host("san.com").build())
+        .build());
     server.enqueue(new MockResponse());
 
     assert200Http2Response(execute(url), "san.com");
@@ -475,13 +480,16 @@ public final class ConnectionCoalescingTest {
   }
 
   @Test public void misdirectedRequestResponseCode() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("seed connection"));
+        .body("seed connection")
-    server.enqueue(new MockResponse()
+        .build());
-        .setResponseCode(421)
+    server.enqueue(new MockResponse.Builder()
-        .setBody("misdirected!"));
+        .code(421)
-    server.enqueue(new MockResponse()
+        .body("misdirected!")
-        .setBody("after misdirect"));
+        .build());
+    server.enqueue(new MockResponse.Builder()
+        .body("after misdirect")
+        .build());
 
     // Seed the connection pool.
     assert200Http2Response(execute(url), server.getHostName());

okhttp/src/jvmTest/java/okhttp3/ConnectionReuseTest.kt

@@ -20,6 +20,7 @@ import javax.net.ssl.SSLException
 import mockwebserver3.MockResponse
 import mockwebserver3.MockWebServer
 import mockwebserver3.SocketPolicy
+import okhttp3.Headers.Companion.headersOf
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.ResponseBody.Companion.toResponseBody
@@ -48,39 +49,44 @@ class ConnectionReuseTest {
   private val handshakeCertificates: HandshakeCertificates = localhost()
   private var client: OkHttpClient = clientTestRule.newClient()
 
-  @BeforeEach fun setUp(server: MockWebServer) {
+  @BeforeEach
+  fun setUp(server: MockWebServer) {
     this.server = server
   }
 
-  @Test fun connectionsAreReused() {
+  @Test
-    server.enqueue(MockResponse().setBody("a"))
+  fun connectionsAreReused() {
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "a"))
+    server.enqueue(MockResponse(body = "b"))
     val request = Request(server.url("/"))
     assertConnectionReused(request, request)
   }
 
-  @Test fun connectionsAreReusedForPosts() {
+  @Test
-    server.enqueue(MockResponse().setBody("a"))
+  fun connectionsAreReusedForPosts() {
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "a"))
+    server.enqueue(MockResponse(body = "b"))
     val request = Request(
       url = server.url("/"),
-      body ="request body".toRequestBody("text/plain".toMediaType()),
+      body = "request body".toRequestBody("text/plain".toMediaType()),
     )
     assertConnectionReused(request, request)
   }
 
-  @Test fun connectionsAreReusedWithHttp2() {
+  @Test
+  fun connectionsAreReusedWithHttp2() {
     platform.assumeNotBouncyCastle()
     enableHttp2()
-    server.enqueue(MockResponse().setBody("a"))
+    server.enqueue(MockResponse(body = "a"))
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "b"))
     val request = Request(server.url("/"))
     assertConnectionReused(request, request)
   }
 
-  @Test fun connectionsAreNotReusedWithRequestConnectionClose() {
+  @Test
-    server.enqueue(MockResponse().setBody("a"))
+  fun connectionsAreNotReusedWithRequestConnectionClose() {
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "a"))
+    server.enqueue(MockResponse(body = "b"))
     val requestA = Request.Builder()
       .url(server.url("/"))
       .header("Connection", "close")
@@ -89,51 +95,58 @@ class ConnectionReuseTest {
     assertConnectionNotReused(requestA, requestB)
   }
 
-  @Test fun connectionsAreNotReusedWithResponseConnectionClose() {
+  @Test
+  fun connectionsAreNotReusedWithResponseConnectionClose() {
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .addHeader("Connection", "close")
+        headers = headersOf("Connection", "close"),
-        .setBody("a")
+        body = "a",
+      )
     )
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "b"))
     val requestA = Request(server.url("/"))
     val requestB = Request(server.url("/"))
     assertConnectionNotReused(requestA, requestB)
   }
 
-  @Test fun connectionsAreNotReusedWithUnknownLengthResponseBody() {
+  @Test
+  fun connectionsAreNotReusedWithUnknownLengthResponseBody() {
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody("a")
+        .body("a")
-        .setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
         .clearHeaders()
+        .socketPolicy(SocketPolicy.DISCONNECT_AT_END)
+        .build()
     )
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "b"))
     val request = Request(server.url("/"))
     assertConnectionNotReused(request, request)
   }
 
-  @Test fun connectionsAreNotReusedIfPoolIsSizeZero() {
+  @Test
+  fun connectionsAreNotReusedIfPoolIsSizeZero() {
     client = client.newBuilder()
       .connectionPool(ConnectionPool(0, 5, TimeUnit.SECONDS))
       .build()
-    server.enqueue(MockResponse().setBody("a"))
+    server.enqueue(MockResponse(body = "a"))
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "b"))
     val request = Request(server.url("/"))
     assertConnectionNotReused(request, request)
   }
 
-  @Test fun connectionsReusedWithRedirectEvenIfPoolIsSizeZero() {
+  @Test
+  fun connectionsReusedWithRedirectEvenIfPoolIsSizeZero() {
     client = client.newBuilder()
       .connectionPool(ConnectionPool(0, 5, TimeUnit.SECONDS))
       .build()
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setResponseCode(301)
+        code = 301,
-        .addHeader("Location: /b")
+        headers = headersOf("Location", "/b"),
-        .setBody("a")
+        body = "a"
+      )
     )
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "b"))
     val request = Request(server.url("/"))
     val response = client.newCall(request).execute()
     assertThat(response.body.string()).isEqualTo("b")
@@ -141,18 +154,19 @@ class ConnectionReuseTest {
     assertThat(server.takeRequest().sequenceNumber).isEqualTo(1)
   }
 
-  @Test fun connectionsNotReusedWithRedirectIfDiscardingResponseIsSlow() {
+  @Test
+  fun connectionsNotReusedWithRedirectIfDiscardingResponseIsSlow() {
     client = client.newBuilder()
       .connectionPool(ConnectionPool(0, 5, TimeUnit.SECONDS))
       .build()
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setResponseCode(301)
+        .code(301)
         .addHeader("Location: /b")
-        .setBodyDelay(1, TimeUnit.SECONDS)
+        .bodyDelay(1, TimeUnit.SECONDS)
-        .setBody("a")
+        .body("a")
-    )
+        .build())
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "b"))
     val request = Request(server.url("/"))
     val response = client.newCall(request).execute()
     assertThat(response.body.string()).isEqualTo("b")
@@ -160,10 +174,11 @@ class ConnectionReuseTest {
     assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)
   }
 
-  @Test fun silentRetryWhenIdempotentRequestFailsOnReusedConnection() {
+  @Test
-    server.enqueue(MockResponse().setBody("a"))
+  fun silentRetryWhenIdempotentRequestFailsOnReusedConnection() {
-    server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST))
+    server.enqueue(MockResponse(body = "a"))
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(socketPolicy = SocketPolicy.DISCONNECT_AFTER_REQUEST))
+    server.enqueue(MockResponse(body = "b"))
     val request = Request(server.url("/"))
     val responseA = client.newCall(request).execute()
     assertThat(responseA.body.string()).isEqualTo("a")
@@ -174,11 +189,12 @@ class ConnectionReuseTest {
     assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)
   }
 
-  @Test fun http2ConnectionsAreSharedBeforeResponseIsConsumed() {
+  @Test
+  fun http2ConnectionsAreSharedBeforeResponseIsConsumed() {
     platform.assumeNotBouncyCastle()
     enableHttp2()
-    server.enqueue(MockResponse().setBody("a"))
+    server.enqueue(MockResponse(body = "a"))
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "b"))
     val request = Request(server.url("/"))
     val response1 = client.newCall(request).execute()
     val response2 = client.newCall(request).execute()
@@ -188,9 +204,10 @@ class ConnectionReuseTest {
     assertThat(server.takeRequest().sequenceNumber).isEqualTo(1)
   }
 
-  @Test fun connectionsAreEvicted() {
+  @Test
-    server.enqueue(MockResponse().setBody("a"))
+  fun connectionsAreEvicted() {
-    server.enqueue(MockResponse().setBody("b"))
+    server.enqueue(MockResponse(body = "a"))
+    server.enqueue(MockResponse(body = "b"))
     client = client.newBuilder()
       .connectionPool(ConnectionPool(5, 250, TimeUnit.MILLISECONDS))
       .build()
@@ -206,7 +223,8 @@ class ConnectionReuseTest {
     assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)
   }
 
-  @Test fun connectionsAreNotReusedIfSslSocketFactoryChanges() {
+  @Test
+  fun connectionsAreNotReusedIfSslSocketFactoryChanges() {
     platform.assumeNotBouncyCastle()
     enableHttps()
     server.enqueue(MockResponse())
@@ -231,7 +249,8 @@ class ConnectionReuseTest {
     }
   }
 
-  @Test fun connectionsAreNotReusedIfHostnameVerifierChanges() {
+  @Test
+  fun connectionsAreNotReusedIfHostnameVerifierChanges() {
     platform.assumeNotBouncyCastle()
     enableHttps()
     server.enqueue(MockResponse())
@@ -261,7 +280,8 @@ class ConnectionReuseTest {
    *
    * https://github.com/square/okhttp/issues/2409
    */
-  @Test fun connectionsAreNotReusedIfNetworkInterceptorInterferes() {
+  @Test
+  fun connectionsAreNotReusedIfNetworkInterceptorInterferes() {
     val responsesNotClosed: MutableList<Response?> = ArrayList()
     client =
       client.newBuilder()
@@ -280,14 +300,14 @@ class ConnectionReuseTest {
         })
         .build()
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setResponseCode(301)
+        code = 301,
-        .addHeader("Location: /b")
+        headers = headersOf("Location", "/b"),
-        .setBody("/a has moved!")
+        body = "/a has moved!",
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "/b is here")
-        .setBody("/b is here")
     )
     val request = Request(server.url("/"))
     val call = client.newCall(request)

okhttp/src/jvmTest/java/okhttp3/CookiesTest.java

@@ -62,11 +62,13 @@ public class CookiesTest {
         .build();
 
     HttpUrl urlWithIpAddress = urlWithIpAddress(server, "/path/foo");
-    server.enqueue(new MockResponse().addHeader("Set-Cookie: a=android; "
+    server.enqueue(new MockResponse.Builder()
-        + "expires=Fri, 31-Dec-9999 23:59:59 GMT; "
+        .addHeader("Set-Cookie: a=android; "
-        + "path=/path; "
+            + "expires=Fri, 31-Dec-9999 23:59:59 GMT; "
-        + "domain=" + urlWithIpAddress.host() + "; "
+            + "path=/path; "
-        + "secure"));
+            + "domain=" + urlWithIpAddress.host() + "; "
+            + "secure")
+        .build());
     get(urlWithIpAddress);
 
     List<HttpCookie> cookies = cookieManager.getCookieStore().getCookies();
@@ -90,13 +92,15 @@ public class CookiesTest {
         .build();
 
     HttpUrl urlWithIpAddress = urlWithIpAddress(server, "/path/foo");
-    server.enqueue(new MockResponse().addHeader("Set-Cookie: a=android; "
+    server.enqueue(new MockResponse.Builder()
-        + "Comment=this cookie is delicious; "
+        .addHeader("Set-Cookie: a=android; "
-        + "Domain=" + urlWithIpAddress.host() + "; "
+            + "Comment=this cookie is delicious; "
-        + "Max-Age=60; "
+            + "Domain=" + urlWithIpAddress.host() + "; "
-        + "Path=/path; "
+            + "Max-Age=60; "
-        + "Secure; "
+            + "Path=/path; "
-        + "Version=1"));
+            + "Secure; "
+            + "Version=1")
+        .build());
     get(urlWithIpAddress);
 
     List<HttpCookie> cookies = cookieManager.getCookieStore().getCookies();
@@ -119,16 +123,18 @@ public class CookiesTest {
         .build();
 
     HttpUrl urlWithIpAddress = urlWithIpAddress(server, "/path/foo");
-    server.enqueue(new MockResponse().addHeader("Set-Cookie: a=\"android\"; "
+    server.enqueue(new MockResponse.Builder()
-        + "Comment=\"this cookie is delicious\"; "
+        .addHeader("Set-Cookie: a=\"android\"; "
-        + "CommentURL=\"http://google.com/\"; "
+            + "Comment=\"this cookie is delicious\"; "
-        + "Discard; "
+            + "CommentURL=\"http://google.com/\"; "
-        + "Domain=" + urlWithIpAddress.host() + "; "
+            + "Discard; "
-        + "Max-Age=60; "
+            + "Domain=" + urlWithIpAddress.host() + "; "
-        + "Path=\"/path\"; "
+            + "Max-Age=60; "
-        + "Port=\"80,443," + server.getPort() + "\"; "
+            + "Path=\"/path\"; "
-        + "Secure; "
+            + "Port=\"80,443," + server.getPort() + "\"; "
-        + "Version=\"1\""));
+            + "Secure; "
+            + "Version=\"1\"")
+        .build());
     get(urlWithIpAddress);
 
     List<HttpCookie> cookies = cookieManager.getCookieStore().getCookies();
@@ -191,9 +197,10 @@ public class CookiesTest {
   }
 
   @Test public void receiveAndSendMultipleCookies() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
         .addHeader("Set-Cookie", "a=android")
-        .addHeader("Set-Cookie", "b=banana"));
+        .addHeader("Set-Cookie", "b=banana")
+        .build());
     server.enqueue(new MockResponse());
 
     CookieManager cookieManager = new CookieManager(null, ACCEPT_ORIGINAL_SERVER);
@@ -212,14 +219,15 @@ public class CookiesTest {
 
   @Test public void testRedirectsDoNotIncludeTooManyCookies() throws Exception {
     MockWebServer redirectTarget = new MockWebServer();
-    redirectTarget.enqueue(new MockResponse().setBody("A"));
+    redirectTarget.enqueue(new MockResponse.Builder().body("A").build());
     redirectTarget.start();
     HttpUrl redirectTargetUrl = urlWithIpAddress(redirectTarget, "/");
 
     MockWebServer redirectSource = new MockWebServer();
-    redirectSource.enqueue(new MockResponse()
+    redirectSource.enqueue(new MockResponse.Builder()
-        .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+        .code(HttpURLConnection.HTTP_MOVED_TEMP)
-        .addHeader("Location: " + redirectTargetUrl));
+        .addHeader("Location: " + redirectTargetUrl)
+        .build());
     redirectSource.start();
     HttpUrl redirectSourceUrl = urlWithIpAddress(redirectSource, "/");
 

okhttp/src/jvmTest/java/okhttp3/DuplexTest.java

@@ -43,7 +43,6 @@ import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.api.extension.RegisterExtension;
-
 import static java.util.Arrays.asList;
 import static okhttp3.tls.internal.TlsUtil.localhost;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -91,7 +90,7 @@ public final class DuplexTest {
   @Test public void trueDuplexClientWritesFirst() throws Exception {
     enableProtocol(Protocol.HTTP_2);
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders(),
         new MockDuplexResponseBody()
             .receiveRequest("request A\n")
@@ -134,7 +133,7 @@ public final class DuplexTest {
   @Test public void trueDuplexServerWritesFirst() throws Exception {
     enableProtocol(Protocol.HTTP_2);
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders(),
         new MockDuplexResponseBody()
             .sendResponse("response A\n")
@@ -177,11 +176,11 @@ public final class DuplexTest {
   @Test public void clientReadsHeadersDataTrailers() throws Exception {
     enableProtocol(Protocol.HTTP_2);
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders()
             .addHeader("h1", "v1")
             .addHeader("h2", "v2")
-            .setTrailers(Headers.of("trailers", "boom")),
+            .trailers(Headers.of("trailers", "boom")),
         new MockDuplexResponseBody()
             .sendResponse("ok")
             .exhaustResponse());
@@ -207,7 +206,7 @@ public final class DuplexTest {
 
     enableProtocol(Protocol.HTTP_2);
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders()
             .addHeader("h1", "v1")
             .addHeader("h2", "v2"),
@@ -236,7 +235,7 @@ public final class DuplexTest {
   @Test public void requestBodyEndsAfterResponseBody() throws Exception {
     enableProtocol(Protocol.HTTP_2);
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders(),
         new MockDuplexResponseBody()
             .exhaustResponse()
@@ -271,7 +270,7 @@ public final class DuplexTest {
     enableProtocol(Protocol.HTTP_2);
 
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders()
             .add100Continue(),
         new MockDuplexResponseBody()
@@ -327,16 +326,17 @@ public final class DuplexTest {
         .build();
 
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders()
-            .setResponseCode(HttpURLConnection.HTTP_MOVED_PERM)
+            .code(HttpURLConnection.HTTP_MOVED_PERM)
             .addHeader("Location: /b"),
         new MockDuplexResponseBody()
             .sendResponse("/a has moved!\n", duplexResponseSent)
             .requestIOException()
             .exhaustResponse());
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("this is /b"));
+        .body("this is /b")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -381,15 +381,15 @@ public final class DuplexTest {
         .build();
 
     MockDuplexResponseBody mockResponseBody1 = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders()
-            .setResponseCode(HttpURLConnection.HTTP_UNAUTHORIZED),
+            .code(HttpURLConnection.HTTP_UNAUTHORIZED),
         new MockDuplexResponseBody()
             .sendResponse("please authenticate!\n")
             .requestIOException()
             .exhaustResponse());
     MockDuplexResponseBody mockResponseBody2 = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders(),
         new MockDuplexResponseBody()
             .sendResponse("response body\n")
@@ -431,8 +431,9 @@ public final class DuplexTest {
   @Test public void fullCallTimeoutAppliesToSetup() throws Exception {
     enableProtocol(Protocol.HTTP_2);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setHeadersDelay(500, TimeUnit.MILLISECONDS));
+        .headersDelay(500, TimeUnit.MILLISECONDS)
+        .build());
 
     Request request = new Request.Builder()
         .url(server.url("/"))
@@ -454,7 +455,7 @@ public final class DuplexTest {
     enableProtocol(Protocol.HTTP_2);
 
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders(),
         new MockDuplexResponseBody()
             .sendResponse("response A\n")
@@ -490,7 +491,7 @@ public final class DuplexTest {
   @Test public void duplexWithRewriteInterceptors() throws Exception {
     enableProtocol(Protocol.HTTP_2);
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders(),
         new MockDuplexResponseBody()
             .receiveRequest("REQUEST A\n")
@@ -541,7 +542,7 @@ public final class DuplexTest {
 
     enableProtocol(Protocol.HTTP_2);
     MockDuplexResponseBody mockDuplexResponseBody = enqueueResponseWithBody(
-        new MockResponse()
+        new MockResponse.Builder()
             .clearHeaders(),
         new MockDuplexResponseBody()
             .sendResponse("success!")
@@ -588,8 +589,9 @@ public final class DuplexTest {
   @Test public void headersReadTimeoutDoesNotStartUntilLastRequestBodyByteFire() throws Exception {
     enableProtocol(Protocol.HTTP_2);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-      .setHeadersDelay(1500, TimeUnit.MILLISECONDS));
+        .headersDelay(1500, TimeUnit.MILLISECONDS)
+        .build());
 
     Request request = new Request.Builder()
       .url(server.url("/"))
@@ -613,9 +615,10 @@ public final class DuplexTest {
   @Test public void bodyReadTimeoutDoesNotStartUntilLastRequestBodyByteFire() throws Exception {
     enableProtocol(Protocol.HTTP_2);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-      .setBodyDelay(1500, TimeUnit.MILLISECONDS)
+      .bodyDelay(1500, TimeUnit.MILLISECONDS)
-      .setBody("this should never be received"));
+      .body("this should never be received")
+      .build());
 
     Request request = new Request.Builder()
       .url(server.url("/"))
@@ -643,8 +646,9 @@ public final class DuplexTest {
   @Test public void headersReadTimeoutDoesNotStartUntilLastRequestBodyByteNoFire() throws Exception {
     enableProtocol(Protocol.HTTP_2);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-      .setHeadersDelay(500, TimeUnit.MILLISECONDS));
+      .headersDelay(500, TimeUnit.MILLISECONDS)
+      .build());
 
     Request request = new Request.Builder()
       .url(server.url("/"))
@@ -667,9 +671,10 @@ public final class DuplexTest {
   @Test public void bodyReadTimeoutDoesNotStartUntilLastRequestBodyByteNoFire() throws Exception {
     enableProtocol(Protocol.HTTP_2);
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-      .setBodyDelay(500, TimeUnit.MILLISECONDS)
+      .bodyDelay(500, TimeUnit.MILLISECONDS)
-      .setBody("success"));
+      .body("success")
+      .build());
 
     Request request = new Request.Builder()
       .url(server.url("/"))
@@ -686,9 +691,9 @@ public final class DuplexTest {
   }
 
   private MockDuplexResponseBody enqueueResponseWithBody(
-      MockResponse response, MockDuplexResponseBody body) {
+      MockResponse.Builder builder, MockDuplexResponseBody body) {
-    MwsDuplexAccess.instance.setBody(response, body);
+    MwsDuplexAccess.instance.setBody(builder, body);
-    server.enqueue(response);
+    server.enqueue(builder.build());
     return body;
   }
 

okhttp/src/jvmTest/java/okhttp3/EventListenerTest.java

@@ -120,8 +120,9 @@ public final class EventListenerTest {
   }
 
   @Test public void successfulCallEventSequence() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc"));
+        .body("abc")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -139,8 +140,9 @@ public final class EventListenerTest {
   }
 
   @Test public void successfulCallEventSequenceForIpAddress() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-      .setBody("abc"));
+        .body("abc")
+        .build());
 
     String ipAddress = InetAddress.getLoopbackAddress().getHostAddress();
 
@@ -160,8 +162,9 @@ public final class EventListenerTest {
   }
 
   @Test public void successfulCallEventSequenceForEnqueue() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc"));
+        .body("abc")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -191,8 +194,9 @@ public final class EventListenerTest {
   }
 
   @Test public void failedCallEventSequence() {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setHeadersDelay(2, TimeUnit.SECONDS));
+        .headersDelay(2, TimeUnit.SECONDS)
+        .build());
 
     client = client.newBuilder()
         .readTimeout(Duration.ofMillis(250))
@@ -215,9 +219,11 @@ public final class EventListenerTest {
   }
 
   @Test public void failedDribbledCallEventSequence() throws IOException {
-    server.enqueue(new MockResponse().setBody("0123456789")
+    server.enqueue(new MockResponse.Builder()
+        .body("0123456789")
         .throttleBody(2, 100, TimeUnit.MILLISECONDS)
-        .setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
+        .socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
+        .build());
 
     client = client.newBuilder()
         .protocols(Collections.singletonList(Protocol.HTTP_1_1))
@@ -262,8 +268,9 @@ public final class EventListenerTest {
   }
 
   @Test public void cancelAsyncCall() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc"));
+        .body("abc")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -282,8 +289,9 @@ public final class EventListenerTest {
   }
 
   @Test public void multipleCancelsEmitsOnlyOneEvent() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc"));
+        .body("abc")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -409,8 +417,9 @@ public final class EventListenerTest {
   @Test public void successfulEmptyHttpsCallEventSequence() throws IOException {
     enableTlsWithTunnel();
     server.setProtocols(asList(Protocol.HTTP_1_1));
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc"));
+        .body("abc")
+        .build());
 
     assertSuccessfulEventOrder(anyResponse);
 
@@ -421,8 +430,10 @@ public final class EventListenerTest {
   @Test public void successfulChunkedHttpsCallEventSequence() throws IOException {
     enableTlsWithTunnel();
     server.setProtocols(asList(Protocol.HTTP_1_1));
-    server.enqueue(
+    server.enqueue(new MockResponse.Builder()
-        new MockResponse().setBodyDelay(100, TimeUnit.MILLISECONDS).setChunkedBody("Hello!", 2));
+        .bodyDelay(100, TimeUnit.MILLISECONDS)
+        .chunkedBody("Hello!", 2)
+        .build());
 
     assertSuccessfulEventOrder(anyResponse);
 
@@ -433,8 +444,10 @@ public final class EventListenerTest {
   @Test public void successfulChunkedH2CallEventSequence() throws IOException {
     enableTlsWithTunnel();
     server.setProtocols(asList(Protocol.HTTP_2, Protocol.HTTP_1_1));
-    server.enqueue(
+    server.enqueue(new MockResponse.Builder()
-        new MockResponse().setBodyDelay(100, TimeUnit.MILLISECONDS).setChunkedBody("Hello!", 2));
+        .bodyDelay(100, TimeUnit.MILLISECONDS)
+        .chunkedBody("Hello!", 2)
+        .build());
 
     assertSuccessfulEventOrder(matchesProtocol(Protocol.HTTP_2));
 
@@ -489,9 +502,10 @@ public final class EventListenerTest {
   }
 
   @Test public void multipleDnsLookupsForSingleCall() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(301)
+        .code(301)
-        .setHeader("Location", "http://www.fakeurl:" + server.getPort()));
+        .setHeader("Location", "http://www.fakeurl:" + server.getPort())
+        .build());
     server.enqueue(new MockResponse());
 
     FakeDns dns = new FakeDns();
@@ -583,8 +597,9 @@ public final class EventListenerTest {
 
   @Test public void failedConnect() throws UnknownHostException {
     enableTlsWithTunnel();
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
+        .socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -612,8 +627,9 @@ public final class EventListenerTest {
 
   @Test public void multipleConnectsForSingleCall() throws IOException {
     enableTlsWithTunnel();
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
+        .socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
+        .build());
     server.enqueue(new MockResponse());
 
     client = client.newBuilder()
@@ -695,13 +711,15 @@ public final class EventListenerTest {
 
   @Test public void authenticatingTunnelProxyConnect() throws IOException {
     enableTlsWithTunnel();
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
         .inTunnel()
-        .setResponseCode(407)
+        .code(407)
         .addHeader("Proxy-Authenticate: Basic realm=\"localhost\"")
-        .addHeader("Connection: close"));
+        .addHeader("Connection: close")
-    server.enqueue(new MockResponse()
+        .build());
-        .inTunnel());
+    server.enqueue(new MockResponse.Builder()
+        .inTunnel()
+        .build());
     server.enqueue(new MockResponse());
 
     client = client.newBuilder()
@@ -746,8 +764,9 @@ public final class EventListenerTest {
 
   @Test public void failedSecureConnect() {
     enableTlsWithTunnel();
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
+        .socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -768,8 +787,9 @@ public final class EventListenerTest {
 
   @Test public void secureConnectWithTunnel() throws IOException {
     enableTlsWithTunnel();
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .inTunnel());
+        .inTunnel()
+        .build());
     server.enqueue(new MockResponse());
 
     client = client.newBuilder()
@@ -793,8 +813,9 @@ public final class EventListenerTest {
 
   @Test public void multipleSecureConnectsForSingleCall() throws IOException {
     enableTlsWithTunnel();
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setSocketPolicy(SocketPolicy.FAIL_HANDSHAKE));
+        .socketPolicy(SocketPolicy.FAIL_HANDSHAKE)
+        .build());
     server.enqueue(new MockResponse());
 
     client = client.newBuilder()
@@ -862,11 +883,13 @@ public final class EventListenerTest {
   }
 
   @Test public void noConnectionFoundOnFollowUp() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(301)
+        .code(301)
-        .addHeader("Location", "/foo"));
+        .addHeader("Location", "/foo")
-    server.enqueue(new MockResponse()
+        .build());
-        .setBody("ABC"));
+    server.enqueue(new MockResponse.Builder()
+        .body("ABC")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -908,12 +931,14 @@ public final class EventListenerTest {
   }
 
   @Test public void multipleConnectionsFoundForSingleCall() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(301)
+        .code(301)
         .addHeader("Location", "/foo")
-        .addHeader("Connection", "Close"));
+        .addHeader("Connection", "Close")
-    server.enqueue(new MockResponse()
+        .build());
-        .setBody("ABC"));
+    server.enqueue(new MockResponse.Builder()
+        .body("ABC")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -946,9 +971,10 @@ public final class EventListenerTest {
   private void responseBodyFail(Protocol expectedProtocol) throws IOException {
     // Use a 2 MiB body so the disconnect won't happen until the client has read some data.
     int responseBodySize = 2 * 1024 * 1024; // 2 MiB
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody(new Buffer().write(new byte[responseBodySize]))
+        .body(new Buffer().write(new byte[responseBodySize]))
-        .setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
+        .socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -970,10 +996,11 @@ public final class EventListenerTest {
   }
 
   @Test public void emptyResponseBody() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("")
+        .body("")
-        .setBodyDelay(1, TimeUnit.SECONDS)
+        .bodyDelay(1, TimeUnit.SECONDS)
-        .setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
+        .socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -989,9 +1016,10 @@ public final class EventListenerTest {
   }
 
   @Test public void emptyResponseBodyConnectionClose() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
         .addHeader("Connection", "close")
-        .setBody(""));
+        .body("")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -1007,10 +1035,11 @@ public final class EventListenerTest {
   }
 
   @Test public void responseBodyClosedClosedWithoutReadingAllData() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc")
+        .body("abc")
-        .setBodyDelay(1, TimeUnit.SECONDS)
+        .bodyDelay(1, TimeUnit.SECONDS)
-        .setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY));
+        .socketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY)
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -1046,8 +1075,9 @@ public final class EventListenerTest {
   }
 
   private void requestBodyFail(@Nullable Protocol expectedProtocol) {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setSocketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY));
+        .socketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY)
+        .build());
 
     NonCompletingRequestBody request = new NonCompletingRequestBody();
     Call call = client.newCall(new Request.Builder()
@@ -1127,8 +1157,9 @@ public final class EventListenerTest {
       }
     };
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setSocketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY));
+        .socketPolicy(SocketPolicy.DISCONNECT_DURING_REQUEST_BODY)
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -1188,7 +1219,9 @@ public final class EventListenerTest {
   }
 
   @Test public void successfulCallEventSequenceWithListener() throws IOException {
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder()
+        .body("abc")
+        .build());
 
     client = client.newBuilder()
         .addNetworkInterceptor(new HttpLoggingInterceptor()
@@ -1211,9 +1244,10 @@ public final class EventListenerTest {
 
   private void requestBodySuccess(RequestBody body, Matcher<Long> requestBodyBytes,
       Matcher<Long> responseHeaderLength) throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(200)
+        .code(200)
-        .setBody("World!"));
+        .body("World!")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -1307,11 +1341,12 @@ public final class EventListenerTest {
         .build());
 
     // Create a response with artificial delays.
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setHeadersDelay(responseHeadersStartDelay, TimeUnit.MILLISECONDS)
+        .headersDelay(responseHeadersStartDelay, TimeUnit.MILLISECONDS)
-        .setBodyDelay(responseBodyStartDelay, TimeUnit.MILLISECONDS)
+        .bodyDelay(responseBodyStartDelay, TimeUnit.MILLISECONDS)
         .throttleBody(5, responseBodyEndDelay, TimeUnit.MILLISECONDS)
-        .setBody("fghijk"));
+        .body("fghijk")
+        .build());
 
     // Make the call.
     try (Response response = call.execute()) {
@@ -1343,9 +1378,10 @@ public final class EventListenerTest {
   }
 
   @Test public void redirectUsingSameConnectionEventSequence() throws IOException {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+        .code(HttpURLConnection.HTTP_MOVED_TEMP)
-        .addHeader("Location: /foo"));
+        .addHeader("Location: /foo")
+        .build());
     server.enqueue(new MockResponse());
 
     Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
@@ -1364,9 +1400,10 @@ public final class EventListenerTest {
   public void redirectUsingNewConnectionEventSequence() throws IOException {
     MockWebServer otherServer = new MockWebServer();
     server.enqueue(
-        new MockResponse()
+        new MockResponse.Builder()
-            .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+            .code(HttpURLConnection.HTTP_MOVED_TEMP)
-            .addHeader("Location: " + otherServer.url("/foo")));
+            .addHeader("Location: " + otherServer.url("/foo"))
+            .build());
     otherServer.enqueue(new MockResponse());
 
     Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
@@ -1384,8 +1421,8 @@ public final class EventListenerTest {
   }
 
   @Test public void applicationInterceptorProceedsMultipleTimes() throws Exception {
-    server.enqueue(new MockResponse().setBody("a"));
+    server.enqueue(new MockResponse.Builder().body("a").build());
-    server.enqueue(new MockResponse().setBody("b"));
+    server.enqueue(new MockResponse.Builder().body("b").build());
 
     client = client.newBuilder()
         .addInterceptor(chain -> {
@@ -1432,8 +1469,9 @@ public final class EventListenerTest {
 
   /** Response headers start, then the entire request body, then response headers end. */
   @Test public void expectContinueStartsResponseHeadersEarly() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .add100Continue());
+        .add100Continue()
+        .build());
 
     Request request = new Request.Builder()
         .url(server.url("/"))
@@ -1453,9 +1491,10 @@ public final class EventListenerTest {
 
   @Test public void timeToFirstByteGapBetweenResponseHeaderStartAndEnd() throws IOException {
     long responseHeadersStartDelay = 250L;
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
         .add100Continue()
-        .setHeadersDelay(responseHeadersStartDelay, TimeUnit.MILLISECONDS));
+        .headersDelay(responseHeadersStartDelay, TimeUnit.MILLISECONDS)
+        .build());
 
     Request request = new Request.Builder()
         .url(server.url("/"))
@@ -1477,8 +1516,9 @@ public final class EventListenerTest {
   @Test public void cacheMiss() throws IOException {
     enableCache();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc"));
+        .body("abc")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -1498,11 +1538,13 @@ public final class EventListenerTest {
   @Test public void conditionalCache() throws IOException {
     enableCache();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .addHeader("ETag: v1")
+        .addHeader("ETag", "v1")
-        .setBody("abc"));
+        .body("abc")
-    server.enqueue(new MockResponse()
+        .build());
-        .setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
+    server.enqueue(new MockResponse.Builder()
+        .code(HttpURLConnection.HTTP_NOT_MODIFIED)
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -1530,13 +1572,15 @@ public final class EventListenerTest {
   @Test public void conditionalCacheMiss() throws IOException {
     enableCache();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
         .addHeader("ETag: v1")
-        .setBody("abc"));
+        .body("abc")
-    server.enqueue(new MockResponse()
+        .build());
-        .setResponseCode(HttpURLConnection.HTTP_OK)
+    server.enqueue(new MockResponse.Builder()
+        .code(HttpURLConnection.HTTP_OK)
         .addHeader("ETag: v2")
-        .setBody("abd"));
+        .body("abd")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))
@@ -1578,7 +1622,10 @@ public final class EventListenerTest {
   @Test public void cacheHit() throws IOException {
     enableCache();
 
-    server.enqueue(new MockResponse().setBody("abc").addHeader("cache-control: public, max-age=300"));
+    server.enqueue(new MockResponse.Builder()
+        .body("abc")
+        .addHeader("cache-control: public, max-age=300")
+        .build());
 
     Call call = client.newCall(new Request.Builder()
         .url(server.url("/"))

okhttp/src/jvmTest/java/okhttp3/FastFallbackTest.kt

@@ -114,12 +114,10 @@ class FastFallbackTest {
       localhostIpv6,
     )
     serverIpv4.enqueue(
-      MockResponse()
+      MockResponse(body = "unexpected call to IPv4")
-        .setBody("unexpected call to IPv4")
     )
     serverIpv6.enqueue(
-      MockResponse()
+      MockResponse(body = "hello from IPv6")
-        .setBody("hello from IPv6")
     )
 
     val call = client.newCall(Request(url))
@@ -139,12 +137,10 @@ class FastFallbackTest {
       localhostIpv4,
     )
     serverIpv4.enqueue(
-      MockResponse()
+      MockResponse(body = "unexpected call to IPv4")
-        .setBody("unexpected call to IPv4")
     )
     serverIpv6.enqueue(
-      MockResponse()
+      MockResponse(body = "hello from IPv6")
-        .setBody("hello from IPv6")
     )
 
     val call = client.newCall(Request(url))
@@ -160,8 +156,7 @@ class FastFallbackTest {
   fun reachesIpv4WhenIpv6IsDown() {
     serverIpv6.shutdown()
     serverIpv4.enqueue(
-      MockResponse()
+      MockResponse(body = "hello from IPv4")
-        .setBody("hello from IPv4")
     )
 
     val call = client.newCall(Request(url))
@@ -178,8 +173,7 @@ class FastFallbackTest {
   fun reachesIpv6WhenIpv4IsDown() {
     serverIpv4.shutdown()
     serverIpv6.enqueue(
-      MockResponse()
+      MockResponse(body = "hello from IPv6")
-        .setBody("hello from IPv6")
     )
 
     val call = client.newCall(Request(url))
@@ -216,8 +210,7 @@ class FastFallbackTest {
     )
     serverIpv6.shutdown()
     serverIpv4.enqueue(
-      MockResponse()
+      MockResponse(body = "hello from IPv4")
-        .setBody("hello from IPv4")
     )
 
     val call = client.newCall(Request(url))
@@ -237,8 +230,7 @@ class FastFallbackTest {
     )
     serverIpv4.shutdown()
     serverIpv6.enqueue(
-      MockResponse()
+      MockResponse(body = "hello from IPv6")
-        .setBody("hello from IPv6")
     )
 
     client = client.newBuilder()
@@ -300,17 +292,16 @@ class FastFallbackTest {
 
     // Set up a same-connection retry.
     serverIpv4.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
+      )
     )
     serverIpv4.enqueue(
-      MockResponse()
+      MockResponse(body = "this was the 2nd request on IPv4")
-        .setBody("this was the 2nd request on IPv4")
     )
     serverIpv6.enqueue(
-      MockResponse()
+      MockResponse(body = "unexpected call to IPv6")
-        .setBody("unexpected call to IPv6")
     )
 
     // Confirm the retry succeeds on the same connection.

okhttp/src/jvmTest/java/okhttp3/InterceptorTest.java

@@ -86,7 +86,9 @@ public final class InterceptorTest {
   }
 
   @Test public void networkInterceptorsCannotShortCircuitResponses() throws Exception {
-    server.enqueue(new MockResponse().setResponseCode(500));
+    server.enqueue(new MockResponse.Builder()
+        .code(500)
+        .build());
 
     Interceptor interceptor = chain -> new Response.Builder()
         .request(chain.request())
@@ -138,7 +140,9 @@ public final class InterceptorTest {
   }
 
   @Test public void networkInterceptorsCannotChangeServerAddress() throws Exception {
-    server.enqueue(new MockResponse().setResponseCode(500));
+    server.enqueue(new MockResponse.Builder()
+        .code(500)
+        .build());
 
     Interceptor interceptor = chain -> {
       Address address = chain.connection().route().address();
@@ -184,9 +188,10 @@ public final class InterceptorTest {
   }
 
   @Test public void networkInterceptorsObserveNetworkHeaders() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody(gzip("abcabcabc"))
+        .body(gzip("abcabcabc"))
-        .addHeader("Content-Encoding: gzip"));
+        .addHeader("Content-Encoding: gzip")
+        .build());
 
     Interceptor interceptor = chain -> {
       // The network request has everything: User-Agent, Host, Accept-Encoding.
@@ -292,9 +297,10 @@ public final class InterceptorTest {
   }
 
   private void rewriteResponseFromServer(boolean network) throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
         .addHeader("Original-Header: foo")
-        .setBody("abc"));
+        .body("abc")
+        .build());
 
     addInterceptor(network, chain -> {
       Response originalResponse = chain.proceed(chain.request());
@@ -385,8 +391,8 @@ public final class InterceptorTest {
   }
 
   @Test public void applicationInterceptorsCanMakeMultipleRequestsToServer() throws Exception {
-    server.enqueue(new MockResponse().setBody("a"));
+    server.enqueue(new MockResponse.Builder().body("a").build());
-    server.enqueue(new MockResponse().setBody("b"));
+    server.enqueue(new MockResponse.Builder().body("b").build());
 
     client = client.newBuilder()
         .addInterceptor(chain -> {
@@ -406,8 +412,8 @@ public final class InterceptorTest {
 
   /** Make sure interceptors can interact with the OkHttp client. */
   @Test public void interceptorMakesAnUnrelatedRequest() throws Exception {
-    server.enqueue(new MockResponse().setBody("a")); // Fetched by interceptor.
+    server.enqueue(new MockResponse.Builder().body("a").build()); // Fetched by interceptor.
-    server.enqueue(new MockResponse().setBody("b")); // Fetched directly.
+    server.enqueue(new MockResponse.Builder().body("b").build()); // Fetched directly.
 
     client = client.newBuilder()
         .addInterceptor(chain -> {
@@ -432,8 +438,8 @@ public final class InterceptorTest {
 
   /** Make sure interceptors can interact with the OkHttp client asynchronously. */
   @Test public void interceptorMakesAnUnrelatedAsyncRequest() throws Exception {
-    server.enqueue(new MockResponse().setBody("a")); // Fetched by interceptor.
+    server.enqueue(new MockResponse.Builder().body("a").build()); // Fetched by interceptor.
-    server.enqueue(new MockResponse().setBody("b")); // Fetched directly.
+    server.enqueue(new MockResponse.Builder().body("b").build()); // Fetched directly.
 
     client = client.newBuilder()
         .addInterceptor(chain -> {
@@ -612,9 +618,10 @@ public final class InterceptorTest {
   }
 
   @Test public void networkInterceptorReturnsConnectionOnEmptyBody() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
+        .socketPolicy(SocketPolicy.DISCONNECT_AT_END)
-        .addHeader("Connection", "Close"));
+        .addHeader("Connection", "Close")
+        .build());
 
     Interceptor interceptor = chain -> {
       Response response = chain.proceed(chain.request());
@@ -700,9 +707,10 @@ public final class InterceptorTest {
         .addInterceptor(interceptor2)
         .build();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc")
+        .body("abc")
-        .throttleBody(1, 1, TimeUnit.SECONDS));
+        .throttleBody(1, 1, TimeUnit.SECONDS)
+        .build());
 
     Request request1 = new Request.Builder()
         .url(server.url("/"))
@@ -780,9 +788,10 @@ public final class InterceptorTest {
         .addInterceptor(interceptor2)
         .build();
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc")
+        .body("abc")
-        .throttleBody(1, 1, TimeUnit.SECONDS));
+        .throttleBody(1, 1, TimeUnit.SECONDS)
+        .build());
 
     byte[] data = new byte[2 * 1024 * 1024]; // 2 MiB.
     Request request1 = new Request.Builder()

okhttp/src/jvmTest/java/okhttp3/JSSETest.kt

@@ -62,7 +62,7 @@ class JSSETest {
 
     enableTls()
 
-    server.enqueue(MockResponse().setBody("abc"))
+    server.enqueue(MockResponse(body = "abc"))
 
     val request = Request(server.url("/"))
 

okhttp/src/jvmTest/java/okhttp3/KotlinSourceModernTest.kt

@@ -46,12 +46,6 @@ import javax.net.ssl.SSLSocket
 import javax.net.ssl.SSLSocketFactory
 import javax.net.ssl.X509KeyManager
 import javax.net.ssl.X509TrustManager
-import mockwebserver3.MockResponse
-import mockwebserver3.MockWebServer
-import mockwebserver3.PushPromise
-import mockwebserver3.QueueDispatcher
-import mockwebserver3.RecordedRequest
-import mockwebserver3.SocketPolicy
 import okhttp3.Handshake.Companion.handshake
 import okhttp3.Headers.Companion.headersOf
 import okhttp3.Headers.Companion.toHeaders
@@ -68,6 +62,12 @@ import okhttp3.internal.proxy.NullProxySelector
 import okhttp3.internal.tls.OkHostnameVerifier
 import okhttp3.logging.HttpLoggingInterceptor
 import okhttp3.logging.LoggingEventListener
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.PushPromise
+import okhttp3.mockwebserver.QueueDispatcher
+import okhttp3.mockwebserver.RecordedRequest
+import okhttp3.mockwebserver.SocketPolicy
 import okhttp3.tls.HandshakeCertificates
 import okhttp3.tls.HeldCertificate
 import okhttp3.tls.internal.TlsUtil.localhost
@@ -337,7 +337,7 @@ class KotlinSourceModernTest {
 
   @Test
   fun dispatcherFromMockWebServer() {
-    val dispatcher = object : mockwebserver3.Dispatcher() {
+    val dispatcher = object : okhttp3.mockwebserver.Dispatcher() {
       override fun dispatch(request: RecordedRequest): MockResponse = TODO()
       override fun peek(): MockResponse = TODO()
       override fun shutdown() = TODO()
@@ -737,7 +737,7 @@ class KotlinSourceModernTest {
     mockWebServer.protocolNegotiationEnabled = false
     mockWebServer.protocols = listOf()
     val protocols: List<Protocol> = mockWebServer.protocols
-    mockWebServer.useHttps(SSLSocketFactory.getDefault() as SSLSocketFactory)
+    mockWebServer.useHttps(SSLSocketFactory.getDefault() as SSLSocketFactory, false)
     mockWebServer.noClientAuth()
     mockWebServer.requestClientAuth()
     mockWebServer.requireClientAuth()
@@ -749,7 +749,7 @@ class KotlinSourceModernTest {
     mockWebServer.start(0)
     mockWebServer.start(InetAddress.getLocalHost(), 0)
     mockWebServer.shutdown()
-    var dispatcher: mockwebserver3.Dispatcher = mockWebServer.dispatcher
+    var dispatcher: okhttp3.mockwebserver.Dispatcher = mockWebServer.dispatcher
     dispatcher = mockWebServer.dispatcher
     mockWebServer.dispatcher = QueueDispatcher()
     mockWebServer.dispatcher = QueueDispatcher()
@@ -909,15 +909,7 @@ class KotlinSourceModernTest {
 
   @Test
   fun queueDispatcher() {
-    var queueDispatcher: QueueDispatcher = object : QueueDispatcher() {
+    val queueDispatcher = QueueDispatcher()
-      override fun dispatch(request: RecordedRequest): MockResponse = TODO()
-      override fun peek(): MockResponse = TODO()
-      override fun enqueueResponse(response: MockResponse) = TODO()
-      override fun shutdown() = TODO()
-      override fun setFailFast(failFast: Boolean) = TODO()
-      override fun setFailFast(failFastResponse: MockResponse?) = TODO()
-    }
-    queueDispatcher = QueueDispatcher()
     var mockResponse: MockResponse = queueDispatcher.dispatch(
         RecordedRequest("", headersOf(), listOf(), 0L, Buffer(), 0, Socket()))
     mockResponse = queueDispatcher.peek()

okhttp/src/jvmTest/java/okhttp3/OkHttpClientTest.kt

@@ -217,7 +217,7 @@ class OkHttpClientTest {
   }
 
   @Test fun nullDefaultProxySelector() {
-    server!!.enqueue(MockResponse().setBody("abc"))
+    server!!.enqueue(MockResponse(body = "abc"))
     ProxySelector.setDefault(null)
     val client = clientTestRule.newClient()
     val request = Request(server!!.url("/"))

okhttp/src/jvmTest/java/okhttp3/OpenJSSETest.kt

@@ -52,7 +52,7 @@ class OpenJSSETest {
   fun testTlsv13Works() {
     enableTls()
 
-    server.enqueue(MockResponse().setBody("abc"))
+    server.enqueue(MockResponse(body = "abc"))
 
     val request = Request(server.url("/"))
 

okhttp/src/jvmTest/java/okhttp3/RouteFailureTest.kt

@@ -52,10 +52,11 @@ class RouteFailureTest {
   val ipv4 = InetAddress.getByName("203.0.113.1")
   val ipv6 = InetAddress.getByName("2001:db8:ffff:ffff:ffff:ffff:ffff:1")
 
-  val refusedStream = MockResponse()
+  val refusedStream = MockResponse(
-    .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+    socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-    .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+    http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
-  val bodyResponse = MockResponse().setBody("body")
+  )
+  val bodyResponse = MockResponse(body = "body")
 
   @BeforeEach
   fun setUp(

okhttp/src/jvmTest/java/okhttp3/ServerTruncatesRequestTest.kt

@@ -32,22 +32,26 @@ import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.Timeout
-import org.junit.jupiter.api.extension.RegisterExtension
 import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.api.extension.RegisterExtension
 import org.junit.jupiter.api.fail
 
 @Timeout(30)
 @Tag("Slowish")
 class ServerTruncatesRequestTest {
-  @RegisterExtension @JvmField val platform = PlatformRule()
+  @RegisterExtension
-  @RegisterExtension @JvmField var clientTestRule = OkHttpClientTestRule()
+  @JvmField
+  val platform = PlatformRule()
+  @RegisterExtension
+  @JvmField
+  var clientTestRule = OkHttpClientTestRule()
 
   private val listener = RecordingEventListener()
   private val handshakeCertificates = localhost()
 
   private var client = clientTestRule.newClientBuilder()
-      .eventListenerFactory(clientTestRule.wrap(listener))
+    .eventListenerFactory(clientTestRule.wrap(listener))
-      .build()
+    .build()
 
   private lateinit var server: MockWebServer
 
@@ -59,20 +63,25 @@ class ServerTruncatesRequestTest {
     platform.assumeNotBouncyCastle()
   }
 
-  @Test fun serverTruncatesRequestOnLongPostHttp1() {
+  @Test
+  fun serverTruncatesRequestOnLongPostHttp1() {
     serverTruncatesRequestOnLongPost(https = false)
   }
 
-  @Test fun serverTruncatesRequestOnLongPostHttp2() {
+  @Test
+  fun serverTruncatesRequestOnLongPostHttp2() {
     enableProtocol(Protocol.HTTP_2)
     serverTruncatesRequestOnLongPost(https = true)
   }
 
   private fun serverTruncatesRequestOnLongPost(https: Boolean) {
-    server.enqueue(MockResponse()
+    server.enqueue(
-      .setSocketPolicy(SocketPolicy.DO_NOT_READ_REQUEST_BODY)
+      MockResponse(
-      .setBody("abc")
+        body = "abc",
-      .apply { this.http2ErrorCode = ErrorCode.NO_ERROR.httpCode })
+        socketPolicy = SocketPolicy.DO_NOT_READ_REQUEST_BODY,
+        http2ErrorCode = ErrorCode.NO_ERROR.httpCode,
+      )
+    )
 
     val call = client.newCall(
       Request(
@@ -120,13 +129,17 @@ class ServerTruncatesRequestTest {
    * If the server returns a full response, it doesn't really matter if the HTTP/2 stream is reset.
    * Attempts to write the request body fails fast.
    */
-  @Test fun serverTruncatesRequestHttp2OnDuplexRequest() {
+  @Test
+  fun serverTruncatesRequestHttp2OnDuplexRequest() {
     enableProtocol(Protocol.HTTP_2)
 
-    server.enqueue(MockResponse()
+    server.enqueue(
-      .setSocketPolicy(SocketPolicy.DO_NOT_READ_REQUEST_BODY)
+      MockResponse(
-      .setBody("abc")
+        body = "abc",
-      .apply { this.http2ErrorCode = ErrorCode.NO_ERROR.httpCode })
+        socketPolicy = SocketPolicy.DO_NOT_READ_REQUEST_BODY,
+        http2ErrorCode = ErrorCode.NO_ERROR.httpCode,
+      )
+    )
 
     val requestBody = AsyncRequestBody()
 
@@ -156,31 +169,31 @@ class ServerTruncatesRequestTest {
     makeSimpleCall()
   }
 
-  @Test fun serverTruncatesRequestButTrailersCanStillBeReadHttp1() {
+  @Test
+  fun serverTruncatesRequestButTrailersCanStillBeReadHttp1() {
     serverTruncatesRequestButTrailersCanStillBeRead(http2 = false)
   }
 
-  @Test fun serverTruncatesRequestButTrailersCanStillBeReadHttp2() {
+  @Test
+  fun serverTruncatesRequestButTrailersCanStillBeReadHttp2() {
     enableProtocol(Protocol.HTTP_2)
     serverTruncatesRequestButTrailersCanStillBeRead(http2 = true)
   }
 
   private fun serverTruncatesRequestButTrailersCanStillBeRead(http2: Boolean) {
-    val mockResponse = MockResponse()
+    val mockResponse = MockResponse.Builder()
-        .setSocketPolicy(SocketPolicy.DO_NOT_READ_REQUEST_BODY)
+      .socketPolicy(SocketPolicy.DO_NOT_READ_REQUEST_BODY)
-        .apply {
+      .trailers(headersOf("caboose", "xyz"))
-          this.trailers = headersOf("caboose", "xyz")
+      .http2ErrorCode(ErrorCode.NO_ERROR.httpCode)
-          this.http2ErrorCode = ErrorCode.NO_ERROR.httpCode
-        }
 
     // Trailers always work for HTTP/2, but only for chunked bodies in HTTP/1.
     if (http2) {
-      mockResponse.setBody("abc")
+      mockResponse.body("abc")
     } else {
-      mockResponse.setChunkedBody("abc", 1)
+      mockResponse.chunkedBody("abc", 1)
     }
 
-    server.enqueue(mockResponse)
+    server.enqueue(mockResponse.build())
 
     val call = client.newCall(
       Request(
@@ -196,11 +209,12 @@ class ServerTruncatesRequestTest {
   }
 
   @Disabled("Follow up with fix in https://github.com/square/okhttp/issues/6853")
-  @Test fun serverDisconnectsBeforeSecondRequestHttp1() {
+  @Test
+  fun serverDisconnectsBeforeSecondRequestHttp1() {
     enableProtocol(Protocol.HTTP_1_1)
 
-    server.enqueue(MockResponse().setResponseCode(200).setBody("Req1"))
+    server.enqueue(MockResponse(code = 200, body = "Req1"))
-    server.enqueue(MockResponse().setResponseCode(200).setBody("Req2"))
+    server.enqueue(MockResponse(code = 200, body = "Req2"))
 
     val eventListener = object : EventListener() {
       var socket: SSLSocket? = null
@@ -235,8 +249,9 @@ class ServerTruncatesRequestTest {
     }
   }
 
-  @Test fun noAttemptToReadResponseIfLoadingRequestBodyIsSourceOfFailure() {
+  @Test
-    server.enqueue(MockResponse().setBody("abc"))
+  fun noAttemptToReadResponseIfLoadingRequestBodyIsSourceOfFailure() {
+    server.enqueue(MockResponse(body = "abc"))
 
     val requestBody = object : RequestBody() {
       override fun contentType(): MediaType? = null
@@ -271,7 +286,7 @@ class ServerTruncatesRequestTest {
   }
 
   private fun makeSimpleCall() {
-    server.enqueue(MockResponse().setBody("healthy"))
+    server.enqueue(MockResponse(body = "healthy"))
     val callB = client.newCall(Request(server.url("/")))
     callB.execute().use { response ->
       assertThat(response.body.string()).isEqualTo("healthy")
@@ -281,19 +296,19 @@ class ServerTruncatesRequestTest {
   private fun enableProtocol(protocol: Protocol) {
     enableTls()
     client = client.newBuilder()
-        .protocols(listOf(protocol, Protocol.HTTP_1_1))
+      .protocols(listOf(protocol, Protocol.HTTP_1_1))
-        .build()
+      .build()
     server.protocols = client.protocols
   }
 
   private fun enableTls() {
     client = client.newBuilder()
-        .sslSocketFactory(
+      .sslSocketFactory(
-          handshakeCertificates.sslSocketFactory(),
+        handshakeCertificates.sslSocketFactory(),
-          handshakeCertificates.trustManager
+        handshakeCertificates.trustManager
-        )
+      )
-        .hostnameVerifier(RecordingHostnameVerifier())
+      .hostnameVerifier(RecordingHostnameVerifier())
-        .build()
+      .build()
     server.useHttps(handshakeCertificates.sslSocketFactory())
   }
 

okhttp/src/jvmTest/java/okhttp3/SessionReuseTest.kt

@@ -99,8 +99,8 @@ class SessionReuseTest {
       .sslSocketFactory(sslSocketFactory, handshakeCertificates.trustManager)
       .build()
 
-    server.enqueue(MockResponse().setBody("abc1"))
+    server.enqueue(MockResponse(body = "abc1"))
-    server.enqueue(MockResponse().setBody("abc2"))
+    server.enqueue(MockResponse(body = "abc2"))
 
     val request = Request(server.url("/"))
 

okhttp/src/jvmTest/java/okhttp3/SocketChannelTest.kt

@@ -151,7 +151,7 @@ class SocketChannelTest {
       }
       .build()
 
-    server.enqueue(MockResponse().setBody("abc"))
+    server.enqueue(MockResponse(body = "abc"))
 
     @Suppress("HttpUrlsUsage") val url =
       if (socketMode is TlsInstance)

okhttp/src/jvmTest/java/okhttp3/SocksProxyTest.java

@@ -49,8 +49,8 @@ public final class SocksProxyTest {
   }
 
   @Test public void proxy() throws Exception {
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder().body("abc").build());
-    server.enqueue(new MockResponse().setBody("def"));
+    server.enqueue(new MockResponse.Builder().body("def").build());
 
     OkHttpClient client = clientTestRule.newClientBuilder()
         .proxy(socksProxy.proxy())
@@ -69,7 +69,7 @@ public final class SocksProxyTest {
   }
 
   @Test public void proxySelector() throws Exception {
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder().body("abc").build());
 
     ProxySelector proxySelector = new ProxySelector() {
       @Override public List<Proxy> select(URI uri) {
@@ -94,7 +94,7 @@ public final class SocksProxyTest {
 
   @Test public void checkRemoteDNSResolve() throws Exception {
     // This testcase will fail if the target is resolved locally instead of through the proxy.
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder().body("abc").build());
 
     OkHttpClient client = clientTestRule.newClientBuilder()
         .proxy(socksProxy.proxy())

okhttp/src/jvmTest/java/okhttp3/WholeOperationTimeoutTest.java

@@ -122,8 +122,9 @@ public final class WholeOperationTimeoutTest {
   }
 
   @Test public void timeoutProcessing() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setHeadersDelay(500, TimeUnit.MILLISECONDS));
+        .headersDelay(500, TimeUnit.MILLISECONDS)
+        .build());
 
     Request request = new Request.Builder()
         .url(server.url("/"))
@@ -141,8 +142,9 @@ public final class WholeOperationTimeoutTest {
   }
 
   @Test public void timeoutProcessingWithEnqueue() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setHeadersDelay(500, TimeUnit.MILLISECONDS));
+        .headersDelay(500, TimeUnit.MILLISECONDS)
+        .build());
 
     Request request = new Request.Builder()
         .url(server.url("/"))
@@ -171,8 +173,9 @@ public final class WholeOperationTimeoutTest {
   }
 
   @Test public void timeoutReadingResponse() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody(BIG_ENOUGH_BODY));
+        .body(BIG_ENOUGH_BODY)
+        .build());
 
     Request request = new Request.Builder()
         .url(server.url("/"))
@@ -192,8 +195,9 @@ public final class WholeOperationTimeoutTest {
   }
 
   @Test public void timeoutReadingResponseWithEnqueue() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody(BIG_ENOUGH_BODY));
+        .body(BIG_ENOUGH_BODY)
+        .build());
 
     Request request = new Request.Builder()
         .url(server.url("/"))
@@ -232,26 +236,31 @@ public final class WholeOperationTimeoutTest {
   }
 
   @Test public void singleTimeoutForAllFollowUpRequests() throws Exception {
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+        .code(HttpURLConnection.HTTP_MOVED_TEMP)
         .setHeader("Location", "/b")
-        .setHeadersDelay(100, TimeUnit.MILLISECONDS));
+        .headersDelay(100, TimeUnit.MILLISECONDS)
-    server.enqueue(new MockResponse()
+        .build());
-        .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+    server.enqueue(new MockResponse.Builder()
+        .code(HttpURLConnection.HTTP_MOVED_TEMP)
         .setHeader("Location", "/c")
-        .setHeadersDelay(100, TimeUnit.MILLISECONDS));
+        .headersDelay(100, TimeUnit.MILLISECONDS)
-    server.enqueue(new MockResponse()
+        .build());
-        .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+    server.enqueue(new MockResponse.Builder()
+        .code(HttpURLConnection.HTTP_MOVED_TEMP)
         .setHeader("Location", "/d")
-        .setHeadersDelay(100, TimeUnit.MILLISECONDS));
+        .headersDelay(100, TimeUnit.MILLISECONDS)
-    server.enqueue(new MockResponse()
+        .build());
-        .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+    server.enqueue(new MockResponse.Builder()
+        .code(HttpURLConnection.HTTP_MOVED_TEMP)
         .setHeader("Location", "/e")
-        .setHeadersDelay(100, TimeUnit.MILLISECONDS));
+        .headersDelay(100, TimeUnit.MILLISECONDS)
-    server.enqueue(new MockResponse()
+        .build());
-        .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+    server.enqueue(new MockResponse.Builder()
+        .code(HttpURLConnection.HTTP_MOVED_TEMP)
         .setHeader("Location", "/f")
-        .setHeadersDelay(100, TimeUnit.MILLISECONDS));
+        .headersDelay(100, TimeUnit.MILLISECONDS)
+        .build());
     server.enqueue(new MockResponse());
 
     Request request = new Request.Builder()
@@ -273,12 +282,14 @@ public final class WholeOperationTimeoutTest {
   public void timeoutFollowingRedirectOnNewConnection() throws Exception {
     MockWebServer otherServer = new MockWebServer();
 
-    server.enqueue(
+    server.enqueue(new MockResponse.Builder()
-        new MockResponse()
+        .code(HttpURLConnection.HTTP_MOVED_TEMP)
-            .setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+        .setHeader("Location", otherServer.url("/"))
-            .setHeader("Location", otherServer.url("/")));
+        .build());
 
-    otherServer.enqueue(new MockResponse().setHeadersDelay(500, TimeUnit.MILLISECONDS));
+    otherServer.enqueue(new MockResponse.Builder()
+        .headersDelay(500, TimeUnit.MILLISECONDS)
+        .build());
 
     Request request = new Request.Builder().url(server.url("/")).build();
 
@@ -297,9 +308,10 @@ public final class WholeOperationTimeoutTest {
   @Test public void noTimeout() throws Exception {
     // Flaky https://github.com/square/okhttp/issues/5304
 
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setHeadersDelay(250, TimeUnit.MILLISECONDS)
+        .headersDelay(250, TimeUnit.MILLISECONDS)
-        .setBody(BIG_ENOUGH_BODY));
+        .body(BIG_ENOUGH_BODY)
+        .build());
 
     Request request = new Request.Builder()
         .url(server.url("/"))

okhttp/src/jvmTest/java/okhttp3/internal/http/CancelTest.kt

@@ -180,13 +180,14 @@ class CancelTest {
     setUp(mode)
     val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody(
+        .body(
           Buffer()
             .write(ByteArray(responseBodySize))
         )
-        .throttleBody(64 * 1024, 125, MILLISECONDS)
+        .throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
-    ) // 500 Kbps
+        .build()
+    )
     val call = client.newCall(Request(server.url("/")))
     val response = call.execute()
     cancelLater(call, 500)
@@ -209,17 +210,15 @@ class CancelTest {
     setUp(mode)
     val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody(
+        .body(
           Buffer()
             .write(ByteArray(responseBodySize))
         )
-        .throttleBody(64 * 1024, 125, MILLISECONDS)
+        .throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
-    ) // 500 Kbps
+        .build()
-    server.enqueue(MockResponse().apply {
+    )
-      setResponseCode(200)
+    server.enqueue(MockResponse(body = "."))
-      setBody(".")
-    })
 
     val call = client.newCall(Request.Builder().url(server.url("/")).build())
     val response = call.execute()

okhttp/src/jvmTest/java/okhttp3/internal/http2/HttpOverHttp2Test.kt

@@ -156,11 +156,7 @@ class HttpOverHttp2Test {
   @ArgumentsSource(ProtocolParamProvider::class)
   fun get(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    server.enqueue(
+    server.enqueue(MockResponse(body = "ABCDE"))
-      MockResponse()
-        .setBody("ABCDE")
-        .setStatus("HTTP/1.1 200 Sweet")
-    )
     val call = client.newCall(Request(server.url("/foo")))
     val response = call.execute()
     assertThat(response.body.string()).isEqualTo("ABCDE")
@@ -176,9 +172,10 @@ class HttpOverHttp2Test {
   @ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
   fun get204Response(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    val responseWithoutBody = MockResponse()
+    val responseWithoutBody = MockResponse.Builder()
-    responseWithoutBody.status = "HTTP/1.1 204"
+      .status("HTTP/1.1 204")
-    responseWithoutBody.removeHeader("Content-Length")
+      .removeHeader("Content-Length")
+      .build()
     server.enqueue(responseWithoutBody)
     val call = client.newCall(Request(server.url("/foo")))
     val response = call.execute()
@@ -197,8 +194,10 @@ class HttpOverHttp2Test {
   @ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
   fun head(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    val mockResponse = MockResponse().setHeader("Content-Length", 5)
+    val mockResponse = MockResponse.Builder()
-    mockResponse.status = "HTTP/1.1 200"
+      .setHeader("Content-Length", 5)
+      .status("HTTP/1.1 200")
+      .build()
     server.enqueue(mockResponse)
     val call = client.newCall(
       Request.Builder()
@@ -232,7 +231,7 @@ class HttpOverHttp2Test {
   fun noDefaultContentLengthOnStreamingPost(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     val postBytes = "FGHIJ".toByteArray()
-    server.enqueue(MockResponse().setBody("ABCDE"))
+    server.enqueue(MockResponse(body = "ABCDE"))
     val call = client.newCall(
       Request(
         url = server.url("/foo"),
@@ -257,7 +256,7 @@ class HttpOverHttp2Test {
   fun userSuppliedContentLengthHeader(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     val postBytes = "FGHIJ".toByteArray()
-    server.enqueue(MockResponse().setBody("ABCDE"))
+    server.enqueue(MockResponse(body = "ABCDE"))
     val call = client.newCall(
       Request(
         url = server.url("/foo"),
@@ -288,7 +287,7 @@ class HttpOverHttp2Test {
   ) {
     setUp(protocol, mockWebServer)
     val postBytes = "FGHIJ".toByteArray()
-    server.enqueue(MockResponse().setBody("ABCDE"))
+    server.enqueue(MockResponse(body = "ABCDE"))
     val call = client.newCall(
       Request(
         url = server.url("/foo"),
@@ -317,8 +316,8 @@ class HttpOverHttp2Test {
   @ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
   fun connectionReuse(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    server.enqueue(MockResponse().setBody("ABCDEF"))
+    server.enqueue(MockResponse(body = "ABCDEF"))
-    server.enqueue(MockResponse().setBody("GHIJKL"))
+    server.enqueue(MockResponse(body = "GHIJKL"))
     val call1 = client.newCall(Request(server.url("/r1")))
     val call2 = client.newCall(Request(server.url("/r1")))
     val response1 = call1.execute()
@@ -337,12 +336,12 @@ class HttpOverHttp2Test {
   fun connectionWindowUpdateAfterCanceling(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE + 1)))
+        .body(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE + 1)))
+        .build()
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "abc")
-        .setBody("abc")
     )
     val call1 = client.newCall(Request(server.url("/")))
     val response1 = call1.execute()
@@ -375,17 +374,16 @@ class HttpOverHttp2Test {
   fun connectionWindowUpdateOnClose(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE + 1)))
+        .body(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE + 1)))
+        .build()
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "abc")
-        .setBody("abc")
     )
     // Enqueue an additional response that show if we burnt a good prior response.
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "XXX")
-        .setBody("XXX")
     )
     val call1 = client.newCall(Request(server.url("/")))
     val response1 = call1.execute()
@@ -406,12 +404,12 @@ class HttpOverHttp2Test {
   ) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE)))
+        .body(Buffer().write(ByteArray(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE)))
+        .build()
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "abc")
-        .setBody("abc")
     )
     val call1 = client.newCall(Request(server.url("/")))
     val response1 = call1.execute()
@@ -439,8 +437,8 @@ class HttpOverHttp2Test {
   @Disabled
   fun synchronousRequest(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    server.enqueue(MockResponse().setBody("A"))
+    server.enqueue(MockResponse(body = "A"))
-    server.enqueue(MockResponse().setBody("A"))
+    server.enqueue(MockResponse(body = "A"))
     val executor = Executors.newCachedThreadPool()
     val countDownLatch = CountDownLatch(2)
     executor.execute(AsyncRequest("/r1", countDownLatch))
@@ -454,9 +452,10 @@ class HttpOverHttp2Test {
   fun gzippedResponseBody(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
         .addHeader("Content-Encoding: gzip")
-        .setBody(gzip("ABCABCABC"))
+        .body(gzip("ABCABCABC"))
+        .build()
     )
     val call = client.newCall(Request(server.url("/r1")))
     val response = call.execute()
@@ -467,14 +466,14 @@ class HttpOverHttp2Test {
   fun authenticate(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setResponseCode(HttpURLConnection.HTTP_UNAUTHORIZED)
+        code = HttpURLConnection.HTTP_UNAUTHORIZED,
-        .addHeader("www-authenticate: Basic realm=\"protected area\"")
+        headers = headersOf("www-authenticate", "Basic realm=\"protected area\""),
-        .setBody("Please authenticate.")
+        body = "Please authenticate.",
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "Successful auth!")
-        .setBody("Successful auth!")
     )
     val credential = basic("username", "password")
     client = client.newBuilder()
@@ -494,11 +493,13 @@ class HttpOverHttp2Test {
   fun redirect(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse().setResponseCode(HttpURLConnection.HTTP_MOVED_TEMP)
+      MockResponse(
-        .addHeader("Location: /foo")
+        code = HttpURLConnection.HTTP_MOVED_TEMP,
-        .setBody("This page has moved!")
+        headers = headersOf("Location", "/foo"),
+        body = "This page has moved!",
+      )
     )
-    server.enqueue(MockResponse().setBody("This is the new location!"))
+    server.enqueue(MockResponse(body = "This is the new location!"))
     val call = client.newCall(Request(server.url("/")))
     val response = call.execute()
     assertThat(response.body.string()).isEqualTo("This is the new location!")
@@ -511,7 +512,7 @@ class HttpOverHttp2Test {
   @ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
   fun readAfterLastByte(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    server.enqueue(MockResponse().setBody("ABC"))
+    server.enqueue(MockResponse(body = "ABC"))
     val call = client.newCall(Request(server.url("/")))
     val response = call.execute()
     val inputStream = response.body.byteStream()
@@ -526,8 +527,8 @@ class HttpOverHttp2Test {
   @ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
   fun readResponseHeaderTimeout(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.NO_RESPONSE))
+    server.enqueue(MockResponse(socketPolicy = SocketPolicy.NO_RESPONSE))
-    server.enqueue(MockResponse().setBody("A"))
+    server.enqueue(MockResponse(body = "A"))
     client = client.newBuilder()
       .readTimeout(Duration.ofSeconds(1))
       .build()
@@ -562,8 +563,10 @@ class HttpOverHttp2Test {
     val body = CharArray(4096) // 4KiB to read.
     Arrays.fill(body, 'y')
     server.enqueue(
-      MockResponse().setBody(String(body))
+      MockResponse.Builder()
+        .body(String(body))
         .throttleBody(1024, 1, TimeUnit.SECONDS) // Slow connection 1KiB/second.
+        .build()
     )
     client = client.newBuilder()
       .readTimeout(Duration.ofSeconds(2))
@@ -584,13 +587,13 @@ class HttpOverHttp2Test {
     setUp(protocol, mockWebServer)
     val body = repeat('y', 2048)
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody(body)
+        .body(body)
         .throttleBody(1024, 1, TimeUnit.SECONDS)
+        .build()
     ) // Slow connection 1KiB/second.
     server.enqueue(
-      MockResponse()
+      MockResponse(body = body)
-        .setBody(body)
     )
     client = client.newBuilder()
       .readTimeout(Duration.ofMillis(500)) // Half a second to read something.
@@ -620,9 +623,10 @@ class HttpOverHttp2Test {
   fun connectionTimeout(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody("A")
+        .body("A")
-        .setBodyDelay(1, TimeUnit.SECONDS)
+        .bodyDelay(1, TimeUnit.SECONDS)
+        .build()
     )
     val client1 = client.newBuilder()
       .readTimeout(Duration.ofSeconds(2))
@@ -662,9 +666,10 @@ class HttpOverHttp2Test {
       .cache(cache)
       .build()
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .addHeader("cache-control: max-age=60")
+        headers = headersOf("cache-control", "max-age=60"),
-        .setBody("A")
+        body = "A",
+      )
     )
     val call1 = client.newCall(Request(server.url("/")))
     val response1 = call1.execute()
@@ -690,13 +695,13 @@ class HttpOverHttp2Test {
       .cache(cache)
       .build()
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .addHeader("ETag: v1")
+        headers = headersOf("ETag", "v1"),
-        .setBody("A")
+        body = "A",
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(code = HttpURLConnection.HTTP_NOT_MODIFIED)
-        .setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED)
     )
     val call1 = client.newCall(Request(server.url("/")))
     val response1 = call1.execute()
@@ -719,14 +724,16 @@ class HttpOverHttp2Test {
       .cache(cache)
       .build()
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .addHeader("cache-control: max-age=60")
+        headers = headersOf("cache-control", "max-age=60"),
-        .setBody("ABCD")
+        body = "ABCD",
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .addHeader("cache-control: max-age=60")
+        headers = headersOf("cache-control", "max-age=60"),
-        .setBody("EFGH")
+        body = "EFGH",
+      )
     )
     val call1 = client.newCall(Request(server.url("/")))
     val response1 = call1.execute()
@@ -767,8 +774,7 @@ class HttpOverHttp2Test {
       .cookieJar(cookieJar)
       .build()
     server.enqueue(
-      MockResponse()
+      MockResponse(headers = headersOf("set-cookie", "a=b"))
-        .addHeader("set-cookie: a=b")
     )
     val call = client.newCall(Request(server.url("/")))
     val response = call.execute()
@@ -779,14 +785,8 @@ class HttpOverHttp2Test {
   @ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
   fun cancelWithStreamNotCompleted(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    server.enqueue(
+    server.enqueue(MockResponse(body = "abc"))
-      MockResponse()
+    server.enqueue(MockResponse(body = "def"))
-        .setBody("abc")
-    )
-    server.enqueue(
-      MockResponse()
-        .setBody("def")
-    )
 
     // Disconnect before the stream is created. A connection is still established!
     val call1 = client.newCall(Request(server.url("/")))
@@ -810,14 +810,12 @@ class HttpOverHttp2Test {
   ) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("abc")
     )
+    server.enqueue(MockResponse(body = "abc"))
     val call = client.newCall(Request(server.url("/")))
     try {
       call.execute()
@@ -836,14 +834,12 @@ class HttpOverHttp2Test {
       .dns(DoubleInetAddressDns()) // Two routes!
       .build()
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("abc")
     )
+    server.enqueue(MockResponse(body = "abc"))
 
     val request = Request(server.url("/"))
     val response = client.newCall(request).execute()
@@ -865,19 +861,22 @@ class HttpOverHttp2Test {
       .dns(DoubleInetAddressDns()) // Two routes!
       .build()
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
+      )
     )
 
     val request = Request(server.url("/"))
@@ -898,14 +897,12 @@ class HttpOverHttp2Test {
   ) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("abc")
     )
+    server.enqueue(MockResponse(body = "abc"))
     val request = Request(server.url("/"))
 
     // First call fails because it only has one route.
@@ -929,23 +926,19 @@ class HttpOverHttp2Test {
   ) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("abc")
-    )
-    server.enqueue(
-      MockResponse()
-        .setBody("def")
     )
+    server.enqueue(MockResponse(body = "abc"))
+    server.enqueue(MockResponse(body = "def"))
     val request = Request(server.url("/"))
 
     // First call makes a new connection and fails because it is the only route.
@@ -979,18 +972,19 @@ class HttpOverHttp2Test {
   fun noRecoveryFromTwoRefusedStreams(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "abc")
-        .setBody("abc")
     )
     val call = client.newCall(Request(server.url("/")))
     try {
@@ -1019,14 +1013,12 @@ class HttpOverHttp2Test {
 
   private fun recoverFromOneHttp2ErrorRequiresNewConnection(errorCode: ErrorCode?) {
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(errorCode!!.httpCode)
+        http2ErrorCode = errorCode!!.httpCode,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("abc")
     )
+    server.enqueue(MockResponse(body = "abc"))
     client = client.newBuilder()
       .dns(DoubleInetAddressDns())
       .build()
@@ -1046,19 +1038,18 @@ class HttpOverHttp2Test {
   ) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
+      )
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(ErrorCode.REFUSED_STREAM.httpCode)
+        http2ErrorCode = ErrorCode.REFUSED_STREAM.httpCode,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("abc")
     )
+    server.enqueue(MockResponse(body = "abc"))
     client = client.newBuilder()
       .dns(DoubleInetAddressDns())
       .build()
@@ -1087,13 +1078,13 @@ class HttpOverHttp2Test {
     )
     val dispatcher = RespondAfterCancelDispatcher(responseDequeuedLatches, requestCanceledLatches)
     dispatcher.enqueueResponse(
-      MockResponse()
+      MockResponse.Builder()
-        .setBodyDelay(10, TimeUnit.SECONDS)
+        .bodyDelay(10, TimeUnit.SECONDS)
-        .setBody("abc")
+        .body("abc")
+        .build()
     )
     dispatcher.enqueueResponse(
-      MockResponse()
+      MockResponse(body = "def")
-        .setBody("def")
     )
     server.dispatcher = dispatcher
     client = client.newBuilder()
@@ -1123,18 +1114,19 @@ class HttpOverHttp2Test {
     )
     val dispatcher = RespondAfterCancelDispatcher(responseDequeuedLatches, requestCanceledLatches)
     dispatcher.enqueueResponse(
-      MockResponse()
+      MockResponse.Builder()
-        .setBodyDelay(10, TimeUnit.SECONDS)
+        .bodyDelay(10, TimeUnit.SECONDS)
-        .setBody("abc")
+        .body("abc")
+        .build()
     )
     dispatcher.enqueueResponse(
-      MockResponse()
+      MockResponse.Builder()
-        .setBodyDelay(10, TimeUnit.SECONDS)
+        .bodyDelay(10, TimeUnit.SECONDS)
-        .setBody("def")
+        .body("def")
+        .build()
     )
     dispatcher.enqueueResponse(
-      MockResponse()
+      MockResponse(body = "ghi")
-        .setBody("ghi")
     )
     server.dispatcher = dispatcher
     client = client.newBuilder()
@@ -1222,14 +1214,12 @@ class HttpOverHttp2Test {
 
   private fun noRecoveryFromErrorWithRetryDisabled(errorCode: ErrorCode?) {
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
-        .setHttp2ErrorCode(errorCode!!.httpCode)
+        http2ErrorCode = errorCode!!.httpCode,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("abc")
     )
+    server.enqueue(MockResponse(body = "abc"))
     client = client.newBuilder()
       .retryOnConnectionFailure(false)
       .build()
@@ -1247,28 +1237,21 @@ class HttpOverHttp2Test {
     protocol: Protocol, mockWebServer: MockWebServer
   ) {
     setUp(protocol, mockWebServer)
+    server.enqueue(MockResponse(code = 401))
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setResponseCode(401)
+        socketPolicy = SocketPolicy.RESET_STREAM_AT_START,
+        http2ErrorCode = ErrorCode.INTERNAL_ERROR.httpCode,
+      )
     )
+    server.enqueue(MockResponse(body = "DEF"))
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.RESET_STREAM_AT_START)
+        code = 301,
-        .setHttp2ErrorCode(ErrorCode.INTERNAL_ERROR.httpCode)
+        headers = headersOf("Location", "/foo")
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("DEF")
-    )
-    server.enqueue(
-      MockResponse()
-        .setResponseCode(301)
-        .addHeader("Location", "/foo")
-    )
-    server.enqueue(
-      MockResponse()
-        .setBody("ABC")
     )
+    server.enqueue(MockResponse(body = "ABC"))
     val latch = CountDownLatch(1)
     val responses: BlockingQueue<String?> = SynchronousQueue()
     val authenticator = okhttp3.Authenticator { route: Route?, response: Response? ->
@@ -1321,9 +1304,10 @@ class HttpOverHttp2Test {
   fun nonAsciiResponseHeader(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
         .addHeaderLenient("Alpha", "α")
         .addHeaderLenient("β", "Beta")
+        .build()
     )
     val call = client.newCall(Request(server.url("/")))
     val response = call.execute()
@@ -1337,13 +1321,13 @@ class HttpOverHttp2Test {
     setUp(protocol, mockWebServer)
     val pushPromise = PushPromise(
       "GET", "/foo/bar", headersOf("foo", "bar"),
-      MockResponse().setBody("bar").setStatus("HTTP/1.1 200 Sweet")
+      MockResponse(body = "bar")
     )
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody("ABCDE")
+        .body("ABCDE")
-        .setStatus("HTTP/1.1 200 Sweet")
+        .addPush(pushPromise)
-        .withPush(pushPromise)
+        .build()
     )
     val call = client.newCall(Request(server.url("/foo")))
     val response = call.execute()
@@ -1366,13 +1350,13 @@ class HttpOverHttp2Test {
     setUp(protocol, mockWebServer)
     val pushPromise = PushPromise(
       "HEAD", "/foo/bar", headersOf("foo", "bar"),
-      MockResponse().setStatus("HTTP/1.1 204 Sweet")
+      MockResponse(code = 204)
     )
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBody("ABCDE")
+        .body("ABCDE")
-        .setStatus("HTTP/1.1 200 Sweet")
+        .addPush(pushPromise)
-        .withPush(pushPromise)
+        .build()
     )
     val call = client.newCall(Request(server.url("/foo")))
     val response = call.execute()
@@ -1395,10 +1379,7 @@ class HttpOverHttp2Test {
   @ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
   fun noDataFramesSentWithNullRequestBody(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    server.enqueue(
+    server.enqueue(MockResponse(body = "ABC"))
-      MockResponse()
-        .setBody("ABC")
-    )
     val call = client.newCall(
       Request.Builder()
         .url(server.url("/"))
@@ -1417,10 +1398,7 @@ class HttpOverHttp2Test {
   @ParameterizedTest @ArgumentsSource(ProtocolParamProvider::class)
   fun emptyDataFrameSentWithEmptyBody(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    server.enqueue(
+    server.enqueue(MockResponse(body = "ABC"))
-      MockResponse()
-        .setBody("ABC")
-    )
     val call = client.newCall(
       Request.Builder()
         .url(server.url("/"))
@@ -1453,9 +1431,10 @@ class HttpOverHttp2Test {
 
     // Delay the response to give 1 ping enough time to be sent and replied to.
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBodyDelay(750, TimeUnit.MILLISECONDS)
+        .bodyDelay(750, TimeUnit.MILLISECONDS)
-        .setBody("ABC")
+        .body("ABC")
+        .build()
     )
     val call = client.newCall(Request(server.url("/")))
     val response = call.execute()
@@ -1491,10 +1470,7 @@ class HttpOverHttp2Test {
       .build()
 
     // Set up the server to ignore the socket. It won't respond to pings!
-    server.enqueue(
+    server.enqueue(MockResponse(socketPolicy = SocketPolicy.STALL_SOCKET_AT_START))
-      MockResponse()
-        .setSocketPolicy(SocketPolicy.STALL_SOCKET_AT_START)
-    )
 
     // Make a call. It'll fail as soon as our pings detect a problem.
     val call = client.newCall(Request(server.url("/")))
@@ -1528,15 +1504,11 @@ class HttpOverHttp2Test {
       .build()
 
     // Stalling the socket will cause TWO requests to time out!
-    server.enqueue(
+    server.enqueue(MockResponse(socketPolicy = SocketPolicy.STALL_SOCKET_AT_START))
-      MockResponse()
-        .setSocketPolicy(SocketPolicy.STALL_SOCKET_AT_START)
-    )
 
     // The 3rd request should be sent to a fresh connection.
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "fresh connection")
-        .setBody("fresh connection")
     )
 
     // The first call times out.
@@ -1573,18 +1545,13 @@ class HttpOverHttp2Test {
       .readTimeout(Duration.ofMillis(500))
       .build()
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setBodyDelay(1000, TimeUnit.MILLISECONDS)
+        .bodyDelay(1000, TimeUnit.MILLISECONDS)
-        .setBody("a")
+        .body("a")
-    )
+        .build()
-    server.enqueue(
-      MockResponse()
-        .setBody("b")
-    )
-    server.enqueue(
-      MockResponse()
-        .setBody("c")
     )
+    server.enqueue(MockResponse(body = "b"))
+    server.enqueue(MockResponse(body = "c"))
 
     // The first call times out.
     val call1 = client.newCall(Request(server.url("/")))
@@ -1649,21 +1616,20 @@ class HttpOverHttp2Test {
     settings[Settings.MAX_CONCURRENT_STREAMS] = 2
 
     // Read & write a full request to confirm settings are accepted.
-    server.enqueue(MockResponse().withSettings(settings))
+    server.enqueue(MockResponse.Builder()
+      .settings(settings)
+      .build())
     val call = client.newCall(Request(server.url("/")))
     val response = call.execute()
     assertThat(response.body.string()).isEqualTo("")
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "ABC")
-        .setBody("ABC")
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "DEF")
-        .setBody("DEF")
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "GHI")
-        .setBody("GHI")
     )
     val call1 = client.newCall(Request(server.url("/")))
     val response1 = call1.execute()
@@ -1688,18 +1654,15 @@ class HttpOverHttp2Test {
   fun connectionNotReusedAfterShutdown(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
+        body = "ABC",
-        .setBody("ABC")
+        socketPolicy = SocketPolicy.DISCONNECT_AT_END,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("DEF")
     )
+    server.enqueue(MockResponse(body = "DEF"))
     // Enqueue an additional response that show if we burnt a good prior response.
     server.enqueue(
-      MockResponse()
+      MockResponse(body = "XXX")
-        .setBody("XXX")
     )
     val connections: MutableList<RealConnection?> = ArrayList()
     val localClient = client.newBuilder().eventListener(object : EventListener() {
@@ -1741,14 +1704,12 @@ class HttpOverHttp2Test {
   fun connectionShutdownAfterHealthCheck(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
+        body = "ABC",
-        .setBody("ABC")
+        socketPolicy = SocketPolicy.DISCONNECT_AT_END,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .setBody("DEF")
     )
+    server.enqueue(MockResponse(body = "DEF"))
     val client2 = client.newBuilder()
       .addNetworkInterceptor(object : Interceptor {
         var executedCall = false
@@ -1783,14 +1744,16 @@ class HttpOverHttp2Test {
   fun responseHeadersAfterGoaway(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse.Builder()
-        .setHeadersDelay(1, TimeUnit.SECONDS)
+        .headersDelay(1, TimeUnit.SECONDS)
-        .setBody("ABC")
+        .body("ABC")
+        .build()
     )
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .setSocketPolicy(SocketPolicy.DISCONNECT_AT_END)
+        body = "DEF",
-        .setBody("DEF")
+        socketPolicy = SocketPolicy.DISCONNECT_AT_END,
+      )
     )
     val latch = CountDownLatch(2)
     val errors = ArrayList<IOException?>()
@@ -1840,22 +1803,10 @@ class HttpOverHttp2Test {
     assumeTrue(protocol === Protocol.HTTP_2)
     server.useHttps(handshakeCertificates.sslSocketFactory())
     val queueDispatcher = QueueDispatcher()
-    queueDispatcher.enqueueResponse(
+    queueDispatcher.enqueueResponse(MockResponse(inTunnel = true))
-      MockResponse()
+    queueDispatcher.enqueueResponse(MockResponse(inTunnel = true))
-        .inTunnel()
+    queueDispatcher.enqueueResponse(MockResponse(body = "call2 response"))
-    )
+    queueDispatcher.enqueueResponse(MockResponse(body = "call1 response"))
-    queueDispatcher.enqueueResponse(
-      MockResponse()
-        .inTunnel()
-    )
-    queueDispatcher.enqueueResponse(
-      MockResponse()
-        .setBody("call2 response")
-    )
-    queueDispatcher.enqueueResponse(
-      MockResponse()
-        .setBody("call1 response")
-    )
 
     // We use a re-entrant dispatcher to initiate one HTTPS connection while the other is in flight.
     server.dispatcher = object : Dispatcher() {
@@ -2028,15 +1979,8 @@ class HttpOverHttp2Test {
   @ArgumentsSource(ProtocolParamProvider::class)
   fun http2WithProxy(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
-    server.enqueue(
+    server.enqueue(MockResponse(inTunnel = true))
-      MockResponse()
+    server.enqueue(MockResponse(body = "ABCDE"))
-        .inTunnel()
-    )
-    server.enqueue(
-      MockResponse()
-        .setBody("ABCDE")
-        .setStatus("HTTP/1.1 200 Sweet")
-    )
     val client = client.newBuilder()
       .proxy(server.toProxyAddress())
       .build()
@@ -2070,19 +2014,14 @@ class HttpOverHttp2Test {
   fun proxyAuthenticateOnConnect(protocol: Protocol, mockWebServer: MockWebServer) {
     setUp(protocol, mockWebServer)
     server.enqueue(
-      MockResponse()
+      MockResponse(
-        .inTunnel()
+        code = 407,
-        .setResponseCode(407)
+        headers = headersOf("Proxy-Authenticate", "Basic realm=\"localhost\""),
-        .addHeader("Proxy-Authenticate: Basic realm=\"localhost\"")
+        inTunnel = true,
-    )
+      )
-    server.enqueue(
-      MockResponse()
-        .inTunnel()
-    )
-    server.enqueue(
-      MockResponse()
-        .setBody("response body")
     )
+    server.enqueue(MockResponse(inTunnel = true))
+    server.enqueue(MockResponse(body = "response body"))
     val client = client.newBuilder()
       .proxy(server.toProxyAddress())
       .proxyAuthenticator(RecordingOkAuthenticator("password", "Basic"))

okhttp/src/jvmTest/java/okhttp3/internal/tls/CertificatePinnerChainValidationTest.java

@@ -101,8 +101,9 @@ public final class CertificatePinnerChainValidationTest {
     server.useHttps(serverHandshakeCertificates.sslSocketFactory());
 
     // The request should complete successfully.
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc"));
+        .body("abc")
+        .build());
     Call call1 = client.newCall(new Request.Builder()
         .url(server.url("/"))
         .build());
@@ -149,9 +150,10 @@ public final class CertificatePinnerChainValidationTest {
     server.useHttps(serverHandshakeCertificates.sslSocketFactory());
 
     // The request should complete successfully.
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc")
+        .body("abc")
-        .setSocketPolicy(SocketPolicy.DISCONNECT_AT_END));
+        .socketPolicy(SocketPolicy.DISCONNECT_AT_END)
+        .build());
     Call call1 = client.newCall(new Request.Builder()
         .url(server.url("/"))
         .build());
@@ -163,9 +165,10 @@ public final class CertificatePinnerChainValidationTest {
     client.connectionPool().evictAll();
 
     // Confirm that a second request also succeeds. This should detect caching problems.
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("def")
+        .body("def")
-        .setSocketPolicy(SocketPolicy.DISCONNECT_AT_END));
+        .socketPolicy(SocketPolicy.DISCONNECT_AT_END)
+        .build());
     Call call2 = client.newCall(new Request.Builder()
         .url(server.url("/"))
         .build());
@@ -233,9 +236,10 @@ public final class CertificatePinnerChainValidationTest {
         compromisedIntermediateCa.certificate(), goodCertificate.certificate());
 
     server.useHttps(socketFactory);
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc")
+        .body("abc")
-        .addHeader("Content-Type: text/plain"));
+        .addHeader("Content-Type: text/plain")
+        .build());
 
     // Make a request from client to server. It should succeed certificate checks (unfortunately the
     // rogue CA is trusted) but it should fail certificate pinning.
@@ -312,9 +316,10 @@ public final class CertificatePinnerChainValidationTest {
     SSLSocketFactory socketFactory = newServerSocketFactory(rogueCertificate,
         goodIntermediateCa.certificate(), compromisedIntermediateCa.certificate());
     server.useHttps(socketFactory);
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc")
+        .body("abc")
-        .addHeader("Content-Type: text/plain"));
+        .addHeader("Content-Type: text/plain")
+        .build());
 
     // Make a request from client to server. It should succeed certificate checks (unfortunately the
     // rogue CA is trusted) but it should fail certificate pinning.
@@ -595,8 +600,9 @@ public final class CertificatePinnerChainValidationTest {
     server.useHttps(serverHandshakeCertificates.sslSocketFactory());
 
     // The request should complete successfully.
-    server.enqueue(new MockResponse()
+    server.enqueue(new MockResponse.Builder()
-        .setBody("abc"));
+        .body("abc")
+        .build());
     Call call1 = client.newCall(new Request.Builder()
         .url(server.url("/"))
         .build());

okhttp/src/jvmTest/java/okhttp3/internal/tls/ClientAuthTest.java

@@ -130,7 +130,9 @@ public final class ClientAuthTest {
 
     server.useHttps(socketFactory);
     server.requestClientAuth();
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder()
+        .body("abc")
+        .build());
 
     Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
     Response response = call.execute();
@@ -148,7 +150,9 @@ public final class ClientAuthTest {
 
     server.useHttps(socketFactory);
     server.requireClientAuth();
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder()
+        .body("abc")
+        .build());
 
     Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
     Response response = call.execute();
@@ -166,7 +170,9 @@ public final class ClientAuthTest {
 
     server.useHttps(socketFactory);
     server.noClientAuth();
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder()
+        .body("abc")
+        .build());
 
     Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
     Response response = call.execute();
@@ -183,7 +189,9 @@ public final class ClientAuthTest {
 
     server.useHttps(socketFactory);
     server.requestClientAuth();
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder()
+        .body("abc")
+        .build());
 
     Call call = client.newCall(new Request.Builder().url(server.url("/")).build());
     Response response = call.execute();
@@ -282,7 +290,9 @@ public final class ClientAuthTest {
   }
 
   @Test public void invalidClientAuthEvents() throws Throwable {
-    server.enqueue(new MockResponse().setBody("abc"));
+    server.enqueue(new MockResponse.Builder()
+        .body("abc")
+        .build());
 
     clientCert = new HeldCertificate.Builder()
         .signedBy(clientIntermediateCa)

okhttp/src/jvmTest/java/okhttp3/internal/ws/WebSocketHttpTest.java

@@ -106,7 +106,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void textMessage() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     WebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -119,7 +121,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void binaryMessage() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     WebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -132,7 +136,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void nullStringThrows() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     WebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -149,7 +155,9 @@ public final class WebSocketHttpTest {
   @Test public void nullByteStringThrows() {
     TestUtil.assumeNotWindows();
 
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     WebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -164,7 +172,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void serverMessage() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     WebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -177,7 +187,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void throwingOnOpenFailsImmediately() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
 
     final RuntimeException e = new RuntimeException();
     clientListener.setNextEventDelegate(new WebSocketListener() {
@@ -195,7 +207,10 @@ public final class WebSocketHttpTest {
 
   @Disabled("AsyncCall currently lets runtime exceptions propagate.")
   @Test public void throwingOnFailLogs() throws Exception {
-    webServer.enqueue(new MockResponse().setResponseCode(200).setBody("Body"));
+    webServer.enqueue(new MockResponse.Builder()
+        .code(200)
+        .body("Body")
+        .build());
 
     final RuntimeException e = new RuntimeException("boom");
     clientListener.setNextEventDelegate(new WebSocketListener() {
@@ -210,7 +225,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void throwingOnMessageClosesImmediatelyAndFails() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     newWebSocket();
 
     clientListener.assertOpen();
@@ -230,7 +247,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void throwingOnClosingClosesImmediatelyAndFails() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     newWebSocket();
 
     clientListener.assertOpen();
@@ -250,7 +269,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void unplannedCloseHandledByCloseWithoutFailure() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     newWebSocket();
 
     clientListener.assertOpen();
@@ -270,7 +291,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void unplannedCloseHandledWithoutFailure() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     newWebSocket();
 
     WebSocket webSocket = clientListener.assertOpen();
@@ -280,7 +303,10 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void non101RetainsBody() throws IOException {
-    webServer.enqueue(new MockResponse().setResponseCode(200).setBody("Body"));
+    webServer.enqueue(new MockResponse.Builder()
+        .code(200)
+        .body("Body")
+        .build());
     newWebSocket();
 
     clientListener.assertFailure(200, "Body", ProtocolException.class,
@@ -288,7 +314,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void notFound() throws IOException {
-    webServer.enqueue(new MockResponse().setStatus("HTTP/1.1 404 Not Found"));
+    webServer.enqueue(new MockResponse.Builder()
+        .status("HTTP/1.1 404 Not Found")
+        .build());
     newWebSocket();
 
     clientListener.assertFailure(404, null, ProtocolException.class,
@@ -296,8 +324,12 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void clientTimeoutClosesBody() {
-    webServer.enqueue(new MockResponse().setResponseCode(408));
+    webServer.enqueue(new MockResponse.Builder()
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+        .code(408)
+        .build());
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     WebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -313,10 +345,11 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void missingConnectionHeader() throws IOException {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .setResponseCode(101)
+        .code(101)
         .setHeader("Upgrade", "websocket")
-        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk="));
+        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
+        .build());
     newWebSocket();
 
     clientListener.assertFailure(101, null, ProtocolException.class,
@@ -324,11 +357,12 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void wrongConnectionHeader() throws IOException {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .setResponseCode(101)
+        .code(101)
         .setHeader("Upgrade", "websocket")
         .setHeader("Connection", "Downgrade")
-        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk="));
+        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
+        .build());
     newWebSocket();
 
     clientListener.assertFailure(101, null, ProtocolException.class,
@@ -336,10 +370,11 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void missingUpgradeHeader() throws IOException {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .setResponseCode(101)
+        .code(101)
         .setHeader("Connection", "Upgrade")
-        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk="));
+        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
+        .build());
     newWebSocket();
 
     clientListener.assertFailure(101, null, ProtocolException.class,
@@ -347,11 +382,12 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void wrongUpgradeHeader() throws IOException {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .setResponseCode(101)
+        .code(101)
         .setHeader("Connection", "Upgrade")
         .setHeader("Upgrade", "Pepsi")
-        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk="));
+        .setHeader("Sec-WebSocket-Accept", "ujmZX4KXZqjwy6vi1aQFH5p4Ygk=")
+        .build());
     newWebSocket();
 
     clientListener.assertFailure(101, null, ProtocolException.class,
@@ -359,10 +395,11 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void missingMagicHeader() throws IOException {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .setResponseCode(101)
+        .code(101)
         .setHeader("Connection", "Upgrade")
-        .setHeader("Upgrade", "websocket"));
+        .setHeader("Upgrade", "websocket")
+        .build());
     newWebSocket();
 
     clientListener.assertFailure(101, null, ProtocolException.class,
@@ -370,11 +407,12 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void wrongMagicHeader() throws IOException {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .setResponseCode(101)
+        .code(101)
         .setHeader("Connection", "Upgrade")
         .setHeader("Upgrade", "websocket")
-        .setHeader("Sec-WebSocket-Accept", "magic"));
+        .setHeader("Sec-WebSocket-Accept", "magic")
+        .build());
     newWebSocket();
 
     clientListener.assertFailure(101, null, ProtocolException.class,
@@ -406,7 +444,9 @@ public final class WebSocketHttpTest {
         })
         .build();
 
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
 
     WebSocket webSocket = newWebSocket();
     clientListener.assertOpen();
@@ -422,7 +462,9 @@ public final class WebSocketHttpTest {
         })
         .build();
 
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
 
     WebSocket webSocket = newWebSocket();
     clientListener.assertOpen();
@@ -432,7 +474,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void overflowOutgoingQueue() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
 
     WebSocket webSocket = newWebSocket();
     clientListener.assertOpen();
@@ -466,7 +510,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void closeReasonMaximumLength() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
 
     String clientReason = repeat('C', 123);
     String serverReason = repeat('S', 123);
@@ -486,7 +532,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void closeReasonTooLong() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
 
     WebSocket webSocket = newWebSocket();
     WebSocket server = serverListener.assertOpen();
@@ -543,8 +591,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void readTimeoutAppliesToHttpRequest() {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .setSocketPolicy(SocketPolicy.NO_RESPONSE));
+        .socketPolicy(SocketPolicy.NO_RESPONSE)
+        .build());
 
     WebSocket webSocket = newWebSocket();
 
@@ -561,9 +610,10 @@ public final class WebSocketHttpTest {
     webServer.setDispatcher(new Dispatcher() {
       @Override public MockResponse dispatch(RecordedRequest request) {
         return upgradeResponse(request)
-            .setBody(new Buffer().write(ByteString.decodeHex("81"))) // Truncated frame.
+            .body(new Buffer().write(ByteString.decodeHex("81"))) // Truncated frame.
             .removeHeader("Content-Length")
-            .setSocketPolicy(SocketPolicy.KEEP_OPEN);
+            .socketPolicy(SocketPolicy.KEEP_OPEN)
+            .build();
       }
     });
 
@@ -575,7 +625,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void readTimeoutDoesNotApplyAcrossFrames() throws Exception {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     WebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -595,7 +647,9 @@ public final class WebSocketHttpTest {
         .pingInterval(Duration.ofMillis(500))
         .build();
 
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     RealWebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -623,7 +677,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void clientDoesNotPingServerByDefault() throws Exception {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     RealWebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -656,15 +712,17 @@ public final class WebSocketHttpTest {
 
     // Stall in onOpen to prevent pongs from being sent.
     final CountDownLatch latch = new CountDownLatch(1);
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(new WebSocketListener() {
+    webServer.enqueue(new MockResponse.Builder()
-      @Override public void onOpen(WebSocket webSocket, Response response) {
+      .webSocketUpgrade(new WebSocketListener() {
-        try {
+        @Override public void onOpen(WebSocket webSocket, Response response) {
-          latch.await(); // The server can't respond to pings!
+          try {
-        } catch (InterruptedException e) {
+            latch.await(); // The server can't respond to pings!
-          throw new AssertionError(e);
+          } catch (InterruptedException e) {
+            throw new AssertionError(e);
+          }
         }
-      }
+      })
-    }));
+      .build());
 
     long openAtNanos = System.nanoTime();
     newWebSocket();
@@ -680,7 +738,9 @@ public final class WebSocketHttpTest {
 
   /** https://github.com/square/okhttp/issues/2788 */
   @Test public void clientCancelsIfCloseIsNotAcknowledged() {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     RealWebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -709,7 +769,9 @@ public final class WebSocketHttpTest {
         .eventListenerFactory(clientTestRule.wrap(listener))
         .build();
 
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
     WebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -730,8 +792,9 @@ public final class WebSocketHttpTest {
   }
 
   @Test public void callTimeoutAppliesToSetup() throws Exception {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .setHeadersDelay(500, TimeUnit.MILLISECONDS));
+        .headersDelay(500, TimeUnit.MILLISECONDS)
+        .build());
 
     client = client.newBuilder()
         .readTimeout(Duration.ZERO)
@@ -748,8 +811,9 @@ public final class WebSocketHttpTest {
         .callTimeout(Duration.ofMillis(100))
         .build();
 
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .withWebSocketUpgrade(serverListener));
+        .webSocketUpgrade(serverListener)
+        .build());
     WebSocket webSocket = newWebSocket();
 
     clientListener.assertOpen();
@@ -774,9 +838,10 @@ public final class WebSocketHttpTest {
         .protocols(asList(Protocol.HTTP_1_1))
         .build();
 
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
-        .setResponseCode(HttpURLConnection.HTTP_NOT_FOUND)
+        .code(HttpURLConnection.HTTP_NOT_FOUND)
-        .setBody("not found!"));
+        .body("not found!")
+        .build());
     webServer.enqueue(new MockResponse());
 
     newWebSocket();
@@ -835,9 +900,10 @@ public final class WebSocketHttpTest {
   }
 
   private void successfulExtensions(String extensionsHeader) throws Exception {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
         .addHeader("Sec-WebSocket-Extensions", extensionsHeader)
-        .withWebSocketUpgrade(serverListener));
+        .webSocketUpgrade(serverListener)
+        .build());
 
     WebSocket client = newWebSocket();
     clientListener.assertOpen();
@@ -881,9 +947,10 @@ public final class WebSocketHttpTest {
   }
 
   private void extensionNegotiationFailure(String extensionsHeader) throws Exception {
-    webServer.enqueue(new MockResponse()
+    webServer.enqueue(new MockResponse.Builder()
         .addHeader("Sec-WebSocket-Extensions", extensionsHeader)
-        .withWebSocketUpgrade(serverListener));
+        .webSocketUpgrade(serverListener)
+        .build());
 
     newWebSocket();
     clientListener.assertOpen();
@@ -899,17 +966,19 @@ public final class WebSocketHttpTest {
     serverListener.assertExhausted();
   }
 
-  private MockResponse upgradeResponse(RecordedRequest request) {
+  private MockResponse.Builder upgradeResponse(RecordedRequest request) {
     String key = request.getHeader("Sec-WebSocket-Key");
-    return new MockResponse()
+    return new MockResponse.Builder()
-        .setStatus("HTTP/1.1 101 Switching Protocols")
+        .status("HTTP/1.1 101 Switching Protocols")
         .setHeader("Connection", "Upgrade")
         .setHeader("Upgrade", "websocket")
         .setHeader("Sec-WebSocket-Accept", WebSocketProtocol.INSTANCE.acceptHeader(key));
   }
 
   private void websocketScheme(String scheme) {
-    webServer.enqueue(new MockResponse().withWebSocketUpgrade(serverListener));
+    webServer.enqueue(new MockResponse.Builder()
+        .webSocketUpgrade(serverListener)
+        .build());
 
     Request request = new Request.Builder()
         .url(scheme + "://" + webServer.getHostName() + ":" + webServer.getPort() + "/")

samples/compare/src/test/kotlin/okhttp3/compare/ApacheHttpClientTest.kt

@@ -39,8 +39,9 @@ class ApacheHttpClientTest {
   }
 
   @Test fun get(server: MockWebServer) {
-    server.enqueue(MockResponse()
+    server.enqueue(MockResponse.Builder()
-        .setBody("hello, Apache HttpClient 5.x"))
+        .body("hello, Apache HttpClient 5.x")
+        .build())
 
     val request = HttpGet(server.url("/").toUri())
     request.addHeader("Accept", "text/plain")

samples/compare/src/test/kotlin/okhttp3/compare/JavaHttpClientTest.kt

@@ -44,8 +44,9 @@ class JavaHttpClientTest {
       .followRedirects(NORMAL)
       .build()
 
-    server.enqueue(MockResponse()
+    server.enqueue(MockResponse.Builder()
-        .setBody("hello, Java HTTP Client"))
+        .body("hello, Java HTTP Client")
+        .build())
 
     val request = HttpRequest.newBuilder(server.url("/").toUri())
         .header("Accept", "text/plain")

samples/compare/src/test/kotlin/okhttp3/compare/JettyHttpClientTest.kt

@@ -42,8 +42,7 @@ class JettyHttpClientTest {
   }
 
   @Test fun get(server: MockWebServer) {
-    server.enqueue(MockResponse()
+    server.enqueue(MockResponse(body = "hello, Jetty HTTP Client"))
-        .setBody("hello, Jetty HTTP Client"))
 
     val request = client.newRequest(server.url("/").toUri())
         .header("Accept", "text/plain")

samples/compare/src/test/kotlin/okhttp3/compare/OkHttpClientTest.kt

@@ -35,8 +35,7 @@ class OkHttpClientTest {
   @Test fun get(server: MockWebServer) {
     platform.assumeNotBouncyCastle()
 
-    server.enqueue(MockResponse()
+    server.enqueue(MockResponse(body = "hello, OkHttp"))
-        .setBody("hello, OkHttp"))
 
     val client = OkHttpClient()