// The client accesses each method using a string of the form "Type.Method",
// where Type is the receiver's concrete type.
func (server *Server) Register(rcvr any) error {
	return server.register(rcvr, "", false)
}

// RegisterName is like [Register] but uses the provided name for the type
// instead of the receiver's concrete type.
func (server *Server) RegisterName(name string, rcvr any) error {
	return server.register(rcvr, name, true)
}

                    broadcaster.foo(it)
                }
            }
        }

        then:
        received1.size() == 60
        received2.size() == 60
        received1 == received2
        received1.findAll { it.startsWith("a") } == events1
        received1.findAll { it.startsWith("b") } == events2
    }

    List<String> events(String prefix, int count) {

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

A method declaration binds an identifier, the <i>method name</i>, to a method,
and associates the method with the receiver's <i>base type</i>.
</p>

<pre class="ebnf">
MethodDecl = "func" Receiver MethodName Signature [ FunctionBody ] .
Receiver   = Parameters .
</pre>

<p>
The receiver is specified via an extra parameter section preceding the method

    override fun apply(receiver: AssignmentRecordConventionReceiver) {
        receiver.receive(assignmentRecord)
    }
}


/**
 * A convention that applies a data addition operation (e.g. addFoo("bar")).
 */
class AdditionRecordConvention(private val dataAdditionRecord: DataAdditionRecord) :
    Convention<AdditionRecordConventionReceiver> {
    override fun apply(receiver: AdditionRecordConventionReceiver) {

        def received = new CountDownLatch(1)
        def result = null

        when:
        start {
            waiting.countDown()
            result = daemonConnection.receive(20, TimeUnit.SECONDS)
            received.countDown()
        }
        waiting.await()
        Thread.sleep(500)
        connection.queueIncoming("incoming")
        received.await()

        then:

	}
	if active && upd.next != next {
		t.Fatalf("%s: expected timer to be %v, got %v", name, next, upd.next)
	}
}

// test and reset the receiver's state
func checkReceiver(name string, t *testing.T, receiver *receiver, expected bool) {
	triggered := receiver.reset()
	if expected && !triggered {
		t.Fatalf("%s: function should have been called", name)
	} else if !expected && triggered {

  }

  @Test
  @TestMetadata("receiver.kt")
  public void testReceiver() {
    runTest("analysis/analysis-api/testData/components/referenceShortener/shortenRange/receiver.kt");
  }

  @Test
  @TestMetadata("receiver2.kt")
  public void testReceiver2() {
    runTest("analysis/analysis-api/testData/components/referenceShortener/shortenRange/receiver2.kt");
  }

  @Test

  }

  @Test
  @TestMetadata("receiver.kt")
  public void testReceiver() {
    runTest("analysis/analysis-api/testData/components/referenceShortener/shortenRange/receiver.kt");
  }

  @Test
  @TestMetadata("receiver2.kt")
  public void testReceiver2() {
    runTest("analysis/analysis-api/testData/components/referenceShortener/shortenRange/receiver2.kt");
  }

  @Test

    def receive_wrapper(self, receive):
        received = 0

        async def inner():
            nonlocal received
            message = await receive()
            if message["type"] != "http.request":
                return message  # pragma: no cover

            body_len = len(message.get("body", b""))
            received += body_len
            if received > self.max_content_size: