InterHubMessage message = Stub() {
            getDelivery() >> InterHubMessage.Delivery.SingleHandler
        }
        return message
    }

    def stateful() {
        InterHubMessage message = Stub() {
            getDelivery() >> InterHubMessage.Delivery.Stateful
        }
        return message
    }

    def broadcast() {
        InterHubMessage message = Stub() {

  // string description of gradient attribute.
  static StringRef GetGradientAttrName() { return "tf.gradient"; }

  // This attribute marks if a function is stateful.
  // Returns the string description of stateful attribute.
  static StringRef GetStatefulAttrName() { return "tf.signature.is_stateful"; }

  // Returns true if the op can be duplicated during transformations.

class QueueInitializerTest extends AbstractQueueTest {
    final QueueInitializer initializer = new QueueInitializer()
    final Dispatch<InterHubMessage> queue = Mock()

    def "does nothing when no stateful messages received"() {
        when:
        initializer.onQueueAdded(queue)

        then:
        0 * queue._
    }

    def "discards message on end of stream received"() {
        given:

    @Override
    public String toString() {
        return "[" + getClass().getSimpleName() + "]";
    }

    @Override
    public Delivery getDelivery() {
        return Delivery.Stateful;
    }

import java.net.InetAddress
import okhttp3.internal.interleave

/**
 * Implementation of HappyEyeballs Sorting Addresses.
 *
 * The current implementation does not address any of:
 *  - Async DNS split by IP class
 *  - Stateful handling of connectivity results
 *  - The prioritisation of addresses
 *
 * https://datatracker.ietf.org/doc/html/rfc8305#section-4
 */
fun reorderForHappyEyeballs(addresses: List<InetAddress>): List<InetAddress> {

        if (message instanceof EndOfStream) {
            endOfStream = (EndOfStream) message;
        } else {
            throw new UnsupportedOperationException(String.format("Received unexpected stateful message: %s", message));
        }
    }

    void onQueueAdded(Dispatch<InterHubMessage> queue) {
        if (endOfStream != null) {
            queue.dispatch(endOfStream);
        }
    }

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to a listener interface to indicate that its events are stateful.
 *
 * <p>The listener infrastructure will ensure that a listener of this type will either receive all events, or no events.

// merging same input values if they're identical. These optimizations are
// desirable but not for those TFLite ops which have variable tensors as inputs.
// Yes, they have identical input values, but those identical values are
// "stateful", their values can change during invocations.
//
// A typical example is unidirectional_sequence_lstm have two variable tensor
// inputs: activation state & cell state. They may have same initial values

 * limitations under the License.
 */

package org.gradle.internal.serialize;

public class Serializers {
    public static <T> StatefulSerializer<T> stateful(final Serializer<T> serializer) {
        return new StatefulSerializerAdapter<T>(serializer);
    }

    private static class StatefulSerializerAdapter<T> implements StatefulSerializer<T> {

module {
  func.func private @f() {
    func.call @g() : () -> ()
    func.return
  }
  func.func private @g() {
    func.call @f() : () -> ()
    func.return
  }
}

// -----
// Test stateful and stateless partitioned calls.
// CHECK-LABEL: func @f
func.func @f() {
  // CHECK: "tf.PartitionedCall"() <{config = "",  config_proto = "", executor_type = "", f = @g}> : () -> ()