// Arrange
        TransWaitNamedPipeResponse resp = new TransWaitNamedPipeResponse();
        // Act & Assert - no exceptions should be thrown
        assertDoesNotThrow(() -> resp.writeSetupWireFormat(null, 0));
        assertDoesNotThrow(() -> resp.writeParametersWireFormat(null, 0));
        assertDoesNotThrow(() -> resp.writeDataWireFormat(null, 0));
        assertDoesNotThrow(() -> resp.readSetupWireFormat(null, 0, 0));

    client = TestClient(app)
    resp = client.get(
        "/query",
        params={
            "param": "123",
            "param2": "456",
        },
    )
    assert resp.status_code == 200
    assert resp.json() == {
        "param": "123",
        "param2": "456",
    }


def test_header_pass_extra_list():
    client = TestClient(app)

    resp = client.get(
        "/header",

    private SmbComWriteResponse resp;
    private Configuration cfgMock;

    @BeforeEach
    public void setUp() {
        // create a mock configuration that satisfies constructor requirements.
        cfgMock = mock(Configuration.class);
        resp = new SmbComWriteResponse(cfgMock);
    }

    @Test
    public void testInitialCountIsZero() {
        assertEquals(0, resp.getCount(), "Initial count should be zero");

            }
        } else {
            resp.setHeader("WWW-Authenticate", "NTLM");
        }
        resp.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        resp.setContentLength(0);
        resp.flushBuffer();
        return null;
    }

		}
	}
}

func fwdStatusToAPIError(statusCode int, resp *http.Response) *APIError {
	if statusCode < http.StatusBadRequest {
		return nil
	}
	desc := resp.Header.Get(xhttp.AmzFwdErrorMessage)
	if strings.TrimSpace(desc) == "" {
		apiErr := errorCodes.ToAPIErr(ErrInvalidRequest)
		return &apiErr
	}
	code := resp.Header.Get(xhttp.AmzFwdErrorCode)
	if strings.TrimSpace(code) == "" {

	ctx, cancel := context.WithTimeout(context.Background(), dsync.DefaultTimeouts.RefreshCall)
	defer cancel()

	resp := lockRPCRefresh.NewResponse()
	refreshed, err := l.ll.Refresh(ctx, *args)
	if err != nil {
		return l.makeResp(resp, err)
	}
	if !refreshed {
		return l.makeResp(resp, errLockNotFound)
	}
	return l.makeResp(resp, err)
}

// LockHandler - Acquires a lock.

        int decoded = resp.decode(buf, headerStart);
        assertTrue(decoded > 0, "Decode should return positive length");

        assertEquals(NtStatus.NT_STATUS_MORE_PROCESSING_REQUIRED, resp.getStatus());
        assertArrayEquals(blob, resp.getBlob(), "Security blob should match");
        assertEquals(sessionFlags, resp.getSessionFlags(), "Session flags should decode");

    void constructor_happyPath() {
        // Arrange
        Configuration cfg = Mockito.mock(Configuration.class);

        // Act
        Smb2LogoffResponse resp = new Smb2LogoffResponse(cfg);

        // Assert
        assertNotNull(resp, "Response instance should be created");
    }

    @Nested
    @DisplayName("writeBytesWireFormat")
    class WriteBytesWireFormat {

        @ParameterizedTest

	if o.args.AuthToken != "" {
		req.Header.Set("Authorization", o.args.AuthToken)
	}

	resp, err := o.client.Do(req)
	if err != nil {
		return false, err
	}
	defer o.args.CloseRespFn(resp.Body)

	// Read the body to be saved later.
	opaRespBytes, err := io.ReadAll(resp.Body)
	if err != nil {
		return false, err
	}

	// Handle large OPA responses when OPA URL is of

            }

            if (!resp.isReceived()) {
                throw new CIFSException("Did not receive response");
            }

            if (resp.getErrorCode() == 0x10B) {
                this.handle.markClosed();
            }
            if (resp.getErrorCode() == 0x10C) {
                resp.getNotifyInformation().clear();
            }