*
 * @param <T> The type which this option represents.
 */
public abstract class AbstractJavadocOptionFileOption<T> implements JavadocOptionFileOptionInternal<T> {
    protected final String option;
    protected T value;

    protected AbstractJavadocOptionFileOption(String option, T value) {
        if (option == null) {
            throw new IllegalArgumentException("option == null!");
        }

			return getErrorMessage(options)
		}
		return nil
	}, options...)
}

// UntilOrFail calls Until, and fails t with Fatalf if it ends up returning an error
func UntilOrFail(t test.Failer, fn func() bool, options ...Option) {
	t.Helper()
	err := Until(fn, options...)
	if err != nil {
		t.Fatalf("retry.UntilOrFail: %v", err)
	}
}

func getErrorMessage(options []Option) error {
	cfg := defaultConfig

    private static final ENV_VARIABLES = "environmentVariables"
    List<Option> options = []
    File processJsonFile

    OptionsVerifier(File processJsonFile) {
        this.processJsonFile = processJsonFile
    }

    void minHeap(String value) {
        options.add(new MinHeap(value))
    }

    void maxHeap(String value) {
        options.add(new MaxHeap(value))
    }

    void jvmArgs(String value) {

        return this;
    }

    public JavadocOptionFileWriterContext writeOptionHeader(String option) throws IOException {
        write("-");
        write(option);
        write(" ");
        return this;
    }

    public JavadocOptionFileWriterContext writeOption(String option) throws IOException {
        writeOptionHeader(option);
        newLine();
        return this;
    }

        CommandLineOption option = parser.option(options)
            .hasDescription(description);

        if(deprecated) {
            option.deprecated();
        }

        if (incubating) {
            option.incubating();
        }

        return option;
    }

/**
 * A flag, does not take an argument.
 *
 * If a command line option is provided, the {@link TaskOptionsGenerator} automatically creates an opposite option.
 * For example, {@code "--no-foo"} is created for the provided option {@code "--foo"} or {@code "--bar"} for the provided option {@code "--no-bar"}.
 *
 * Options whose names starts with "--no" are 'disable options' and set the option value to false.
 */

    private final JavadocOptionFileOption<T> option;

    public JavadocOptionFileOptionInternalAdapter(JavadocOptionFileOption<T> option) {
        this.option = option;
    }

    @Override
    public JavadocOptionFileOptionInternal<T> duplicate() {
        // TODO: We basically don't support copying custom Javadoc options
        return this;
    }

    @Override

                private $optionType myProp;

                @Option(option = "$optionName", description = "$optionDescription")
                @Option(option = "myProp", description = "Configures command line option 'myProp'.")
                public void setMyProp($optionType myProp) {
                    this.myProp = myProp;
                }

                @TaskAction

    @Override
    public void configure(CommandLineParser parser) {
        CommandLineOption option = parser.option(getPropertyOption(), getPropertyOptionDetailed());
        option = option.hasArguments();
        option.hasDescription(getPropertyOptionDescription());
    }

    @Override
    public Map<String, String> convert(ParsedCommandLine options, Map<String, String> properties) throws CommandLineArgumentException {

        version << ["1.8", "8"]
    }

    def "When execute updateDaemonJvm with invalid argument --jvm-version option Then fails with expected exception message"() {
        when:
        fails "updateDaemonJvm", "--jvm-version=$invalidVersion"

        then:
        failureDescriptionContains("Problem configuring option 'jvm-version' on task ':updateDaemonJvm' from command line.")