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

				NewerNoncurrentVersions: 5,
				set:                     true,
			},
			err: nil,
		},
	}

	for i, tc := range testcases {
		if got := tc.n.Validate(); got != tc.err {
			t.Fatalf("%d: expected %v but got %v", i+1, tc.err, got)
		}
	}

	}
	if err != nil {
		logger.Fatal(err, "Unable to generate root access key using KMS")
	}

	sKey, err := GlobalKMS.MAC(GlobalContext, &kms.MACRequest{Message: []byte("root secret key")})
	if err != nil {
		// Here, we must have permission. Otherwise, we would have failed earlier.
		logger.Fatal(err, "Unable to generate root secret key using KMS")
	}

}

func (rt *RTimedMetrics) String() string {
	s := rt.toMetric()
	return fmt.Sprintf("Errors in LastMinute: %v, LastHour: %v, SinceUptime: %v", s.LastMinute.Count, s.LastHour.Count, s.Totals.Count)
}

func (rt *RTimedMetrics) toMetric() madmin.TimedErrStats {
	if rt == nil {
		return madmin.TimedErrStats{}
	}
	errCounts := make(map[string]int)
	for k, v := range rt.ErrCounts {
		errCounts[k] = v

		testCase := testCase
		t.Run("", func(t *testing.T) {
			srvCtxt := serverCtxt{}
			err := mergeDisksLayoutFromArgs(testCase.args, &srvCtxt)
			if err != nil && testCase.success {
				t.Fatalf("Test %d: unexpected error: %v", i+1, err)
			}
			_, _, err = createServerEndpoints(testCase.serverAddr, srvCtxt.Layout.pools, srvCtxt.Layout.legacy)
			if err != nil && testCase.success {

package cmd

import (
	"testing"
	"time"
)

func TestVersion(t *testing.T) {
	Version = "2017-05-07T06:37:49Z"
	_, err := time.Parse(time.RFC3339, Version)
	if err != nil {
		t.Fatal(err)
	}

}

func fatalErr(err error) {
	if err == nil {
		return
	}
	log.Fatalln(err)
}

func fatalIf(b bool, msg string, v ...interface{}) {
	if !b {
		return
	}
	log.Fatalf(msg, v...)

package disk_test

import (
	"testing"

	"github.com/minio/minio/internal/disk"
)

func TestFree(t *testing.T) {
	di, err := disk.GetInfo(t.TempDir(), true)
	if err != nil {
		t.Fatal(err)
	}

	if di.FSType == "UNKNOWN" {
		t.Error("Unexpected FSType", di.FSType)
	}

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			s3Select, err := NewS3Select(bytes.NewReader(requestXML))
			if err != nil {
				b.Fatal(err)
			}

			if err = s3Select.Open(newBytesRSC(csvData)); err != nil {
				b.Fatal(err)
			}

			s3Select.Evaluate(&nullResponseWriter{})
			s3Select.Close()
		}
	})
}

func benchmarkSelectAll(b *testing.B, count int) {

	metrics := getHistogramMetrics(ttfbHist, getBucketTTFBDistributionMD(), false)
	// additional labels for +Inf for all histogram metrics
	if expPoints := len(labels) * (len(histBuckets) + 1); expPoints != len(metrics) {
		t.Fatalf("Expected %v data points but got %v", expPoints, len(metrics))
	}