}

    def "reports task origin for lazily realized tasks"() {
        given:
        buildFile << """
            tasks.register('lazyTask') {
                doLast { println 'nothing to see here' }
            }
        """

        when:
        runBuild('lazyTask')

        then:
        task(':lazyTask').originPlugin.displayName == "build.gradle"
    }

    @TargetGradleVersion('>=3.0 <5.1')

                        // TODO(mlopatkin) Manifest of the signed JAR contains signature information and must be the first entry in the JAR.
                        //  Looking into the manifest here should be more effective.
                        // This policy doesn't transform signed JARs so no further checks are necessary.
                        return new SkipClasspathElementTransform(source);
                    }

     * State when we calculated the cache key.
     *
     * We always calculate the cache key when we have a {@link BeforeExecutionState}.
     * In some places we need to know that both are present or absent, we encode this here.
     */
    public static class CacheKeyCalculatedState {
        private final BuildCacheKey key;
        private final BeforeExecutionState beforeExecutionState;

                "validateExternalPlugins",
                "--continue",
                *extraParameters] as String[])
            validation.ignoreDeprecationWarnings("We are only checking type validation problems here")

            def result
            if (failsValidation) {
                result = validation.buildAndFail()
            } else {
                result = validation.build()
            }

    subprojectName: String
): Boolean {
    return if (testCoverage.os == Os.MACOS && testCoverage.arch == Arch.AMD64) {
        subprojectName.contains("native") ||
            // Include precondition-tester here so we understand that tests do run on macOS intel as well
            subprojectName in listOf("file-watching", "snapshots", "workers", "logging", "precondition-tester")
    } else {
        true
    }

        HashCode cacheKey = hashCodeSerializer.read(decoder);

        ImplementationSnapshot taskImplementation = implementationSnapshotSerializer.read(decoder);

        // We can't use an immutable list here because some hashes can be null
        int taskActionsCount = decoder.readSmallInt();
        ImmutableList.Builder<ImplementationSnapshot> taskActionImplementationsBuilder = ImmutableList.builder();

        FileCopyDetailsInternal dir;
        if (detailsForPath.isEmpty()) {
            // TODO - this is pretty nasty, look at avoiding using a time bomb stub here
            dir = new StubbedFileCopyDetails(path, includeEmptyDirs, chmod);
        } else {
            dir = detailsForPath.get(0);
        }
        delegateAction.processFile(dir);
    }

        dependsOn(RelativeId(SanityCheck.buildTypeId(model)))
    }

    /*
     To avoid unnecessary rerun, what we do here is a bit complicated:

     1. Build a Gradle distribution with a fixed timestamp and hash it, but never use this distribution.
     2. Build a Gradle distribution with this hash as a version + fixed timestamp -> dogfood-first

* Join our [Slack Channel](https://gradle.com/slack-invite)


## Contributing

If you're looking to contribute to Gradle or provide a patch/pull request, you can find more info [here](https://github.com/gradle/gradle/blob/master/CONTRIBUTING.md).

import org.gradle.util.internal.VersionNumber

plugins {
    `java-platform`
}

group = "gradlebuild"

description = "Provides a platform that constrains versions of external dependencies used by Gradle"

// Here you should declare versions which should be shared by the different modules of buildSrc itself
val javaParserVersion = "3.18.0"
val groovyVersion = GroovySystem.getVersion()