features().each { featureName ->
            def sourceSetName = featureName == MavenJavaModule.MAIN_FEATURE ? MavenJavaModule.MAIN_FEATURE : "${featureName}SourceSet"
            def className = classNameForFeature(featureName)
            file("src/${sourceSetName}/java/${className}.java").text = """
                /**
                 * This is my awesome implementation of the ${featureName} feature
                 */

    private final Project project;
    private final String featureName;

    public ProjectDerivedCapability(Project project) {
        this(project, null);
    }

    public ProjectDerivedCapability(Project project, @Nullable String featureName) {
        this.project = project;
        this.featureName = featureName;
    }

    @Override
    public String getGroup() {

func TestKubeFeaturesRegistered(t *testing.T) {
	registeredFeatures := utilfeature.DefaultFeatureGate.DeepCopy().GetAll()

	for featureName := range defaultKubernetesFeatureGates {
		if _, ok := registeredFeatures[featureName]; !ok {
			t.Errorf("The feature gate %q is not registered in the DefaultFeatureGate", featureName)
		}
	}
}

// TestClientFeaturesRegistered tests that all client features are registered.

	tests := []struct {
		testName       string
		featureName    string
		expectedResult bool
	}{
		{
			testName:    "Disabled - with unknown feature",
			featureName: "some unknown feature",
		},
		{
			testName:    "Disabled - with empty feature",
			featureName: "",
		},
		{
			testName:       "Disabled - default",
			featureName:    storage.RequestWatchProgress,
			expectedResult: false,
		},
	}

func TestEnabledDefaults(t *testing.T) {
	for featureName, feature := range InitFeatureGates {
		featureList := make(map[string]bool)

		enabled := Enabled(featureList, featureName)
		if enabled != feature.Default {
			t.Errorf("Enabled returned %v instead of default value %v for feature %s", enabled, feature.Default, featureName)
		}
	}
}

func TestCheckDeprecatedFlags(t *testing.T) {

                jar.setDescription("Assembles a jar archive containing the " + (featureName == null ? "main " + docsType + "." : (docsType + " of the '" + featureName + "' feature.")));
                jar.setGroup(BasePlugin.BUILD_GROUP);
                jar.from(artifactSource);
                jar.getArchiveClassifier().set(camelToKebabCase(featureName == null ? docsType : (featureName + "-" + docsType)));
            });

                }.files
                doLast {
                    assert normal*.name == ["producer-1.0-${featureName}.jar"]
                    assert reselected*.name == ${expectedArtifacts}
                }
            }
        """

        expect:
        succeeds(":resolve")

        where:
        featureName      | expectedArtifacts
        // We request sources for a variant that does not have sources.

func Enabled(featureList map[string]bool, featureName string) bool {
	if enabled, ok := featureList[featureName]; ok {
		return enabled
	}
	return InitFeatureGates[featureName].Default
}

// Supports indicates whether a feature name is supported on the given
// feature set
func Supports(featureList FeatureList, featureName string) bool {
	for k := range featureList {
		if featureName == k {
			return true
		}
	}

    }

    @Override
    void assertPublished() {
        assertPublished(null, "jar")
    }

    static String variantName(String featureName, String baseName) {
        if (featureName == MAIN_FEATURE) {
            baseName
        } else {
            featureName + 'SourceSet' + baseName.capitalize()
        }
    }

    private static String featurePrefix(String feature) {

	// Tests that need to modify feature gates for the duration of their test should use:
	//   featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.<FeatureName>, <value>)
	DefaultMutableFeatureGate featuregate.MutableFeatureGate = featuregate.NewFeatureGate()

	// DefaultFeatureGate is a shared global FeatureGate.