}
            }

            class Plugin3 {
                static class Rules extends RuleSource {
                    @Mutate
                    void m(String s) {
                        "foo"
                    }
                }
            }

            apply type: Plugin1
            apply type: Plugin2
            apply type: Plugin3
        """

        when:

			},
			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"

        file("build/resources/main/META-INF/gradle-plugins").listFiles().size() == 1
    }

    @Issue("https://github.com/gradle/gradle/issues/1061")
    def "one plugin project can depend on another when using publishing plugins"() {
        given:
        settingsFile << "include 'a', 'b'"
        file("a/build.gradle") << """
            apply plugin: 'java-gradle-plugin'
            apply plugin: 'maven-publish'

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