}
                    attributes.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, "foo"))
                }
                dependencyScope("deps")
                resolvable("res") {
                    extendsFrom(deps)
                    attributes.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, "foo"))
                }
            }

            dependencies {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Contains classes implementing an enhanced dependency resolution API, intended to
 * replace resolvable configurations.
 */
@org.gradle.api.NonNullApi

        jacocoAggregation.setVisible(false);

        Configuration codeCoverageResultsConf = configurations.resolvable("aggregateCodeCoverageReportResults").get();
        codeCoverageResultsConf.setDescription("Resolvable configuration used to gather files for the JaCoCo coverage report aggregation via ArtifactViews, not intended to be used directly");

    id("gradlebuild.internal.java")

//    id("gradlebuild.repositories")
//    id("gradlebuild.integration-tests")
}

val testRepo = configurations.dependencyScope("testRepo")
val resolveTestRepo = configurations.resolvable("resolveTestRepo") {
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage.JAVA_RUNTIME))
        attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.LIBRARY))

                classes.push('alreadyRendered');
            }
            if (dependency.hasConflict) {
                classes.push('hasConflict');
            }
            if (!dependency.resolvable) {
                classes.push('unresolvable');
            }
            if (classes.length > 0) {
                node.attr['class'] = classes.join(' ');
            }

import gradlebuild.configureAsRuntimeJarClasspath

plugins {
    java
}

val agentsClasspath = configurations.dependencyScope("agentsClasspath")
val resolveAgentsClasspath = configurations.resolvable("resolveAgentsClasspath") {
    extendsFrom(agentsClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

val startScripts = tasks.register<GradleStartScriptGenerator>("startScripts") {

            "This will fail with an error in Gradle 9.0. Be sure to mark configurations meant for resolution as canBeConsumed=false or use the 'resolvable(String)' configuration factory method to create them. " +
            "Consult the upgrading guide for further information: https://docs.gradle.org/current/userguide/upgrading_version_8.html#depending_on_root_configuration")

        If you are unable to do so, please ensure you have collected the relevant debugging information manually and attached below;
        issue without enough information will not be resolvable.
  - type: checkboxes
    id: area
    attributes:
      label: Affected product area
      options:
      - label: "Ambient"
      - label: "Docs"
      - label: "Dual Stack"
      - label: "Installation"

 * corresponding source sets and any domain objects which are created by the {@link BasePlugin} on the source sets' behalf.
 * This includes their resolvable configurations and dependency scopes, as well as any associated tasks.
 *
 * TODO: We should strip almost all logic from this class. It should be a simple container for features and should provide

    /**
     * A cache of the defined dependencies for dependency configurations. This tracks the cached internal
     * dependency representations for these types so when constructing leaf configuration metadata
     * (resolvable and consumable), these conversions do not need to be executed multiple times.
     */
    class DependencyCache {
        private final Map<String, DefaultLocalConfigurationMetadataBuilder.DependencyState> cache = new HashMap<>();