assertEquals(0, cap.getValue().length, "Optimistic token must be zero-length");
    }

    @ParameterizedTest
    @ValueSource(bytes = { 0x00, 0x7F, (byte) 0xFF })
    @DisplayName("initSecContext throws on invalid token type")
    void testInitSecContextInvalidTokenType(byte firstByte) throws Exception {
        SpnegoContext ctx = newContext();

                    ci += n * 3;
                    System.arraycopy(SPACE_CHARS, 0, d, s, n);
                    break;
                }
                c[ci++] = ' ';
                i = src[srcIndex + si] & 0xFF;
                toHexChars(i, c, ci, 2);
                ci += 2;
                if (i < 0 || Character.isISOControl((char) i)) {
                    d[si % 16] = '.';
                } else {

        try (InputStream stream = cache.getInputStream()) {
            for (int i = 0; i < 256; i++) {
                int byteValue = stream.read();
                assertEquals("Byte at position " + i, i & 0xFF, byteValue);
            }
            assertEquals(-1, stream.read()); // End of stream
        }
    }

    @Test
    public void testStreamReadPartial() throws IOException {

    @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);

     * @return the unsigned byte value as an integer
     * @throws IOException if an I/O error occurs
     */
    public int readUnsignedByte() throws IOException {
        return readByte() & 0xff;
    }

    /**
     * Reads an unsigned 32-bit integer value.
     * @return the unsigned integer value as a long
     * @throws IOException if an I/O error occurs
     */

    void testSpecialFileIdPatterns() {
        // Test various special patterns
        byte[] allZeros = new byte[16];
        byte[] allOnes = new byte[16];
        Arrays.fill(allOnes, (byte) 0xFF);
        byte[] alternating = new byte[16];
        for (int i = 0; i < alternating.length; i++) {
            alternating[i] = (byte) (i % 2 == 0 ? 0xAA : 0x55);
        }

                Arguments.of(new byte[] { (byte) 0xAB }, "ab"),
                Arguments.of(new byte[] { (byte) 0x7F, (byte) 0x80, (byte) 0xFF }, "7f80ff"));
    }

    // Verifies that toString() formats bytes as lower-case hex with zero-padding
    @ParameterizedTest(name = "toString renders hex for {0}")
    @MethodSource("hexCases")

        }

        @Test
        @DisplayName("Should not modify buffer beyond encoded area")
        void testEncodeDoesNotModifyBeyondArea() {
            // Given
            byte testByte = (byte) 0xFF;
            java.util.Arrays.fill(buffer, testByte);
            SrvCopychunk chunk = new SrvCopychunk(1024, 2048, 4096);

            // When
            chunk.encode(buffer, startIndex);

            // Then

        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();