if c.Type == condType {
			return &c
		}
	}
	return nil
}

// SetCondition adds/replaces the given condition in the replication controller status.
func SetCondition(status *v1.ReplicationControllerStatus, condition v1.ReplicationControllerCondition) {
	currentCond := GetCondition(*status, condition.Type)
	if currentCond != nil && currentCond.Status == condition.Status && currentCond.Reason == condition.Reason {
		return
	}

func GetBoolCondition(conditions []*v1alpha1.IstioCondition, condition string, defaultValue bool) bool {
	got := GetCondition(conditions, condition)
	if got == nil {
		return defaultValue
	}
	if got.Status == StatusTrue {
		return true
	}
	if got.Status == StatusFalse {
		return false
	}
	return defaultValue
}

func GetCondition(conditions []*v1alpha1.IstioCondition, condition string) *v1alpha1.IstioCondition {

		Message:            msg,
	}
}

// GetCondition returns a replicaset condition with the provided type if it exists.
func GetCondition(status apps.ReplicaSetStatus, condType apps.ReplicaSetConditionType) *apps.ReplicaSetCondition {
	for _, c := range status.Conditions {
		if c.Type == condType {
			return &c
		}
	}
	return nil
}

func isSuccessful(svm *storagemigration.StorageVersionMigration) bool {
	successCondition := getCondition(svm, storagemigration.MigrationSucceeded)
	if successCondition != nil && successCondition.Status == corev1.ConditionTrue {
		return true
	}
	return false
}

func isFailed(svm *storagemigration.StorageVersionMigration) bool {
	failedCondition := getCondition(svm, storagemigration.MigrationFailed)

    // Then branch
    if (matchPattern(if_op.getCondition(), m_NonZero())) {
      return InlineRegion(if_op.getLoc(), rewriter, if_op,
                          &if_op.getThenRegion());
    }

    // Else branch
    if (matchPattern(if_op.getCondition(), m_Zero())) {
      if (if_op.getElseRegion().empty()) {
        // Remove the op

// 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

				},
			},
			condition: "",
			want:      metav1.Condition{},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := GetCondition(tt.conditions, tt.condition); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("GetCondition got %v, want %v", got, tt.want)
			}
		})
	}
}

func TestCreateCondition(t *testing.T) {
	transitionTime := metav1.Now()
	tests := []struct {

				}
			}
		}
	}()
	return client
}

func approved(csr *cert.CertificateSigningRequest) bool {
	return GetCondition(csr.Status.Conditions, cert.CertificateApproved).Status == corev1.ConditionTrue
}

func GetCondition(conditions []cert.CertificateSigningRequestCondition, condition cert.RequestConditionType) cert.CertificateSigningRequestCondition {
	for _, cond := range conditions {

	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()) {
				return nil
			}
		}
	}

	if !reflect.DeepEqual(old, w.Status) {
		w.Dirty = true
	}
}

func (w *WrappedStatus) Unwrap() config.Status {
	return w.Status
}

var EmptyCondition = metav1.Condition{}

func GetCondition(conditions []metav1.Condition, condition string) metav1.Condition {
	for _, cond := range conditions {
		if cond.Type == condition {
			return cond
		}
	}
	return EmptyCondition
}