var options []option

// Option names should be lower case. e.g. avx instead of AVX.
type option struct {
	Name      string
	Feature   *bool
	Specified bool // whether feature value was specified in GODEBUG
	Enable    bool // whether feature should be enabled
	Required  bool // whether feature is mandatory and can not be disabled
}

func processOptions() {
	env := os.Getenv("GODEBUG")
field:
	for env != "" {

    testers.add(MultisetIteratorTester.class);
    testers.add(MultisetSerializationTester.class);
    return testers;
  }

  private static Set<Feature<?>> computeEntrySetFeatures(Set<Feature<?>> features) {
    Set<Feature<?>> derivedFeatures = new HashSet<>(features);
    derivedFeatures.remove(CollectionFeature.GENERAL_PURPOSE);
    derivedFeatures.remove(CollectionFeature.SUPPORTS_ADD);

        useLocation("<long>", 123)

        when:
        handler.featureUsed(deprecatedFeatureUsage('feature'))

        then:
        def events = outputEventListener.events
        events.size() == 1
        events[0].message == TextUtil.toPlatformLineSeparators('<long>: line 123\nfeature removal')
    }

    def 'logs deprecation warning once for each unique Gradle script location that appears first in the stack trace'() {

		"File with Authorization Configuration to configure the authorizer chain."+
		"Note: This feature is in Alpha since v1.29."+
		"--feature-gate=StructuredAuthorizationConfiguration=true feature flag needs to be set to true for enabling the functionality."+
		"This feature is mutually exclusive with the other --authorization-mode and --authorization-webhook-* flags.")

This works similar to <<feature_variants.adoc#sec::declare_feature_variants,defining optional feature variants>> in build scripts.
We then use one of the `add` methods for adding dependencies to define which dependencies this optional feature needs.

                adhocComponent.addVariantsFromConfiguration(feature.getApiElementsConfiguration(), new JavaConfigurationVariantMapping("compile", true, feature.getCompileClasspathConfiguration()));
                adhocComponent.addVariantsFromConfiguration(feature.getRuntimeElementsConfiguration(), new JavaConfigurationVariantMapping("runtime", true, feature.getRuntimeClasspathConfiguration()));
            }
        }
    }

        }

        then:
        checkDependencies()
    }

    // this test doesn't make sense with Gradle metadata
    @RequiredFeature(feature=GradleMetadataResolveRunner.GRADLE_METADATA, value="false")
    // only test one combination
    @RequiredFeature(feature=GradleMetadataResolveRunner.REPOSITORY_TYPE, value="ivy")
    def "maven module is not affected by rule requiring ivy module descriptor input"() {

    @Override
    public void enableFeaturePreview(String name) {
        Feature feature = Feature.withName(name);
        if (feature.isActive()) {
            services.get(FeatureFlags.class).enable(feature);
        } else {
            DeprecationLogger
                .deprecate("enableFeaturePreview('" + feature.name() + "')")
                .withAdvice("The feature flag is no longer relevant, please remove it from your settings file.")

cluster. Most K8s platform settings are necessarily component settings.
The available features and the components that comprise each feature are as follows:

| Feature | Components |
|---------|------------|
CRDs, and other cluster wide configs | Base
Traffic Management | Pilot
Security | Pilot
Configuration management | Pilot
AutoInjection | Pilot

	"k8s.io/utils/ptr"
)

func TestApplyFeatureGates(t *testing.T) {
	tests := []struct {
		name       string
		features   map[featuregate.Feature]bool
		wantConfig *v1.Plugins
	}{
		{
			name: "Feature gate DynamicResourceAllocation disabled",
			features: map[featuregate.Feature]bool{
				features.DynamicResourceAllocation: false,
			},
			wantConfig: &v1.Plugins{
				MultiPoint: v1.PluginSet{
					Enabled: []v1.Plugin{