def "generated jars (api & test-kit) are valid archives"() {
        setup:
        productionCode()
        testCode()

        def version = distribution.version.version
        def generatedJars = [
            'gradle-api',
            'gradle-test-kit'
        ].collect { file("user-home/caches/$version/generated-gradle-jars/${it}-${version}.jar" )}

        when:

import java.io.File;

/**
 * Cache for generated jars such as {@code gradle-api-${version}.jar} and {@code gradle-test-kit-${version}.jar}.
 */
public interface GeneratedGradleJarCache {

    String CACHE_KEY = "generated-gradle-jars";

    String CACHE_DISPLAY_NAME = "Generated Gradle JARs cache";

    /**
     * Returns the generated jar uniquely identified by {@code identifier}.
     *

    protected void assertIsGradleJar(TestFile jar) {
        jar.assertIsFile()
        assertThat(jar.name, jar.manifest.mainAttributes.getValue('Implementation-Version'), equalTo(baseVersion))
        assertThat(jar.name, jar.manifest.mainAttributes.getValue('Implementation-Title'), equalTo('Gradle'))
    }

    private static void assertIsGradleApiMetadataJar(TestFile jar) {
        new JarTestFixture(jar.canonicalFile).with {

    fun `provides a source code generation oriented model over a classpath`() {

        val jars = listOf(
            withClassJar(
                "some.jar",
                Plugin::class.java,
                PluginCollection::class.java,
                ObjectFactory::class.java
            )
        )

        apiTypeProviderFor(jars).use { api ->

            assertThat(api.typeOrNull<Test>(), nullValue())

    }

    def "direct has GMM and no sources jar and transitive has GMM and has sources jar"() {
        transitive.adhocVariants().variant("jar", [
                "org.gradle.category": "library",
                "org.gradle.dependency.bundling": "external",
                "org.gradle.usage": "java-runtime"
        ]) {
            artifact("transitive-1.0.jar")
        }.variant("sources", [

    private ModuleVersionIdentifier moduleVersion;

    /**
     * Creates single entry module library
     *
     * @param library a path to jar or class folder in idea format
     * @param javadoc paths to javadoc jars or javadoc folders
     * @param source paths to source jars or source folders
     * @param scope scope
     */

    static class LibraryElementsDisambiguationRules implements AttributeDisambiguationRule<LibraryElements>, ReusableAction {
        final LibraryElements jar;

        @Inject
        LibraryElementsDisambiguationRules(LibraryElements jar) {
            this.jar = jar;
        }

        @Override
        public void execute(MultipleCandidatesDetails<LibraryElements> details) {

    <orderEntry type="module-library" scope="RUNTIME">
      <library>
        <CLASSES>
          <root url="jar://$CUSTOM_DIR$/../cache/junit/junit/jars/junit-4.7.jar!/"/>
        </CLASSES>
        <JAVADOC/>
        <SOURCES>
          <root url="jar://$CUSTOM_DIR$/../cache/junit/junit/sources/junit-4.7-sources.jar!/"/>
        </SOURCES>
      </library>
    </orderEntry>
  </component>

            mkdir()
            File(this, "gradle-8.0.2.jar").writeText("stub")
            File(this, "all-deps-in-the-world-1.2.2.jar").writeText("stub")
        }

        assertFails("Install directory $target does not look like a Gradle installation. Cannot delete it to install.")
        assertTargetIsPreserved()
    }

    @Test
    fun `does not install to dir without jars`() {
        target.resolve("bin").apply {

        assertContainsGradleKotlinDslJars(initClassPath)
        assertIncludes(initClassPath, spec.jars.init)

        def someInitClassPath = canonicalClasspathOf(model, spec.scripts.someInit)
        assertNotContainsBuildSrc(someInitClassPath)
        assertContainsGradleKotlinDslJars(someInitClassPath)
        assertIncludes(someInitClassPath, spec.jars.someInit)
    }