then:
        def task = events.operation("Task :custom")
        task.descendant('Execute doSomethingAmazing for :custom')
    }

    def "task actions defined in doFirst and doLast blocks of Groovy build scripts have informative names"() {
        given:
        buildFile << """
            task custom {
                doFirst {}
                doLast {}
            }
        """

			stk = append(stk, stackEntry{b: c})
		}
	}
}

// domBlock contains extra per-block information to record the dominator tree.
type domBlock struct {
	firstChild *ssa.Block // first child of block in dominator tree
	sibling    *ssa.Block // next child of parent in dominator tree
}

// A block heap is used as a priority queue to implement the PiggyBank

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Tests a many interesting cases (network, syscalls, a little GC, busy goroutines,
// blocked goroutines, LockOSThread, pipes, and GOMAXPROCS).

//go:build ignore

package main

import (
	"bytes"
	"io"
	"log"
	"net"
	"os"
	"runtime"
	"runtime/trace"
	"sync"
	"time"
)

apiVersion: release-notes/v2
kind: bug-fix
area: installation
issue:
- 48112
releaseNotes:
- |

	time.Sleep(1 * time.Second)

	err = expectSyncNotBlocked(fakeDiscoveryClient, &qc.workerLock)
	if err != nil {
		t.Fatalf("Expected quotacontroller.Sync to be running but it is blocked: %v", err)
	}
	assertMonitors(t, qc, "pods", "deployments")

	// Simulate the discovery client returning an error

        )
    }

    @Test
    fun `Settings target - top-level - pluginManagement block - empty body`() {

        val fragment = fragment("pluginManagement", "...")
        val program = Program.PluginManagement(fragment)

        assertThat(
            "reduces to static program that evaluates pluginManagement block then applies default plugin requests",
            partialEvaluationOf(
                program,

public interface ManagedExecutor extends AsyncStoppable, ExecutorService {
    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed.
     */
    @Override
    void stop();

    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed. Once the given

			// of entered -> blocked -> runnable -> running. If in the running state
			// we block, then we have a futile wakeup. Because of the runtime.Gosched
			// on these specially marked goroutines, we should end up back in runnable
			// first. If at any point we go to a different state, switch back to entered
			// and wait for the next time the goroutine blocks.
			if ev.Kind() != trace.EventStateTransition {

		// sent to the Sink. Deep copy and send the copy to the queue.
		event := e.DeepCopy()

		select {
		case b.buffer <- event:
		default:
			sendErr = fmt.Errorf("audit buffer queue blocked")
			return true
		}
	}
	return true
}

func (b *bufferedBackend) String() string {
	return fmt.Sprintf("%s<%s>", PluginName, b.delegateBackend)

        }
    }

    @Override
    public void release() {
        lock.lock();
        try {
            if (!requestStarted) {
                throw new IllegalStateException("Response is not blocked, should call waitUntilBlocked() first.");
            }
            released = true;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }