return addOption(new StringJavadocOptionFileOption(option, value));
    }

    public <T> JavadocOptionFileOption<T> addEnumOption(String option) {
        return addEnumOption(option, null);
    }

    public <T> JavadocOptionFileOption<T> addEnumOption(String option, T value) {
        return addOption(new EnumJavadocOptionFileOption<T>(option, value));
    }

        options.addOption(Option.builder(Character.toString(VERSION))
                .longOpt("version")
                .desc("Display version information")
                .build());
        options.addOption(Option.builder(Character.toString(QUIET))
                .longOpt("quiet")
                .desc("Quiet output - only show errors")
                .build());

    }

    def "keeps track of removed options"() {
        when:
        def line = new ParsedCommandLine([cmdOption("a"), cmdOption("b"), cmdOption("c")]);
        line.addOption("a", cmdOption("a"))
        line.addOption("b", cmdOption("b"))
        // allowOneOf(a, b)
        line.removeOption(cmdOption("a"))

        then:
        !line.hasOption("a")
        line.hasOption("b")

import org.gradle.sample.app.data.Message;

public class Main {

    public static void main(String[] args) throws Exception {
        Options options = new Options();
        options.addOption("json", true, "data to parse");
        options.addOption("debug", false, "prints module infos");
        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(options, args);

        if (cmd.hasOption("debug")) {

        optionFile.getSourceNames() != null
        optionFile.getSourceNames().getValue() != null
        optionFile.getSourceNames().getValue().isEmpty()
    }

    def "test addOption"() {
        when:
        optionFile.addOption(optionFileOptionMock)

        then:
        noExceptionThrown()
        1 * optionFileOptionMock.getOption() >> "testOption"
    }

	"istio.io/istio/pkg/log"
)

type counter struct {
	baseMetric
	c api.Float64Counter
	// precomputedAddOption is just a precomputation to avoid allocations on each record call
	precomputedAddOption []api.AddOption
}

var _ Metric = &counter{}

func newCounter(o options) *counter {
	c, err := meter().Float64Counter(o.name,
		api.WithDescription(o.description),
		api.WithUnit(string(o.unit)))
	if err != nil {

        addFlag("-unchecked", options.isUnchecked(), result);
        addConcatenatedOption("-g:", options.getDebugLevel(), result);
        addFlag("-optimise", options.isOptimize(), result);
        addOption("-encoding", options.getEncoding(), result);
        addFlag("-verbose", "verbose".equals(options.getDebugLevel()), result);
        addFlag("-Ydebug", "debug".equals(options.getDebugLevel()), result);

        parsedCommandLine.addOption(LONG_OPTION, enabledOption)
        testOption.applyFromCommandLine(parsedCommandLine, testSettings)

        then:
        testSettings.value
        testSettings.origin instanceof Origin.CommandLineOrigin
        testSettings.origin.source == LONG_OPTION

        when:
        parsedCommandLine.addOption(DISABLED_LONG_OPTION, disabledOption)

    public List<String> getExtraArguments() {
        return extraArguments;
    }

    void addExtraValue(String value) {
        extraArguments.add(value);
    }

    ParsedCommandLineOption addOption(String optionStr, CommandLineOption option) {
        ParsedCommandLineOption parsedOption = optionsByString.get(optionStr);
        presentOptions.addAll(option.getOptions());
        return parsedOption;
    }

        def option = new CommandLineOption([LONG_OPTION])
        options << option
        parsedCommandLine = new ParsedCommandLine(options)
        def parsedCommandLineOption = parsedCommandLine.addOption(LONG_OPTION, option)
        parsedCommandLineOption.addArgument(SAMPLE_VALUE.toString())
        testOption.applyFromCommandLine(parsedCommandLine, testSettings)

        then: