req, err := newTestRequest(http.MethodPost, resource, 0, nil)
	if err != nil {
		return nil, err
	}

	// management REST API uses signature V4 for authentication.
	err = signRequestV4(req, cred.AccessKey, cred.SecretKey)
	if err != nil {
		return nil, err
	}
	return req, nil
}

     *
     * @param <REQ> The type of the request
     * @param <REP> The type of the response
     * @param message The error message describing the batch operation failure
     * @param allResults List of results from all attempted requests in the batch
     */
    public <REQ extends Request<?>, REP extends Result<REQ>> BatchRequestException(

     * @throws IOException
     */
    private int negotiateWrite(final CommonServerMessageBlockRequest req, final boolean setmid) throws IOException {
        if (setmid) {
            makeKey(req);
        } else {
            req.setMid(0);
            this.mid.set(1);
        }
        final int n = req.encode(this.sbuf, 4);
        Encdec.enc_uint32be(n & 0xFFFF, this.sbuf, 0); /* 4 byte ssn msg header */

	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(buf))
	if err != nil {
		return err
	}

	if token != "" {
		req.Header.Set("Authorization", token)
	}
	req.Header.Set("Content-Type", "application/json")

	clnt := http.Client{Transport: getRemoteInstanceTransport()}
	resp, err := clnt.Do(req)
	if err != nil {
		return err
	}

	rec := httptest.NewRecorder()
	req, err := newTestSignedRequestV4(http.MethodPut, getPutPolicyURL("", bucketName), int64(len(policyBytes)), bytes.NewReader(policyBytes),
		credentials.AccessKey, credentials.SecretKey, nil)
	if err != nil {
		t.Fatalf("Failed to create HTTP request for PutBucketPolicyHandler: <ERROR> %v", err)
	}
	apiRouter.ServeHTTP(rec, req)
	if rec.Code != http.StatusNoContent {

            if (th.isSMB2()) {
                final Smb2IoctlRequest req = new Smb2IoctlRequest(th.getConfig(), Smb2IoctlRequest.FSCTL_PIPE_PEEK, fd.getFileId());
                req.setMaxOutputResponse(16);
                req.setFlags(Smb2IoctlRequest.SMB2_O_IOCTL_IS_FSCTL);
                final Smb2IoctlResponse resp = th.send(req, RequestParam.NO_RETRY);

        List<Profile> profiles = profileSelector.getActiveProfiles(profilesById.values(), context, req -> {
            if (!ModelProblem.Severity.WARNING.equals(req.getSeverity())) {
                errors.add(new ProfileActivationException(req.getMessage(), req.getException()));
            }
        });

        if (!errors.isEmpty()) {
            throw errors.get(0);
        }

     */
    return (int) Math.pow(a, 1.0 / concentration);
  }

  @AfterExperiment
  void tearDown() {
    double req = requests.get();
    double hit = req - misses.get();

    // Currently, this is going into /dev/null, but I'll fix that
    System.out.println("hit rate: " + hit / req);
  }

  // for proper distributions later:
  // import JSci.maths.statistics.ProbabilityDistribution;

		if testCase.removeAuthHeader {
			req.Header.Del("Authorization")
		}
		switch testCase.fault {
		case malformedEncoding:
			req, err = malformChunkSizeSigV4(req, testCase.chunkSize-1)
		case signatureMismatch:
			req, err = malformDataSigV4(req, 'z')
		case unexpectedEOF:
			req, err = truncateChunkByHalfSigv4(req)
		case tooBigDecodedLength:

        when(tree.acquire(false)).thenReturn(tree);

        CommonServerMessageBlockRequest req = mock(CommonServerMessageBlockRequest.class);
        CommonServerMessageBlockResponse resp = mock(CommonServerMessageBlockResponse.class);

        // Configure the tree to throw transport error on first call, succeed on second
        when(tree.send(eq(req), eq(resp), anySet()))