return git.tag().setName(tagName).setAnnotated(true).setMessage(message).call();
    }

    public Ref getHead() throws IOException {
        return git.getRepository().findRef("HEAD");
    }

    @Override
    public TestFile getWorkTree() {
        return new TestFile(git.getRepository().getWorkTree());
    }

    @Override
    public TestFile file(Object... path) {

	info.Origin.Hash = refs["HEAD"]

	return info, nil
}

// findRef finds some ref name for the given hash,
// for use when the server requires giving a ref instead of a hash.
// There may be multiple ref names for a given hash,
// in which case this returns some name - it doesn't matter which.
func (r *gitRepo) findRef(ctx context.Context, hash string) (ref string, ok bool) {
	refs, err := r.loadRefs(ctx)

func TestCacheCRDFinder(t *testing.T) {
	called := 0
	getter := func() ([]schema.GroupKind, error) {
		called += 1
		return nil, nil
	}
	finder := NewCRDFinder(getter)
	if called != 0 {
		t.Fatalf("Creating the finder shouldn't call the getter, has called = %v", called)
	}
	_, err := finder.HasCRD(schema.GroupKind{Group: "", Kind: "Pod"})
	if err != nil {
		t.Fatalf("Failed to call HasCRD: %v", err)
	}
	if called != 1 {

    for (finder in PsiElementFinder.EP.getPoint(project).extensionList) {
        if (finder::class.java.name == KOTLIN_JAVA_ELEMENT_FINDER_CLASS_NAME) {
            continue
        }
        action(finder)
    }
}

    private final ProjectFinder finder;

    protected TypeSafeProjectDependencyFactory(DefaultProjectDependencyFactory factory, ProjectFinder finder) {
        this.factory = factory;
        this.finder = finder;
    }

    protected ProjectDependencyInternal create(String path) {
        return (ProjectDependencyInternal) factory.create(finder.getProject(path));
    }

        deletedFiles == [file, parent]
    }

    FilesFinder finder(files) {
        Stub(FilesFinder) {
            find(_, _) >> { baseDir, filter ->
                assert filter instanceof NonReservedFileFilter
                files.findAll { filter.accept(it) }
            }
        }
    }

    AbstractCacheCleanup cleanupAction(FilesFinder finder, Spec<File> spec) {
        new AbstractCacheCleanup(finder) {

  private val finder = FastFallbackExchangeFinder(routePlanner, taskRunner)

  @AfterEach
  fun tearDown() {
    taskFaker.close()
    routePlanner.close()
  }

  @Test
  fun takeConnectedConnection() {
    val plan0 = routePlanner.addPlan()
    plan0.connectState = TLS_CONNECTED

    taskRunner.newQueue().execute("connect") {
      val result0 = finder.find()

//	old := *ptr;
//	*ptr = new;
//	return old;
TEXT ·Xchg(SB), NOSPLIT, $0-20
	MOVD	ptr+0(FP), R0
	MOVW	new+8(FP), R1
#ifndef GOARM64_LSE
	MOVBU	internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB), R4
	CBZ 	R4, load_store_loop
#endif
	SWPALW	R1, (R0), R2
	MOVW	R2, ret+16(FP)
	RET
#ifndef GOARM64_LSE
load_store_loop:
	LDAXRW	(R0), R2
	STLXRW	R1, (R0), R3
	CBNZ	R3, load_store_loop
	MOVW	R2, ret+16(FP)

 */
/** @addtogroup Framework
 * @{
 */

#ifndef CUNIT_CUNIT_INTL_H_SEEN
#define CUNIT_CUNIT_INTL_H_SEEN

/* activate these when source preparation is complete
#include <libintl.h>
#ifndef _
#  define _(String) gettext (String)
#endif
#ifndef gettext_noop
#  define gettext_noop(String) String
#endif
#ifndef N_
#  define N_(String) gettext_noop (String)
#endif
*/

    final def distDir = tmpDir.createDir("gradle-home")
    final DistributionInitScriptFinder finder = new DistributionInitScriptFinder(distDir)

    def setup() {
    }

    def "does nothing when init.d directory does not exist there is no distribution"() {
        def scripts = []

        when:
        finder.findScripts(scripts)

        then:
        scripts.empty
    }