attributeProvider(Usage.USAGE_ATTRIBUTE, testProvider)
                    }
                }
            }
            """.stripIndent()

        expect:
        fails "outgoingVariants"
        failure.assertHasCause("Unexpected type for attribute 'org.gradle.usage' provided. Expected a value of type org.gradle.api.attributes.Usage but found a value of type java.lang.Integer.")
    }

        Configuration ipc = configurations.resolvableDependencyScopeUnlocked(names.withPrefix("cppCompile"));
        includePathConfiguration = ipc;
        includePathConfiguration.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, Usage.C_PLUS_PLUS_API));
        includePathConfiguration.getAttributes().attribute(DEBUGGABLE_ATTRIBUTE, identity.isDebuggable());

     *
     * Does <strong>NOT</strong> check anything to do with deprecated usage.
     *
     * @param conf the existing configuration
     * @return the existing configuration, with its usage now matching the requested usage
     * @throws UnmodifiableUsageException if the usage doesn't match this request and cannot be mutated
     */
    Configuration verifyExistingConfigurationUsage(Configuration conf);

    /**

                extendsFrom(configurations.implementation)
                attributes {
                    // This is what AGP 7 will most likely do:
                    attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_API))
                    attribute(TargetJvmEnvironment.TARGET_JVM_ENVIRONMENT_ATTRIBUTE, objects.named(TargetJvmEnvironment, TargetJvmEnvironment.ANDROID))
                }
            }

// itself and is thus wasteful to perform in every invocation of the compiler.
//
// Usage:
//
//	go tool preprofile [-v] [-o output] -i input
//
//

package main

import (
	"bufio"
	"cmd/internal/objabi"
	"cmd/internal/pgo"
	"cmd/internal/telemetry"
	"flag"
	"fmt"
	"log"
	"os"
)

func usage() {
	fmt.Fprintf(os.Stderr, "usage: go tool preprofile [-v] [-o output] -i input\n\n")
	flag.PrintDefaults()

    private static final String UNUSABLE = "This configuration does not allow any usage";

    private static final String IS_DEPRECATED = "(but this behavior is marked deprecated)";

    private UsageDescriber() { /* not instantiable */ }

    /**
     * Builds a human-readable description of the usage allowed by the given role.
     *
     * @param role the role to describe

     * the resulting set of files.
     *
     * @implSpec Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if
     * called on a configuration that does not permit this usage, or has allowed this usage but marked it as deprecated.
     *
     * @return The files of this configuration.
     */
    Set<File> resolve();

     *
     * Does <strong>NOT</strong> check anything to do with deprecated usage.
     *
     * @return the existing configuration, with its usage now matching the requested usage
     * @throws UnmodifiableUsageException if the usage doesn't match this request and cannot be mutated
     */
    @Override
    public Configuration verifyExistingConfigurationUsage(Configuration conf) {
        warnAboutReservedName();

}

func (e *UsageError) Error() string {
	usage := e.Command.Usage()
	suffix := ""
	if usage.Async {
		suffix = " [&]"
	}
	return fmt.Sprintf("usage: %s %s%s", e.Name, usage.Args, suffix)
}

// ErrUsage may be returned by a Command to indicate that it was called with
// invalid arguments; its Usage method may be called to obtain details.

    private val libraryCategory: Category
    private val javaRuntimeUsage: Usage
    private val javaApiUsage: Usage

    init {
        jarLibraryElements = objectFactory.named(LibraryElements.JAR)
        libraryCategory = objectFactory.named(Category.LIBRARY)
        javaRuntimeUsage = objectFactory.named(Usage.JAVA_RUNTIME)
        javaApiUsage = objectFactory.named(Usage.JAVA_API)
    }