":build-logic:classes",
            ":build-logic:jar",
            ":assemble")
        fixture.assertStateStored()

        when:
        configurationCacheRun("assemble")

        then:
        result.assertTasksExecuted(":assemble")
        fixture.assertStateLoaded()

        when:
        pluginSourceFile << """
            // some change
        """

                file("file2")
            }
        }
        def fixture = newConfigurationCacheFixture()

        when:
        configurationCacheRun("report")

        then:
        fixture.assertStateStored()
        outputContains(output1)

        when:
        configurationCacheRun("report")

        then:
        fixture.assertStateLoaded()
        outputContains(output1)

import (
	"k8s.io/apimachinery/pkg/util/runtime"

	utilfeature "k8s.io/apiserver/pkg/util/feature"
	"k8s.io/component-base/featuregate"
)

const (
	// Every feature gate should add method here following this template:
	//
	// // owner: @username
	// // alpha: v1.4
	// MyFeature featuregate.Feature = "MyFeature"
	//
	// Feature gates should be listed in alphabetical, case-sensitive

}

// Feature represents a feature being gated
type Feature struct {
	featuregate.FeatureSpec
	MinimumVersion     *version.Version
	HiddenInHelpText   bool
	DeprecationMessage string
}

// FeatureList represents a list of feature gates
type FeatureList map[string]Feature

// ValidateVersion ensures that a feature gate list is compatible with the chosen Kubernetes version

  }

  private static Set<Feature<?>> computeReserializedMapFeatures(Set<Feature<?>> mapFeatures) {
    Set<Feature<?>> derivedFeatures = Helpers.copyToSet(mapFeatures);
    derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
    derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS);
    return derivedFeatures;
  }

  private static Set<Feature<?>> computeEntrySetFeatures(Set<Feature<?>> mapFeatures) {

 *
 * <p>Features are classified by their capabilities. Each variant of a feature provides at least
 * the same set of capabilities as the feature itself. Since all variants of a feature are derived
 * from the same sources, they all expose the same API or "content" and thus provide the same
 * capabilities. Some variants may expose additional capabilities than those of its owning feature,
 * for example with fat jars.</p>
 *

		wantSELinuxMount                    *bool
	}{
		{
			name:           "podInfoOnMount feature enabled, before: none, update: enabled",
			old:            driverWithNothing,
			update:         driverWithPodInfoOnMountEnabled,
			wantGeneration: 1,
		},
		{
			name:           "podInfoOnMount feature enabled, before: enabled, update: disabled",
			old:            driverWithPodInfoOnMountEnabled,

            }
            return enabled
        }
    }

    static class Feature {
        final Map<String, String> displayNames

        Feature(Map<String, String> displayNames) {
            this.displayNames = displayNames
        }
    }

    static Feature booleanFeature(String name) {
        new Feature(['true': "with $name".toString(), 'false': "without $name".toString()])
    }

An `h3` may include an incubating marker `(i)` at the end of its text to indicate that the feature is incubating.

Here's an example:

    ## h2 New and Noteworthy

    ### h3 Some feature (i)

    This is some incubating feature.

    #### h4 Some detail

    This detail about the feature is collapsed. The reader can expand it if they are interested.

### Generating

        EnumSet<FeaturePreviews.Feature> active = EnumSet.noneOf(FeaturePreviews.Feature)
        for (FeaturePreviews.Feature feature : FeaturePreviews.Feature.values()) {
            if (feature.isActive()) {
                active.add(feature)
            }
        }
        active
    }

    static def inactiveFeatures() {
        def features = EnumSet.allOf(FeaturePreviews.Feature)
        features.removeAll(activeFeatures())