return "Pattern: " + CLEAN + "<TaskName>: Cleans the output files of a task.";
    }

    @Override
    public String toString() {
        return "Rule: " + getDescription();
    }

    @Override
    public void apply(String taskName) {
        if (!taskName.startsWith(CLEAN) || taskName.equals(CLEAN)) {
            return;
        }
        String targetTaskName = taskName.substring(CLEAN.length());

    private final File outputFile;
    private final int maximumFailures;
    private final String taskName;

    BuildOperationLogInfo(String taskName, File outputFile, int maximumFailures) {
        this.outputFile = outputFile;
        this.maximumFailures = maximumFailures;
        this.taskName = taskName;
    }

    public int getMaximumFailedOperationsShown() {
        return maximumFailures;
    }

    }

    public boolean hasTask(String taskName) {
        return tasks.containsKey(taskName);
    }

    public GroupedTaskOutputFixture task(String taskName) {
        boolean foundTask = hasTask(taskName);

        if (!foundTask) {
            throw new AssertionError(String.format("The grouped output for task '%s' could not be found.%nOutput:%n%s", taskName, originalOutput));
        }

            systemProp.org.gradle.internal.cmdline.max.length=1000
        """

        when:
        succeeds taskName, "-i"

        then:
        executedAndNotSkipped(":$taskName")
        assertOutputContainsShorteningMessage()

        where:
        method                    | taskName
        'JavaExec task'           | 'run'
        'project.javaexec'        | 'runWithJavaExec'

    }


    @Override
    public BuildOperationLogger newOperationLogger(String taskName, File outputDir) {
        final File outputFile = createOutputFile(outputDir);
        final BuildOperationLogInfo configuration = createLogInfo(taskName, outputFile, MAX_FAILURES);
        return new DefaultBuildOperationLogger(configuration, logger, outputFile);
    }

// tag::all[]
// tag::task-rule[]
tasks.addRule("Pattern: ping<ID>") {
    val taskName = this
    if (startsWith("ping")) {
        task(taskName) {
            doLast {
                println("Pinging: " + (taskName.replace("ping", "")))
            }
        }
    }
}
// end::task-rule[]

tasks.register("groupPing") {
    dependsOn("pingServer1", "pingServer2")
}

                }
            }

            task ${taskName}(type: InputDirectoryContentToOutputFileAction) {
                inputDirectory = new File("${drive}\\\\")
                output = file("${TextUtil.escapeString(outputFile.absolutePath)}")
            }
        """
        when:
        buildScript script

        then:
        succeeds taskName
        outputFile.text.contains inputFileName

        cleanup:

        return this;
    }

    @Override
    public List<String> getArgs() {
        return Collections.singletonList(taskName);
    }

    public LaunchableGradleTaskSelector setTaskName(String taskName) {
        this.taskName = taskName;
        return this;
    }

    @Override
    public String getProjectPath() {
        return projectIdentifier.getProjectPath();
    }

            import java.util.concurrent.TimeUnit

            tasks.addRule("") { taskName ->
                if (taskName.startsWith("verifyMaxWorkers")) {
                    task(taskName) { task ->
                        doLast {
                            def count = (taskName - "verifyMaxWorkers") as int
                            def latch = new CountDownLatch(count)

                }
            });
        });
    }

    private <T extends AbstractArchiveTask> void addArchiveTask(final Project project, String taskName, Class<T> type, final Distribution distribution) {
        final TaskProvider<T> archiveTask = project.getTasks().register(taskName, type, task -> {
            task.setDescription("Bundles the project as a distribution.");
            task.setGroup(DISTRIBUTION_GROUP);