if (offerBasic) {
                    resp.addHeader("WWW-Authenticate", "Basic realm=\"" + realm + "\"");
                }
                resp.setHeader("Connection", "close");
                resp.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                resp.flushBuffer();
                return;
            }
        }

        try {
            SmbFile file;

            if (ntlm != null) {

        // Simulate successful negotiation for skeleton implementation
        RdmaNegotiateResponse response = new RdmaNegotiateResponse();
        response.setStatus(0); // Success
        response.setSelectedVersion(request.getMaxVersion());
        response.setCreditsGranted(request.getCreditsRequested());
        response.setMaxReceiveSize(request.getMaxReceiveSize());

	for _, disk := range si.Disks {
		setIdx := fmt.Sprintf("%d-%d", disk.PoolIndex, disk.SetIndex)
		indexed[setIdx] = append(indexed[setIdx], disk)
	}

	for id, disks := range indexed {
		ss := madmin.SetStatus{
			ID:        id,
			SetIndex:  disks[0].SetIndex,
			PoolIndex: disks[0].PoolIndex,
		}
		for _, disk := range disks {
			ss.Disks = append(ss.Disks, disk)
			if disk.Healing {

      assertThat(headersToList(response)).containsExactly("Content-Length: 0")
    }
  }

  @Test
  fun setStatusControlsWholeStatusLine() {
    val response = MockResponse().setStatus("HTTP/1.1 202 That'll do pig")
    assertThat(headersToList(response)).containsExactly("Content-Length: 0")
    assertThat(response.status).isEqualTo("HTTP/1.1 202 That'll do pig")
  }

  @Test

     */
    protected void writeJsonResponse(final HttpServletResponse response, final int status, final Map<String, Object> data)
            throws IOException {
        response.setStatus(status);
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(objectMapper.writeValueAsString(data));
    }

    /**

        for (final OpenSearchAccessResult accessResult : arList) {
            if (logger.isDebugEnabled()) {
                logger.debug("Indexing: url={}", accessResult.getUrl());
            }
            accessResult.setStatus(Constants.DONE_STATUS);
            accessResultList.add(accessResult);

            if (accessResult.getHttpStatusCode() != 200) {
                // invalid page
                if (logger.isDebugEnabled()) {

            responseData.setParentUrl("http://fess.codelibs.org/");
            responseData.setResponseBody(data.getBytes());
            responseData.setSessionId("test-1");
            responseData.setStatus(0);
            responseData.setUrl("http://fess.codelibs.org/test.html");
            /*ResultData resultData =*/fessXpathTransformer.transform(responseData);
            // System.out.println(resultData.toString());

 public:
  explicit TestUnavailableErrorOp(tensorflow::OpKernelConstruction* ctx)
      : tensorflow::OpKernel(ctx) {}
  void Compute(tensorflow::OpKernelContext* ctx) override {
    ctx->SetStatus(tensorflow::errors::Unavailable("Test error."));
  }
};
REGISTER_KERNEL_BUILDER(
    Name("TestNonCommUnavailable").Device(tensorflow::DEVICE_DEFAULT),
    TestUnavailableErrorOp);
REGISTER_KERNEL_BUILDER(