super(config, SMB2_LOGOFF);
    }

    @Override
    protected Smb2LogoffResponse createResponse(final CIFSContext tc, final ServerMessageBlock2Request<Smb2LogoffResponse> req) {
        return new Smb2LogoffResponse(tc.getConfig());
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override

        super(config, SMB2_ECHO);
    }

    @Override
    protected Smb2EchoResponse createResponse(final CIFSContext tc, final ServerMessageBlock2Request<Smb2EchoResponse> req) {
        return new Smb2EchoResponse(tc.getConfig());
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override

        final LuceneQueryParser parser = new LuceneQueryParser(defaultField, analyzer);
        parser.setAllowLeadingWildcard(allowLeadingWildcard);
        LaRequestUtil.getOptionalRequest().ifPresent(req -> {
            if (req.getAttribute(Constants.DEFAULT_QUERY_OPERATOR) instanceof final String op) {
                parser.setDefaultOperator(Operator.valueOf(op));
            } else {

	},
) {
	for i, testCase := range testCases {
		// initialize httptest Recorder, this records any mutations to response writer inside the handler.
		rec := httptest.NewRecorder()
		// construct HTTP request
		req, err := newTestSignedRequestV4(testCase.method, getBucketLifecycleURL("", testCase.bucketName),
			int64(len(testCase.body)), bytes.NewReader(testCase.body), testCase.accessKey, testCase.secretKey, nil)
		if err != nil {

}

func (client *storageRESTClient) DeleteBulk(ctx context.Context, volume string, paths ...string) (err error) {
	values := make(url.Values)
	values.Set(storageRESTVolume, volume)

	req := &DeleteBulkReq{Paths: paths}
	body, err := req.MarshalMsg(nil)
	if err != nil {
		return err
	}

	respBody, err := client.call(ctx, storageRESTMethodDeleteBulk, values, bytes.NewReader(body), int64(len(body)))
	if err != nil {

        private static final long serialVersionUID = 1L;

        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            // Do nothing - just for testing
        }

        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            // Do nothing - just for testing
        }
    }

	c.Assert(response.StatusCode, http.StatusOK)

	req, err := http.NewRequest(http.MethodPut, getPutObjectURL(s.endPoint, bucketName, "test-cve-object.txt"), nil)
	c.Assert(err, nil)

	req.Body = io.NopCloser(bytes.NewReader([]byte("foobar!\n")))
	req.Trailer = http.Header{}
	req.Trailer.Set("x-amz-checksum-crc32", "rK0DXg==")

	now := UTCNow()

	req = signer.StreamingUnsignedV4(req, "", 8, now)

	maliciousHeaders := http.Header{

                final int index = i;
                threads[i] = new Thread(() -> {
                    try {
                        Smb2EchoRequest req = new Smb2EchoRequest(mockConfig);
                        byte[] buffer = new byte[100];
                        int written = req.writeBytesWireFormat(buffer, 0);
                        success[index] = (written == 4 && SMBUtil.readInt2(buffer, 0) == 4);

}

func parseDiscoveryDoc(ustr string) (DiscoveryDoc, error) {
	d := DiscoveryDoc{}
	req, err := http.NewRequest(http.MethodGet, ustr, nil)
	if err != nil {
		return d, err
	}
	clnt := http.Client{
		Transport: http.DefaultTransport,
	}
	resp, err := clnt.Do(req)
	if err != nil {
		return d, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {

        super(config, SMB2_FLUSH);
        this.fileId = fileId;
    }

    @Override
    protected Smb2FlushResponse createResponse(final CIFSContext tc, final ServerMessageBlock2Request<Smb2FlushResponse> req) {
        return new Smb2FlushResponse(tc.getConfig());
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.RequestWithFileId#setFileId(byte[])
     */
    @Override