def s1 = setOfAutomaticAccessorsFor(["application"])
        def s2 = setOfAutomaticAccessorsFor(["java"])
        def s3 = setOfAutomaticAccessorsFor(["application"])
        def s4 = setOfAutomaticAccessorsFor(["application", "java"])
        def s5 = setOfAutomaticAccessorsFor(["java"])

        expect:
        assertThat(s1, not(equalTo(s2))) // application ≠ java

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

plugins {
    id("gradlebuild.internal.java")
    id("application")
}

description = "Example client application using the build-cache library"

dependencies {
    implementation(projects.buildCache)
    implementation(projects.buildCacheBase)
    implementation(projects.buildCacheLocal)

    unixScriptTemplate.from(layout.projectDirectory.file("../../../platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt"))
    windowsScriptTemplate.from(layout.projectDirectory.file("../../../platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/windowsStartScript.txt"))
}

configurations {
    create("gradleScriptsElements") {

        get() = host.scriptHandler

    /**
     * Applies zero or more plugins or scripts.
     * <p>
     * The given action is used to configure an [ObjectConfigurationAction], which “builds” the plugin application.
     * <p>
     * @param action the action to configure an [ObjectConfigurationAction] with before “executing” it
     * @see [PluginAware.apply]
     */

            """
            * Where:
            Initialization script '${script.canonicalPath}' line: 1
            """
        }
    }

    @Test
    fun `location of missing script application is reported`() {

        withBuildScript("""apply(from = "present.gradle.kts")""")
        val present = withFile("present.gradle.kts", """apply(from = "absent.gradle.kts")""")

                includeBuild '../lib'
            """
            file('build.gradle') << """
                plugins {
                    id 'java'
                    id 'application'
                }
                application {
                   mainClass = 'Main'
                }
                dependencies {
                    implementation 'org.test:lib:1.0'
                }
            """

        else
            "link:{userManualPath}/${descriptor.language.getName()}_plugin.html[${descriptor.language} Plugin]"

        val pluginType = if (descriptor.componentType === ComponentType.LIBRARY) "Library" else "Application"
        val configurationCacheCompatMatrixLink = "link:{userManualPath}/configuration_cache.html#config_cache:plugins:core"
        val configurationCacheCompatibility = when (descriptor.language) {

#       Darwin, MinGW, and NonStop.
#
#   (3) This script is generated from the Groovy template
#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
#       within the Gradle project.
#
#       You can find Gradle at https://github.com/gradle/gradle/.
#

                id("org.jetbrains.kotlin.jvm") version kotlinVersion
                id("org.jetbrains.kotlin.kapt") version kotlinVersion apply false
                val java = id("java")
                val app = id("application")
                app.apply(java.apply)
            }
            """.trimIndent()
        )
    }

    integTestImplementation(testFixtures(project(":build-cache")))
    integTestImplementation(libs.jetty)

    integTestDistributionRuntimeOnly(project(":distributions-jvm")) {
        because("Uses application plugin.")
    }