repositories {
                mavenCentral()
            }

            gradlePlugin {
                plugins {
                    sofPlugin {
                        id = 'com.example.plugin'
                        implementationClass = 'SofPlugin'
                    }
                }
            }

            publishing {
                repositories {
                    maven {

            pluginManagement {
                includeBuild 'build-logic'
            }
        """
        file("build-logic/src/main/java/FooPlugin.java") << """
            import ${Project.name};
            import ${Plugin.name};

            public class FooPlugin implements Plugin<Project> {
                public void apply(Project project) { }
            }
        """
        file("build-logic/build.gradle") << """

import org.gradle.api.JavaVersion
import org.gradle.api.plugins.quality.PmdPlugin
import org.gradle.test.fixtures.VersionCoverage

class PmdCoverage {
    /**
     * @see {org.gradle.api.plugins.quality.pmd.AbstractPmdPluginVersionIntegrationTest#requiredSourceCompatibility()} Java source compatibility for PMD versions
     */

            tasks.named("validateExternalPlugins") {
                dependsOn(validationTask)
            }
        """
        validatePlugins {
            onPlugin("ProguardPlugin") {
                passes()
            }
            onPlugin("proguard") {
                passes()
            }
        }
    }

         * applied to, it doesn't care about the project path.
         */
        void passing(Closure<Boolean> pluginIdPredicate) {
            passingPluginsPredicate = pluginIdPredicate
        }

        void onPlugin(String id, String projectPath = ":", @DelegatesTo(value = PluginValidation, strategy = Closure.DELEGATE_FIRST) Closure<?> spec) {
            TestFile projectRootFile = owner.file(".")

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

package org.gradle.api.plugins.quality.pmd

import org.gradle.api.plugins.quality.PmdPlugin
import org.gradle.integtests.fixtures.MultiVersionIntegrationSpec
import org.gradle.integtests.fixtures.TargetCoverage
import org.gradle.quality.integtest.fixtures.PmdCoverage
import org.gradle.test.precondition.TestPrecondition

                    onPlugins(['org.jetbrains.kotlin.jvm']) { registerValidationFailure(delegate) }
                } else {
                    onPlugin(testedPluginId) { registerValidationFailure(delegate) }
                }
                // Register validation failures for plugins brought in by this plugin

        assertTrue(existing("build/generated-sources/kotlin-dsl-plugins/kotlin/FooPlugin.kt").isFile)

        fooScript.renameTo(fooScript.parentFile.resolve("bar.gradle.kts"))

        build("generateScriptPluginAdapters")
        assertFalse(existing("build/generated-sources/kotlin-dsl-plugins/kotlin/FooPlugin.kt").exists())

        ]
    }

    @Override
    void configureValidation(String testedPluginId, String version) {
        validatePlugins {
            if (testedPluginId == 'com.moowork.node') {
                onPlugin('com.moowork.node') {
                    failsWith([
                        (missingAnnotationMessage { type('com.moowork.gradle.node.npm.NpmSetupTask').property('args').missingInputOrOutput().includeLink() }): ERROR,

import org.gradle.integtests.fixtures.jvm.JavaToolchainFixture
import org.gradle.internal.jvm.Jvm
import org.gradle.util.internal.VersionNumber
import org.junit.Assume

/**
 * Tests to ensure toolchains specified by the {@code PmdPlugin} and
 * {@code Pmd} tasks behave as expected.
 */
class PmdPluginToolchainsIntegrationTest extends AbstractPmdPluginVersionIntegrationTest implements JavaToolchainFixture {

    def setup() {