// Arrange
        nodeStatusRequest = new NodeStatusRequest(mockConfig, mockName);
        byte[] dst = new byte[100];
        int originalHexCode = 0xFF;
        mockName.hexCode = originalHexCode;

        // Create a spy to capture the state during writeQuestionSectionWireFormat
        NodeStatusRequest spyRequest = spy(nodeStatusRequest);

        int readDataAvailable = Integer.MAX_VALUE;
        int numberOfMessages = Integer.MAX_VALUE;
        int messageLength = Integer.MAX_VALUE;
        byte[] testData = { 0x7F, 0x7F, 0x7F, 0x7F };

        // Write values to buffer
        SMBUtil.writeInt4(namedPipeState, buffer, bufferIndex);
        SMBUtil.writeInt4(readDataAvailable, buffer, bufferIndex + 4);

     */
    public SID getSID() {
        return sid;
    }

    int decode(final byte[] buf, int bi) {
        allow = buf[bi] == (byte) 0x00;
        bi++;
        flags = buf[bi++] & 0xFF;
        final int size = ServerMessageBlock.readInt2(buf, bi);
        bi += 2;
        access = ServerMessageBlock.readInt4(buf, bi);
        bi += 4;
        sid = new SID(buf, bi);
        return size;
    }

    @Override
    public int read() throws IOException {
        // need oplocks to cache otherwise use BufferedInputStream
        if (read(tmp, 0, 1) == -1) {
            return -1;
        }
        return tmp[0] & 0xFF;
    }

    /**
     * Reads up to b.length bytes of data from this input stream into an array of bytes.
     *
     * @throws IOException if a network error occurs
     */

    @Override

    @Test
    @DisplayName("Test setCommand with various SMB command codes")
    void testSetCommandWithVariousCodes() {
        // Test common SMB command codes
        int[] commandCodes = { 0x00, 0x72, 0x73, 0x74, 0x75, 0xFF };

        for (int command : commandCodes) {
            doNothing().when(messageBlock).setCommand(command);
            when(messageBlock.getCommand()).thenReturn(command);

        char[] plaintext = "SecureData".toCharArray();
        byte[] encrypted = storage.encryptCredentials(plaintext);

        // Tamper with the encrypted data
        encrypted[encrypted.length - 1] ^= 0xFF;

        // Should throw exception due to authentication tag failure
        assertThrows(GeneralSecurityException.class, () -> {
            storage.decryptCredentials(encrypted);

            // Write some error data
            buffer[errorStart + 8] = (byte) 0xFF;
            buffer[errorStart + 9] = (byte) 0xFE;
            buffer[errorStart + 10] = (byte) 0xFD;
            buffer[errorStart + 11] = (byte) 0xFC;

            testMessage.setBytesRead(0);
            testMessage.decode(buffer, 0);

        byte[] buffer = new byte[256];
        // Fill with non-zero values first
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) 0xFF;
        }

        // When
        request.writeBytesWireFormat(buffer, 10);

        // Then - verify reserved field is zero
        assertEquals(0, SMBUtil.readInt2(buffer, 12));
    }

        // Given
        byte[] buffer = new byte[256];
        // Fill buffer with test pattern
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) (i & 0xFF);
        }
        byte[] originalBuffer = buffer.clone();

        // When
        int bytesWritten = response.writeBytesWireFormat(buffer, 10);

        // Then
        assertEquals(0, bytesWritten);

        when(resp.getErrorCode()).thenReturn(0x10B);
        when(resp.getNotifyInformation()).thenReturn(new ArrayList<>());
        setupSmb1(resp, 42);
        SmbWatchHandleImpl sut = new SmbWatchHandleImpl(handle, 0xFF, false);

        List<FileNotifyInformation> result = sut.watch();

        assertNotNull(result);
        verify(handle, times(1)).markClosed();