/** NT find capability */
    int CAP_NT_FIND = 0x0200;
    /** DFS capability */
    int CAP_DFS = 0x1000;
    /** Extended security capability */
    int CAP_EXTENDED_SECURITY = 0x80000000;

    // file attribute encoding
    /** Read-only file attribute */
    int ATTR_READONLY = 0x01;
    /** Hidden file attribute */
    int ATTR_HIDDEN = 0x02;
    /** System file attribute */
    int ATTR_SYSTEM = 0x04;

    }

    @Test
    public void testToStringContainsCount() {
        // Little-endian: count = 512 (0x0200)
        byte[] buf = new byte[12];
        buf[0] = 0x00;
        buf[1] = 0x02; // count = 512 in little-endian
        resp.readParameterWordsWireFormat(buf, 0);
        String str = resp.toString();

    /**
     * Pipe operations should behave like the <code>TransactNamedPipe</code> Win32 Named Pipe function.
     */

    int PIPE_TYPE_TRANSACT = 0x0200;

    /**
     * Pipe is used for DCE
     */
    int PIPE_TYPE_DCE_TRANSACT = 0x0200 | 0x0400;

    /**
     * Pipe should use it's own exclusive transport connection
     */
    int PIPE_TYPE_UNSHARED = 0x800;

    /**

    hasher.putBytes(new byte[] {});
    hasher.putBytes(new byte[] {8});
    hasher.assertBytes(expected);
  }

  public void testShort() {
    TestHasher hasher = new TestHasher();
    hasher.putShort((short) 0x0201);
    hasher.assertBytes(new byte[] {1, 2});
  }

  public void testInt() {
    TestHasher hasher = new TestHasher();
    hasher.putInt(0x04030201);
    hasher.assertBytes(new byte[] {1, 2, 3, 4});
  }

    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);
  }

  public void testShort() {
    Sink sink = new Sink(4);
    sink.putShort((short) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros
  }

  public void testInt() {
    Sink sink = new Sink(4);

            assertEquals(expectedDialect, response.getSelectedDialect());
        }
    }

    private static Stream<Arguments> provideDialectVersions() {
        return Stream.of(Arguments.of(0x0202, DialectVersion.SMB202, true), Arguments.of(0x0210, DialectVersion.SMB210, true),
                Arguments.of(0x0300, DialectVersion.SMB300, true), Arguments.of(0x0302, DialectVersion.SMB302, true),

        assertEquals(0x0040, SmbConstants.CAP_STATUS32);
        assertEquals(0x0080, SmbConstants.CAP_LEVEL_II_OPLOCKS);
        assertEquals(0x0100, SmbConstants.CAP_LOCK_AND_READ);
        assertEquals(0x0200, SmbConstants.CAP_NT_FIND);
        assertEquals(0x1000, SmbConstants.CAP_DFS);
        assertEquals(0x4000, SmbConstants.CAP_LARGE_READX);
        assertEquals(0x8000, SmbConstants.CAP_LARGE_WRITEX);

        byte[] rawData = new byte[48]; // 8 (size/zero) + 8 (customData) + 32 (machineId)
        // Simulate some data
        rawData[0] = 48; // size
        rawData[16] = 0x01; // machineId start
        rawData[17] = 0x02;

        AvSingleHost avSingleHost = new AvSingleHost(rawData);

        assertNotNull(avSingleHost);
        assertEquals(AvPair.MsvAvSingleHost, avSingleHost.getType());

        assertFalse(key.isZero());
    }

    @Test
    @DisplayName("Should create lease key from byte array")
    void testLeaseKeyFromBytes() {
        byte[] testBytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

        Smb2LeaseKey key = new Smb2LeaseKey(testBytes);

        assertArrayEquals(testBytes, key.getKey());

        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 1, 3);

        // Verify size
        assertEquals(3, encodable.size(), "Size should be equal to the specified length");
    }

    @Test
    void testEncodeBasic() {
        // Test basic encoding
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };