&& getWorkingDir().equals(options.getWorkingDir())
            && normalized(getDefaultCharacterEncoding()).equals(normalized(options.getDefaultCharacterEncoding()))
            && getHeapSizeMb(getMinHeapSize()) >= getHeapSizeMb(options.getMinHeapSize())
            && getHeapSizeMb(getMaxHeapSize()) >= getHeapSizeMb(options.getMaxHeapSize())
            && normalized(getJvmArgs()).containsAll(normalized(options.getJvmArgs()))

			&cache.ListWatch{
				ListFunc: func(options metav1.ListOptions) (runtime.Object, error) {
					options.FieldSelector = opts.FieldSelector
					options.LabelSelector = opts.LabelSelector
					return l(options)
				},
				WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) {
					options.FieldSelector = opts.FieldSelector
					options.LabelSelector = opts.LabelSelector
					return w(options)

			args: []string{"1.2.3.4:6443"},
			flags: map[string]string{
				options.FileDiscovery:            "https://foo",
				options.TokenDiscovery:           "abcdef.0123456789abcdef",
				options.TokenDiscoverySkipCAHash: "true",
			},
			expectError: true,
		},
		{
			name: "pass if file discovery is set",
			flags: map[string]string{
				options.FileDiscovery: "https://foo",
			},

        final Options options = new Options();

        final CmdLineParser parser = new CmdLineParser(options);
        try {
            parser.parseArgument(args);
        } catch (final CmdLineException e) {
            System.err.println(e.getMessage());
            System.err.println("java " + Crawler.class.getCanonicalName() + " [options...] arguments...");

    }

    def "can convert stop option - #options"() {
        when:
        def converted = convert(options)

        then:
        converted.stop == stop

        where:
        options    | stop
        []         | false
        ['--stop'] | true
    }

    def "can convert status option - #options"() {
        when:
        def converted = convert(options)

        then:

    def "ignores other options"() {
        expect:
        !DaemonForkOptionsBuilder.findUnreliableArgument(["--show-version", "-ea", "pkg.Main"]).isPresent()
    }

    def "recognizes unreliable options in JVM args"() {
        expect:
        DaemonForkOptionsBuilder.findUnreliableArgument(options).get() == options[0]
        where:
        options << [
            ["-cp", "/path/to/jar"],

    private static File gradleUserHome(ParsedCommandLine options) {
        if (options.hasOption(GRADLE_USER_HOME_OPTION)) {
            return new File(options.option(GRADLE_USER_HOME_OPTION).getValue());
        }
        return GradleUserHomeLookup.gradleUserHome();
    }

    private static Logger logger(ParsedCommandLine options) {
        return new Logger(options.hasOption(GRADLE_QUIET_OPTION));
    }

                    + numOfThreads + "]";
        }

    }

    static void initializeProbes() {
        // Force probes to be loaded
        ProcessProbe.getInstance();
        OsProbe.getInstance();
        JvmInfo.jvmInfo();
    }

    public static void main(final String[] args) {

			fs := pflag.NewFlagSet("Test", pflag.PanicOnError)
			options.AddFlags(fs)
			require.NoError(t, fs.Parse(nil))
			assert.Equal(t, tc.options(), options, "Flag defaults should match default options.")

			assert.Empty(t, options.Validate(), "Options should be valid.")
			config := &server.Config{}
			require.NoError(t, options.ApplyTo(config))
			if tc.expected == "" {
				assert.Nil(t, config.AuditBackend)

        def value2 = options.getOption(new InternalFlag("prop2", false))
        value2.get()
        value2.explicit

        def value3 = options.getOption(new InternalFlag("prop3", true))
        !value3.get()
        value3.explicit

        def value4 = options.getOption(new InternalFlag("prop4", false))
        value4.get()
        value4.explicit
    }