}

    def "reports failure if build fails in build phase"() {
        setupProject()
        file("a/build.gradle") << """
            tasks.register("taskE") {
                doLast {
                    throw new RuntimeException("taskD failed")
                }
            }
        """

        when:
        def events = ProgressEvents.create()
        withConnection {

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 org.apache.commons.io.FileUtils
import org.apache.commons.lang.StringUtils
import org.apache.tools.ant.Project
import org.apache.tools.ant.taskdefs.Expand
import org.apache.tools.ant.taskdefs.Tar
import org.apache.tools.ant.taskdefs.Untar
import org.apache.tools.ant.taskdefs.Zip
import org.apache.tools.ant.types.ArchiveFileSet
import org.apache.tools.ant.types.EnumeratedAttribute
import org.apache.tools.ant.types.ZipFileSet

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)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle

import org.apache.tools.ant.taskdefs.Expand
import org.gradle.api.logging.configuration.WarningMode
import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache
import org.gradle.internal.jvm.Jvm
import org.gradle.test.fixtures.file.TestFile

        istiod18[label="Istio 1.18.5 Control"]
        istiod19[label="Istio 1.19.3 Control"]
        ztunnelds[label="ztunnel"]
        cnids[label="cni"]
        extrads[label="prometheus, etc"]
        tagdef[label="tag default->1.18.5"]
        tagrap[label="tag rapid->1.19.3"]
        tagsta[label="tag stable->1.18.5"]
    }

    subgraph cluster_app {
        rankdir=TB
        node [style=filled];

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.plugins;

import org.apache.tools.ant.taskdefs.Chmod;
import org.gradle.api.Action;
import org.gradle.api.UncheckedIOException;
import org.gradle.internal.IoActions;
import org.gradle.internal.os.OperatingSystem;