*
     * @return Whether or not it is required that this signature be generated.
     */
    boolean isRequired();

    /**
     * Whether or not it is required that this signature be generated.
     *
     * @param required Whether or not it is required that this signature be generated.
     * @see #isRequired
     */
    void setRequired(boolean required);

    public Parameter() {}

    public Parameter(org.apache.maven.api.plugin.descriptor.Parameter p) {
        this.setAlias(p.getAlias());
        this.setName(p.getName());
        this.setRequired(p.isRequired());
        this.setEditable(p.isEditable());
        this.setDescription(p.getDescription());
        this.setExpression(p.getExpression());
        this.setDeprecated(p.getDeprecated());

        this.missingParameters = new HashMap<>();

        if (mojoDescriptor.getParameters() != null) {
            for (Parameter param : mojoDescriptor.getParameters()) {
                if (param.isRequired()) {
                    missingParameters.put(param.getName(), param);
                }
            }
        }
    }

    public Collection<Parameter> getMissingParameters() {

    }

    public void addDependenciesFrom(LocalTaskNode taskNode) {
        // Only add hard successors that will actually be executed
        Node prepareNode = taskNode.getPrepareNode();
        if (taskNode.isRequired()) {
            prepareNode.require();
            addDependencySuccessor(prepareNode);
        }
    }

        assertEquals("java.lang.String", mp.getType());
        assertEquals("java.lang.String", mp.getImplementation());
        assertTrue(mp.isEditable());
        assertFalse(mp.isRequired());
        assertEquals("parameter-description", mp.getDescription());
        assertEquals("deprecated-parameter", mp.getDeprecated());
        assertEquals("${jar.finalName}", mp.getExpression());

	"k8s.io/kubernetes/pkg/features"
)

// Checks whether app armor is required for the pod to run. AppArmor is considered required if any
// non-unconfined profiles are specified.
func isRequired(pod *v1.Pod) bool {
	if pod.Spec.SecurityContext != nil && pod.Spec.SecurityContext.AppArmorProfile != nil &&
		pod.Spec.SecurityContext.AppArmorProfile.Type != v1.AppArmorProfileTypeUnconfined {
		return true
	}

    }

    @Inject
    public Sign() {
        // If we aren't required and don't have a signatory then we just don't run
        onlyIf("Signing is required, or signatory is set", spec(task -> isRequired() || getSignatory() != null));
    }

    /**
     * Configures the task to sign the archive produced for each of the given tasks (which must be archive tasks).
     */
    public void sign(Task... tasks) {

		return &validator{validateHostErr: err}
	}
	return &validator{}
}

type validator struct {
	validateHostErr error
}

func (v *validator) Validate(pod *v1.Pod) error {
	if !isRequired(pod) {
		return nil
	}

	if v.ValidateHost() != nil {
		return v.validateHostErr
	}

	var retErr error

            if (signatureSpec.isRequired()) {
                throw new InvalidUserDataException("Unable to generate signature as the file to sign has not been specified");
            } else {
                return null;
            }
        }

        Signatory signatory = getSignatory();
        if (signatory == null) {
            if (signatureSpec.isRequired()) {

     * Whether this task should fail if no signatory or signature type are configured at generation time.
     *
     * If {@code required} is a {@link Callable}, it will be stored and "called" on demand (i.e. when {@link #isRequired()} is called) and the return value will be interpreting according to the Groovy
     * Truth. For example:
     *
     * <pre>
     * signing {
     *   required = { gradle.taskGraph.hasTask("publish") }
     * }