type RedisTarget struct {
	initOnce once.Init

	id         event.TargetID
	args       RedisArgs
	pool       *redis.Pool
	store      store.Store[event.Event]
	firstPing  bool
	loggerOnce logger.LogOnce
	quitCh     chan struct{}
}

// ID - returns target ID.
func (target *RedisTarget) ID() event.TargetID {
	return target.id
}

// Name - returns the Name of the target.

	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	}

	CheckUser(t, user, user)

	// Find
	var user2 User
	DB.Find(&user2, "id = ?", user.ID)
	DB.Model(&user2).Association("Account").Find(&user2.Account)
	CheckUser(t, user2, user)

	// Count
	AssertAssociationCount(t, user, "Account", 1, "")

	// Append

// MQTTTarget - MQTT target.
type MQTTTarget struct {
	initOnce once.Init

	id         event.TargetID
	args       MQTTArgs
	client     mqtt.Client
	store      store.Store[event.Event]
	quitCh     chan struct{}
	loggerOnce logger.LogOnce
}

// ID - returns target ID.
func (target *MQTTTarget) ID() event.TargetID {
	return target.id
}

// Name - returns the Name of the target.

// is a compiler-computed md5.sum for the blob, 'pkpath' is the
// package path, 'pkid' is the hard-coded ID that the compiler is
// using for the package (or -1 if the compiler doesn't think a
// hard-coded ID is needed), and 'cmode'/'cgran' are the coverage
// counter mode and granularity requested by the user. Return value is
// the ID for the package for use by the package code itself,
// or 0 for impossible errors.

type Multicluster struct {
	configCluster  cluster.ID
	secretHandlers []func(name string, namespace string)
	component      *multicluster.Component[*CredentialsController]
}

var _ credentials.MulticlusterController = &Multicluster{}

func NewMulticluster(configCluster cluster.ID, controller multicluster.ComponentBuilder) *Multicluster {
	m := &Multicluster{
		configCluster: configCluster,

type kubeNamespace struct {
	ctx          resource.Context
	id           resource.ID
	name         string
	prefix       string
	cleanupMutex sync.Mutex
	cleanupFuncs []func() error
	skipDump     bool
}

func (n *kubeNamespace) Dump(ctx resource.Context) {
	if n.skipDump {
		scopes.Framework.Debugf("=== Skip dumping Namespace %s State for %v...", n.name, ctx.ID())
		return
	}

	if !ok {
		log.Warnf("collection %s could not be found", col.String())
		return nil
	}
	for id, store := range i.stores {
		cfg := store.Get(colschema.GroupVersionKind(), name.Name.String(), name.Namespace.String())
		if cfg == nil {
			continue
		}
		result, err := cfgToInstance(*cfg, col, colschema, id)
		if err != nil {
			log.Errorf("failed converting found config %s %s/%s to instance: %s, ",

	type user struct {
		ID    int `gorm:"primaryKey"`
		Name  string
		Email string `gorm:"default:(-)"`
		Age   int    `gorm:"default:(-)"`
	}

	s, err := schema.Parse(&user{}, schemaCache, schema.NamingStrategy{})
	if err != nil {
		t.Errorf("parse schema error: %v, is not expected", err)
		return
	}
	dest := []*user{
		{
			ID:    1,
			Name:  "alice",
			Email: "email",

	// stack trace. Specifically, it means that after the arguments
	// there's a varint length, followed by 4*length varints. Each
	// group of 4 represents the PC, file ID, func ID, and line number
	// in that order.
	IsStack bool

	// Experiment indicates the ID of an experiment this event is associated
	// with. If Experiment is not NoExperiment, then the event is experimental
	// and will be exposed as an EventExperiment.

	if err != nil {
		return err
	}

	return installProviders(ctx, providerYAML)
}

type serverImpl struct {
	id        resource.ID
	ns        namespace.Instance
	providers []Provider
}

func (s *serverImpl) ID() resource.ID {
	return s.id
}

func (s *serverImpl) Namespace() namespace.Instance {
	return s.ns
}

func (s *serverImpl) Providers() []Provider {