configField.setAccessible(true);
            assertEquals(mockConfig, configField.get(request));
        }

        @Test
        @DisplayName("Should handle null configuration")
        void testConstructorWithNullConfig() {
            assertDoesNotThrow(() -> {
                Smb2EchoRequest request = new Smb2EchoRequest(null);
                assertNotNull(request);

import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.smb2.create.CreateContextResponse;

/**
 * SMB2 Durable Handle Response Create Context
 *
 * MS-SMB2 Section 2.2.14.2.3
 */
public class DurableHandleResponse implements CreateContextResponse {

    /**
     * Context name for durable handle response
     */
    public static final String CONTEXT_NAME = "DHnQ";

        this.registrationId = registrationId;
    }

    /**
     * Gets the context handle.
     *
     * @return the context handle
     */
    public byte[] getContextHandle() {
        return contextHandle;
    }

    /**
     * Sets the context handle.
     *
     * @param contextHandle the context handle
     */
    public void setContextHandle(byte[] contextHandle) {

     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        if (this.handle == null || !this.handle.isValid()) {
            // one extra acquire to keep this open till the stream is released
            if (this.file instanceof SmbNamedPipe) {
                this.handle = this.file.openUnshared(SmbConstants.O_EXCL, ((SmbNamedPipe) this.file).getPipeType() & 0xFF0000, this.sharing,

package jcifs.internal.smb2.persistent;

/**
 * Constants for SMB2/3 durable and persistent handle capabilities.
 */
public final class Smb2HandleCapabilities {

    /**
     * Flag indicating persistent handle capability
     */
    public static final int SMB2_DHANDLE_FLAG_PERSISTENT = 0x00000002;

    /**
     * Default timeout for durable handles (2 minutes)
     */
    public static final long DEFAULT_DURABLE_TIMEOUT = 120000;

package jcifs.dcerpc.msrpc;

/**
 * MSRPC implementation for opening an LSA policy handle.
 * This class provides functionality to open a handle to the LSA policy
 * database on a remote server using the LSA RPC interface.
 */
public class MsrpcLsarOpenPolicy2 extends lsarpc.LsarOpenPolicy2 {

    /**
     * Creates a new request to open an LSA policy handle.
     *
     * @param server the server name to connect to

    /**
     * Construct bind message
     *
     */
    public DcerpcBind() {
    }

    DcerpcBind(final DcerpcBinding binding, final DcerpcHandle handle) {
        this.binding = binding;
        this.max_xmit = handle.getMaxXmit();
        this.max_recv = handle.getMaxRecv();
        this.ptype = 11;
        this.flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

    @Override
    public int getOpnum() {

    /**
     * Constructs a new DcerpcBind message.
     */
    public DcerpcBind() {
    }

    DcerpcBind(final DcerpcBinding binding, final DcerpcHandle handle) {
        this.binding = binding;
        max_xmit = handle.max_xmit;
        max_recv = handle.max_recv;
        ptype = 11;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

    @Override
    public int getOpnum() {
        return 0;
    }

    }

    @Test
    @DisplayName("Should handle getNextResponse correctly")
    void testGetNextResponse() {
        // When
        CommonServerMessageBlockResponse nextResponse = response.getNextResponse();

        // Then - should return null as no next response is set
        assertEquals(null, nextResponse);
    }

    @Test
    @DisplayName("Should handle prepare method correctly")
    void testPrepareMethod() {

        @Test
        @DisplayName("Should handle null buffer in decode")
        void testNullBuffer() {
            FileFsSizeInformation info = new FileFsSizeInformation();

            assertThrows(NullPointerException.class, () -> {
                info.decode(null, 0, 0);
            });
        }

        @Test
        @DisplayName("Should handle insufficient buffer length")