val result = mockwebserver3.MockResponse.Builder()
  val copyFromWebSocketListener = webSocketListener
  if (copyFromWebSocketListener != null) {
    result.webSocketUpgrade(copyFromWebSocketListener)
  }

  val body = getBody()
  if (body != null) result.body(body)

  for (pushPromise in pushPromises) {
    result.addPush(pushPromise.wrap())
  }

  result.settings(settings)
  result.status(status)
  result.headers(headers)

            final String schedulerId = getSchedulerIds(namePrefix).get(0);
            final Response response = checkMethodBase(requestBody).put("/api/admin/scheduler/" + schedulerId + "/start");
            if (response.getBody().jsonPath().getInt("response.status") == 0) {
                logger.info("Start scheduler \"{}\"", schedulerId);
                return;
            }
            ThreadUtil.sleep(1000L);
        }

RecordedRequest request = server.takeRequest();
assertEquals("POST /v1/chat/send HTTP/1.1", request.getRequestLine());
assertEquals("application/json; charset=utf-8", request.getHeaders().get("Content-Type"));
assertEquals("{}", request.getBody().readUtf8());
```

### Kotlin
```kotlin
val request = server.takeRequest()
assertEquals("POST /v1/chat/send HTTP/1.1", request.requestLine)

    assertThat(response.status).isEqualTo("HTTP/1.1 202 That'll do pig")
  }

  @Test
  fun setBodyAdjustsHeaders() {
    val response = MockResponse().setBody("ABC")
    assertThat(headersToList(response)).containsExactly("Content-Length: 3")
    assertThat(response.getBody()!!.readUtf8()).isEqualTo("ABC")
  }

  @Test
  fun mockResponseAddHeader() {
    val response =
      MockResponse()
        .clearHeaders()

            when(mockReferral.getNode()).thenReturn("\\server1\\share1\\path1");
            first = DfsReferralDataImpl.fromReferral(mockReferral, "\\\\server1\\share1\\path1", System.currentTimeMillis() + 10000, 20);

            // Setup second referral
            DfsReferralDataImpl second = new DfsReferralDataImpl();
            when(mockReferral.getNode()).thenReturn("\\server2\\share2\\path2");

        assertNotNull(referral.getRpath());
        assertNotNull(referral.getAltPath());
        assertNotNull(referral.getNode());
        assertEquals("\\\\server\\\\share", referral.getRpath());
        assertEquals("\\\\alt\\\\path", referral.getAltPath());
        assertEquals("NODE01", referral.getNode());

        String result = referral.toString();

        assertTrue(result.contains("Referral["));

     * to call getCopy and removeAllNodes only with a true K, then we could check containsKey first.
     * But that check wouldn't eliminate the warnings.)
     */
    @SuppressWarnings({"unchecked", "nullness"})
    K castKey = (K) key;
    List<V> oldValues = getCopy(castKey);
    removeAllNodes(castKey);
    return oldValues;
  }

  @Override

      call.execute()
    }
  }

  @Test
  fun interruptReadingResponseBody() {
    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
    server.enqueue(
      MockResponse()
        .setBody(Buffer().write(ByteArray(responseBodySize)))
        .throttleBody((64 * 1024).toLong(), 125, TimeUnit.MILLISECONDS),
    ) // 500 Kbps
    server.start()
    val call =
      client.newCall(
        Request

     */
    public final String getRpath() {
        return this.rpath;
    }

    /**
     * Gets the node name for this referral.
     *
     * @return the node
     */
    public final String getNode() {
        return this.node;
    }

    /**
     * Gets the special name for this referral.
     *
     * @return the specialName
     */
    public final String getSpecialName() {

            dr.pathConsumed = consumed;
        } else {
            if (log.isDebugEnabled()) {
                log.debug("Node " + ref.getNode() + " path " + reqPath + " remain " + reqPath.substring(consumed) + " path consumed "
                        + consumed);
            }
            dfsPathSplit(ref.getNode(), arr);
            dr.server = arr[1];
            dr.share = arr[2];
            dr.path = arr[3];