def setup() {
        buildFile << """
            configurations {
                conf {
                    attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_API))
                }
            }
            apply plugin: 'java-base'
        """
    }

    def "defaults to the external dependencies variant (#bundling)"() {
        given:

    private final PreferRuntimeVariantUsageDisambiguationRule usageDisambiguationRule;
    private final PreferJarVariantUsageDisambiguationRule formatDisambiguationRule;

    public PreferJavaRuntimeVariant(NamedObjectInstantiator instantiator) {
        Usage runtimeUsage = instantiator.named(Usage.class, Usage.JAVA_RUNTIME);

                "name": "api",
                "attributes": { "usage": "compile" }
            },
            {
                "attributes": { "usage": "runtime", "packaging": "zip" },
                "name": "runtime"
            }
        ]
    }
'''), metadata)

        then:
        1 * metadata.addVariant("api", attributes(usage: "compile")) >> variant1

configurations.create('transitiveSourcesElements') {
    visible = false
    canBeResolved = false
    extendsFrom(configurations.implementation)
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_RUNTIME))
        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))
        attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType, 'source-folders'))
    }

// Usage:
//
//	cfg := Config{Foo: "default-foo"}
//	flag.Bind(fs, "foo", "f", "the foo value", &cfg.Foo)
func Bind[T Flaggable](fs *pflag.FlagSet, name, shorthand, usage string, val *T) {
	switch d := any(val).(type) {
	case *string:
		fs.StringVarP(d, name, shorthand, *d, usage)
	case *bool:
		fs.BoolVarP(d, name, shorthand, *d, usage)
	case *time.Duration:

	for testName, testCase := range testCases {
		t.Run(testName, func(t *testing.T) {
			actual, err := evaluator.Usage(testCase.service)
			if err != nil {
				t.Errorf("%s unexpected error: %v", testName, err)
			}
			if !quota.Equals(testCase.usage, actual) {
				t.Errorf("%s expected: %v, actual: %v", testName, testCase.usage, actual)
			}
		})
	}
}

func TestServiceConstraintsFunc(t *testing.T) {

import org.gradle.api.attributes.LibraryElements
import org.gradle.api.attributes.Usage
import org.gradle.api.attributes.java.TargetJvmEnvironment
import org.gradle.api.model.ObjectFactory
import org.gradle.kotlin.dsl.named


fun ConsumableConfiguration.configureAsRuntimeElements(objects: ObjectFactory) {
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))

    }

    @Override
    public void usage(String usage, Action<? super VariantVersionMappingStrategy> action) {
        variant(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage.class, usage), action);
    }

    @Override
    public void defaultResolutionConfiguration(String usage, String defaultConfiguration) {

    }
    // endregion Role-Based Configurations

    // region Warnings
    def "changing usage for configuration #configuration produces warnings"() {
        given: "a buildscript which attempts to change a configuration's usage"
        buildFile << """
            plugins {
                id 'java-library'
            }

            configurations {

        buildFile << """
            def usage = Attribute.of('usage', String)
            def buildType = Attribute.of('buildType', String)
            def flavor = Attribute.of('flavor', String)
            configurations {
                conf {
                    attributes {
                        attribute(usage, 'usage-value')
                    }
                }
            }