pvLister corelisters.PersistentVolumeLister,
	podLister corelisters.PodLister,
	asw cache.ActualStateOfWorld,
	dsw cache.DesiredStateOfWorld,
	pluginMgr *volume.VolumePluginMgr,
	csiMigratedPluginManager csimigration.PluginManager,
	intreeToCSITranslator csimigration.InTreeToCSITranslator) {
	registerMetrics.Do(func() {
		legacyregistry.CustomMustRegister(newAttachDetachStateCollector(pvcLister,
			podLister,
			pvLister,
			asw,
			dsw,

        }

        @Override
        public void applyTo(PluginManagerInternal pluginManager) {
            PluginCoordinates altCoords = pluginRequest.getAlternativeCoordinates().orElse(null);
            if (altCoords != null && pluginManager.hasPlugin(altCoords.getId().getId())) {
                return;
            }

            pluginManager.apply(pluginRequest.getId().getId());
        }
    }

        // Only check the build files, not all *.kts files in the project
        includes += listOf("*.gradle.kts")
    }

    withType<Test>().configureEach {
        shouldRunAfter(ktlintCheck)
    }
}

pluginManager.withPlugin("gradlebuild.code-quality") {
    tasks {
        named("codeQuality") {
            dependsOn(ktlintCheck)
        }
    }

            BuildPluginManager pluginManager,
            MavenPluginManager mavenPluginManager,
            LifecycleDependencyResolver lifeCycleDependencyResolver,
            ExecutionEventCatapult eventCatapult,
            Provider<MojosExecutionStrategy> mojosExecutionStrategy,
            MessageBuilderFactory messageBuilderFactory) {
        this.pluginManager = pluginManager;

    @Issue('https://github.com/gradle/gradle/issues/15664')
    def 'plugins are applied in the order they are declared in the plugins block'() {
        given:
        publishPlugin """
            if (!project.pluginManager.hasPlugin('java')) {
                throw new Exception('plugin application order is not correct')
            }
        """

        when:
        buildScript """
            plugins {

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

syntax = "proto3";

package v1beta1;
option go_package = "k8s.io/kubernetes/pkg/kubelet/pluginmanager/pluginwatcher/example_plugin_apis/v1beta1";

import "github.com/gogo/protobuf/gogoproto/gogo.proto";

option (gogoproto.goproto_stringer_all) = false;
option (gogoproto.stringer_all) =  true;

        project.apply plugin: 'reporting-base'

        expect:
        project.plugins.hasPlugin(ReportingBasePlugin)
    }

    def "adds reporting extension"() {
        given:
        project.pluginManager.apply(ReportingBasePlugin)

        expect:
        project.reporting instanceof ReportingExtension

        project.configure(project) {
            reporting {
                baseDir "somewhere"

class BuildInitPluginSpec extends AbstractProjectBuilderSpec {
    def setup() {
        project.gradle.attachSettings(Stub(SettingsState))
    }

    def "adds 'init' task"() {
        when:
        project.pluginManager.apply BuildInitPlugin

        then:
        project.tasks.init instanceof InitBuild
        project.tasks.init.group == "Build Setup"
    }

    @Override
    String getBuildScriptConfigurationForValidation() {
        """
            micronaut {
                version '${TestedVersions.micronaut}'
           }

           pluginManager.withPlugin('io.micronaut.application') {

               ${mavenCentralRepository()}

               application {
                   mainClass = 'dummy'
               }
           }
        """
    }

import org.gradle.test.fixtures.AbstractProjectBuilderSpec

class PublishingPluginTest extends AbstractProjectBuilderSpec {

    PublishingExtension extension

    def setup() {
        project.pluginManager.apply(PublishingPlugin)
        extension = project.extensions.getByType(PublishingExtension)
    }

    def "publishing extension is installed"() {
        expect:
        extension.publications != null