'Did not receive all expected requests. Waiting for 1 further requests, received [], released [], not yet received [GET /a]',
            'Did not receive all expected requests. Waiting for 1 further requests, received [], released [], not yet received [GET /b]',
            'Did not receive all expected requests. Waiting for 1 further requests, received [], released [], not yet received [GET /c, GET /d]',

	// Set up channel on which to send signal notifications.
	// We must use a buffered channel or risk missing the signal
	// if we're not ready to receive when the signal is sent.
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)

	// Block until a signal is received.
	s := <-c
	fmt.Println("Got signal:", s)
}

func ExampleNotify_allSignals() {
	// Set up channel on which to send signal notifications.

/**
 *
 */
public interface Response extends Message {

    /**
     * 
     * @return whether the response is received
     */
    boolean isReceived ();


    /**
     * Set received status
     */
    void received ();


    /**
     * Unset received status
     */
    void clearReceived ();


    /**
     * 
     * @return number of credits granted by the server
     */

```yaml
receivers:
  otlp:
    protocols:
      grpc:
      http:
processors:
  batch:
exporters:
  logging:
    loglevel: debug
service:
  pipelines:
    logs:
      receivers: [otlp]
      processors: [batch]

    }

    @Test
    fun `triggers the custom accessor with empty block`() {
        val resolution = schema.resolve("configureCustomInstance { }")
        assertTrue(runtimeInstanceFromResult(schema, resolution, configureLambdas, runtimeCustomAccessors, ::MyReceiver).myHiddenInstance.isInitialized())
    }


    @Test

        }
    }

    private
    fun withResolvedReceiver(objectOrigin: ObjectOrigin.HasReceiver, ifReceiverResolved: (receiver: ObjectOrigin) -> ObjectOrigin): ExpressionResolutionProgress {
        val receiver = objectOrigin.receiver
        return withResolved(receiver, ifReceiverResolved)
    }

    sealed interface ResolutionNode {

// the receiver stops reading them.
func Ranger[Elem any]() (*Sender[Elem], *Receiver[Elem]) {
	c := make(chan Elem)
	d := make(chan struct{})
	s := &Sender[Elem]{
		values: c,
		done:   d,
	}
	r := &Receiver[Elem]{
		values: c,
		done:   d,
	}
	runtime.SetFinalizer(r, (*Receiver[Elem]).finalize)
	return s, r
}

// A Sender is used to send values to a Receiver.
type Sender[Elem any] struct {

     */
    @Override
    public final void clearReceived () {
        this.received = false;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#isReceived()
     */
    @Override
    public final boolean isReceived () {
        return this.received;
    }


    /**
     * {@inheritDoc}
     *

  ports:
    - name: grpc-opencensus
      port: 55678
      protocol: TCP
      targetPort: 55678
    - name: grpc-otlp # Default endpoint for OpenTelemetry receiver.
      port: 4317
      protocol: TCP
      targetPort: 4317
  selector:
    app: opentelemetry-collector
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: opentelemetry-collector
spec:
  selector:
    matchLabels:

}

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