BuildTestFile populate(String projectName, @DelegatesTo(BuildTestFile) Closure cl) {
        new BuildTestFixture(projectDir).withBuildInSubDir().populate(projectName, cl)
    }

    TestFile singleProjectBuildInSubfolder(String projectName, @DelegatesTo(BuildTestFile) Closure cl = {}) {
        new BuildTestFixture(projectDir).withBuildInSubDir().singleProjectBuild(projectName, cl)
    }

        assert tmpFile.renameTo(file)
        onPublish(file)
    }

    private void writeContents(output, Closure cl) {
        output.withWriter("utf-8", cl)
    }

    private void writeZipped(TestFile testFile, Closure cl) {
        def bos = new ByteArrayOutputStream()
        writeContents(bos, cl)

        ZipArchiveOutputStream zipStream = new ZipArchiveOutputStream(testFile)
        try {

        multiProjectBuild(projectName, subprojects, CompiledLanguage.JAVA, cl)
    }

    def multiProjectBuild(String projectName, List<String> subprojects, CompiledLanguage language, @DelegatesTo(value = BuildTestFile, strategy = Closure.DELEGATE_FIRST) Closure cl = {}) {
        def rootMulti = populate(projectName) {
            subprojects.each {

    }

    def apply(Closure cl) {
        cl.delegate = this
        cl.resolveStrategy = Closure.DELEGATE_FIRST
        cl()
    }

    TestFile dir(String name) {
        baseDir.file(name).createDir()
    }

    TestFile dir(String name, @DelegatesTo(value = TestWorkspaceBuilder.class, strategy = Closure.DELEGATE_FIRST) Closure<?> cl) {
        dir(name).create(cl)
    }

    TestFile file(String name) {

    }

    def "cannot convert arbitrary type to Long"() {
        when:
        def cl = {}
        converter.convert(cl, Long.class, false)

        then:
        def e = thrown(UnsupportedNotationException)
        e.message == TextUtil.toPlatformLineSeparators("""Cannot convert the provided notation to an object of type Long: ${cl.toString()}.
The following types/formats are supported:
  - A String or CharSequence

    def factory = new ClasspathInferer()

    def "determines action and tooling API classpath when loaded via a URLClassLoader"() {
        def cl = urlClassLoader(toolingApiClassPath + isolatedClasses(CustomAction, CustomModel))
        def actionClass = cl.loadClass(CustomAction.name)

        expect:
        def classpath = classpathFor(actionClass)

		return false
	}

	fixed := false
	walk(f, func(n any) {
		cl, ok := n.(*ast.CompositeLit)
		if !ok {
			return
		}
		se, ok := cl.Type.(*ast.SelectorExpr)
		if !ok {
			return
		}
		if !isTopName(se.X, "printer") || se.Sel == nil {
			return
		}

		if ss := se.Sel.String(); ss == "Config" {
			for i, e := range cl.Elts {
				if _, ok := e.(*ast.KeyValueExpr); ok {
					break
				}

	options := DefaultTokenCleanerOptions()
	cl := fake.NewSimpleClientset()
	informerFactory := informers.NewSharedInformerFactory(cl, options.SecretResync)
	secrets := informerFactory.Core().V1().Secrets()
	tcc, err := NewTokenCleaner(cl, secrets, options)
	if err != nil {
		return nil, nil, nil, err
	}
	return tcc, cl, secrets, nil
}

func TestCleanerNoExpiration(t *testing.T) {
	cleaner, cl, secrets, err := newTokenCleaner()

        def entry2 = new File("b.jar")
        TestClassLoader cl = Mock()

        given:
        System.in = createStdInContent(entry1, entry2)

        when:
        def securityManager = new BootstrapSecurityManager(cl)

        then:
        0 * cl._

        when:
        securityManager.checkPermission(new AllPermission())

        then:
        1 * cl.addURL(entry1.toURI().toURL())

For details see the [language spec](/ref/spec#For_statements).

<!-- go.dev/issue/46477, CL 566856, CL 586955, CL 586956 -->
Go 1.23 includes preview support for [generic type aliases](/issue/46477).