},
			defaultPlugins: &v1.Plugins{
				Filter: v1.PluginSet{
					Enabled: []v1.Plugin{
						{Name: "Plugin1"},
						{Name: "Plugin2"},
						{Name: "Plugin3"},
					},
				},
			},
			expectedPlugins: &v1.Plugins{
				Filter: v1.PluginSet{
					Enabled: []v1.Plugin{
						{Name: "Plugin1", Weight: ptr.To[int32](2)},
						{Name: "Plugin2"},
						{Name: "Plugin3", Weight: ptr.To[int32](3)},
					},

	so, err := os.ReadFile("plugin2.so")
	if err != nil {
		log.Panic(err)
	}
	if err := os.WriteFile("plugin2-dup.so", so, 0444); err != nil {
		log.Panic(err)
	}
	prettyPrintf("cp plugin2.so plugin2-dup.so\n")

	goCmd(nil, "build", "-buildmode=plugin", "-o=sub/plugin1.so", "./sub/plugin1")
	goCmd(nil, "build", "-buildmode=plugin", "-o=unnamed1.so", "./unnamed1/main.go")

            }
        """

        file("plugin1.gradle") << """
            task sayMessageFrom1 { doLast { println new pkg.Thing().getMessage() } }
            apply from: 'plugin2.gradle'
        """

        file("plugin2.gradle") << """
            task sayMessageFrom2 { doLast { println new pkg.Thing().getMessage() } }
            apply from: 'plugin3.gradle'
        """

        file("plugin3.gradle") << """

        file('plugin-1/settings.gradle') << '''
            includeBuild("../plugin-0")
        '''
        file("plugin-1/build.gradle") << '''
            plugins {
                id("groovy-gradle-plugin")
                id("my.plugin-0")
            }
            gradlePlugin {
                plugins {
                    test {
                        id = "my.plugin-1"

				annotations: map[string][]kubecontainer.Annotation{
					"test-plugin1": {
						{
							Name:  "cdi.k8s.io/test-plugin1_claim-uid1",
							Value: "vendor.com/device=device1",
						},
						{
							Name:  "cdi.k8s.io/test-plugin1_claim-uid2",
							Value: "vendor.com/device=device2",
						},
					},
					"test-plugin2": {
						{
							Name:  "cdi.k8s.io/test-plugin2_claim-uid1",

                assert libs.versions.versionlibs.v3.get() == '3.0'
            }

            tasks.register('checkPlugins') {
                assert libs.plugins.p.some.plugin.p1.get().getPluginId() == 'plugin1'
                assert libs.plugins.p.somePlugin.p2.get().getPluginId() == 'plugin2'
            }
        """

        when:
        lib1.pom.expectGet()
        lib1.artifact.expectGet()
        lib2.pom.expectGet()

[[sec:types_of_plugins]]
== Types of plugins

Plugins can be implemented as *binary plugins*, *precompiled script plugins*, or *script plugins*:

Binary Plugins :: Binary plugins are compiled plugins typically written in Java or Kotlin DSL that are packaged as JAR files.
They are applied to a project using the `plugins {}` block.

		klog.ErrorS(err, "Error initializing dynamic plugin prober")
		pm.prober = &dummyPluginProber{}
	}

	if pm.plugins == nil {
		pm.plugins = map[string]VolumePlugin{}
	}
	if pm.probedPlugins == nil {
		pm.probedPlugins = map[string]VolumePlugin{}
	}

	allErrs := []error{}
	for _, plugin := range plugins {
		name := plugin.GetPluginName()

var _ framework.EnqueueExtensions = &PodTopologySpread{}

// Name is the name of the plugin used in the plugin registry and configurations.
const Name = names.PodTopologySpread

// Name returns name of the plugin. It is used in logs, etc.
func (pl *PodTopologySpread) Name() string {
	return Name
}

// New initializes a new plugin and returns it.

	"k8s.io/kubernetes/pkg/scheduler/framework"
	"k8s.io/kubernetes/pkg/scheduler/framework/parallelize"
	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/names"
	"k8s.io/kubernetes/pkg/scheduler/util"
)

// Name is the name of the plugin used in the plugin registry and configurations.
const Name = names.InterPodAffinity

var _ framework.PreFilterPlugin = &InterPodAffinity{}