uuid []byte
}

// Write -  implement hash.Hash Write
func (u UUIDHash) Write(p []byte) (n int, err error) {
	return len(p), nil
}

// Sum -  implement md5.Sum
func (u UUIDHash) Sum(b []byte) []byte {
	return u.uuid
}

// Reset -  implement hash.Hash Reset
func (u UUIDHash) Reset() {}

// Size -  implement hash.Hash Size
func (u UUIDHash) Size() int {
	return len(u.uuid)
}

	sendErr  bool
	closeErr bool
}

func (target ExampleTarget) ID() TargetID {
	return target.id
}

// Save - Sends event directly without persisting.
func (target ExampleTarget) Save(eventData Event) error {
	return target.send(eventData)
}

// Store - Returns a nil store.
func (target ExampleTarget) Store() TargetStore {
	return nil
}

func (target ExampleTarget) send(eventData Event) error {

		t.Fatalf("Build OR condition, but got %v", result.Statement.SQL.String())
	}
}

type Int64 int64

func (v Int64) Value() (driver.Value, error) {
	return v - 1, nil
}

func (f *Int64) Scan(v interface{}) error {
	y := v.(int64)
	*f = Int64(y + 1)
	return nil
}

func TestPluck(t *testing.T) {
	users := []*User{
		GetUser("pluck-user1", Config{}),
		GetUser("pluck-user2", Config{}),

	client     *kms.Client
}

func (c *kmsConn) Version(ctx context.Context) (string, error) {
	resp, err := c.client.Version(ctx, &kms.VersionRequest{})
	if len(resp) == 0 && err != nil {
		return "", err
	}
	return resp[0].Version, nil
}

func (c *kmsConn) APIs(ctx context.Context) ([]madmin.KMSAPI, error) {
	return nil, ErrNotSupported
}

	peerResyncMap map[string]resyncState
}

func newSiteResyncMetrics(ctx context.Context) *siteResyncMetrics {
	s := siteResyncMetrics{
		resyncStatus:  make(map[string]SiteResyncStatus),
		peerResyncMap: make(map[string]resyncState),
	}
	go s.save(ctx)
	go s.init(ctx)
	return &s
}

// init site resync metrics
func (sm *siteResyncMetrics) init(ctx context.Context) {

type healRoutine struct {
	tasks   chan healTask
	workers int
}

func activeListeners() int {
	// Bucket notification and http trace are not costly, it is okay to ignore them
	// while counting the number of concurrent connections
	return int(globalHTTPListen.Subscribers()) + int(globalTrace.Subscribers())
}

func waitForLowIO(maxIO int, maxWait time.Duration, currentIO func() int) {
	// No need to wait run at full speed.
	if maxIO <= 0 {

	Bucket       string
	Prefix       string
	StorageClass string
}

func (az *warmBackendAzure) tier() *blob.AccessTier {
	if az.StorageClass == "" {
		return nil
	}
	for _, t := range blob.PossibleAccessTierValues() {
		if strings.EqualFold(az.StorageClass, string(t)) {
			return &t
		}
	}
	return nil
}

func (az *warmBackendAzure) getDest(object string) string {
	destObj := object
	if az.Prefix != "" {

	return nil
}

// IsDaysNull returns true if days field is null
func (e Expiration) IsDaysNull() bool {
	return e.Days == ExpirationDays(0)
}

// IsDateNull returns true if date field is null
func (e Expiration) IsDateNull() bool {
	return e.Date.IsZero()
}

// IsNull returns true if both date and days fields are null
func (e Expiration) IsNull() bool {
	return e.IsDaysNull() && e.IsDateNull()

	// which needs to patched like a jump.
	"ADR":  true,
	"ADRP": true,
}

func jumpArm64(word string) bool {
	return arm64Jump[word]
}

var arm64SpecialOperand map[string]arm64.SpecialOperand

// ARM64SpecialOperand returns the internal representation of a special operand.
func ARM64SpecialOperand(name string) arm64.SpecialOperand {
	if arm64SpecialOperand == nil {

	}
	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)