plugin.getVersion(),
                "maven-plugin",
                null,
                remoteRepositories,
                null);
        this.plugin = plugin;
    }

    public Plugin getPlugin() {
        return plugin;
    }

    }

    @Override
    public PluginDependency obtain() {
        String pluginName = getParameters().getPluginName().get();
        PluginModel data = getParameters().getConfig().get().getPlugin(pluginName);
        ImmutableVersionConstraint version = data.getVersion();
        return new DefaultPluginDependency(
            data.getId(), new DefaultMutableVersionConstraint(version)
        );
    }

    private
    class SettingsScriptHost(val host: KotlinScriptHost<Settings>) : Host {
        override fun getLogger(): Logger = Logging.getLogger(Settings::class.java)
        override fun getLogging(): LoggingManager = host.target.serviceOf()
        override fun getFileOperations(): FileOperations = host.fileOperations
        override fun getProcessOperations(): ProcessOperations = host.processOperations
    }

     */
    Plugin getPlugin(String id) throws UnknownPluginException;

    /**
     * Returns a plugin with the specified type if this plugin has been used in the project.
     *
     * @param type The type of the plugin
     * @throws UnknownPluginException When there is no plugin with the given type.
     */
    <T extends Plugin> T getPlugin(Class<T> type) throws UnknownPluginException;

    /**

 * expressions.
 *
 * @since 4.0.0
 */
@Experimental
public interface MojoExecution {

    @Nonnull
    Plugin getPlugin();

    @Nonnull
    PluginExecution getModel();

    @Nonnull
    MojoDescriptor getDescriptor();

    @Nonnull
    String getExecutionId();

    @Nonnull
    String getGoal();

                    // Note: not all of these specialise at time of writing, but may do in the future
                    getTaskDependencies();
                    getState();
                    getLogging();
                    getLogging().captureStandardOutput(LogLevel.INFO);
                    getStandardOutputCapture();
                    getInputs();
                    getOutputs();
                }
            }

    }

    @Override
    public void setOnlyIf(Closure onlyIfClosure) {
        super.setOnlyIf(onlyIfClosure);
    }

    @Override
    public org.gradle.api.logging.LoggingManager getLogging() {
        return super.getLogging();
    }

    @Override
    public TaskInputsInternal getInputs() {
        return super.getInputs();
    }

    @Override
    public TaskOutputsInternal getOutputs() {

import (
	"os"
	"syscall"
	"testing"

	"k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
)

func TestFSGroupMount(t *testing.T) {
	tmpDir, plug := getPlugin(t)
	defer os.RemoveAll(tmpDir)
	info, err := os.Stat(tmpDir)
	if err != nil {
		t.Errorf("Error getting stats for %s (%v)", tmpDir, err)
	}
	s := info.Sys().(*syscall.Stat_t)
	if s == nil {

            PluginApplication pluginApplication = pluginApplicationTracker.findRunningPluginApplication(buildOperation.getParentId());
            return pluginApplication == null ? null : pluginApplication.getPlugin();
        });
    }

    @Override
    public void finished(BuildOperationDescriptor buildOperation, OperationFinishEvent finishEvent) {
        // origins have to be stored until the end of the build
    }

 */

package org.gradle.api.internal.project;

import org.apache.tools.ant.Task;

public class TestAntTask extends Task {
    @Override
    public void execute() {
        org.apache.commons.logging.LogFactory.getLog("ant-test").info("a jcl log message");
        org.slf4j.LoggerFactory.getLogger("ant-test").info("an slf4j log message");
        org.apache.log4j.Logger.getLogger("ant-test").info("a log4j log message");
    }