assertEquals(0, response.getChunkBytesWritten());
            assertEquals(0, response.getTotalBytesWritten());
        }

        @Test
        @DisplayName("Should handle negative values as unsigned")
        void testDecodeNegativeValuesAsUnsigned() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[12];
            SMBUtil.writeInt4(-1, buffer, 0); // chunksWritten

        void testConstructorAndOpnum() {
            // When: Creating close handle message
            samr.SamrCloseHandle message = new samr.SamrCloseHandle(mockPolicyHandle);

            // Then: Should have correct opnum and handle
            assertEquals(0x01, message.getOpnum());
            assertEquals(mockPolicyHandle, message.handle);
        }

        @Test

    }

    /**
     * Sets the context handle for the async notify request.
     *
     * @param contextHandle the context handle from registration
     */
    public void setContextHandle(byte[] contextHandle) {
        this.contextHandle = contextHandle != null ? contextHandle.clone() : null;
    }

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

    }

    /**
     * Checks whether the asynchronous interim response has been handled.
     *
     * @return whether the interim response has been handled
     */
    public boolean isAsyncHandled() {
        return this.asyncHandled;
    }

    /**
     * Sets whether the asynchronous interim response has been handled.
     *
     * @param asyncHandled
     *            the asyncHandled to set
     */

        // Just verify that contexts were written
        assertTrue(bytesWritten > 60); // Should be larger than basic negotiate request
    }

    @Test
    @DisplayName("Should handle empty negotiate contexts array")
    void testWriteBytesWireFormatEmptyContexts() {
        // Given
        when(mockConfig.getMaximumVersion()).thenReturn(DialectVersion.SMB302);

        assertNull(transPeekNamedPipe.name);
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, -1, Integer.MAX_VALUE, Integer.MIN_VALUE, 0xFFFF })
    @DisplayName("Constructor should handle various FID values")
    void testConstructorWithVariousFids(int fid) {
        // Act
        transPeekNamedPipe = new TransPeekNamedPipe(mockConfig, TEST_PIPE_NAME, fid);

        // Assert

        System.arraycopy(buffer, bodyOffset + 8, actualPath, 0, pathBytes.length);
        assertArrayEquals(pathBytes, actualPath);
    }

    @Test
    @DisplayName("Should handle chain operation correctly")
    void testChain() {
        // Given
        ServerMessageBlock2 nextMessage = mock(ServerMessageBlock2.class);

        // When
        boolean result = request.chain(nextMessage);

    }

    /**
     * Gets the context handle returned by the server.
     *
     * @return the context handle
     */
    public byte[] getContextHandle() {
        return contextHandle != null ? contextHandle.clone() : null;
    }

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

        // Then
        assertNotNull(exception);
        assertEquals(message, exception.getMessage());
        assertEquals(cause, exception.getCause());
    }

    @Test
    @DisplayName("Should handle null message gracefully")
    void testNullMessage() {
        // When/Then
        assertDoesNotThrow(() -> {
            RuntimeCIFSException exception = new RuntimeCIFSException((String) null);

        assertArrayEquals(testHash, avChannelBindings.getRaw(), "Value should match the provided hash");
    }

    /**
     * Test that the constructor handles a null channel binding hash.
     */
    @Test
    void testConstructorWithNullHash() {
        AvChannelBindings avChannelBindings = new AvChannelBindings(null);