public interface GitRepository {
    URI getUrl();

    Ref createBranch(String branchName) throws GitAPIException;

    Ref checkout(String branchName) throws GitAPIException;

    Ref createLightWeightTag(String tagName) throws GitAPIException;

    TestFile getWorkTree();

    TestFile file(Object... path);

    RevCommit commit(String message) throws GitAPIException;

    def "can apply a plugin declared in a catalog"() {
        String taskName = 'greet'
        String message = 'Hello from plugin!'
        String pluginId = 'com.acme.greeter'
        String pluginVersion = '1.5'
        def plugin = new PluginBuilder(file("greeter"))
            .addPluginWithPrintlnTask(taskName, message, pluginId)
            .publishAs("some", "artifact", pluginVersion, pluginPortal, executer)

                }
            }
        """
    }

    def createTaskThatRunsInParallelUsingWorkerLeaseInjectionWith(String taskName) {
        setupParallelTaskAndExpectations(taskName)

        buildFile << """
            ${callbackWorkerLeaseService}

            tasks.matching { it.name == '${taskName}' }.all { task ->
                def workerLeaseService = task.asDynamicObject.publicType.getDeclaredField("workerLeaseService")

import model.CIBuildModel
import model.JsonBasedGradleSubprojectProvider
import model.PerformanceTestCoverage
import model.PerformanceTestType
import model.Stage
import model.StageName
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import java.io.File

class PerformanceTestBuildTypeTest {
    init {
        DslContext.initForTest()
    }

    const std::vector<std::string>& tag_names,
    absl::string_view input_arg_shapes_str) {
  mlir::DialectRegistry registry;
  RegisterAllTensorFlowDialects(registry);
  mlir::MLIRContext context(registry);
  context.loadAllAvailableDialects();

  auto module =
      TfToStablehlo(input_path, &context, exported_model_signatures, tag_names,
                    input_arg_shapes_str, /*is_input_mlir_module=*/false);

                .filterIsInstance<Element>()
                .first { it.predicate() }

        asElement()
            .firstElement { tagName == "component" && getAttribute("name") == "VcsDirectoryMappings" }
            .firstElement { tagName == "mapping" }
            .setAttribute("vcs", "Git")
    })
}

}

// GetWebhookRevision extracts tag target revision from webhook object.
func GetWebhookRevision(wh admitv1.MutatingWebhookConfiguration) (string, error) {
	if tagName, ok := wh.ObjectMeta.Labels[label.IoIstioRev.Name]; ok {
		return tagName, nil
	}
	return "", fmt.Errorf("could not extract tag revision from webhook")
}

// DeleteTagWebhooks deletes the given webhooks.

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

    }

    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'