import org.gradle.api.tasks.options.Option
import org.gradle.api.tasks.options.OptionValues

subprojects{
    task hello(type: CustomTask)
}

class CustomTask extends DefaultTask {
    @TaskAction
    void doSomething() {
    }

    @Option(option = "stringValue", description = "Configures a string value in CustomTask.")
    public void setStringValue(String value) {
    }

    @OptionValues("stringValue")

        if (typeof options.template...

    def "adding custom javadoc options makes task out-of-date with html5 option"() {
        given: "a javadoc task without custom options"
        buildFile << """
            task javadoc(type: Javadoc) {
                destinationDir = file("build/javadoc")
                source "src/main/java"
                options {
                    author()
                }
            }

    /** This option is deprecated and may be repurposed as Java debug in a future version.
     * Use {@code -X/--verbose} instead. */
    @Deprecated
    public static final String DEBUG = "debug";

    protected Options options;

    @SuppressWarnings("checkstyle:linelength")
    public CLIManager() {
        options = new Options();
        options.addOption(Option.builder(Character.toString(HELP))

inline void LogOptions(const XlaCompiler::Options& options) {
  VLOG(2) << "XlaCompiler::Options[device_type=" << options.device_type
          << ",device_ordinal=" << options.device_ordinal
          << ",client=" << options.client << ",flib_def=" << options.flib_def
          << ",graph_def_version=" << options.graph_def_version
          << ",options.shape_determination_fns.layout_preference_fn?="

				options.NetworkingPodSubnet,
				options.FeatureGatesString,
				options.NetworkingDNSDomain,
				options.NetworkingServiceSubnet,
			},
		}, {
			name: "kube-proxy",
			want: []string{options.CfgPath,
				options.KubeconfigPath,
				options.KubernetesVersion,
				options.ImageRepository,
				options.DryRun,
				options.APIServerAdvertiseAddress,
				options.ControlPlaneEndpoint,
				options.APIServerBindPort,

        public <T> T selectOption(String question, final Collection<T> options, final T defaultOption) {
            return choice(question, options).defaultOption(defaultOption).ask();
        }

        @Override
        public <T> Choice<T> choice(String question, Collection<T> options) {
            if (options.isEmpty()) {
                throw new IllegalArgumentException("No options provided.");
            }

        options.add(new SystemProperty(name, value))
    }

    void environmentVariable(String name, String value) {
        options.add(new EnvironmentVariable(name, value))
    }

    void defaultCharacterEncoding(String value) {
        options.add(new DefaultCharacterEncoding(value))
    }

    void enableAssertions() {
        options.add(new EnableAssertions())
    }

			knownFormats: formats,
			options:      options,
		},
	}
}

func (r *RatchetingSchemaValidator) Validate(new interface{}, options ...ValidationOption) *validate.Result {
	sv := validate.NewSchemaValidator(r.schema, r.root, r.path, r.knownFormats, r.options...)
	return sv.Validate(new)
}

func (r *RatchetingSchemaValidator) ValidateUpdate(new, old interface{}, options ...ValidationOption) *validate.Result {

import org.gradle.api.Task;
import org.gradle.api.internal.tasks.options.BooleanOptionElement;
import org.gradle.api.internal.tasks.options.BuiltInOptionElement;
import org.gradle.api.internal.tasks.options.InstanceOptionDescriptor;
import org.gradle.api.internal.tasks.options.OptionDescriptor;
import org.gradle.api.internal.tasks.options.OptionElement;
import org.gradle.api.internal.tasks.options.OptionReader;
import org.gradle.api.specs.Specs;