super.connect(snk)
                write(message.bytes)
                close()
            }
        })
    }

    String makeTask(Map<String, String> args, String taskName) {
        return "${taskName}Task"(args)
    }

    @SuppressWarnings('unused')
    // called by string
    def execTask(Map<String, String> args) {
        """
            tasks.register("run", Exec) {

                }
            }
        """)
        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 -> {});

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

    }

    def "logs replaced task"() {
        when:
        DeprecationLogger.deprecateTask("taskName").replaceWith("replacementTask").willBeRemovedInGradle9().undocumented().nagUser()

        then:
        expectMessage "The taskName task has been deprecated. This is scheduled to be removed in Gradle ${NEXT_GRADLE_VERSION}. Please use the replacementTask task instead."
    }

        if (useDependedOn) {
            return new TasksFromProjectDependencies(taskName, () -> {
                return getAllDependencies().withType(ProjectDependency.class);
            }, taskDependencyFactory, projectStateRegistry);
        } else {
            return new TasksFromDependentProjects(taskName, getName(), taskDependencyFactory);
        }
    }

- For example: `./gradlew :launcher:quickTest`.
2. Install Gradle locally and try out a change in behavior manually. 
- Install: `./gradlew install -Pgradle_installPath=/any/path`
- Use: `/any/path/bin/gradle taskName`.

It's also a good idea to run `./gradlew sanityCheck` before submitting your change because this will help catch code style issues.

> **NOTE:** Do **NOT** run `gradle build` on the local development environment,

        def conf = conf("conf")
        when:
        def dep = conf.getTaskDependencyFromProjectDependency(false, "bar") as TasksFromDependentProjects
        then:
        dep.taskName == "bar"
        dep.configurationName == "conf"
    }

    def "mutations are prohibited after resolution"() {
        def conf = conf("conf")
        resolver.resolveGraph(conf) >> graphResolved()