json.NewEncoder(w).Encode(res)
	return
}

func main() {
	flag.Parse()
	serveFunc := func() error {
		return http.ListenAndServe(":8080", nil)
	}

	if certFile != "" || keyFile != "" {
		if certFile == "" || keyFile == "" {
			log.Fatal("Please provide both a key file and a cert file to enable TLS.")
		}
		serveFunc = func() error {
			return http.ListenAndServeTLS(":8080", certFile, keyFile, nil)

// This can be used for goroutines that live beyond the parent context.
func bgContext(parent context.Context) context.Context {
	return bgCtx{parent: parent}
}

type bgCtx struct {
	parent context.Context
}

func (a bgCtx) Done() <-chan struct{} {
	return nil
}

func (a bgCtx) Err() error {
	return nil
}

func (a bgCtx) Deadline() (deadline time.Time, ok bool) {

	}
	ps.Unlock()
	close(doneCh2)
}

type maskString string

func (m maskString) Mask() uint64 {
	return 1
}

func TestPubSub(t *testing.T) {
	ps := New[Maskable, Maskable](1)
	ch1 := make(chan Maskable, 1)
	doneCh1 := make(chan struct{})
	defer close(doneCh1)
	if err := ps.Subscribe(MaskAll, ch1, doneCh1, func(entry Maskable) bool { return true }); err != nil {
		t.Fatalf("unexpected error: %v", err)

}

// Init initializes or clears list l.
func (l *LruList[K, V]) Init() *LruList[K, V] {
	l.root.next = &l.root
	l.root.prev = &l.root
	l.len = 0
	return l
}

// NewList returns an initialized list.
func NewList[K comparable, V any]() *LruList[K, V] { return new(LruList[K, V]).Init() }

// Length returns the number of elements of list l.
// The complexity is O(1).
func (l *LruList[K, V]) Length() int { return l.len }

	}

	return err
}

func (e *AliasedExpression) aggregateRow(r Record, tableAlias string) error {
	return e.Expression.aggregateRow(r, tableAlias)
}

func (e *Expression) aggregateRow(r Record, tableAlias string) error {
	for _, ex := range e.And {
		err := ex.aggregateRow(r, tableAlias)
		if err != nil {
			return err
		}
	}
	return nil
}

	DownloadTimes madmin.TimeDurations
	DownloadTTFB  madmin.TimeDurations
	Error         string
}

func newRandomReader(size int) io.Reader {
	return io.LimitReader(randreader.New(), int64(size))
}

type firstByteRecorder struct {
	t *time.Time
	r io.Reader
}

func (f *firstByteRecorder) Read(p []byte) (n int, err error) {
	if f.t != nil || len(p) == 0 {
		return f.r.Read(p)
	}

		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgActiveWorkerStat(b *testing.B) {
	v := ActiveWorkerStat{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgActiveWorkerStat(b *testing.B) {
	v := ActiveWorkerStat{}
	bts := make([]byte, 0, v.Msgsize())

// returns the slice of errors from all function calls.
func (g *NotificationGroup) Wait() []NotificationPeerErr {
	g.workers.Wait()
	return g.errs
}

// Go calls the given function in a new goroutine.
//
// The first call to return a non-nil error will be
// collected in errs slice and returned by Wait().
func (g *NotificationGroup) Go(ctx context.Context, f func() error, index int, addr xnet.Host) {

// Values should match if type is the same.
var valueBuilders = []func() *Value{
	FromNull,
	func() *Value {
		return FromBool(true)
	},
	func() *Value {
		return FromBytes([]byte("byte contents"))
	},
	func() *Value {
		return FromFloat(math.Pi)
	},
	func() *Value {
		return FromInt(0x1337)
	},
	func() *Value {
		t, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")
		if err != nil {

func (z *BucketStats) Msgsize() (s int) {
	s = 1 + 7 + msgp.Int64Size + 17 + z.ReplicationStats.Msgsize() + 11 + 1 + 6 + msgp.ArrayHeaderSize
	for za0001 := range z.QueueStats.Nodes {
		s += z.QueueStats.Nodes[za0001].Msgsize()
	}
	s += 7 + msgp.Int64Size + 11 + z.ProxyStats.Msgsize()
	return
}

// DecodeMsg implements msgp.Decodable