def appliesBaseReportingPluginAndAddsConventionObject() {
        when:
        plugin.apply(project)

        then:
        project.plugins.hasPlugin(ReportingBasePlugin.class)
        project.convention.getPlugin(ProjectReportsPluginConvention.class)
    }

    def addsTasksToProject() {
        when:
        plugin.apply(project);

        then:

        given:
        file('src/main/java/Test.java') << """
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class Test {
    private static final Log logger = LogFactory.getLog(Test.class);
}
"""

        and:
        buildFile << """
apply plugin: 'java'

${mavenCentralRepository()}

dependencies {
    compileOnly 'commons-logging:commons-logging:1.2'
}
"""

		ws.Path(logsPath)
		ws.Route(ws.GET("").
			To(s.getLogs).
			Operation("getLogs"))
		if !enableSystemLogQuery {
			ws.Route(ws.GET("/{logpath:*}").
				To(s.getLogs).
				Operation("getLogs").
				Param(ws.PathParameter("logpath", "path to the log").DataType("string")))
		} else {
			ws.Route(ws.GET("/{logpath:*}").
				To(s.getLogs).
				Operation("getLogs").

        then:
        model.getPlugin("my").version.requiredVersion == "1.3"
    }

    def "can declare a plugin referencing a version"() {
        builder.version("ver", "1.5")
        builder.plugin("my", "org.plugin").versionRef("ver")

        when:
        def model = builder.build()

        then:
        model.getPlugin("my").version.requiredVersion == "1.5"
    }

		}()

		clog, _, _, err := getLog(runner, resources, config, namespace, pod, "")
		appendGlobalErr(err)
		writeFile(filepath.Join(archive.CniPath(tempDir, pod), "cni.log"), clog, config.DryRun)
		log.Infof("Done with CNI logs %v", pod)
	}()
}

// getLog fetches the logs for the given namespace/pod/container and returns the log text and stats for it.

    protected final String sourceClass;

    protected final Log logger;

    public JclLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = LogFactory.getLog(clazz);
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isFatalEnabled();
    }

    @Override
    public void fatal(final String message) {
        logger.fatal(message);

        MojoDescriptor mojoDescriptor = execution.getMojoDescriptor();

        if (mojoDescriptor == null) {
            mojoDescriptor = pluginManager.getMojoDescriptor(
                    execution.getPlugin(),
                    execution.getGoal(),
                    project.getRemotePluginRepositories(),
                    session.getRepositorySession());

            execution.setMojoDescriptor(mojoDescriptor);

     * multiple such objects.
     * @deprecated Use extensions instead. This is scheduled for removal in Gradle 9.
     * @see org.gradle.api.plugins.ExtensionAware
     */
    @Deprecated
    <T> T getPlugin(Class<T> type) throws IllegalStateException;

    /**
     * Locates the plugin convention object with the given type.
     *
     * @param type The convention object type.

; public abstract void release(); public abstract void removeAttribute(String); public abstract void setAttribute(String, Object); public static LogFactory getFactory() throws LogConfigurationExce; public static Log getLog(Class) throws LogConfigurationExce; public static Log getLog(String) throws LogConfigurationExce; public static void release(ClassLoader); public static void releaseAll(); protected static ClassLoader getContextClassLoade() throws LogConfigurationExce; private static LogFactory...

        get() = host.scriptHandler

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