/**
 * byte配列用の変換ユーティリティです。
 *
 * @author higa
 */
public abstract class BinaryConversionUtil {

    /**
     * {@literal byte}の配列に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @return {@literal byte}の配列
     */
    public static byte[] toBinary(final Object o) {
        if (o instanceof byte[]) {
            return (byte[]) o;
        } else if (o == null) {

    /**
     * 
     */
    public static final byte SMB2_OPLOCK_LEVEL_NONE = 0x0;
    /**
     * 
     */
    public static final byte SMB2_OPLOCK_LEVEL_II = 0x1;
    /**
     * 
     */
    public static final byte SMB2_OPLOCK_LEVEL_EXCLUSIVE = 0x8;
    /**
     * 
     */
    public static final byte SMB2_OPLOCK_LEVEL_BATCH = 0x9;
    /**
     * 
     */

					VersionID: [16]byte{2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
					ModTime:   baseTime.Add(60 * time.Minute).UnixNano(),
					Signature: [4]byte{2, 1, 1, 1},
					Type:      ObjectType,
					Flags:     0,
				}},
				{header: xlMetaV2VersionHeader{
					VersionID: [16]byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
					ModTime:   baseTime.Add(30 * time.Minute).UnixNano(),
					Signature: [4]byte{1, 1, 1, 1},

    /**
     * @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
     */

    }


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


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


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


    @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;
    }


    /**
     * 

    private int[] dialects;
    private int capabilities;
    private byte[] clientGuid = new byte[16];
    private int securityMode;
    private NegotiateContextRequest[] negotiateContexts;
    private byte[] preauthSalt;


    /**
     * @param config
     * @param securityMode
     */

func getSHA256Hash(data []byte) string {
	return hex.EncodeToString(getSHA256Sum(data))
}

// getSHA256Hash returns SHA-256 sum of given data.
func getSHA256Sum(data []byte) []byte {
	hash := sha256.New()
	hash.Write(data)
	return hash.Sum(nil)
}

// getMD5Sum returns MD5 sum of given data.
func getMD5Sum(data []byte) []byte {
	hash := md5.New()
	hash.Write(data)
	return hash.Sum(nil)

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
     */