void testDeriveKeys_DifferentSessionKeySizes() {
        // Test with various session key sizes
        int[] keySizes = { 8, 16, 24, 32, 64, 128 };
        int dialect = Smb2Constants.SMB2_DIALECT_0311;

        for (int size : keySizes) {
            // Given
            byte[] testKey = new byte[size];
            new SecureRandom().nextBytes(testKey);

            // When

        return 0L;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.createTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;

pkg p1, const A //deprecated
pkg p1, const A = 1
pkg p1, const A ideal-int
pkg p1, const A64 = 1
pkg p1, const A64 int64
pkg p1, const AIsLowerA = 11
pkg p1, const AIsLowerA ideal-int
pkg p1, const B0 = 2
pkg p1, const B0 ideal-int
pkg p1, const ConstChase2 = 11
pkg p1, const ConstChase2 ideal-int
pkg p1, const ConversionConst = 5
pkg p1, const ConversionConst MyInt
pkg p1, const FloatConst = 1.5  // 3/2
pkg p1, const FloatConst ideal-float

      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public boolean setCount(T element, int oldCount, int newCount) {
      return standardSetCount(element, oldCount, newCount);
    }

    @Override
    public int setCount(T element, int count) {
      return standardSetCount(element, count);
    }

        void testVariousPadding(int padding) {
            assertDoesNotThrow(() -> request.setPadding((byte) padding));
        }

        @ParameterizedTest
        @DisplayName("Should handle various read lengths")
        @ValueSource(ints = { 0, 1, 512, 1024, 4096, 65536, 1048576 })
        void testVariousReadLengths(int length) {
            assertDoesNotThrow(() -> request.setReadLength(length));

    private final int bytes;
    private boolean done;

    private MessageDigestHasher(MessageDigest digest, int bytes) {
      this.digest = digest;
      this.bytes = bytes;
    }

    @Override
    protected void update(byte b) {
      checkNotDone();
      digest.update(b);
    }

    @Override
    protected void update(byte[] b, int off, int len) {
      checkNotDone();

    private static byte[] buildIoctlResponseBody(int ctlCode, byte[] fileId, int inputCount, byte[] inputBytes, int outputCount,
            byte[] outputBytes, int ioctlFlags) {
        final int headerLen = 64; // SMB2 header is 64 bytes
        final int bodyFixed = 48; // body size minus 1 for structure size field overlap
        final int payloadStart = headerLen + bodyFixed;
        final int bodyLen = bodyFixed + inputCount + outputCount;

     */

    @Override
    public int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

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

    @Override
    public int read(final byte[] b, final int off, final int len) throws IOException {

    private final int sid;

    SmbComFindClose2(final int sid) {
        this.sid = sid;
        command = SMB_COM_FIND_CLOSE2;
    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        writeInt2(sid, dst, dstIndex);
        return 2;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

import jcifs.internal.util.SMBUtil;

/**
 * Information about a network interface for SMB3 Multi-Channel
 */
public class NetworkInterfaceInfo {

    private int interfaceIndex;
    private int capability;
    private int linkSpeed; // In units of 1 Mbps
    private byte[] sockaddrStorage;
    private InetAddress address;
    private boolean ipv6;
    private boolean rssCapable; // Receive Side Scaling