return nil
}

func UpdateConfigCondition(cfg config.Config, condition *v1alpha1.IstioCondition) config.Config {
	cfg = cfg.DeepCopy()
	var status *v1alpha1.IstioStatus
	if cfg.Status == nil {
		cfg.Status = &v1alpha1.IstioStatus{}
	}
	status = cfg.Status.(*v1alpha1.IstioStatus)
	status.Conditions = updateCondition(status.Conditions, condition)
	return cfg
}

			}
		})
	}
}

func Test_getTypedStatus(t *testing.T) {
	x := v1alpha1.IstioStatus{}
	b, _ := json.Marshal(statusStillPropagating)
	_ = json.Unmarshal(b, &x)
	type args struct {
		in any
	}
	tests := []struct {
		name    string
		args    args
		wantOut *v1alpha1.IstioStatus
		wantErr bool
	}{
		{
			name:    "Nondestructive cast",

	}
	return result
}

func (m *Manager) CreateIstioStatusController(fn func(status *v1alpha1.IstioStatus, context any) *v1alpha1.IstioStatus) *Controller {
	wrapper := func(status any, context any) GenerationProvider {
		var input *v1alpha1.IstioStatus
		if status != nil {
			converted := status.(*IstioGenerationProvider)
			input = converted.IstioStatus
		}
		result := fn(input, context)
		return &IstioGenerationProvider{result}
	}

	}
}

func GetTypedStatus(in any) (out *v1alpha1.IstioStatus, err error) {
	if ret, ok := in.(*v1alpha1.IstioStatus); ok {
		return ret, nil
	}
	return nil, fmt.Errorf("cannot cast %T: %v to IstioStatus", in, in)
}

func GetOGProvider(in any) (out GenerationProvider, err error) {
	if ret, ok := in.(*v1alpha1.IstioStatus); ok && ret != nil {
		return &IstioGenerationProvider{ret}, nil
	}

		UpdateInterval:  200 * time.Millisecond,
		StaleInterval:   time.Minute,
		clock:           clock.RealClock{},
		configStore:     cs,
		workers: m.CreateIstioStatusController(func(status *v1alpha1.IstioStatus, context any) *v1alpha1.IstioStatus {
			if status == nil {
				return nil
			}
			distributionState := context.(Progress)
			if needsReconcile, desiredStatus := ReconcileStatuses(status, distributionState); needsReconcile {

		Namespace:  "r1",
		Name:       "r1",
		Generation: "12",
	}
	var runCount int32
	x := make(chan struct{})
	y := make(chan struct{})
	mgr := NewManager(nil)
	fakefunc := func(status *v1alpha1.IstioStatus, context any) *v1alpha1.IstioStatus {
		x <- struct{}{}
		atomic.AddInt32(&runCount, 1)
		y <- struct{}{}
		return nil
	}
	c1 := mgr.CreateIstioStatusController(fakefunc)
	c2 := mgr.CreateIstioStatusController(fakefunc)

// HasHealthCondition returns true if a given WorkloadEntry has ConditionHealthy
// condition.
func HasHealthCondition(wle *config.Config) bool {
	if wle == nil {
		return false
	}
	s, ok := wle.Status.(*v1alpha1.IstioStatus)
	if !ok {
		return false
	}
	return status.GetCondition(s.Conditions, status.ConditionHealthy) != nil

	err := ia.Init(stop)
	if err != nil {
		return nil, fmt.Errorf("unable to initialize analysis controller, releasing lease: %s", err)
	}
	ctl := statusManager.CreateIstioStatusController(func(status *v1alpha1.IstioStatus, context any) *v1alpha1.IstioStatus {
		msgs := context.(diag.Messages)
		// zero out analysis messages, as this is the sole controller for those
		status.ValidationMessages = []*v1alpha12.AnalysisMessageBase{}
		for _, msg := range msgs {

	SetObservedGeneration(int64)
	Unwrap() any
}

type IstioGenerationProvider struct {
	*v1alpha1.IstioStatus
}

func (i *IstioGenerationProvider) SetObservedGeneration(in int64) {
	i.ObservedGeneration = in
}

func (i *IstioGenerationProvider) Unwrap() any {
	return i.IstioStatus

	}
	// The workloadentry has reconnected to the other istiod
	if !s.cb.IsControllerOf(cfg) {
		return nil
	}

	// check if the existing health status is newer than this one
	wleStatus, ok := cfg.Status.(*v1alpha1.IstioStatus)
	if ok {
		healthCondition := status.GetCondition(wleStatus.Conditions, status.ConditionHealthy)
		if healthCondition != nil {
			if healthCondition.LastProbeTime.AsTime().After(condition.LastProbeTime.AsTime()) {