int offset = 10;

        // When
        int bytesRead = request.readBytesWireFormat(buffer, offset);

        // Then
        assertEquals(0, bytesRead);
    }

    @DisplayName("Should handle different completion filter combinations")
    @ParameterizedTest
    @CsvSource({ "1, FILE_NOTIFY_CHANGE_FILE_NAME", "2, FILE_NOTIFY_CHANGE_DIR_NAME", "4, FILE_NOTIFY_CHANGE_ATTRIBUTES",

import jcifs.smb1.dcerpc.rpc;

/**
 * MS-RPC SAMR close handle operation.
 *
 * This class implements the SAMR CloseHandle operation for releasing
 * Security Account Manager (SAM) handles.
 */
public class MsrpcSamrCloseHandle extends samr.SamrCloseHandle {

    /**
     * Creates a new request to close a SAM handle.
     *
     * @param policyHandle the policy handle to close
     */

            NtStatus.NT_STATUS_INVALID_PARAMETER })
    @DisplayName("Should handle various status codes")
    void testVariousStatusCodes(int status) {
        response.setStatusForTest(status);
        assertEquals(status, response.getErrorCode());
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 10, 100, 255 })
    @DisplayName("Should handle various credit values")
    void testVariousCreditValues(int credits) {

 */
@Named
@Singleton
public class DefaultExceptionHandler implements ExceptionHandler {
    @Override
    public ExceptionSummary handleException(Throwable exception) {
        return handle("", exception);
    }

    private ExceptionSummary handle(String message, Throwable exception) {
        String reference = getReference(Collections.newSetFromMap(new IdentityHashMap<>()), exception);

        List<ExceptionSummary> children = null;

         * Constructs a SamrCloseHandle request.
         *
         * @param handle The policy handle to close
         */
        public SamrCloseHandle(final rpc.policy_handle handle) {
            this.handle = handle;
        }

        @Override
        public void encode_in(final NdrBuffer _dst) throws NdrException {
            this.handle.encode(_dst);
        }

        @Override

         * Constructs a SamrCloseHandle request.
         *
         * @param handle The policy handle to close
         */
        public SamrCloseHandle(final rpc.policy_handle handle) {
            this.handle = handle;
        }

        @Override
        public void encode_in(final NdrBuffer _dst) throws NdrException {
            handle.encode(_dst);
        }

        @Override

            SIDCacheImpl cache = new SIDCacheImpl(mock(CIFSContext.class));
            DcerpcHandle handle = mock(DcerpcHandle.class);
            LsaPolicyHandle policy = mock(LsaPolicyHandle.class);
            jcifs.SID[] none = new jcifs.SID[0];

            cache.resolveSids(handle, policy, none);
            verify(handle, times(1)).sendrecv(any(jcifs.dcerpc.msrpc.MsrpcLookupSids.class));
        }
    }

        });
    }

    @Test
    @DisplayName("Should handle null nonce")
    void testNullNonce() {
        // When/Then
        assertThrows(NullPointerException.class, () -> {
            transformHeader.setNonce(null);
        });
    }

    @Test
    @DisplayName("Should handle invalid nonce length")
    void testInvalidNonceLength() {
        // Given

     */
    public static final int SMB2_LEASE_READ_CACHING = 0x01;

    /**
     * Handle caching lease (H)
     */
    public static final int SMB2_LEASE_HANDLE_CACHING = 0x02;

    /**
     * Write caching lease (W)
     */
    public static final int SMB2_LEASE_WRITE_CACHING = 0x04;

    /**
     * Read and Handle caching (RH)
     */
    public static final int SMB2_LEASE_READ_HANDLE = 0x03;

    /**

            try {
                digest.verify(data, 0, data.length, 0, response);
                // If no exception is thrown, verification should return false or handle gracefully
                assertTrue(true, "Verify operation after close should either throw exception or handle gracefully");
            } catch (RuntimeException e) {
                // Accept runtime exceptions that might be thrown due to closed state