}

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        if (len < 8) {
            throw new SMBProtocolDecodingException("Invalid compression context length: " + len);
        }

        int start = bufferIndex;

        // Read compression count
        int compressionCount = SMBUtil.readInt2(buffer, bufferIndex);

                    .orElse(false);
        } catch (final InvalidAccessTokenException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invalid access token.", e);
            }
            return false;
        }
    }

     * @param data the raw credential type data
     * @throws PACDecodingException if the credential type data is invalid
     */
    public PacCredentialType(final byte[] data) throws PACDecodingException {
        this.credentialType = data;
        if (!isCredentialTypeCorrect()) {
            throw new PACDecodingException("Invalid PAC credential type");
        }
    }

    /**

    }

    @ParameterizedTest
    @NullAndEmptySource
    @DisplayName("Invalid names are skipped; next valid is returned")
    void skipsMalformedNames_thenReturnsValid(String badName) throws Exception {
        // Arrange: first entry is invalid (null or empty), second is valid
        setupParentForUrlCreation();

            assertEquals(1024, response.getCount());
            assertEquals(512, response.getRemaining());
        }

        @Test
        @DisplayName("Should throw exception for invalid structure size")
        void testInvalidStructureSize() {
            byte[] buffer = new byte[64];
            SMBUtil.writeInt2(16, buffer, 0); // Wrong structure size (should be 17)

        buffer.putShort(0, (short) 1);
        buffer.putShort(2, (short) 1);
        buffer.putInt(4, data.length + 1); // Invalid offset
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> NtlmMessage.readSecurityBuffer(data, 0),
                "Should throw ArrayIndexOutOfBoundsException for invalid offset.");
    }

    @Test
    void testWriteULong() {
        // Test writeULong
        byte[] data = new byte[4];

        // Validate buffer size to prevent overflow
        int bufferSize = SmbComTransaction.TRANSACTION_BUF_SIZE;
        if (bufferSize < 0 || bufferSize > MAX_BUFFER_SIZE) {
            throw new IllegalStateException("Invalid buffer size: " + bufferSize);
        }

        return new byte[bufferSize];
    }

    static void getBuffers(final SmbComTransaction req, final SmbComTransactionResponse rsp) {
        req.txn_buf = getBuffer();

            when(mockFile.getPath()).thenReturn("/share/file.txt");
            assertTrue(ALWAYSACTIVE.accept(mockFile));
        }
    }

    @Nested
    @DisplayName("Invalid input – null file handling")
    class InvalidPath {
        @Test
        void acceptWithNullThrows() {
            SmbFileFilter throwOnNull = new SmbFileFilter() {
                @Override

      // OkHttp does not reject invalid Punycode.
      "xn--a",
      "xn--a.ß",
      "xn--a.xn--zca",
      "xn--a-yoc",
      // OkHttp doesn't reject U+FFFD encoded in Punycode.
      "xn--zn7c.com",

    @DisplayName("initSecContext throws on invalid token type")
    void testInitSecContextInvalidTokenType(byte firstByte) throws Exception {
        SpnegoContext ctx = newContext();

        // Invalid first byte should be rejected by token parsing
        CIFSException ex = assertThrows(CIFSException.class, () -> ctx.initSecContext(new byte[] { firstByte }, 0, 1));
        assertEquals("Invalid token", ex.getMessage());