param("performance.db.username", "tcagent")
    }
}

fun performanceTestCommandLine(
    task: String,
    baselines: String,
    extraParameters: String = "",
    os: Os = Os.LINUX,
    arch: Arch = Arch.AMD64,
    testJavaVersion: String = os.perfTestJavaVersion.major.toString(),
    testJavaVendor: String = os.perfTestJavaVendor.name.lowercase(),
) = listOf(

	// Convert local messages to JSON and send to mergeCh
	go func() {
		buf := bytes.NewBuffer(grid.GetByteBuffer()[:0])
		enc := json.NewEncoder(buf)
		tmpEvt := struct{ Records []event.Event }{[]event.Event{{}}}
		for {
			select {
			case ev := <-localCh:
				buf.Reset()
				tmpEvt.Records[0] = ev
				if err := enc.Encode(tmpEvt); err != nil {

	tr.ResponseHeaderTimeout = 0
	tr.TLSClientConfig.InsecureSkipVerify = insecure

	return func() *http.Transport {
		return tr
	}
}

// uaTransport - User-Agent  transport
type uaTransport struct {
	ua string
	rt http.RoundTripper
}

func (u *uaTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	req2 := req.Clone(req.Context())
	req2.Header.Set("User-Agent", u.ua)
	return u.rt.RoundTrip(req2)

// testBucketLifecycle is a generic testing of lifecycle requests
func testBucketLifecycle(obj ObjectLayer, instanceType, bucketName string, apiRouter http.Handler,
	t *testing.T, testCases []struct {
		method             string
		bucketName         string
		accessKey          string
		secretKey          string
		body               []byte
		expectedRespStatus int
		lifecycleResponse  []byte
		errorResponse      APIErrorResponse

type metacache struct {
	// do not re-arrange the struct this struct has been ordered to use less
	// space - if you do so please run https://github.com/orijtech/structslop
	// and verify if your changes are optimal.
	ended        time.Time  `msg:"end"`
	started      time.Time  `msg:"st"`
	lastHandout  time.Time  `msg:"lh"`
	lastUpdate   time.Time  `msg:"u"`
	bucket       string     `msg:"b"`

	}
	t.Fatal(file, "not found in testdata/testdata.zip")
	return nil
}

func TestReadExtended(t *testing.T) {
	cases := []struct {
		file            string
		recordDelimiter string
		fieldDelimiter  string
		header          bool
		wantColumns     []string
		wantTenFields   string
		totalFields     int
	}{
		{
			file:            "nyc-taxi-data-100k.csv",
			recordDelimiter: "\n",

package clause

// Limit limit clause
type Limit struct {
	Limit  *int
	Offset int
}

// Name where clause name
func (limit Limit) Name() string {
	return "LIMIT"
}

// Build build where clause
func (limit Limit) Build(builder Builder) {
	if limit.Limit != nil && *limit.Limit >= 0 {
		builder.WriteString("LIMIT ")
		builder.AddVar(builder, *limit.Limit)
	}
	if limit.Offset > 0 {

package jstream

import (
	"unicode/utf8"
)

type scratch struct {
	data []byte
	fill int
}

// reset scratch buffer
func (s *scratch) reset() { s.fill = 0 }

// bytes returns the written contents of scratch buffer
func (s *scratch) bytes() []byte { return s.data[0:s.fill] }

// grow scratch buffer
func (s *scratch) grow() {
	ndata := make([]byte, cap(s.data)*2)
	copy(ndata, s.data)
	s.data = ndata
}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build goexperiment.arenas

package arena_test

import (
	"arena"
	"testing"
)

type T1 struct {
	n int
}
type T2 [1 << 20]byte // 1MiB

func TestSmoke(t *testing.T) {
	a := arena.NewArena()
	defer a.Free()

	tt := arena.New[T1](a)
	tt.n = 1

	ts := arena.MakeSlice[T1](a, 99, 100)

	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[TargetConsole-1]
	_ = x[TargetHTTP-2]
	_ = x[TargetKafka-3]
}

const _TargetType_name = "ConsoleHTTPKafka"

var _TargetType_index = [...]uint8{0, 7, 11, 16}

func (i TargetType) String() string {
	i -= 1
	if i >= TargetType(len(_TargetType_index)-1) {