@DisplayName("Should use SMB 3.0.x context for non-3.1.1 dialects")
    void testDeriveKeys_NonSMB311Dialects(int dialect) {
        // When
        byte[] signingKey = Smb3KeyDerivation.deriveSigningKey(dialect, sessionKey, preauthIntegrity);

        // Then
        assertNotNull(signingKey, "Should derive key for dialect: " + dialect);

    private final boolean smb2;
    private final int dialect;

    /**
     *
     */
    DialectVersion() {
        this.smb2 = false;
        this.dialect = -1;
    }

    DialectVersion(final int dialectId) {
        this.smb2 = true;
        this.dialect = dialectId;
    }

    /**
     * Check if this is an SMB2 dialect version
     *
     * @return the smb2
     */

  fi
  cd ..
fi


for dialect in "${dialects[@]}" ; do
  if [ "$GORM_DIALECT" = "" ] || [ "$GORM_DIALECT" = "${dialect}" ]
  then
    echo "testing ${dialect}..."

    if [ "$GORM_VERBOSE" = "" ]
    then
      GORM_DIALECT=${dialect} go test -race -count=1 ./...
      if [ -d tests ]
      then
        cd tests
        GORM_DIALECT=${dialect} go test -race -count=1 ./...
        cd ..
      fi

     */
    public int getSecurityMode() {
        return this.securityMode;
    }

    /**
     * Gets the negotiated SMB dialect
     *
     * @return the SMB dialect negotiated with the server
     */
    public int getDialect() {
        return this.dialect;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override

        final ByteArrayOutputStream bos = new ByteArrayOutputStream();

        for (final String dialect : this.dialects) {
            bos.write(0x02);
            try {
                bos.write(Strings.getASCIIBytes(dialect));
            } catch (final IOException e) {
                throw new RuntimeCIFSException(e);
            }
            bos.write(0x0);
        }

    private volatile boolean closed = false;

    /**
     * Constructs a SMB2 signing digest with the specified session key and dialect
     *
     * @param sessionKey
     *            the session key for signing
     * @param dialect
     *            the SMB2 dialect version
     * @param preauthIntegrityHash
     *            the pre-authentication integrity hash (for SMB 3.1.1)
     * @throws GeneralSecurityException

        // Set security mode (2 bytes)
        int testSecurityMode = 0x0003;
        SMBUtil.writeInt2(testSecurityMode, buffer, bufferIndex + 20);

        // Set dialect (2 bytes)
        int testDialect = 0x0311;
        SMBUtil.writeInt2(testDialect, buffer, bufferIndex + 22);

        // Execute decode
        int bytesDecoded = response.decode(buffer, bufferIndex, 24);

        }

        @ParameterizedTest
        @ValueSource(ints = { 0x0202, 0x0210, 0x0300, 0x0302, 0x0311 })
        @DisplayName("All specific dialects should be greater than or equal to SMB 2.0.2")
        void testDialectVersionProgression(int dialect) {
            assertTrue(dialect >= Smb2Constants.SMB2_DIALECT_0202,

     *            negotiated cipher identifier
     * @param dialect
     *            SMB dialect version
     * @param encryptionKey
     *            key for client->server encryption
     * @param decryptionKey
     *            key for server->client decryption
     */
    public Smb2EncryptionContext(final int cipherId, final DialectVersion dialect, final byte[] encryptionKey, final byte[] decryptionKey) {

        // Verify dialect count
        assertEquals(manyDialects.length, SMBUtil.readInt2(buffer, 22));

        // Verify all dialects
        for (int i = 0; i < manyDialects.length; i++) {
            assertEquals(manyDialects[i], SMBUtil.readInt2(buffer, 24 + i * 2));
        }
    }

    @Test
    @DisplayName("Test encode preserves dialect order")
    void testEncodePreservesDialectOrder() {