return b
}

// WithReason sets the Reason field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Reason field is set to the value of the last call.
func (b *ValidationApplyConfiguration) WithReason(value v1.StatusReason) *ValidationApplyConfiguration {
	b.Reason = &value
	return b
}

        this(dependencyDescriptor, reason, endorsing, dependencyDescriptor.getConfigurationArtifacts());
    }

    private MavenDependencyMetadata(MavenDependencyDescriptor dependencyDescriptor, @Nullable String reason, boolean endorsing, List<IvyArtifactName> artifacts) {
        super(reason, endorsing, artifacts);

        }
    }

    private static class DependencyToAll extends DependentsSet {

        private final String reason;

        private DependencyToAll(String reason) {
            this.reason = Preconditions.checkNotNull(reason);
        }

        private DependencyToAll() {
            this(null);
        }

        @Override
        public boolean isEmpty() {

    }

    static class SkippingRuleStatement extends Statement {

        private final String reason

        SkippingRuleStatement(String reason) {
            this.reason = reason
        }

        @Override
        void evaluate() throws Throwable {
            assumeTrue("Test does not support configuration cache: $reason", false)
        }
    }

			}

			switch {
			case len(test.reason) == 0:
				if resultGot.reason != nil {
					t.Errorf("unexpected panic: %v", resultGot.reason)
				}
			case !strings.Contains(fmt.Sprintf("%v", resultGot.reason), test.reason):
				t.Errorf("expected panic to contain: %q, but got: %v", test.reason, resultGot.reason)
			}
		})
	}

        then:
        DaemonExpirationResult result = agg.checkExpiration()
        result.status == anyStatus
        result.reason == reason

        where:
        c1Status         | c2Status         | anyStatus        | reason
        QUIET_EXPIRE     | DO_NOT_EXPIRE    | QUIET_EXPIRE     | "r1"
        DO_NOT_EXPIRE    | GRACEFUL_EXPIRE  | GRACEFUL_EXPIRE  | "r2"

        configureAction.execute(attributes);
        return Cast.uncheckedCast(this);
    }

    @Override
    public String getReason() {
        return reason;
    }

    @Override
    public T because(String reason) {
        this.reason = reason;
        return Cast.uncheckedCast(this);
    }

    public void setAttributes(AttributeContainer attributes) {
        this.attributes = attributes;
    }

			Kind:            "Pod",
			Name:            "foo",
			Namespace:       "baz",
			UID:             "long uid string",
			APIVersion:      "v1",
			ResourceVersion: "0",
			FieldPath:       "",
		},
		Reason: "ForTesting",
		Source: api.EventSource{Component: "test"},
		Type:   api.EventTypeNormal,
	}
	field := ToSelectableFields(eventA)
	expectA := fields.Set{
		"metadata.name":                  "f0118",

		}
		if len(event.Reason) == 0 {
			allErrs = append(allErrs, field.Required(field.NewPath("reason"), ""))
		}
		if len(event.Reason) > ReasonLengthLimit {
			allErrs = append(allErrs, field.Invalid(field.NewPath("reason"), "", fmt.Sprintf("can have at most %v characters", ReasonLengthLimit)))
		}
		if len(event.Message) > NoteLengthLimit {

        assert failure != null || selected != null;

        this.requested = requested;
        this.reason = reason;
        this.selected = selected;
        this.failure = failure;
        this.constraint = constraint;
        this.fromVariant = fromVariant;
        this.targetVariant = targetVariant;
    }

    @Override
    public ComponentSelector getRequested() {
        return requested;
    }

    @Override