// pair has matching devices or no devices.
  if (auto source = llvm::dyn_cast<tf_executor::NextIterationSourceOp>(op)) {
    return ops_have_same_device(source, source.GetSink());
  } else if (auto sink = llvm::dyn_cast<tf_executor::NextIterationSinkOp>(op)) {
    return ops_have_same_device(sink.GetSource(), sink);
  }

  return llvm::isa<tf_executor::EnterOp, tf_executor::ExitOp,

				t.Errorf("managerImpl.processShutdownEvent() error = %v, wantErr %v", err, tt.wantErr)
			}

			underlier, ok := logger.GetSink().(ktesting.Underlier)
			if !ok {
				t.Fatalf("Should have had a ktesting LogSink, got %T", logger.GetSink())
			}

			log := underlier.GetBuffer().String()
			if !strings.Contains(log, tt.expectedOutputContains) {
				// Log will be shown on failure. To see it

      $_state.types = { result_type, token_type, control_type };
      $_state.attributes.append(attributes.begin(), attributes.end());
    }]>
   ];

  let extraClassDeclaration = [{
    NextIterationSinkOp GetSink() {
      return cast<NextIterationSinkOp>(*getToken().user_begin());
    }
  }];

  let assemblyFormat = "`:` type($output) attr-dict";
  let hasCustomAssemblyFormat = 0;
}

  /**
   * Returns a sink that can be used to write data to the peer.
   *
   * @throws IllegalStateException if this stream was initiated by the peer and a [writeHeaders] has
   *     not yet been sent.
   */
  fun getSink(): Sink {
    this.withLock {
      check(hasResponseHeaders || isLocallyInitiated) {
        "reply before requesting the sink"
      }
    }
    return sink
  }

  /**

      }
      pushPromises(stream, request, response.pushPromises)
      if (body != null) {
        sleepNanos(bodyDelayNanos)
        val responseBodySink =
          stream.getSink().withThrottlingAndSocketPolicy(
            policy = response,
            disconnectHalfway = response.socketPolicy == DisconnectDuringResponseBody,
            expectedByteCount = body.contentLength,

    // source.
    if (auto next_iter_source =
            llvm::dyn_cast<mlir::tf_executor::NextIterationSourceOp>(
                input_inst))
      input_inst = next_iter_source.GetSink();

    auto node_it = nodes_.find(input_inst);
    TF_RET_CHECK(node_it != nodes_.end())
        << "Use of OpResult encountered before def!";
    if (mlir::isa<mlir::tf_executor::ControlType>(input_result.getType())) {

    // source.
    if (auto next_iter_source =
            llvm::dyn_cast<mlir::tf_executor::NextIterationSourceOp>(
                input_inst))
      input_inst = next_iter_source.GetSink();

    auto node_it = nodes_.find(input_inst);
    TF_RET_CHECK(node_it != nodes_.end())
        << "Use of OpResult encountered before def!";
    if (mlir::isa<mlir::tf_executor::ControlType>(input_result.getType())) {

     */
    public void setDomain ( String domain ) {
        this.domain = domain;
    }


    @Override
    public String getLink () {
        return this.link;
    }


    @Override
    public void setLink ( String link ) {
        this.link = link;
    }


    /**
     * @return the key
     */
    @Override
    public String getKey () {

  }

  private void setSuccessor(int entry, int succ) {
    long succMask = (~0L) >>> 32;
    setLink(entry, (link(entry) & ~succMask) | ((succ + 1) & succMask));
  }

  private void setPredecessor(int entry, int pred) {
    long predMask = ~0L << 32;
    setLink(entry, (link(entry) & ~predMask) | ((long) (pred + 1) << 32));
  }

  private void setSucceeds(int pred, int succ) {

        else {
            link = path;
        }

        if ( log.isTraceEnabled() ) {
            log.trace("Initial link is " + link);
        }

        if ( dr == null || !link.equals(dr.getLink()) ) {
            while ( true ) {
                dr = links.map.get(link);

                if ( dr != null ) {
                    if ( log.isTraceEnabled() ) {