anonymous = true;
                    }

                    if (request.getDigest() != null) {
                        /* success - install the signing digest */
                        log.debug("Setting digest");
                        setDigest(request.getDigest());
                    }

                    token = response.getBlob();

    // Send messages until the client's outgoing buffer overflows!
    val message: ByteString = ByteString.of(*ByteArray(1024 * 1024))
    var messageCount: Long = 0
    while (true) {
      val success = webSocket.send(message)
      if (!success) break
      messageCount++
      val queueSize = webSocket.queueSize()
      assertThat(queueSize).isBetween(0L, messageCount * message.size)
      // Expect to fail before enqueueing 32 MiB.

            this.set(true);
            return "cause=[Because this test isn't done]";
          }
        };
    assertThat(testFuture.toString())
        .matches("[^\\[]+\\[status=SUCCESS, result=\\[java.lang.Boolean@\\w+\\]\\]");
  }

  /**
   * This test attempts to cause a future to wait for longer than it was requested to from a timed

        // For TCP fallback, we simulate successful negotiation
        RdmaNegotiateResponse response = new RdmaNegotiateResponse();
        response.setStatus(0); // Success
        response.setSelectedVersion(request.getMaxVersion());
        response.setCreditsGranted(request.getCreditsRequested());
        response.setMaxReceiveSize(Math.min(request.getMaxReceiveSize(), 65536));

                windowStart = now;
            }

            recentAttempts.incrementAndGet();
            lastAttempt = now;
        }

        void recordSuccess() {
            // Reduce counter on success to allow recovery
            recentAttempts.updateAndGet(val -> Math.max(0, val - 1));
        }

        void reset() {
            recentAttempts.set(0);
            blocked.set(false);

        resp.prepare(nextReq);
        assertEquals(expectedSessionId, nextReq.getSessionId(), "prepare() should propagate sessionId");
    }

    @Test
    @DisplayName("Decode with SUCCESS should parse body and non-guest flag")
    void testDecodeSuccessParsesBody() throws Exception {
        Smb2SessionSetupResponse resp = newResponse();

        byte[] buf = new byte[256];
        int headerStart = 0;

	mimeXML mimeType = "application/xml"
)

// writeSuccessResponseJSON writes success headers and response if any,
// with content-type set to `application/json`.
func writeSuccessResponseJSON(w http.ResponseWriter, response []byte) {
	writeResponse(w, http.StatusOK, response, mimeJSON)
}

// writeSuccessResponseXML writes success headers and response if any,
// with content-type set to `application/xml`.

                    }
                    return addrs; // Success
                default:
                    throw new UnknownHostException(hostname);
                }

                if (addr != null) { // Success
                    if (log.isDebugEnabled()) {

		},
	}
}

// Wrapper for calling Create Bucket and ensure we get one and only one success.
func TestCreateBucket(t *testing.T) {
	ExecObjectLayerAPITest(ExecObjectLayerAPITestArgs{t: t, objAPITest: testCreateBucket, endpoints: []string{"MakeBucket"}})
}

// testCreateBucket - Test for calling Create Bucket and ensure we get one and only one success.
func testCreateBucket(obj ObjectLayer, instanceType, bucketName string, apiRouter http.Handler,

					logger.Fatal(errInvalidArgument, "Unable to use the drive %s: %v", endpoints[i], err)
				}
			}
		}
	}

	// Pre-emptively check if one of the formatted disks
	// is invalid. This function returns success for the
	// most part unless one of the formats is not consistent
	// with expected Erasure format. For example if a user is
	// trying to pool FS backend into an Erasure set.