Mac m = Mac.getInstance("HmacMD5");
        m.init(new SecretKeySpec(Hex.decode(key), "HMAC"));
        byte[] mac = m.doFinal(bytes);
        checkBytes(Hex.decode(expect), mac);
    }


    @Test
    public void testRC4Checksum1 () throws PACDecodingException, GeneralSecurityException {

        this.node[ 3 ] = B(hex_to_bin(arr, 30, 2));
        this.node[ 4 ] = B(hex_to_bin(arr, 32, 2));
        this.node[ 5 ] = B(hex_to_bin(arr, 34, 2));
    }


    @Override
    public String toString () {
        return bin_to_hex(this.time_low, 8) + '-' + bin_to_hex(this.time_mid, 4) + '-' + bin_to_hex(this.time_hi_and_version, 4) + '-'

        node[3] = B(hex_to_bin(arr, 30, 2));
        node[4] = B(hex_to_bin(arr, 32, 2));
        node[5] = B(hex_to_bin(arr, 34, 2));
    }

    public String toString() {
        return bin_to_hex(time_low, 8) + '-' +
                bin_to_hex(time_mid, 4) + '-' +
                bin_to_hex(time_hi_and_version, 4) + '-' +
                bin_to_hex(clock_seq_hi_and_reserved, 2) +
                bin_to_hex(clock_seq_low, 2) + '-' +

     * @param src
     * @param srcIndex
     * @param size
     * @return hex string
     */
    public static String toHexString ( byte[] src, int srcIndex, int size ) {
        char[] c = new char[2 * size];
        for ( int i = 0, j = 0; i < size; i++ ) {
            c[ j++ ] = HEX_DIGITS[ ( src[ srcIndex + i ] >> 4 ) & 0x0F ];
            c[ j++ ] = HEX_DIGITS[ src[ srcIndex + i ] & 0x0F ];
        }
        return new String(c);

	for i, test := range derivePartKeyTest {
		expectedPartKey, err := hex.DecodeString(test.PartKey)
		if err != nil {
			t.Fatalf("Test %d failed to decode expected part-key: %v", i, err)
		}
		partKey := key.DerivePartKey(test.PartID)
		if !bytes.Equal(partKey[:], expectedPartKey) {
			t.Errorf("Test %d derives wrong part-key: got '%s' want: '%s'", i, hex.EncodeToString(partKey[:]), test.PartKey)
		}
	}
}

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"crypto/md5"
	"encoding/hex"

	"github.com/minio/minio/internal/hash/sha256"
)

// getSHA256Hash returns SHA-256 hash in hex encoding of given data.
func getSHA256Hash(data []byte) string {
	return hex.EncodeToString(getSHA256Sum(data))
}

// getSHA256Hash returns SHA-256 sum of given data.
func getSHA256Sum(data []byte) []byte {

						var tmp [16]byte
						rng.Read(tmp[:])
						res := []string{hex.EncodeToString(tmp[:])}

						for i := 0; i < readers; i++ {
							rng.Read(tmp[:])
							ok, err := l.RLock(context.Background(), dsync.LockArgs{
								UID:       uuid.NewString(),
								Resources: res,
								Source:    hex.EncodeToString(tmp[:8]),
								Owner:     hex.EncodeToString(tmp[8:]),
								Quorum:    0,
							})

      dest[9] = '%';
      dest[11] = UPPER_HEX_DIGITS[cp & 0xF];
      cp >>>= 4;
      dest[10] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
      cp >>>= 2;
      dest[8] = UPPER_HEX_DIGITS[cp & 0xF];
      cp >>>= 4;
      dest[7] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
      cp >>>= 2;
      dest[5] = UPPER_HEX_DIGITS[cp & 0xF];
      cp >>>= 4;
      dest[4] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
      cp >>>= 2;

        size = ( size % 2 == 0 ) ? size / 2 : size / 2 + 1;
        for( int i = 0, j = 0; i < size; i++ ) {
            c[j++] = HEX_DIGITS[(src[i] >> 4 ) & 0x0F];
            if( j == c.length ) {
                break;
            }
            c[j++] = HEX_DIGITS[src[i] & 0x0F];
        }
        return new String( c );
    }

/** 

  force-pseudo-nesting: 0
  function-name-format: 2
  hex-length: 0
  hex-notation: 2
  id-name-format: 2
  indentation:
    - 2
    -
      size: 4
  leading-zero:
    - 2
    -
      include: false
  max-file-line-count: 0
  max-file-length: 0
  mixins-before-declarations: 2
  no-attribute-selectors: 0
  no-color-hex: 0
  no-color-keywords: 0
  no-color-literals: 0
  no-combinators: 0