protected NtlmPasswordAuthentication negotiate(HttpServletRequest req, HttpServletResponse resp, boolean skipAuthentication)
                    throws IOException, ServletException {
                if (skipAuthentication) {
                    return null;
                }
                return super.negotiate(req, resp, skipAuthentication);
            }

            @Override

    void testConstructorWithConfiguration() {
        // Given & When
        Smb2TreeDisconnectResponse resp = new Smb2TreeDisconnectResponse(mockConfig);

        // Then
        assertNotNull(resp);
        assertTrue(resp instanceof ServerMessageBlock2Response);
        assertTrue(resp instanceof ServerMessageBlock2);
    }

    @Test
    @DisplayName("Should write empty bytes to wire format")

                (short) negoReq.getSecurityMode(), negoReq.getDialects()));

        Smb2IoctlResponse resp;
        try {
            resp = send(req, RequestParam.NO_RETRY);
        } catch (final SMBSignatureValidationException e) {
            throw new SMBProtocolDowngradeException("Signature error during negotiate validation", e);

     */
    @Override
    public SmbComNTCreateAndXResponse initResponse(final CIFSContext tc) {
        final SmbComNTCreateAndXResponse resp = new SmbComNTCreateAndXResponse(tc.getConfig());
        setResponse(resp);
        return resp;
    }

    /**
     * Adds flags to the flags0 field.
     *
     * @param fl
     *            the flags0 to set
     */

	}

	resp, err := h.client.Do(req)
	if err != nil {
		return fmt.Errorf("%s returned '%w', please check your endpoint configuration", h.Endpoint(), err)
	}

	// Drain any response.
	xhttp.DrainBody(resp.Body)

	if resp.StatusCode >= 200 && resp.StatusCode <= 299 {
		// accepted HTTP status codes.
		return nil
	} else if resp.StatusCode == http.StatusForbidden {

    @DisplayName("Should create response with configuration")
    void testConstructor() {
        // When
        Smb2NegotiateResponse resp = new Smb2NegotiateResponse(mockConfig);

        // Then
        assertNotNull(resp);
        assertTrue(resp instanceof ServerMessageBlock2Response);
        assertTrue(resp instanceof SmbNegotiationResponse);
    }

    @Test
    @DisplayName("Should return initial credits from getCredit")

		# Write object back to S3 Object Lambda
		# response sends the transformed data
		# back to MinIO and then to the user
		resp = make_response(transformed_object, 200)
		resp.headers['x-amz-request-route'] = request_route
		resp.headers['x-amz-request-token'] = request_token
		return resp

	else:
		abort(400)

if __name__ == '__main__':
	app.run()
```

				t.Fatal(err)
			}

			w := &testResponseWriter{}
			s3Select.Evaluate(w)
			s3Select.Close()
			resp := http.Response{
				StatusCode:    http.StatusOK,
				Body:          io.NopCloser(bytes.NewReader(w.response)),
				ContentLength: int64(len(w.response)),
			}
			res, err := minio.NewSelectResults(&resp, "testbucket")
			if err != nil {
				t.Error(err)
				return
			}
			got, err := io.ReadAll(res)

     */
    private static void setResults(Smb2QueryDirectoryResponse resp, FileEntry[] results) throws Exception {
        Field f = Smb2QueryDirectoryResponse.class.getDeclaredField("results");
        f.setAccessible(true);
        f.set(resp, results);
    }

    /**
     * Reflectively set the 'status' on a SMB2 response to drive control flow.
     */

		for update := range updates {
			resp := storageNSScannerRPC.NewResponse()
			resp.Update = &update
			out <- resp
		}
	}()
	ui, err := s.getStorage().NSScanner(ctx, *params.Cache, updates, madmin.HealScanMode(params.ScanMode), nil)
	wg.Wait()
	if err != nil {
		return grid.NewRemoteErr(err)
	}
	// Send final response.
	resp := storageNSScannerRPC.NewResponse()
	resp.Final = &ui
	out <- resp
	return nil