ex.causes == [failure]

        and: "expected events received"
        resultsOfFirstListener.size() == 1
        resultsOfLastListener.size() == 1

        and: "build execution is successful"
        assertHasBuildSuccessfulLogging()
    }

    def "receive build progress events for successful operations"() {
        given:
        goodCode()

        when:

        1 * connection.receive() >> new Success(new Status(12345, "3.0", "BOGUS"))
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()

        and:
        1 * connector.maybeConnect(daemon2) >>> connection
        _ * connection.daemon >> daemon2
        1 * connection.dispatch({it instanceof ReportStatus})
        1 * connection.receive() >> new Success(new Status(12346, "3.0", "BOGUS"))

// CHECK-NEXT:   %[[RESULT_0:.*]] = tf_device.receive "key-0"
// CHECK-NEXT:   %[[RESULT_1:.*]] = "tf.AddV2"(%[[RESULT_0]], %[[RESULT_0]])
// CHECK-SAME:  device = "/job:worker/replica:0/task:1/device:CPU:0"

// Subgraph of @while_body function that is placed on worker:2
// CHECK: func @[[BODY_PARTITION_1]]() attributes {host = "/job:worker/replica:0/task:2"}
// CHECK-NEXT:   %[[RESULT_0:.*]] = tf_device.receive "key-1"

 * limitations under the License.
 */

package org.gradle.build.event;

import org.gradle.api.provider.Provider;
import org.gradle.tooling.events.OperationCompletionListener;

/**
 * Allows a plugin to receive information about the operations that run within a build.
 *

    @Override
    void flush() {
        outgoingBuffered.drainTo(outgoing)
    }

    @Override
    InterHubMessage receive() {
        def message = incoming.take()
        return message == END ? null : (InterHubMessage) message
    }

    /**
     * Queues the given message to return from {@link #receive()}.
     */
    void queueIncoming(InterHubMessage message) {
        incoming.put(message)
    }

    /**

you need access credentials for a successful exploit).

If you have not received a reply to your email within 48 hours or you have not heard from the security team
for the past five days please contact the security team directly:

- Primary security coordinator: ******@****.***
- Secondary coordinator: ******@****.***
- If you receive no response: ******@****.***

### Disclosure Process

MinIO uses the following disclosure process:

		panic("fail")
	}
	if !calledF {
		println("BUG: did not call f")
		panic("fail")
	}
	if <-c == nil {
		println("BUG: did not receive from c")
		panic("fail")
	}
	if !calledG {
		println("BUG: did not call g")
		panic("fail")
	}
	if <-c1 == nil {
		println("BUG: did not receive from c1")
		panic("fail")
	}

}

// WaitForSigusr1 blocks until a SIGUSR1 is received. It calls ready
// when it is set up to receive SIGUSR1. The ready function should
// cause a SIGUSR1 to be sent. The r and w arguments are a pipe that
// the signal handler can use to report when the signal is received.
//
// Once SIGUSR1 is received, it returns the ID of the current M and
// the ID of the M the SIGUSR1 was received on. If the caller writes

	select {
	case <-sw.done:
	default:
		close(sw.done)
		sw.source.Close()
	}
}

// receive reads result from the decoder in a loop and sends down the result channel.
func (sw *StreamWatcher) receive() {
	defer utilruntime.HandleCrash()
	defer close(sw.result)
	defer sw.Stop()
	for {
		action, obj, err := sw.source.Decode()
		if err != nil {

// it must coordinate with f explicitly.
//
// For a chan-based timer created with NewTimer(d), as of Go 1.23,
// any receive from t.C after Stop has returned is guaranteed to block
// rather than receive a stale time value from before the Stop;
// if the program has not received from t.C already and the timer is
// running, Stop is guaranteed to return true.
// Before Go 1.23, the only safe way to use Stop was insert an extra