"""

        file('src/main/java/Foo.java') << 'public class Foo {}'

        when:
        succeeds 'javadoc'

        then:
        file('build/docs/javadoc/Foo.html').text.contains("'some text'")

        where:
        option << (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_16) ? ['header'] : ['header', 'footer'])
    }

        expect:
        userInputHandler.selectOption('Select count', [1, 2, 3], 2) == 2
    }

    def "returns first option when no default"() {
        expect:
        userInputHandler.choice('Select count', [1, 2, 3])
            .ask() == 1
    }

    def "returns default option for choice"() {
        expect:
        userInputHandler.choice('Select count', [1, 2, 3])
            .defaultOption(2)

If the `--incubating` option is provided, Gradle will generate build scripts which may use the latest versions of APIs, which are marked `@Incubating` and remain <<feature_lifecycle.adoc#feature_lifecycle,subject to change>>. To disable this behavior, use `--no-incubating`.

import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.Optional;
import org.gradle.api.tasks.OutputFile;
import org.gradle.api.tasks.TaskAction;
import org.gradle.api.tasks.options.Option;
import org.gradle.api.tasks.options.OptionValues;
import org.gradle.api.tasks.wrapper.internal.DefaultWrapperVersionsResources;
import org.gradle.api.tasks.wrapper.internal.WrapperDefaults;

                                    bool skip_partitioned_calls) {
  TFToStablehloOptions options;
  options.skip_quantization_ops = skip_quantization_ops;
  options.skip_resize = skip_resize;
  options.skip_partitioned_calls = skip_partitioned_calls;
  PopulateLegalizeTFToStablehloPipeline(pm, options);
}

}  // namespace odml

 */

package org.gradle.internal.buildoption;

import org.gradle.cli.CommandLineParser;
import org.gradle.cli.ParsedCommandLine;

import java.util.Map;

/**
 * A build option representing a boolean option with a enabled mode only e.g. {@code "--foreground"}.
 *
 * @since 4.3
 */
public abstract class EnabledOnlyBooleanBuildOption<T> extends AbstractBuildOption<T, CommandLineOptionConfiguration> {

	}
}

type TestStruct struct {
	Name string `json:"name"`
}

func TestDeepCopyTypes(t *testing.T) {
	cases := []struct {
		input  Spec
		modify func(c Spec) Spec
		option cmp.Option
	}{
		// Istio type
		{
			&networking.VirtualService{Gateways: []string{"foo"}},
			func(c Spec) Spec {
				c.(*networking.VirtualService).Gateways = []string{"bar"}
				return c
			},

	}

	clnt := &http.Client{
		Transport: globalRemoteTargetTransport,
	}

	client, err := storage.NewClient(context.Background(),
		option.WithCredentialsJSON(credsJSON),
		option.WithScopes(storage.ScopeReadWrite),
		option.WithHTTPClient(clnt),
		option.WithUserAgent(fmt.Sprintf("gcs-tier-%s", tier)+SlashSeparator+ReleaseTag),
	)
	if err != nil {
		return nil, err
	}

		return []demangle.Option{demangle.NoParams, demangle.NoEnclosingParams}
	case "full":
		return []demangle.Option{demangle.NoClones}
	case "none": // no demangling
		return []demangle.Option{}
	}

	panic(fmt.Sprintf("unknown demanglerMode %s", demanglerMode))
}

func demangleSingleFunction(fn *profile.Function, options []demangle.Option) {
	if fn.Name != "" && fn.SystemName != fn.Name {

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