for _, conditionType := range conditionTypes {
		newCondition := getCondition(newConditions, conditionType)
		// if we weren't failing, then this returned nil.  We should set the "ok" variant of the condition
		if newCondition == nil {
			newCondition = newSuccessfulCondition(conditionType)
		}
		oldCondition := getCondition(status.Conditions, conditionType)

		conditions    []metav1.Condition
		conditionType string
		expected      *metav1.Condition
	}{
		{
			name: "not-present",
			conditions: []metav1.Condition{
				{Type: "first"},
			},
			conditionType: "second",
			expected:      nil,
		},
		{
			name: "present",
			conditions: []metav1.Condition{
				{Type: "first"},
				{Type: "second"},
			},
			conditionType: "second",

func IsConditionTrue(svm *svmv1alpha1.StorageVersionMigration, conditionType svmv1alpha1.MigrationConditionType) bool {
	return indexOfCondition(svm, conditionType) != -1
}

func indexOfCondition(svm *svmv1alpha1.StorageVersionMigration, conditionType svmv1alpha1.MigrationConditionType) int {
	for i, c := range svm.Status.Conditions {
		if c.Type == conditionType && c.Status == corev1.ConditionTrue {
			return i
		}
	}
	return -1

type PodReadinessGateApplyConfiguration struct {
	ConditionType *v1.PodConditionType `json:"conditionType,omitempty"`
}

// PodReadinessGateApplyConfiguration constructs an declarative configuration of the PodReadinessGate type for use with
// apply.
func PodReadinessGate() *PodReadinessGateApplyConfiguration {
	return &PodReadinessGateApplyConfiguration{}
}

			return &conditions[i]
		}
	}

	return nil
}

// IsStatusConditionTrue returns true when the conditionType is present and set to `metav1.ConditionTrue`
func IsStatusConditionTrue(conditions []metav1.Condition, conditionType string) bool {
	return IsStatusConditionPresentAndEqual(conditions, conditionType, metav1.ConditionTrue)
}

// PodConditionByKubelet returns if the pod condition type is owned by kubelet
func PodConditionByKubelet(conditionType v1.PodConditionType) bool {
	for _, c := range PodConditionsByKubelet {
		if c == conditionType {
			return true
		}
	}
	if utilfeature.DefaultFeatureGate.Enabled(features.PodReadyToStartContainersCondition) {
		if conditionType == v1.PodReadyToStartContainers {
			return true
		}
	}
	return false
}

	tests := []struct {
		name                 string
		crdCondition         []CustomResourceDefinitionCondition
		conditionType        CustomResourceDefinitionConditionType
		expectedcrdCondition []CustomResourceDefinitionCondition
	}{
		{
			name: "test remove CRDCondition when the conditionType meets",
			crdCondition: []CustomResourceDefinitionCondition{
				{
					Type:               Established,

	return IsCRDConditionPresentAndEqual(crd, conditionType, ConditionTrue)
}

// IsCRDConditionFalse indicates if the condition is present and false.
func IsCRDConditionFalse(crd *CustomResourceDefinition, conditionType CustomResourceDefinitionConditionType) bool {
	return IsCRDConditionPresentAndEqual(crd, conditionType, ConditionFalse)
}

}

// GetFlowSchemaConditionByType gets conditions.
func GetFlowSchemaConditionByType(flowSchema *flowcontrol.FlowSchema, conditionType flowcontrol.FlowSchemaConditionType) *flowcontrol.FlowSchemaCondition {
	for i := range flowSchema.Status.Conditions {
		if flowSchema.Status.Conditions[i].Type == conditionType {
			return &flowSchema.Status.Conditions[i]
		}
	}
	return nil
}

				t.Error(err)
			}

			newCond := util.GetDeploymentCondition(test.d.Status, test.conditionType)
			switch {
			case newCond == nil:
				if test.d.Spec.ProgressDeadlineSeconds != nil && *test.d.Spec.ProgressDeadlineSeconds != math.MaxInt32 {
					t.Errorf("%s: expected deployment condition: %s", test.name, test.conditionType)
				}
			case newCond.Status != test.conditionStatus || newCond.Reason != test.conditionReason: