maxParameterCount = 6;
        maxDataCount = 0;
        maxSetupCount = (byte)0x00;
    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        dst[dstIndex++] = subCommand;
        dst[dstIndex++] = (byte)0x00;
        return 2;
    }
    int writeParametersWireFormat( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        writeInt2( fid, dst, dstIndex );

    /**
     * @param data
     * @return MIC
     * @throws CIFSException
     */
    byte[] calculateMIC ( byte[] data ) throws CIFSException;


    /**
     * @param data
     * @param mic
     * @throws CIFSException
     */
    void verifyMIC ( byte[] data, byte[] mic ) throws CIFSException;


    /**
     * @return whether MIC can be used
     */

 *
 */
public class Smb2FlushRequest extends ServerMessageBlock2Request<Smb2FlushResponse> implements RequestWithFileId {

    private byte[] fileId;


    /**
     * @param config
     * @param fileId
     */
    public Smb2FlushRequest ( Configuration config, byte[] fileId ) {
        super(config, SMB2_FLUSH);
        this.fileId = fileId;
    }


    @Override

	}
}

func TestARNUnmarshalXML(t *testing.T) {
	testCases := []struct {
		data        []byte
		expectedARN *ARN
		expectErr   bool
	}{
		{[]byte("<ARN></ARN>"), nil, true},
		{[]byte("<ARN>arn:minio:sqs:::</ARN>"), nil, true},
		{[]byte("<ARN>arn:minio:sqs::1:webhook</ARN>"), &ARN{TargetID{"1", "webhook"}, ""}, false},
		{[]byte("<ARN>arn:minio:sqs:us-east-1:1:webhook</ARN>"), &ARN{TargetID{"1", "webhook"}, "us-east-1"}, false},
	}

     */
    public static final int HASH_ALGO_SHA512 = 0x1;

    private int[] hashAlgos;
    private byte[] salt;


    /**
     * 
     * @param config
     * @param hashAlgos
     * @param salt
     */
    public PreauthIntegrityNegotiateContext ( Configuration config, int[] hashAlgos, byte[] salt ) {
        this.hashAlgos = hashAlgos;
        this.salt = salt;
    }


    /**
     * 

     */
    @Override
    public void getUserSessionKey ( CIFSContext tc, byte[] chlng, byte[] dest, int offset ) throws SmbException {
        if ( this.hashesExternal ) {
            return;
        }
        super.getUserSessionKey(tc, chlng, dest, offset);
    }

    }


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


    @Override
    protected int writeBytesWireFormat ( byte[] dst, int dstIndex ) {
        int start = dstIndex;
        dst[ dstIndex++ ] = (byte) 0x04;
        dstIndex += writeString(this.path, dst, dstIndex);
        return dstIndex - start;
    }

   *
   * @since 15.0
   */
  public static CharSource empty() {
    return EmptyCharSource.INSTANCE;
  }

  /** A byte source that reads chars from this source and encodes them as bytes using a charset. */
  private final class AsByteSource extends ByteSource {

    final Charset charset;

    AsByteSource(Charset charset) {

 * limitations under the License.
 */
package okhttp3.internal.http2.flowcontrol

class WindowCounter(
  val streamId: Int,
) {
  /** The total number of bytes consumed. */
  var total: Long = 0L
    private set

  /** The total number of bytes acknowledged by outgoing `WINDOW_UPDATE` frames. */
  var acknowledged: Long = 0L
    private set

  val unacknowledged: Long
    @Synchronized get() = total - acknowledged

import jcifs.smb.NtStatus;
import jcifs.smb.SmbException;


/**
 * @author mbechler
 *
 */
public class Smb2IoctlResponse extends ServerMessageBlock2Response {

    private final byte[] outputBuffer;
    private int ctlCode;
    private byte[] fileId;
    private int ioctlFlags;
    private Decodable outputData;
    private Decodable inputData;
    private int outputLength;


    /**
     * @param config
     */