result.plugin instanceof ScriptPluginIdentifier
        result.plugin.uri == scriptUri
    }

    def "ignores non-project plugins"() {
        given:
        file("build.gradle") << """
            apply(plugin: MyPlugin, to: gradle)
            class MyPlugin implements Plugin<Gradle> {
                void apply(Gradle gradle) {}

        settingsFile << """
            include("a")
            include("b")
        """
        buildFile << """
            plugins.apply(my.MyPlugin)
        """
        file("a/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """
        // Intentionally don't apply to project b. Should split this case (some projects don't have the model available) out into a separate test

        when:

plugins {
    id 'java-gradle-plugin'
}

gradlePlugin {
    plugins {
        myBasePlugin {
            id = 'my-base-plugin'
            implementationClass = 'MyBasePlugin'
        }
        myPlugin {
            id = 'my-plugin'
            implementationClass = 'MyPlugin'
        }
    }

        <forkId implementation="int" default-value="-1">${forkId}</forkId>
      </configuration>
    </mojo>
    <mojo>
      <goal>resolve-late-bound-plugin</goal>
      <description>Resolve a late-bound plugin during a build, right before it is to be used.</description>
      <requiresDirectInvocation>false</requiresDirectInvocation>
      <requiresProject>false</requiresProject>

import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.plugin.descriptor.PluginDescriptor;
import org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle;

/**
 * Represents a maven plugin runtime
 *
 * @since 4.0.0
 */
@Experimental
public interface Plugin {

    @Nonnull
    org.apache.maven.api.model.Plugin getModel();

    @Nonnull
    PluginDescriptor getDescriptor();

Than McIntosh <******@****.***> 1694009737 -0400

Austin Clements <******@****.***> 1683216807 -0400

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

// Package plugin defines the plugin implementations that the main pprof driver requires.
package plugin

import (
	"io"
	"net/http"
	"regexp"
	"time"

	"github.com/google/pprof/profile"
)

// Options groups all the optional plugins into pprof.

type PolicyHook = generic.PolicyHook[*Policy, *PolicyBinding, PolicyEvaluator]

type Plugin struct {
	*generic.Plugin[PolicyHook]
}

var _ admission.Interface = &Plugin{}
var _ admission.ValidationInterface = &Plugin{}
var _ initializer.WantsFeatures = &Plugin{}
var _ initializer.WantsExcludedAdmissionResources = &Plugin{}

func NewPlugin(_ io.Reader) *Plugin {

			return nil, err
		}

		return plugin, nil
	})
}

// Plugin is an implementation of admission.Interface.
type Plugin struct {
	*generic.Webhook
}

var _ admission.ValidationInterface = &Plugin{}

// NewValidatingAdmissionWebhook returns a generic admission webhook plugin.
func NewValidatingAdmissionWebhook(configFile io.Reader) (*Plugin, error) {