description = "My custom configuration"
                assert canBeResolved
                canBeConsumed = false
            }

            configurations.create("legacy") {
                description = "My custom configuration"
                assert canBeResolved
                assert canBeConsumed
            }
        """

        expect:

        !implementation.visible
        !implementation.canBeConsumed
        !implementation.canBeResolved

        when:
        def runtimeOnly = project.configurations.getByName(JvmConstants.RUNTIME_ONLY_CONFIGURATION_NAME)

        then:
        runtimeOnly.transitive
        !runtimeOnly.visible
        !runtimeOnly.canBeConsumed
        !runtimeOnly.canBeResolved
        runtimeOnly.extendsFrom == [] as Set

            }

            configurations.cons.canBeConsumed = true
            configurations.cons.canBeResolved = false
            configurations.cons.canBeDeclared = false

            configurations.res.canBeConsumed = false
            configurations.res.canBeResolved = true
            configurations.res.canBeDeclared = false

            configurations.dep.canBeConsumed = false

        then:
        !api.canBeConsumed
        !api.canBeResolved
        api.extendsFrom.empty

        when:
        def runtime = project.configurations.getByName(JavaPlatformPlugin.RUNTIME_CONFIGURATION_NAME)

        then:
        !runtime.canBeConsumed
        !runtime.canBeResolved
        runtime.extendsFrom == [api] as Set

        when:

        this.transitive = transitive;
        this.hierarchy = ImmutableSet.copyOf(hierarchy);
        this.attributes = attributes;
        this.capabilities = capabilities;
        this.canBeConsumed = canBeConsumed;
        this.deprecatedForConsumption = deprecatedForConsumption;
        this.canBeResolved = canBeResolved;
        this.dependencies = dependencies;
        this.variants = variants;

                [implementation, runtimeOnly, compileOnly, api, compileOnlyApi].each {
                    it.canBeConsumed = true
                    it.canBeResolved = true
                }

                [runtimeClasspath, compileClasspath].each {
                    it.canBeDeclared = true
                    it.canBeConsumed = true
                }
            }
        """

        expect:

            plugins {
                id("$plugin")
            }
            configurations {
                ${configuration}Consumable {
                    extendsFrom($configuration)
                    assert canBeConsumed
                    canBeResolved = false
                    attributes {
                        attribute(Attribute.of("test", String), "test")
                    }
                }
            }
        """

        then:
        def configuration = project.configurations.getByName(JvmConstants.JAVADOC_ELEMENTS_CONFIGURATION_NAME)
        !configuration.visible
        !configuration.canBeResolved
        configuration.canBeConsumed
        (configuration.attributes.getAttribute(Usage.USAGE_ATTRIBUTE) as Usage).name == Usage.JAVA_RUNTIME
        (configuration.attributes.getAttribute(Category.CATEGORY_ATTRIBUTE) as Category).name == Category.DOCUMENTATION

                    canBeResolved = false
                    assert canBeConsumed
                    attributes {
                        attribute(Attribute.of('color', String), 'blue')
                    }
                }
                redVariant {
                    canBeResolved = false
                    assert canBeConsumed
                    attributes {

    registerFeature(gradle7.name) {
        usingSourceSet(gradle7)
        capability(project.group.toString(), project.name, project.version.toString()) // <1>
    }
}

configurations.configureEach {
    if (canBeConsumed && name.startsWith(gradle7.name))  {
        attributes {
            attribute(GradlePluginApiVersion.GRADLE_PLUGIN_API_VERSION_ATTRIBUTE, // <2>
                      objects.named(GradlePluginApiVersion, '7.0'))
        }