setRecommendedPluginOrder: []string{"pluginA", "pluginB", "pluginC", "pluginD"},
			setDefaultOffPlugins:      sets.Set[string]{},
		},

		// scenario 3: use default off plugins and specified by enable-admission-plugins with RecommendedPluginOrder
		{
			expectedPluginNames:       []string{"pluginA", "pluginB", "pluginC", "pluginD"},
			setRecommendedPluginOrder: []string{"pluginA", "pluginB", "pluginC", "pluginD"},

        buildFile """
            class Plugin1 implements Plugin {
                void apply(project) {
                    project.rootProject.project(":b").apply(plugin: Plugin2)
                }
            }
            class Plugin2 implements Plugin {
                void apply(project) {

                }
            }

            project(":a").apply plugin: Plugin1
        """
        succeeds("help")

            }
        """

        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"

	// initialized later.

	// Each plugin can make use of VolumeConfig.  The single arg to this func contains *all* enumerated
	// options meant to configure volume plugins.  From that single config, create an instance of volume.VolumeConfig
	// for a specific plugin and pass that instance to the plugin's ProbeVolumePlugins(config) func.

	// HostPath recycling is for testing and development purposes only!

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

[[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.

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

	"k8s.io/kubernetes/pkg/volume/secret"
)

// ProbeVolumePlugins collects all volume plugins into an easy to use list.
func ProbeVolumePlugins(featureGate featuregate.FeatureGate) ([]volume.VolumePlugin, error) {
	allPlugins := []volume.VolumePlugin{}

	// The list of plugins to probe is decided by the kubelet binary, not
	// by dynamic linking or other "magic".  Plugins will be analyzed and
	// initialized later.
	//

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