"""

    private
    fun testGradleInstallation() =
        GradleInstallation.Local(distribution.gradleHomeDir)

    protected
    fun compileKotlin(taskName: String = "classes"): ExecutionResult =
        build(taskName).assertTaskExecuted(":compileKotlin")

    protected
    fun withClassJar(fileName: String, vararg classes: Class<*>) =
        withZip(fileName, classEntriesFor(*classes))

                }
            }
        """)
        this
    }

    PluginBuilder addPluginWithPrintlnTask(String taskName, String message, String id = "test-plugin", String className = "TestPlugin") {
        addPlugin("project.task(\"$taskName\") { doLast { println \"$message\" } }", id, className)
        this
    }

    PluginBuilder addRuleSource(String pluginId) {

            if (taskProject != null) {
                String taskName = taskPath.getName();
                return new TaskSelection(
                    taskProject.getPath(),
                    taskName,
                    tasks -> tasks.add(taskProject.getTasks().getByName(taskName))
                );
            }
            return new TaskSelection(null, null, tasks -> {});

@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().getTaskDependencyFromProjectDependency(useDependedOn, taskName)"), level = DeprecationLevel.HIDDEN)
fun <T : Configuration> NamedDomainObjectProvider<T>.getTaskDependencyFromProjectDependency(useDependedOn: Boolean, taskName: String): TaskDependency =
    get().getTaskDependencyFromProjectDependency(useDependedOn, taskName)


/**
 * See [Configuration.getDependencies].
 */

        def pluginPortal = MavenHttpPluginRepository.asGradlePluginPortal(executer, mavenRepo)
        pluginPortal.start()
        def taskName = 'pluginTask'
        def message = 'hello from plugin'
        def plugin = new PluginBuilder(testDirectory.file("some-plugin"))
            .addPluginWithPrintlnTask(taskName, message, 'org.gradle.test.hello-world')
            .publishAs("g", "a", "1.0", pluginPortal, createExecuter())

    val defaultExecuter = "embedded"

    // For all the other executers, add an executer specific task
    testType.executers.forEach { executer ->
        val taskName = "$executer${prefix.capitalize()}Test"
        val testTask = createTestTask(taskName, executer, sourceSet, testType) {}
        if (executer == defaultExecuter) {
            // The test task with the default executer runs with 'check'

        someTaskOutput.assertExists()
    }

    private void assertTaskOutputCached(String taskName) {
        assert listCacheFiles().any { it.name == cacheOperations.getCacheKeyForTask(taskName) }
    }

    private void assertTaskOutputNotCached(String taskName) {
        def cacheKey = cacheOperations.getCacheKeyForTaskOrNull(taskName)
        assert cacheKey == null
    }

    @Override

            }
        }

        class ParTask extends DefaultTask {
            @TaskAction zzz() {
                def taskName = name
                services.get(WorkerExecutor.class).noIsolation().submit(TestWorkAction) {
                    it.name = taskName
                }
            }
        }
        """
    }

}
"""
        String generatedContent = ""
        builder.configs.forEach { config, taskName ->
            generatedContent += """
allprojects {
    tasks.register("${taskName}", ${GenerateGraphTask.name}) {
        it.outputFile = rootProject.file("\${rootProject.buildDir}/last-graph.txt")

Executing Gradle on the command-line conforms to the following structure:

----
gradle [taskName...] [--option-name...]
----

Options are allowed _before_ and _after_ task names.

----
gradle [--option-name...] [taskName...]
----

If multiple tasks are specified, you should separate them with a space.

----
gradle [taskName1 taskName2...] [--option-name...]
----