when: ':processResources is executed twice'
        configurationCacheRun 'processResources'
        configurationCacheRun 'processResources'

        then: 'the 2nd time it is loaded from the cache'
        configurationCache.assertStateLoaded()

        and: 'the task is up-to-date'
        result.assertTaskSkipped ':processResources'
    }

        def processResources = project.tasks['processCustomResources']
        processResources.description == "Processes custom resources."
        processResources instanceof Copy
        TaskDependencyMatchers.dependsOn().matches(processResources)
        processResources.destinationDir == new File(project.buildDir, 'resources/custom')
        def resources = processResources.source

            ":build-logic:jar",
            ":processResources",
            ":compileJava",
            ":classes",
            ":jar",
            ":assemble"
        )
        fixture.assertStateStored()

        when:
        configurationCacheRun("assemble")

        then:
        result.assertTasksExecuted(
            ":processResources",
            ":compileJava",
            ":classes",

    // See gradlebuild.unittest-and-compile.gradle.kts
    configurations["transitiveSourcesElements"].outgoing.artifact(apiExtensionsOutputDir) {
        builtBy(generateKotlinDependencyExtensions)
    }

    processResources {
        // Add generated sources to the main jar because `src` or any other Gradle distribution does not include them.
        // A more general solution is probably required: https://github.com/gradle/gradle/issues/21114

            }
            processResources.dependsOn(broken)
        """
        dependency("org.test:buildB:1.0")
        buildB.buildFile << """
            task broken {
                doLast {
                    ${server.callFromBuild('buildB')}
                    throw new RuntimeException("broken")
                }
            }
            processResources.dependsOn(broken)
        """

                        }
                        def buildTypes = ['debug', 'release']
                        def flavors = ['free', 'paid']
                        def processResources = p.tasks.processResources
                        buildTypes.each { bt ->
                            flavors.each { f ->
                                String baseName = "${f.capitalize()}${bt.capitalize()}"

        succeeds("test")
        executedAndNotSkipped(":compileJava", ":processResources", ":compileTestJava", ":test")

        when:
        sourceFile.text = "class Thing { static public int FLAG = 1; }"

        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":compileJava", ":compileTestJava", ":test")
        skipped(":processResources")

        when:

> Task :compileJava
> Task :processResources
> Task :classes
> Task :jar
> Task :generateMetadataFileForBinaryAndSourcesPublication
> Task :generatePomFileForBinaryAndSourcesPublication
> Task :sourcesJar
> Task :publishBinaryAndSourcesPublicationToExternalRepository SKIPPED
> Task :publishBinaryAndSourcesPublicationToInternalRepository
> Task :generateMetadataFileForBinaryPublication
> Task :generatePomFileForBinaryPublication

        !compileJava.result.upToDate

        def processResources = events.operation('Task :processResources')
        processResources.descriptor.name == ":processResources"
        processResources.descriptor.taskPath == ":processResources"
        assertEmptyInputsTask(processResources)

        def disabled = events.operation('Task :disabled')

        }
        2.times {
            fails 'processResources', '-PprocessResources.broken', '--continue' // add --continue to force compileJava to always run
            result.assertTasksExecutedInOrder ':processResources', ':compileJava'
        }
        2.times {
            fails 'processResources', '-Pclasses.broken'
            result.assertTasksExecutedInOrder ':processResources', ':compileJava', ':classes'
        }
    }