val mainClassName: Property<String>
}

val app = extensions.create<LaunchableJar>("app")

val manifestClasspath = configurations.dependencyScope("manifestClasspath")
val resolveManifestClasspath = configurations.resolvable("resolveManifestClasspath") {
    isTransitive = false
    extendsFrom(manifestClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

tasks.jar.configure {

            testReportDirectory.convention(javaPluginExtension.getTestReportDir());
        });

        // A resolvable configuration to collect test results
        Configuration testResultsConf = configurations.resolvable("aggregateTestReportResults").get();
        testResultsConf.extendsFrom(testAggregation);

val distribution = configurations.dependencyScope("distribution") {
    description = "Dependencies to extract the public Gradle API from"
}
val distributionClasspath = configurations.resolvable("distributionClasspath") {
    extendsFrom(distribution.get())
    configureAsRuntimeJarClasspath(objects)
}

// Defines configurations used to resolve external dependencies
// that the public API depends on.

plugins {
    // because this snippet is used in TestReportIntegrationTest which rewrites build files for different JUnit flavors
    id 'java'
}

// tag::test-report[]
// A resolvable configuration to collect test reports data
configurations {
    testReportData {
        canBeConsumed = false
        attributes {
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))

                    }
                    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

        resolve.prepare()
        resolve
    }

    @ToBeFixedForConfigurationCache(because = "resolves configuration at execution time")
    def "can declare a configuration which extends from a resolvable configuration which uses consistency"() {
        withRuntimeClasspathAsReference()
        def foo = mavenHttpRepo.module('org', 'foo', '1.0').publish()
        def bar = mavenHttpRepo.module('org', 'bar', '1.0').publish()

        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))

        buildFile.text = """
            repositories {
                maven { url '${mavenRepo.uri}' }
            }

            configurations {
                dependencyScope("conf")
                resolvable("res") {
                    extendsFrom conf
                }
            }

            configurations.conf.dependencies.addLater(provider(() -> project.dependencies.create("org:foo:1.0")))