bs.ReplicatedSize > 0 ||
		bs.ReplicaSize > 0
}

func (bs *BucketReplicationStat) updateXferRate(sz int64, duration time.Duration) {
	if sz > minLargeObjSize {
		bs.XferRateLrg.addSize(sz, duration)
	} else {
		bs.XferRateSml.addSize(sz, duration)
	}
}

// RMetricName - name of replication metric
type RMetricName string

const (
	// Large - objects larger than 128MiB

	secure := globalIsTLS
	if globalMinioEndpointURL != nil {
		host = globalMinioEndpointURL.Host
		secure = globalMinioEndpointURL.Scheme == "https"
	}

	duration := time.Until(cred.Expiration)
	if duration > time.Hour || duration < time.Hour {
		// Always limit to 1 hour.
		duration = time.Hour
	}

	clnt, err := miniogo.New(host, &miniogo.Options{
		Creds:     credentials.NewStaticV4(cred.AccessKey, cred.SecretKey, cred.SessionToken),

package logger

import (
	"context"
	"errors"
	"fmt"
	"log/slog"
	"time"
)

type slogLogger struct {
	Logger                    *slog.Logger
	LogLevel                  LogLevel
	SlowThreshold             time.Duration
	Parameterized             bool
	Colorful                  bool // Ignored in slog
	IgnoreRecordNotFoundError bool
}

func NewSlogLogger(logger *slog.Logger, config Config) Interface {
	return &slogLogger{

import assertk.assertions.isTrue
import java.net.InetAddress
import java.net.ServerSocket
import java.net.Socket
import java.util.concurrent.TimeUnit
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.Duration.Companion.nanoseconds
import okio.buffer
import okio.source
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows

class UtilTest {
  @Test

     *     next
     * @since 28.0 (but only since 33.4.0 in the Android flavor)
     */
    public static Scheduler newFixedDelaySchedule(Duration initialDelay, Duration delay) {
      return newFixedDelaySchedule(
          toNanosSaturated(initialDelay), toNanosSaturated(delay), NANOSECONDS);
    }

    /**

     * will not be used and a network request will be made.
     *
     * @param maxAge a non-negative duration. This is stored and transmitted with [TimeUnit.SECONDS]
     *     precision; finer precision will be lost.
     */
    fun maxAge(maxAge: Duration) =
      apply {
        val maxAgeSeconds = maxAge.inWholeSeconds
        require(maxAgeSeconds >= 0) { "maxAge < 0: $maxAgeSeconds" }

        } catch (Exception e) {
            // Expected
        }
        long duration = System.currentTimeMillis() - startTime;

        // Test should complete in under 1 second (much less than the original 25+ seconds)
        assertTrue("Test should complete quickly (duration: " + duration + "ms)", duration < 1000);
    }

    // Fast mock implementations to minimize overhead

        rateLimiter = new AuthenticationRateLimiter(3, // max attempts per account
                5, // max attempts per IP
                20, // max global attempts per minute
                Duration.ofSeconds(2), // short lockout for testing
                Duration.ofMinutes(1) // cleanup interval
        );
    }

    @AfterEach
    public void tearDown() {
        if (rateLimiter != null) {
            rateLimiter.close();
        }

	// This exploit needs browser to be enabled.
	if !globalBrowserEnabled {
		globalBrowserEnabled = true
		defer func() { globalBrowserEnabled = false }()
	}

	// initialize HTTP NewRecorder, this records any mutations to response writer inside the handler.
	rec := httptest.NewRecorder()
	req, perr := newPostRequestV4("", bucketName, objectName, []byte("pwned"), credentials.AccessKey, credentials.SecretKey)
	if perr != nil {

}

type latencyStat struct {
	lastmin lastMinuteLatency
	curr    time.Duration
	avg     time.Duration
	peak    time.Duration
	N       int64
}

func (l *latencyStat) update(d time.Duration) {
	l.lastmin.add(d)
	l.N++
	if d > l.peak {
		l.peak = d
	}
	l.curr = l.lastmin.getTotal().avg()
	l.avg = time.Duration((int64(l.avg)*(l.N-1) + int64(l.curr)) / l.N)
}