public org.apache.maven.plugin.MojoExecution getDelegate() {
        return delegate;
    }

    @Override
    public Plugin getPlugin() {
        return new Plugin() {
            @Override
            public org.apache.maven.api.model.Plugin getModel() {
                return delegate.getPlugin().getDelegate();
            }

            @Override
            public PluginDescriptor getDescriptor() {

        _ * startEvent.getDescriptor() >> projectConfigurationDescriptor

        def binaryPluginApplicationResult = Stub(InternalPluginApplicationResult)
        _ * binaryPluginApplicationResult.getPlugin() >> Stub(InternalBinaryPluginIdentifier) {
            getClassName() >> 'com.acme.SomePlugin'
            getPluginId() >> 'com.acme.some'
        }

    }

    private static class ProjectConfigurationResult {
        private final Map<InternalPluginIdentifier, PluginApplicationResult> pluginApplicationResults = new ConcurrentHashMap<>();

        void increment(PluginApplication pluginApplication, long duration) {
            InternalPluginIdentifier plugin = pluginApplication.getPlugin();
            pluginApplicationResults

    }

    def "fails when getting unknown plugin"() {
        when:
        container.getPlugin("unknown")

        then:
        thrown(UnknownPluginException)
    }

    def "fails when getting plugin of unknown type"() {
        when:
        container.getPlugin(plugin1Class)

        then:
        thrown(UnknownPluginException)
    }

            RequirementMatcher matcher = provides.get(key);

            if (matcher == null) {
                getLog().debug("Toolchain {} is missing required property: {}", this, key);
                return false;
            }
            if (!matcher.matches(requirement.getValue())) {
                getLog().debug("Toolchain {} doesn't match required property: {}", this, key);
                return false;
            }
        }

            val accessorsClass = loadClass(className)
            assertThat(
                accessorsClass.declaredMethods.map { it.name },
                hasItems("getMy", "getOwn", "getPlugin")
            )

            val expectedPluginSpec = mock<PluginDependencySpec>()
            val plugins = mock<PluginDependenciesSpec> {
                on { id(any()) } doReturn expectedPluginSpec
            }

	ps.registry[name] = plugin
}

// getPlugin creates an instance of the named plugin.  It returns `false` if
// the name is not known. The error is returned only when the named provider was
// known but failed to initialize.  The config parameter specifies the io.Reader
// handler of the configuration file for the cloud provider, or nil for no configuration.
func (ps *Plugins) getPlugin(name string, config io.Reader) (Interface, bool, error) {

	testPodPath                       = "pods/poduid/volumeDevices/kubernetes.io~local-volume"
	testBlockFormattingToFSGlobalPath = "plugins/kubernetes.io/local-volume/mounts/pvA"
)

func getPlugin(t *testing.T) (string, volume.VolumePlugin) {
	tmpDir, err := utiltesting.MkTmpdir("localVolumeTest")
	if err != nil {
		t.Fatalf("can't make a temp dir: %v", err)
	}

	plugMgr := volume.VolumePluginMgr{}

        this.plugin = plugin;
        this.totalConfigurationTime = totalConfigurationTime;
    }

    @Override
    public PluginIdentifier getPlugin() {
        return plugin;
    }

    @Override
    public Duration getTotalConfigurationTime() {
        return totalConfigurationTime;
    }

        MavenSession session = createMavenSession(getProject("project-contributing-system-scope-plugin-dep"));
        MavenProject project = session.getCurrentProject();
        Plugin plugin = project.getPlugin("org.apache.maven.its.plugins:maven-it-plugin");

        RepositoryRequest repositoryRequest = new DefaultRepositoryRequest();
        repositoryRequest.setLocalRepository(getLocalRepository());