def includedSelector = invocations[0].taskSelectors[0]

        when:
        withBuild { BuildLauncher launcher ->
            launcher.forLaunchables(includedSelector)
        }

        then:
        thrown(BuildException)

        when:
        withBuild { BuildLauncher launcher ->
            launcher.forLaunchables(includedTask)
        }

        then:

            }
            model = model.withBuild(build);
        }
        Reporting reporting = model.getReporting();
        if (reporting != null) {
            expandReport(reporting.getPlugins());
        }
        return model.withBuild(build);
    }

    private List<Plugin> expandPlugin(List<Plugin> oldPlugins) {

        file("build.gradle") << """
        logger.debug("debugging stuff")
        logger.info("infoing stuff")
"""

        when:
        String debug = withBuild { it.withArguments('-d') }.standardOutput

        and:
        String info = withBuild { it.withArguments('-i') }.standardOutput

        then:
        debug.count("debugging stuff") == 1
        debug.count("infoing stuff") == 1

        and:

        when:
        runDumpTaskWithTapi()

        then:
        agentWasNotApplied()
    }

    private void runDumpTaskWithTapi() {
        withConnection {
            buildOutput = withBuild {
                it.forTasks("hello")
            }.stdout.toString()
        }
    }

    private void agentWasApplied() {
        agentStatusWas(true)
    }

    private void agentWasNotApplied() {

            if (build != null) {
                PluginManagement pluginManagement = build.getPluginManagement();
                if (pluginManagement != null) {
                    return model.withBuild(mergePluginContainerPlugins(build, pluginManagement));
                }
            }
            return model;
        }

        private Build mergePluginContainerPlugins(Build target, PluginContainer source) {

            Build.Builder builder = Build.newBuilder(targetBuild);
            mergePluginContainer_Plugins(builder, targetBuild, source.getBuild(), false, context);

            return target.withBuild(builder.build());
        }

        @SuppressWarnings({"checkstyle:methodname"})
        @Override
        protected void mergePluginContainer_Plugins(
                PluginContainer.Builder builder,

            Build.Builder builder = Build.newBuilder(targetBuild);
            mergePluginContainer_Plugins(builder, targetBuild, source.getBuild(), false, context);

            return target.withBuild(builder.build());
        }

        @SuppressWarnings({"checkstyle:methodname"})
        @Override
        protected void mergePluginContainer_Plugins(
                PluginContainer.Builder builder,

        withConnection {
            def model = it.model(modelType)
            cl(model)
            new ConfigurableOperation(model).buildModel()
        }
    }

    ConfigurableOperation withBuild(Closure cl = {}) {
        withConnection {
            def build = it.newBuild()
            cl(build)
            def out = new ConfigurableOperation(build)
            build.run()
            out
        }

        // Add the Gradle API filter between the user classloader and the worker infrastructure classloader
        return new HierarchicalClassLoaderStructure(workerExtensionSpec)
                .withChild(gradleApiFilter)
                .withChild(userSpec);
    }

    public ClassLoaderStructure getInProcessClassLoaderStructure(final Iterable<File> additionalClasspath, Class<?>... classes) {

            new HierarchicalClassLoaderStructure(classLoaderRegistry.getGradleWorkerExtensionSpec())
                .withChild(getMinimalGradleFilter())
                .withChild(targetGroovyClasspath)
                .withChild(gradleAndUserFilter)
                .withChild(compilerClasspath);

        return new DaemonForkOptionsBuilder(forkOptionsFactory)
            .javaForkOptions(javaForkOptions)