typically it will create a network listener and call [Accept] or, for an HTTP
listener, [HandleHTTP] and [http.Serve].

A client wishing to use the service establishes a connection and then invokes
[NewClient] on the connection.  The convenience function [Dial] ([DialHTTP]) performs
both steps for a raw network connection (an HTTP connection).  The resulting

     * Returns the number of work items in the plan.
     */
    int size();

    /**
     * An immutable snapshot of the set of scheduled nodes.
     */
    interface ScheduledNodes {
        /**
         * Invokes the consumer with the list of scheduled nodes and the set of entry nodes. Entry nodes may not be a subset of scheduled nodes.
         *
         * @param visitor the consumer of nodes and entry nodes
         */

)

type aesCipherAsm struct {
	function code     // code for cipher message instruction
	key      []byte   // key (128, 192 or 256 bits)
	storage  [32]byte // array backing key slice
}

// cryptBlocks invokes the cipher message (KM) instruction with
// the given function code. This is equivalent to AES in ECB
// mode. The length must be a multiple of BlockSize (16).
//
//go:noescape

	"istio.io/istio/pkg/util/istiomultierror"
)

// Visitor is performs a partial check operation on a single message.
type Visitor func(echoClient.Response) error

// Visit is a utility method that just invokes this Visitor function on the given response.
func (v Visitor) Visit(r echoClient.Response) error {
	return v(r)
}

// And returns a Visitor that performs a logical AND of this Visitor and the one provided.

import spock.lang.Specification

import java.util.concurrent.CountDownLatch

class DefaultDynamicCallContextTrackerTest extends Specification {
    def tracker = new DefaultDynamicCallContextTracker()

    def "invokes callbacks in the right order with the right arguments"() {
        given:
        def log = []
        tracker.onEnter { log += ["enter", it] }
        tracker.onLeave { log += ["leave", it] }

        when:

[[gradle_wrapper_basics]]
= Gradle Wrapper Basics

The **recommended way to execute any Gradle build** is with the Gradle Wrapper.

image::gradle-basic-2.png[]

The _Wrapper_ script invokes a declared version of Gradle, downloading it beforehand if necessary.

image::wrapper-workflow.png[]

The Wrapper is available as a `gradlew` or `gradlew.bat` file.

The Wrapper provides the following benefits:

    /**
     * Finalizes this plan once all nodes have been added. Must be called after {@link #determineExecutionPlan()}.
     */
    FinalizedExecutionPlan finalizePlan();

    /**
     * Invokes the given action when a task completes (as per {@link Node#isComplete()}). Does nothing for tasks that have already completed.
     */
    void onComplete(Consumer<LocalTaskNode> handler);

    /**

        1 * parser.parseTasks(request2) >> [selection2]
        1 * executionPlan.addEntryTasks(tasks1)
        1 * executionPlan.addEntryTasks(tasks2)
    }

    def "invokes given selector"() {
        given:
        def startParameters = Mock(StartParameterInternal)

        when:
        _ * gradle.getStartParameter() >> startParameters
        _ * startParameters.getTaskRequests() >> []

By default, 'go run' runs the compiled binary directly: 'a.out arguments...'.
If the -exec flag is given, 'go run' invokes the binary using xprog:
	'xprog a.out arguments...'.
If the -exec flag is not given, GOOS or GOARCH is different from the system
default, and a program named go_$GOOS_$GOARCH_exec can be found
on the current search path, 'go run' invokes the binary using that program,
for example 'go_js_wasm_exec a.out arguments...'. This allows execution of

        }

        then:
        handler.releaseAll()

        then:
        gradle.waitForFinish()
    }

    def "log messages from a worker daemon are associated with the task that invokes them"() {
        def buildOperations = new BuildOperationsFixture(executer, temporaryFolder)

        workActionThatProducesLotsOfOutput.writeToBuildFile()
        buildFile << """