Thread.sleep(1000)
                        }
                    }
                }
            }

            abstract class Extract extends DefaultTask {
                @InputFile
                abstract RegularFileProperty getArchiveFile()
                @OutputDirectory
                abstract DirectoryProperty getDestinationDir()

                @Inject

        settingsFile """
            include "dist"
            include "lib"
        """

        file("dist/build.gradle").text = """
            abstract class ZipSrc extends DefaultTask {
                @Internal
                int countResolved

                @Internal
                abstract DirectoryProperty getSources()

                @InputFiles

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

package org.gradle.api.internal.tasks

import org.gradle.api.Action
import org.gradle.api.DefaultTask
import org.gradle.api.internal.tasks.execution.ExecuteTaskBuildOperationType
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.ClasspathNormalizer
import org.gradle.api.tasks.CompileClasspathNormalizer

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

package org.gradle.internal.cc.impl.inputs.undeclared

import org.gradle.api.DefaultTask
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.tasks.TaskAction
import org.gradle.internal.cc.impl.AbstractConfigurationCacheIntegrationTest
import org.gradle.test.precondition.Requires

    }

    void setup() {
        spec.systemPropertyDefinitions.collect {
            it.setup(test, propertyKey)
        }

        test.buildFile << """
            task $task(type: DefaultTask) {
                def property = providers.systemProperty('$propertyKey')
                doFirst {
                    println('Execution: ' + property.orNull)
                }
            }
            """

        def bytes = new byte[1024 * 1024]
        new Random().nextBytes(bytes)
        file("output.txt").bytes = bytes

        buildFile << """
            @CacheableTask
            abstract class CustomTask extends DefaultTask {
                @OutputFile File outputFile = new File(temporaryDir, "output.txt")
                @Input String run = project.findProperty("run") ?: ""
                @javax.inject.Inject abstract FileSystemOperations getFs()

            import org.gradle.api.*;
            import org.gradle.api.tasks.*;
            import org.gradle.work.*;
            @DisableCachingByDefault(because = "test task")
            public class MyTask extends DefaultTask {
                @Optional @Input
                boolean getPrimitive() {
                    return true;
                }
                @TaskAction public void execute() {}
            }
        '''

        when:
        configurationCacheFails ":some"

        then:
        problems.assertFailureHasProblems(failure) {
            withUniqueProblems(
                "Task `:some` of type `org.gradle.api.DefaultTask`: cannot serialize Gradle script object references as these are not supported with the configuration cache."
            )
            withProblemsWithStackTraceCount(0)
        }
    }

import static org.gradle.integtests.fixtures.executer.TaskOrderSpecs.exact

class FinalizerTaskIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        buildFile '''
            class BreakingTask extends DefaultTask {
                @TaskAction
                def run() {}
            }

            tasks.withType(BreakingTask).configureEach { t ->
                if (project.hasProperty("${t.name}.broken")) {

                }
            }
        """
    }

    private addTasksWithProblems(String brokenFieldValue = 'project.configurations') {
        buildFile """
            class Broken extends DefaultTask {
                // Serialization time problem
                private final brokenField = $brokenFieldValue

                @TaskAction
                void execute() {