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())
    }

			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

				opts = append(opts,
					option.Localhost(option.LocalhostIPv6),
					option.AdditionalLocalhost(option.LocalhostIPv4),
					option.Wildcard(option.WildcardIPv6),
					option.AdditionalWildCard(option.WildcardIPv4),
					option.DNSLookupFamily(option.DNSLookupFamilyIPS))
			} else {
				opts = append(opts,
					option.Localhost(option.LocalhostIPv4),
					option.AdditionalLocalhost(option.LocalhostIPv6),

     *
     * @param option The option, without the '-' or '--' prefix.
     * @return true if the option was present.
     */
    public boolean hadOptionRemoved(String option) {
        option(option);
        return removedOptions.contains(option);
    }

    /**
     * See also {@link #hasOption}.
     *
     * @param logLevelOptions the options to check

	testCases := []optionAvailTest{
		{
			option:            "this-option-does-not-exist",
			expectedAvailable: false,
		},
		{
			option:            PreferClosestNUMANodes,
			expectedAvailable: true,
		},
	}
	for _, testCase := range testCases {
		t.Run(testCase.option, func(t *testing.T) {
			err := CheckPolicyOptionAvailable(testCase.option)
			isEnabled := (err == nil)

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

            public class SampleTask extends DefaultTask {

                @Option(option = "my-option", description = "Option to trigger generation of opposite option.")
                private Boolean myOption;

                @Option(option = "no-my-option", description = "Option clashing with generated opposite option.")
                private Boolean noMyOption;

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;

                sb.append(option.getOpt());
                sb.append("'>");
                sb.append(option.getOpt());
                sb.append("</a>");
            }

            if (nonNull(option.getLongOpt())) {
                if (nonNull(option.getOpt())) {
                    sb.append(", ");
                }
                sb.append("--<a name='");
                sb.append(option.getLongOpt());

        outputContains("""
Options
     --myProp     Configures command line option 'myProp'.""")
    }

    def "can render option with help for Groovy task"() {
        given:
        buildFile << groovyTaskWithSingleOption('String')
        buildFile << sampleTask()

        when:
        succeeds('help', '--task', 'sample')

        then:
        outputContains("""
Options

                }
                
                @Option(option = "prop2", description = "Configures command line option 'prop2'.")
                public void setProp2(Boolean prop2) {
                    this.prop2 = prop2;
                }
                
                @Option(option = "prop3", description = "Configures command line option 'prop3'.")
                public void setProp3(String prop3) {