def setup() {
        project.pluginManager.apply(PmdPlugin)
    }

    def "applies reporting-base plugin"() {
        expect:
        project.plugins.hasPlugin(ReportingBasePlugin)
    }

    def "pmd 7.0.0 is loading the right dependencies"() {
        expect:

        }
    }
}


internal
sealed class PluginDependencySpecAccessor {

    abstract val extension: ExtensionSpec

    data class ForPlugin(
        val id: String,
        val implementationClass: String,
        override val extension: ExtensionSpec
    ) : PluginDependencySpecAccessor()

    data class ForGroup(
        val id: String,

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

implementation-class=org.gradle.api.plugins.quality.PmdPlugin...

         * 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(".")

			}

			mounter, err := volPlug.NewMounter(volSpec, pod, volume.VolumeOptions{})
			if err != nil || mounter == nil {
				t.Fatalf("csiTest.VolumeAll volPlugin.NewMounter is nil or error: %s", err)
			}

			var fsGroup *int64
			if pod.Spec.SecurityContext != nil && pod.Spec.SecurityContext.FSGroup != nil {
				fsGroup = pod.Spec.SecurityContext.FSGroup
			}

 * 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

        script.pluginAdapterClassName == javaClass

        where:
        filename                               | javaClass
        "foo.gradle"                           | "FooPlugin"
        "foo.bar.gradle"                       | "FooBarPlugin"
        "test-plugin.gradle"                   | "TestPluginPlugin"
        "foo.bar.test-plugin.gradle"           | "FooBarTestPluginPlugin"

        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())