incomingFiles.each {
                    writeFile("incoming-file", writer, it)
                }
                incomingArtifacts.each {
                    writeArtifact("incoming-artifact", writer, it)
                }
                incomingArtifacts.resolvedArtifacts.get().each {
                    writeArtifact("incoming-resolved-artifact", writer, it)
                }

}

task checkDeps {
    doLast {
        def deps = configurations.conf.incoming.dependencies
        assert deps.size() == 1
        assert deps.find { it.dependencyProject.path == ':otherProject' && it.targetConfiguration == null }

        deps = configurations.confTwo.incoming.dependencies
        assert deps.size() == 1

  open fun onMessage(
    webSocket: WebSocket,
    bytes: ByteString,
  ) {
  }

  /**
   * Invoked when the remote peer has indicated that no more incoming messages will be transmitted.
   */
  open fun onClosing(
    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
  }

  /**

    ConnectionSet(IncomingQueue incomingQueue, OutgoingQueue outgoingQueue) {
        this.incomingQueue = incomingQueue;
        this.outgoingQueue = outgoingQueue;
    }

    /**
     * Adds a new incoming connection.
     */
    public ConnectionState add(RemoteConnection<InterHubMessage> connection) {
        EndPointQueue queue = outgoingQueue.newEndpoint();

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

package b

import (
	"./a"
)

// InteractionRequest is an incoming request Interaction
type InteractionRequest[T a.InteractionDataConstraint] struct {
	a.Interaction[T]

					ErrReasonAntiAffinityRulesNotMatch,
				),
				framework.NewStatus(
					framework.Unschedulable,
					ErrReasonAntiAffinityRulesNotMatch,
				),
			},
			name: "Test incoming pod's anti-affinity: incoming pod wouldn't considered as a fit as it at least violates one anti-affinity rule of existingPod",
		},
		{
			pod: st.MakePod().Label("foo", "").Label("bar", "").Obj(),
			pods: []*v1.Pod{

                    throw new RuntimeException("broken task")
                }
                tasks.register("resolve", ShowFileCollection) {
                    def view = configurations.resolver.incoming.artifactView {
                        attributes.attribute(color, 'green')
                    }.files
                    files.from(view)
                }

                configurations {

The new [NewRequestWithContext] method creates an incoming request with

        }
    }

    task resolve(type: Copy) {
        def artifacts = configurations.compileClasspath.incoming.artifactView {
            attributes { it.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, 'size')) }
            if (project.hasProperty("lenient")) {
                lenient(true)
            }

        cluster_to_tpu_op_map,
    SmallPtrSetImpl<Operation*>& visited_wrapped_ops, bool incoming) {
  std::queue<IslandOp> op_worklist;
  std::vector<IslandOp> ops;

  op_worklist.push(candidate_island);

  while (!op_worklist.empty()) {
    IslandOp current_op = op_worklist.front();
    op_worklist.pop();
    ops.clear();
    if (incoming) {
      collect_input_defining_islands(current_op, ops);
    } else {