) : KotlinScript, GradleScript {

    internal
    interface Host {
        fun getLogger(): Logger
        fun getLogging(): LoggingManager
        fun getFileOperations(): FileOperations
        fun getProcessOperations(): ProcessOperations
    }

    override val logging: LoggingManager by unsafeLazy(host::getLogging)

    override val logger: Logger by unsafeLazy(host::getLogger)

    @Override
    public StandardOutputCapture getStandardOutputCapture() {
        return getScriptTarget().getStandardOutputCapture();
    }

    @Override
    public LoggingManager getLogging() {
        return getScriptTarget().getLogging();
    }

    @Override
    public Logger getLogger() {
        return getScriptTarget().getLogger();
    }

    @Override
    public String toString() {

    }

    @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() {

    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
    }

                    // 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();
                }
            }

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

    }

    @Test
    void canExecuteExternalScriptAgainstAnArbitraryObject() {
        createBuildSrc()

        testFile('external.gradle') << '''
println 'quiet message'
getLogging().captureStandardOutput(LogLevel.ERROR)
println 'error message'
new BuildSrcClass()
assert 'doStuff' == name
assert buildscript.classLoader == getClass().classLoader.parent

    }

    @Override
    public <T> Provider<T> provider(Callable<T> value) {
        return providerFactory.provider(value);
    }

    @Override
    public LoggingManager getLogging() {
        return loggingManager;
    }

    @Override
    public Logger getLogger() {
        return LOGGER;
    }

    @Override
    public String toString() {
        return "script";

        delegate.javaexec(action)

    @AllowUsingApiForExternalUse
    override fun getChildProjects(): MutableMap<String, Project> =
        delegate.childProjects

    override fun getLogging(): LoggingManager =
        delegate.logging

    override fun getTasks(): TaskContainer =
        delegate.tasks

    override fun getName(): String =
        delegate.name

    private final Property<Boolean> includeMainForScripts = getProject().getObjects().property(Boolean.class);

    public Groovydoc() {
        getLogging().captureStandardOutput(LogLevel.INFO);
    }

    @TaskAction
    protected void generate() {
        checkGroovyClasspathNonEmpty(getGroovyClasspath().getFiles());