mavenCentral()
}

dependencies {
    // Use JUnit Jupiter for testing.
    testImplementation(libs.junit.jupiter)

    testRuntimeOnly("org.junit.platform:junit-platform-launcher")

    // This dependency is used by the application.
    implementation(libs.guava)
}

// Apply a specific Java toolchain to ease working on different environments.
java {
    toolchain {

        'invalid12' | "In version catalog libs, unknown top level elements [toto, tata]"
        'invalid13' | "Expected an array but value of 'groovy' is a string."
        'invalid14' | "In version catalog libs, version reference 'nope' doesn't exist"
        'invalid15' | "In version catalog libs, on alias 'my' notation 'some.plugin.id' is not a valid plugin notation."

        result.assertTasksNotSkipped(":jar", ":assemble", ":build")
        def jarFile = file("build/libs/somelib.jar")
        new ZipTestFixture(jarFile).hasDescendants("META-INF/MANIFEST.MF")

        when:
        configurationCacheRun "build"

        then:
        assertStateLoaded()

        def lib1 = pluginAndLibraryBuild("lib1")

        when:
        lib1.settingsFile.setText("""
            pluginManagement {
                includeBuild("../${settingsPluginBuild.buildName}")
            }
            plugins {
                id("${settingsPluginBuild.settingsPluginId}")
            }
            rootProject.name="${lib1.buildName}"
        """)

        modPath(executable("build/exe/main/main").file).assertExists()
        modPath(sharedLibrary("build/libs/hello/shared/hello").file).assertExists()
        modPath(staticLibrary("build/libs/hello/static/hello").file).assertExists()
    }

    @Issue("https://github.com/gradle/gradle-native/issues/368")
    @RequiresInstalledToolChain(VISUALCPP)

                from configurations.conf
                into "libs"
            }
"""
        when:
        repositoryInteractions {
            'org.utils:api:1.1' {
                expectGetMetadata()
            }
        }
        succeeds "retrieve"

        then:
        file("libs").assertHasDescendants("api-1.1.jar")

            bundle('myBundle', ['foo', 'bar'])
            plugin('pl', 'org.plugin') version('1.2')
        }

        then:
        def libs = sources.compile()
        def foo = libs.foo.get()
        def bar = libs.bar.get()
        assert foo.module.group == 'g'
        assert foo.module.name == 'a'
        assert foo.versionConstraint.requiredVersion == 'v'

            ORG_GRADLE_PROJECT_password: password
        ])
        succeeds("signJar")

        then:
        executed(":signJar")
        file("build", "libs", "sign-1.0.jar.asc").exists()
    }

    def "signs with custom signatory"() {
        given:
        buildFile << """
            signing {
                useInMemoryPgpKeys('foo', 'bar')

        and:
        sharedLibrary(cppLib.dir.file("build/libs/main/shared/main")).assertExists()

        when:
        sample cppLib
        run "mainStaticLibrary"

        then:
        executedAndNotSkipped ":compileMainStaticLibraryMainCpp", ":createMainStaticLibrary", ":mainStaticLibrary"

        and:
        staticLibrary(cppLib.dir.file("build/libs/main/static/main")).assertExists()
    }

}
"""

        when:
        succeeds 'resolve'

        then:
        outputContains("""
Cached rule executed
Cached rule executed""")
        Arrays.asList(file('libs').listFiles()).sort() == [file('libs/projectA-1.0.jar'), file('libs/projectB-1.0.jar')]
    }