if err != nil {
		return false, s3.ToObjectError(err)
	}
	return len(result.CommonPrefixes) > 0 || len(result.Contents) > 0, nil
}

func newWarmBackendS3(conf madmin.TierS3, tier string) (*warmBackendS3, error) {
	u, err := url.Parse(conf.Endpoint)
	if err != nil {
		return nil, err
	}

	// Validation code
	switch {

	lockInit(&t.mu, lockRankTimer)
	t.f = f
	t.arg = arg
}

// A timers is a per-P set of timers.
type timers struct {
	// mu protects timers; timers are per-P, but the scheduler can
	// access the timers of another P, so we have to lock.
	mu mutex

	// heap is the set of timers, ordered by heap[i].when.
	// Must hold lock to access.
	heap []timerWhen

	case madmin.Azure:
		d, err = newWarmBackendAzure(*tier.Azure, tier.Name)
	case madmin.GCS:
		d, err = newWarmBackendGCS(*tier.GCS, tier.Name)
	case madmin.MinIO:
		d, err = newWarmBackendMinIO(*tier.MinIO, tier.Name)
	default:
		return nil, errTierTypeUnsupported
	}
	if err != nil {
		return nil, errTierTypeUnsupported
	}

	if probe {
		if err = checkWarmBackend(ctx, d); err != nil {
			return nil, err

Krishnan Parthasarathi <******@****.***> 1711041695 -0700

	done.Add(4 * procs)
	for p := 0; p < procs; p++ {
		const iters = 1e3
		go func() {
			trace.WithRegion(context.Background(), "special", func() {
				for i := 0; i < iters; i++ {
					runtime.Gosched()
					c0 <- 0
				}
				done.Done()
			})
		}()
		go func() {
			trace.WithRegion(context.Background(), "special", func() {
				for i := 0; i < iters; i++ {
					runtime.Gosched()
					<-c0
				}
				done.Done()

	})
}

func BenchmarkStartStop1000(b *testing.B) {
	benchmark(b, func(pb *testing.PB) {
		for pb.Next() {
			const N = 1000
			timers := make([]*Timer, N)
			for i := range timers {
				timers[i] = AfterFunc(Hour, nil)
			}

			for i := range timers {
				timers[i].Stop()
			}
		}
	})
}

func BenchmarkReset(b *testing.B) {
	b.Run("impl=chan", func(b *testing.B) {

package cmd

import (
	"testing"
	"time"
)

func TestTierMetrics(t *testing.T) {
	tier := "WARM-1"
	globalTierMetrics.Observe(tier, 200*time.Millisecond)
	expSuccess := 10
	expFailure := 5
	for i := 0; i < expSuccess; i++ {
		globalTierMetrics.logSuccess(tier)
	}
	for i := 0; i < expFailure; i++ {
		globalTierMetrics.logFailure(tier)
	}
	metrics := globalTierMetrics.Report()
	var succ, fail float64

		cgran         coverage.CounterGranularity
		src, dst, res []uint32
		iters         int
		merr          bool
		overflow      bool
	}{
		{
			cmode:    coverage.CtrModeSet,
			cgran:    coverage.CtrGranularityPerBlock,
			src:      []uint32{1, 0, 1},
			dst:      []uint32{1, 1, 0},
			res:      []uint32{1, 1, 1},
			iters:    2,
			overflow: false,
		},
		{
			cmode:    coverage.CtrModeCount,

	"testing"
)

func TestReproducibleBuilds(t *testing.T) {
	tests := []string{
		"issue20272.go",
		"issue27013.go",
		"issue30202.go",
	}

	testenv.MustHaveGoBuild(t)
	iters := 10
	if testing.Short() {
		iters = 4
	}
	t.Parallel()
	for _, test := range tests {
		test := test
		t.Run(test, func(t *testing.T) {
			t.Parallel()
			var want []byte
			tmp, err := os.CreateTemp("", "")

Klaus Post <******@****.***> 1708383286 -0800