*/
public interface IsolatedAntBuilder {

    /**
     * Creates a copy of this builder which uses the given libraries. These classes are visible for use in
     * taskdef/typedef tasks.
     *
     * @param classpath The library classpath
     * @return a copy of this builder
     */
    IsolatedAntBuilder withClasspath(Iterable<File> classpath);

    /**

    }

    @Test
    void bridgesLogging() {
        def classpath = ClasspathUtil.getClasspathForClass(TestAntTask)

        builder.withClasspath([classpath]).execute {
            taskdef(name: 'loggingTask', classname: TestAntTask.name)
            loggingTask()
        }

        assertThat(outputEventListener.toString(), containsString('[[INFO] [ant-test] a jcl log message]'))

        def reports = parameters.enabledReports.get()
        def ignoreFailures = parameters.ignoreFailures.get()
        def source = parameters.source

        setLifecycleLogLevel(ant, null)
        ant.taskdef(name: 'codenarc', classname: 'org.codenarc.ant.CodeNarcTask')
        try {

        ClassLoader original = Thread.currentThread().getContextClassLoader()
        ClassLoader cl = new URLClassLoader([] as URL[])
        Thread.currentThread().setContextClassLoader(cl)

        when:
        ant.taskdef(name: 'test', classname: TestTask.class.getName())
        ant.test()

        then:
        noExceptionThrown()

        cleanup:
        Thread.currentThread().setContextClassLoader(original)
    }

            throw new GradleException("Invalid maxFailures $maxFailures. Valid range is >= 0.")
        }

        List<PmdActionParameters.EnabledReport> reports = parameters.enabledReports.get()
        ant.taskdef(name: 'pmd', classname: 'net.sourceforge.pmd.ant.PMDTask')
        ant.pmd(antPmdArgs) {
            parameters.source.addToAntBuilder(ant, 'fileset', FileCollection.AntType.FileSet)
            ruleSets.each {

private
enum class ReferenceType {
    SELF_REF,
    TASK_REF,
    PROHIBITED
}


object TaskReferenceCodec : Codec<Task> {

    override suspend fun WriteContext.encode(value: Task) = when {
        value === isolate.owner.delegate ->
            writeEnum(ReferenceType.SELF_REF)

        isTaskReferencesAllowed(value) -> {
            writeEnum(ReferenceType.TASK_REF)
            writeString(value.name)
        }

import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.KotlinJvm
import org.apache.tools.ant.taskdefs.condition.Os

plugins {
  kotlin("jvm")
  id("org.jetbrains.dokka")
  id("com.vanniktech.maven.publish.base")
  id("com.palantir.graal")
  id("com.github.johnrengelman.shadow")
}

val copyResourcesTemplates = tasks.register<Copy>("copyResourcesTemplates") {
  from("src/main/resources-templates")

	"k8s.io/apiserver/pkg/endpoints/request"
)

type taskKeyType int

const taskKey taskKeyType = iota

type Task struct {
	Func func()
}

func WithTask(parent context.Context, t *Task) context.Context {
	return request.WithValue(parent, taskKey, t)
}

func TaskFrom(ctx context.Context) *Task {
	t, _ := ctx.Value(taskKey).(*Task)
	return t
}

	// Limit the concurrency of running tasks.
	r.taskSem <- struct{}{}

	r.runningTasksMu.Lock()
	defer r.runningTasksMu.Unlock()
	log.Infof("STARTING %s", task)
	r.runningTasks.Insert(task)
}

func (r *Runner) removeRunningTask(task string) {
	defer func() {
		// Free up a slot for another running task.
		<-r.taskSem
	}()

	r.runningTasksMu.Lock()
	defer r.runningTasksMu.Unlock()

import org.apache.tools.ant.taskdefs.condition.Os

plugins {
  id("com.palantir.graal")
  kotlin("jvm")
}

dependencies {
  implementation(libs.junit.jupiter.api)
  implementation(libs.junit.jupiter.engine)
  implementation(libs.junit.platform.console)
  implementation(libs.squareup.okio.fakefilesystem)

  implementation(projects.okhttp)
  implementation(projects.okhttpBrotli)
  implementation(projects.okhttpDnsoverhttps)