./mc mb minio1/test-bucket --insecure

# Load objects to source site with checksum header
echo "Loading objects to source MinIO instance"
OBJ_CHKSUM=$(openssl dgst -sha256 -binary </tmp/data/obj | base64)
aws s3api --endpoint-url=https://localhost:9001 put-object --checksum-algorithm SHA256 --checksum-sha256 "${OBJ_CHKSUM}" --bucket test-bucket --key obj --body /tmp/data/obj --no-verify-ssl --profile enterprise

    return toString;
  }

  /** Hasher that updates a checksum. */
  private final class ChecksumHasher extends AbstractByteHasher {
    private final Checksum checksum;

    private ChecksumHasher(Checksum checksum) {
      this.checksum = checkNotNull(checksum);
    }

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

    @Override

	}
	for algorithm := range bitrotAlgorithms {
		if !algorithm.Available() {
			continue
		}

		checksum, err := hex.DecodeString(checksums[algorithm])
		if err != nil {
			logger.Fatal(errSelfTestFailure, fmt.Sprintf("bitrot: failed to decode %v checksum %s for selftest: %v", algorithm, checksums[algorithm], err))
		}
		var (
			hash = algorithm.New()
			msg  = make([]byte, 0, hash.Size()*hash.BlockSize())

    /**
     * Calculates checksums for specified data.
     *
     * @param data        The content for which to calculate checksums, must not be {@code null}.
     * @param algorithms  The checksum algorithms to use, must not be {@code null}.
     * @return The calculated checksums, indexed by algorithms, never {@code null}.

				if err != nil {
					err = msgp.WrapError(err, "MinioEnv", za0002)
					return
				}
				z.MinioEnv[za0002] = za0003
			}
		case "Checksum":
			z.Checksum, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Checksum")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

                }
            }

            // Pre-store the checksums as any future puts will overwrite them
            for (String extension : checksums.keySet()) {
                ChecksumObserver observer = checksums.get(extension);
                sums.put(extension, observer.getActualChecksum());
            }

            // We do this in here so we can checksum the artifact metadata too, otherwise it could be metadata itself

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        writeLittleEndianInt(baos, PacSignature.KERB_CHECKSUM_HMAC_MD5);
        byte[] checksum = new byte[16];
        for (int i = 0; i < checksum.length; i++) {
            checksum[i] = (byte) i;
        }
        baos.write(checksum);
        byte[] data = baos.toByteArray();

        // Create PacSignature
        PacSignature pacSignature = new PacSignature(data);

        wagon.clearExpectedContent();
        wagon.addExpectedContent("path", "lower-case-checksum");
        wagon.addExpectedContent("path.sha1", "2a25dc564a3b34f68237fc849066cbc7bb7a36a1");
        wagonManager.getArtifact(artifact, repo, null, false);

        wagon.clearExpectedContent();
        wagon.addExpectedContent("path", "upper-case-checksum");
        wagon.addExpectedContent("path.sha1", "B7BB97D7D0B9244398D9B47296907F73313663E6");

        } catch (final IOException e) {
            throw new PACDecodingException("Malformed PAC signature", e);
        }
    }

    /**
     * Gets the checksum type of this signature.
     *
     * @return the checksum type constant
     */
    public int getType() {
        return this.type;
    }

    /**
     * Gets the checksum data.
     *
     * @return the checksum bytes
     */

			}
			if unMarshalXLMeta.Erasure.Checksums[i].Algorithm != jsoniterXLMeta.Erasure.Checksums[i].Algorithm {
				t.Errorf("Expected the Erasure Checksum Algorithm to be \"%s\", got \"%s\".", unMarshalXLMeta.Erasure.Checksums[i].Algorithm, jsoniterXLMeta.Erasure.Checksums[i].Algorithm)
			}