public class InvalidPluginIdException extends GradleException {

    private final String reason;

    public InvalidPluginIdException(String pluginId, String reason) {
        super(String.format("plugin id '%s' is invalid: %s", pluginId, reason));
        this.reason = reason;
    }

    public String getReason() {
        return reason;
    }

    private String reason;

    protected void copyTo(AbstractDependency target) {
        target.reason = reason;
    }

    @Override
    @Deprecated
    public void resolve(org.gradle.api.internal.artifacts.CachingDependencyResolveContext context) {
    }

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

    @Override

		"k8s webhook configuration (re)load error",
	)
)

func reportValidationConfigUpdateError(reason metav1.StatusReason) {
	metricWebhookConfigurationUpdateError.With(reasonLabel.Value(string(reason))).Increment()
}

func reportValidationConfigLoadError(reason string) {
	metricWebhookConfigurationLoadError.With(reasonLabel.Value(reason)).Increment()
}

func reportValidationConfigUpdate() {

    assertThat(nextEvent()).isEqualTo(Pong(payload))
  }

  fun assertClosing(
    code: Int,
    reason: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Closing(code, reason))
  }

  fun assertClosed(
    code: Int,
    reason: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Closed(code, reason))
  }

  fun assertExhausted() {
    assertThat(events).isEmpty()
  }

			return PodAdmitResult{
				Admit:   fit,
				Reason:  "UnexpectedAdmissionError",
				Message: message,
			}
		}
	}
	if !fit {
		var reason string
		var message string
		if len(reasons) == 0 {
			message = fmt.Sprint("GeneralPredicates failed due to unknown reason, which is unexpected.")
			klog.InfoS("Failed to admit pod: GeneralPredicates failed due to unknown reason, which is unexpected", "pod", klog.KObj(admitPod))

				decisionAnnotationKey, decisionAllow,
				reasonAnnotationKey, reason)
			handler.ServeHTTP(w, req)
			return
		}
		if err != nil {
			audit.AddAuditAnnotation(ctx, reasonAnnotationKey, reasonError)
			responsewriters.InternalError(w, req, err)
			return
		}

		klog.V(4).InfoS("Forbidden", "URI", req.RequestURI, "reason", reason)
		audit.AddAuditAnnotations(ctx,
			decisionAnnotationKey, decisionForbid,

			expectChanged: true,
			expected: []metav1.Condition{
				{Type: "first"},
				{Type: "third"},
				{Type: "second", Status: metav1.ConditionTrue, LastTransitionTime: metav1.Time{Time: oneHourBefore}, Reason: "reason", Message: "message"},
			},
		},
		{
			name: "use-supplied-time",

        private final String version;
        private final String fileName;
        private final boolean regex;
        private final String reason;

        TrustCoordinates(@Nullable String group, @Nullable String name, @Nullable String version, @Nullable String fileName, boolean regex, @Nullable String reason) {
            this.group = group;
            this.name = name;
            this.version = version;

        def config = display(CannotWriteToDir, 'cannot_write_output', spec)
        config.description("is not writable because '${config.dir}' ${config.reason}")
            .reason("Expected '${config.problemDir}' to be a directory but it's a file")
            .solution("Make sure that the '${config.property}' is configured to a directory")
            .render()
    }

        DependencyConstraintImpl(String group, String module, VersionConstraint versionConstraint, String reason, ImmutableAttributes attributes) {
            this.group = group;
            this.module = module;
            this.versionConstraint = versionConstraint;
            this.reason = reason;
            this.attributes = attributes;
        }

        @Override
        public String getGroup() {
            return group;