*     }
 * </pre>
 */
@HasInternalProtocol
public interface ComponentSelectionRules {
    /**
     * Adds a simple component selection rule that will apply to all resolved components.
     * Each rule will receive a {@link ComponentSelection} object as an argument.
     *
     * @param selectionAction the Action that implements a rule to be applied
     * @return this
     */

prepared before that call will be sent or received after the call.
Earlier versions of Go used channels with a one-element buffer,
making it difficult to use `Reset` and `Stop` correctly.
A visible effect of this change is that `len` and `cap` of timer channels
now returns 0 instead of 1, which may affect programs that
poll the length to decide whether a receive on the timer channel
will succeed.

    void flush() throws MessageIOException;

    /**
     * {@inheritDoc}
     * @throws MessageIOException On failure to receive the message from the peer.
     */
    @Override
    @Nullable
    T receive() throws MessageIOException;

        ex.causes == [failure]

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

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

    def "receive task progress events for successful tasks"() {
        given:
        goodCode()
        buildFile << """

        outputContains("result = [b.jar.green, c.jar.green]")

        where:
        targetType << ["FileCollection", "Iterable<File>"]
    }

    def "transform can receive parameter object via constructor parameter"() {
        createDirs("a", "b", "c")
        settingsFile << """
            include 'a', 'b', 'c'
        """

    A `Request` also has a `request.receive`, that's a function to "receive" the body of the request.

    The `scope` `dict` and `receive` function are both part of the ASGI specification.

    And those two things, `scope` and `receive`, are what is needed to create a new `Request` instance.

import org.gradle.tooling.events.OperationType
import org.gradle.tooling.model.gradle.BuildInvocations

class ProgressCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {

    def "receive progress events when requesting a model"() {
        given:
        goodCode()

        when: "asking for a model and specifying some task(s) to run first"
        def events = ProgressEvents.create()

If the client requests `http://example.com/items/foo` (an `item_id` `"foo"`), that client will receive an HTTP status code of 200, and a JSON response of:

```JSON
{
  "item": "The Foo Wrestlers"
}
```

But if the client requests `http://example.com/items/bar` (a non-existent `item_id` `"bar"`), that client will receive an HTTP status code of 404 (the "not found" error), and a JSON response of:

```JSON
{

Let's imagine that you have a database `fake_db` that only receives JSON compatible data.

For example, it doesn't receive `datetime` objects, as those are not compatible with JSON.

So, a `datetime` object would have to be converted to a `str` containing the data in <a href="https://en.wikipedia.org/wiki/ISO_8601" class="external-link" target="_blank">ISO format</a>.

// 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"