ChecksumInvalid
	// ChecksumMultipart indicates the checksum is from a multipart upload.
	ChecksumMultipart
	// ChecksumIncludesMultipart indicates the checksum also contains part checksums.
	ChecksumIncludesMultipart
	// ChecksumCRC64NVME indicates CRC64 with 0xad93d23594c93659 polynomial.
	ChecksumCRC64NVME
	// ChecksumFullObject indicates the checksum is of the full object,

                updates = policy.getUpdatePolicy();
            }
            if (policy.getChecksumPolicy() != null) {
                checksums = policy.getChecksumPolicy();
            }
        }

        return new RepositoryPolicy(enabled, updates, checksums);
    }

    public static String toRepositoryChecksumPolicy(final String artifactRepositoryPolicy) {
        return switch (artifactRepositoryPolicy) {

	}

	if len(unMarshalXLMeta.Erasure.Checksums) != len(jsoniterXLMeta.Erasure.Checksums) {
		t.Errorf("Expected the size of Erasure Checksums to be %d, but got %d.", len(unMarshalXLMeta.Erasure.Checksums), len(jsoniterXLMeta.Erasure.Checksums))
	} else {
		for i := 0; i < len(unMarshalXLMeta.Erasure.Checksums); i++ {
			if unMarshalXLMeta.Erasure.Checksums[i].PartNumber != jsoniterXLMeta.Erasure.Checksums[i].PartNumber {

					return
				}
			}
		case "Checksums":
			var zb0003 uint32
			zb0003, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Checksums")
				return
			}
			if cap(z.Checksums) >= int(zb0003) {
				z.Checksums = (z.Checksums)[:zb0003]
			} else {
				z.Checksums = make([]ChecksumInfo, zb0003)
			}
			for za0002 := range z.Checksums {
				err = z.Checksums[za0002].DecodeMsg(dc)

		checksumType |= hash.ChecksumMultipart | hash.ChecksumIncludesMultipart
		checksum.Type = checksumType
		if !checksumType.FullObjectRequested() {
			checksum = *hash.NewChecksumFromData(checksumType, checksumCombined)
		}
		fi.Checksum = checksum.AppendTo(nil, checksumCombined)
		if opts.EncryptFn != nil {
			fi.Checksum = opts.EncryptFn("object-checksum", fi.Checksum)
		}
	}
	// Remove superfluous internal headers.

			}

			if gotChksm == nil {
				t.Fatalf("Got nil checksum for %s", tt.name)
			}
			// Compare the full checksum structs
			if !chksm.Equal(gotChksm) {
				t.Errorf("Checksum mismatch for %s: expected %+v, got %+v", tt.name, chksm, gotChksm)
			}
			// Verify the checksum type
			expectedType := chksm.Type
			if gotChksm.Type != expectedType {

	}
	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())

    int LOGON_INFO = 1;
    /**
     * Buffer type for credential information.
     */
    int CREDENTIAL_TYPE = 2;
    /**
     * Buffer type for server checksum signature.
     */
    int SERVER_CHECKSUM = 6;
    /**
     * Buffer type for privilege server (KDC) checksum signature.
     */
    int PRIVSVR_CHECKSUM = 7;

    /**
     * Buffer type for client name information.
     */
    int CLIENT_NAME_TYPE = 0xA;

	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.Log("Size:", buf.Len(), "bytes")

                    .longOpt("strict-checksums")
                    .desc("Fail the build if checksums don't match")
                    .get());
            options.addOption(Option.builder(CHECKSUM_WARNING_POLICY)
                    .longOpt("lax-checksums")
                    .desc("Warn if checksums don't match")
                    .get());