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

        } else {
            feature.setIterationNameProvider(iteration -> iterationNameProvider.getName(iteration) + " " + currentExecution);
        }

        feature.setDataDriver((dataIterator, iterationRunner, parameters) -> {
            TestDetails testDetails = new TestDetails(feature);
            while(dataIterator.hasNext()) {

var _ clientfeatures.Gates = &clientAdapter{}

func (a *clientAdapter) Enabled(name clientfeatures.Feature) bool {
	return a.mfg.Enabled(featuregate.Feature(name))
}

var _ clientfeatures.Registry = &clientAdapter{}

func (a *clientAdapter) Add(in map[clientfeatures.Feature]clientfeatures.FeatureSpec) error {
	out := map[featuregate.Feature]featuregate.FeatureSpec{}
	for name, spec := range in {
		converted := featuregate.FeatureSpec{

    Set<Feature<?>> features = Sets.<Feature<?>>newHashSet(ExampleBaseFeature.BASE_FEATURE_1);
    assertSame(features, FeatureUtil.addImpliedFeatures(features));
  }

  public void testAddImpliedFeatures_addsImpliedFeatures() throws Exception {
    Set<Feature<?>> features;

    features = Sets.<Feature<?>>newHashSet(ExampleDerivedFeature.DERIVED_FEATURE_1);

    private final Statement next

    private final String feature

    ExpectingFailureRuleStatement(Statement next, String feature) {
        this.next = next
        this.feature = feature
    }

    @Override
    void evaluate() throws Throwable {
        try {
            next.evaluate()
            throw new ToBeFixedSpecInterceptor.UnexpectedSuccessException(feature)

apiVersion: release-notes/v2
kind: feature
area: security
releaseNotes:
- |
  **Updated** default value of the feature flag `VERIFY_CERT_AT_CLIENT` to true.
  This means server certificates will be automatically verified using the OS CA certificates when not using a DestinationRule caCertificates field.
  If undesired please use the new `compatibilityVersion` feature to fallback to old behavior, or `insecureSkipVerify`

type option struct {
	Name      string
	Feature   *bool
	Specified bool // whether feature value was specified in GODEBUG
	Enable    bool // whether feature should be enabled
}

// processOptions enables or disables CPU feature values based on the parsed env string.
// The env string is expected to be of the form cpu.feature1=value1,cpu.feature2=value2...
// where feature names is one of the architecture specific list stored in the

import java.io.File
import java.lang.IllegalStateException
import org.graalvm.nativeimage.hosted.Feature
import org.graalvm.nativeimage.hosted.RuntimeClassInitialization
import org.graalvm.nativeimage.hosted.RuntimeReflection

@AutomaticFeature
class TestRegistration : Feature {
  override fun beforeAnalysis(access: Feature.BeforeAnalysisAccess) {
    // Presumably needed for parsing the testlist.txt file.

	const conflict = "UnknownVersionInteroperabilityProxy feature requires StorageVersionAPI feature flag to be enabled"
	tests := []struct {
		name            string
		featuresEnabled []featuregate.Feature
	}{
		{
			name:            "enabled: UnknownVersionInteroperabilityProxy, disabled: StorageVersionAPI",
			featuresEnabled: []featuregate.Feature{features.UnknownVersionInteroperabilityProxy},
		},
	}