// Stats is a collection of stats for multiple targets.
type Stats struct {
	TotalEvents        int64 // Deprecated
	EventsSkipped      int64
	CurrentQueuedCalls int64 // Deprecated
	EventsErrorsTotal  int64 // Deprecated
	CurrentSendCalls   int64 // Deprecated

	TargetStats map[TargetID]TargetStat
}

// TargetStat is the stats of a single target.
type TargetStat struct {

package cmd

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"strings"
	"testing"
)

// Test read chunk line.
func TestReadChunkLine(t *testing.T) {
	type testCase struct {
		reader         *bufio.Reader
		expectedErr    error
		chunkSize      []byte
		chunkSignature []byte
	}
	// List of readers used.
	readers := []io.Reader{
		// Test - 1

package tests_test

import (
	"regexp"
	"sync"
	"testing"

	"gorm.io/driver/postgres"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils/tests"
	. "gorm.io/gorm/utils/tests"
)

type UserWithTable struct {
	gorm.Model
	Name string
}

func (UserWithTable) TableName() string {
	return "gorm.user"
}

func TestTable(t *testing.T) {
	dryDB := DB.Session(&gorm.Session{DryRun: true})

[`Interface.Methods`](/pkg/go/types#Interface.Methods),
[`MethodSet.Methods`](/pkg/go/types#MethodSet.Methods),
[`Named.Methods`](/pkg/go/types#Named.Methods),
[`Scope.Children`](/pkg/go/types#Scope.Children),
[`Struct.Fields`](/pkg/go/types#Struct.Fields),
[`Tuple.Variables`](/pkg/go/types#Tuple.Variables),
[`TypeList.Types`](/pkg/go/types#TypeList.Types),
[`TypeParamList.TypeParams`](/pkg/go/types#TypeParamList.TypeParams),

package clause

type Returning struct {
	Columns []Column
}

// Name where clause name
func (returning Returning) Name() string {
	return "RETURNING"
}

// Build build where clause
func (returning Returning) Build(builder Builder) {
	if len(returning.Columns) > 0 {
		for idx, column := range returning.Columns {
			if idx > 0 {
				builder.WriteByte(',')
			}

			builder.WriteQuoted(column)
		}
	} else {

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"fmt"
	"testing"
)

func TestBatchJobSizeInRange(t *testing.T) {
	tests := []struct {
		objSize    int64
		sizeFilter BatchJobSizeFilter
		want       bool
	}{
		{
			// 1Mib < 2Mib < 10MiB -> in range
			objSize: 2 << 20,
			sizeFilter: BatchJobSizeFilter{
				UpperBound: 10 << 20,

	remoteHost := remote.HostName()

	// 1: Echo
	serverCanceled := make(chan struct{})
	register := func(manager *Manager) {
		errFatal(manager.RegisterStreamingHandler(handlerTest, StreamHandler{
			Handle: func(ctx context.Context, payload []byte, request <-chan []byte, resp chan<- []byte) *RemoteErr {
				<-ctx.Done()
				serverCanceled <- struct{}{}
				fmt.Println(GetCaller(ctx).Name, "Server Context canceled")
				return nil

	xhttp "github.com/minio/minio/internal/http"
)

// WarmBackendGetOpts is used to express byte ranges within an object. The zero
// value represents the entire byte range of an object.
type WarmBackendGetOpts struct {
	startOffset int64
	length      int64
}

// WarmBackend provides interface to be implemented by remote tier backends
type WarmBackend interface {

// LogOnce provides the function type for logger.LogOnceIf() function
type LogOnce func(ctx context.Context, err error, id string, errKind ...interface{})

type onceErr struct {
	Err   error
	Count int
}

// Holds a map of recently logged errors.
type logOnceType struct {
	IDMap map[string]onceErr
	sync.Mutex
}

// Err is a structure which contains all information
// to print a fatal error message in json or pretty mode
// Err implements error so we can use it anywhere
type Err struct {
	msg    string
	detail string
	action string
	hint   string
}

// Clone returns a new Err struct with the same information
func (u Err) Clone() Err {
	return Err{
		msg:    u.msg,
		detail: u.detail,
		action: u.action,
		hint:   u.hint,
	}
}