// SMB2 header
        validator.validateSmbHeader(0x424D53FE, 64, 0x00);
    }

    @Test
    public void testInvalidProtocolId() throws Exception {
        assertThrows(SmbException.class, () -> {
            validator.validateSmbHeader(0xDEADBEEF, 64, 0x00);
        });
    }

    @Test
    public void testInvalidSmb1HeaderSize() throws Exception {

     * .
     */
    @Test
    public void testToBinary() {
        assertThat(BinaryConversionUtil.toBinary(null), nullValue());
        final byte[] b = { 0x00, 0x01 };
        assertThat(BinaryConversionUtil.toBinary(b), is(b));
        assertThat(BinaryConversionUtil.toBinary("hoge"), is("hoge".getBytes()));
    }

    /**
     * Test method for

        // Offset 2-3: Reserved (2 bytes, should be 0x00)
        // Offset 4-7: Security Information (4 bytes)
        assertEquals(8, bytesWritten);

        // Check FID
        assertEquals(0xABCD, SMBUtil.readInt2(dst, 10));

        // Check reserved bytes are zero
        assertEquals(0x00, dst[12]);
        assertEquals(0x00, dst[13]);

        // Check security information

        // per bouncycastle
        // <li>1: K(i) := PRF( KI, [i]_2 || Label || 0x00 || Context || [L]_2 ) with the counter at the very beginning
        // of the fixedInputData (The default implementation has this format)</li>
        // with the parameters
        // <li>1. KDFCounterParameters(ki, null, "Label || 0x00 || Context || [L]_2]", 8);

        // all fixed inputs go into the suffix:
        // + label

    @Test
    void testSetFid() {
        response.fid = 123;
        assertEquals(123, response.fid);
    }

    @Test
    void testSetFileAttributes() {
        response.fileAttributes = 0x20; // ATTR_ARCHIVE
        assertEquals(0x20, response.fileAttributes);
    }

    @Test
    void testSetLastWriteTime() {
        long time = System.currentTimeMillis();
        response.lastWriteTime = time;

            int off = inv.getArgument(1);
            b[off] = 0x3F;
            b[off + 1] = (byte) 0xF0;
            b[off + 2] = 0x00;
            b[off + 3] = 0x00;
            b[off + 4] = 0x00;
            b[off + 5] = 0x00;
            b[off + 6] = 0x00;
            b[off + 7] = 0x00;
            return 8;
        }).when(raf).read(any(byte[].class), anyInt(), eq(8));

        for (int i = 0; i < 24; i++) {
            buffer[i] = (byte) (i + 1);
        }

        // Add context length (reserved) - 4 bytes
        buffer[24] = 0x00;
        buffer[25] = 0x00;
        buffer[26] = 0x00;
        buffer[27] = 0x00;

        // Decode
        int bytesConsumed = response.decode(buffer, 0, 28);

        // Verify
        assertEquals(28, bytesConsumed, "Should consume exactly 28 bytes");

     */
    public static final int SMB2_GLOBAL_CAP_PERSISTENT_HANDLES = 0x10;

    /**
     * Server supports directory leasing
     */
    public static final int SMB2_GLOBAL_CAP_DIRECTORY_LEASING = 0x20;

    /**
     * Server supports SMB3 encryption
     */
    public static final int SMB2_GLOBAL_CAP_ENCRYPTION = 0x40;

    /**
     * File information class
     */

        this.filename = filename;
        command = SMB_COM_TRANSACTION2;
        subCommand = TRANS2_FIND_NEXT2;
        informationLevel = Trans2FindFirst2.SMB_FILE_BOTH_DIRECTORY_INFO;
        flags = 0x00;
        maxParameterCount = 8;
        maxDataCount = Trans2FindFirst2.LIST_SIZE;
        maxSetupCount = 0;
    }

    @Override
    void reset(final int resumeKey, final String lastName) {
        super.reset();

        this.request = new DfsReferralRequestBuffer(filename, maxReferralLevel);
        this.totalDataCount = 0;
        this.maxParameterCount = 0;
        this.maxDataCount = 4096;
        this.maxSetupCount = (byte) 0x00;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#isForceUnicode()
     */
    @Override
    public boolean isForceUnicode() {
        return true;
    }