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

KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<plugin>
  <description>Maven Internal State-Management Plugins</description>
  <groupId>org.apache.maven.plugins.internal</groupId>
  <artifactId>maven-state-management</artifactId>
  <version>2.1</version>
  <goalPrefix>statemgmt</goalPrefix>
  <isolatedRealm>false</isolatedRealm>

    </plugin>
    <plugin id="codenarc" description="CodeNarc Plugin">
        <extends targetClass="org.gradle.api.Project" id="codenarc" extensionClass="org.gradle.api.plugins.quality.CodeNarcExtension"/>
    </plugin>
    <plugin id="pmd" description="PMD Plugin">
        <extends targetClass="org.gradle.api.Project" id="pmd" extensionClass="org.gradle.api.plugins.quality.PmdExtension"/>
    </plugin>
    <plugin id="jacoco" description="JaCoCo Plugin">

 */

package org.gradle.plugin.use;

import org.gradle.internal.HasInternalProtocol;

import javax.annotation.Nullable;

/**
 * A description of a plugin.
 *
 * @since 3.5
 */
@HasInternalProtocol
public interface PluginId {

    /**
     * The fully qualified plugin ID.
     */
    String getId();

    /**
     * The namespace of the plugin or {@code null} if the ID contains no {@code .}.

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

// Package plugin implements loading and symbol resolution of Go plugins.
//
// A plugin is a Go main package with exported functions and variables that
// has been built with:
//
//	go build -buildmode=plugin
//
// When a plugin is first opened, the init functions of all packages not
// already part of the program are called. The main function is not run.
// A plugin is only initialized once, and cannot be closed.

import "C"

import "testplugin/common"

func F() int { return 17 }

var FuncVar = func() {}

func ReadCommonX() int {
	FuncVar()
	return common.X
}

func main() {
	panic("plugin1.main called")