func main() {
	const async = 1 // asynchronous channels
	var nilch chan int
	closedch := make(chan int)
	close(closedch)

	// sending/receiving from a nil channel blocks
	testBlock(always, func() {
		nilch <- 7
	})
	testBlock(always, func() {
		<-nilch
	})

	// sending/receiving from a nil channel inside a select is never selected
	testPanic(never, func() {
		select {
		case nilch <- 7:
			unreachable()
		default:

 * However, the implementations:
 * <ul>
 * <li>should allow separate threads for dispatching and receiving, i.e. single thread that dispatches
 * and a different single thread that receives should be perfectly safe</li>
 * <li>should allow stopping or requesting stopping from a different thread than receiving/dispatching</li>
 * <li>don't guarantee allowing multiple threads dispatching</li>
 * </ul>
 */

interface FlowControlListener {
  /**
   * Notification that the receiving stream flow control window has changed.
   * [WindowCounter] generally carries the client view of total and acked bytes.
   */
  fun receivingStreamWindowChanged(
    streamId: Int,
    windowCounter: WindowCounter,
    bufferSize: Long,
  )

  /**
   * Notification that the receiving connection flow control window has changed.

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management

releaseNotes:
- |

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Types for receiving build events.
 */

 * limitations under the License.
 */

package org.gradle.internal.remote.internal.hub;

/**
 * A handler for messages that fail while streaming to the peer, either on the sending side or on the receiving side
 */
public interface StreamFailureHandler {
    /**
     * Called when notification of a streaming failure is received on an incoming channel.
     */
    void handleStreamFailure(Throwable t);

 */
package okhttp3.internal.http2

import okhttp3.ConnectionListener
import okhttp3.internal.http2.flowcontrol.WindowCounter

/**
 * ConnectionListener that outputs CSV for flow control of client receiving streams.
 */
class Http2FlowControlConnectionListener : ConnectionListener(), FlowControlListener {
  val start = System.currentTimeMillis()

  override fun receivingStreamWindowChanged(
    streamId: Int,

 * limitations under the License.
 */
package org.gradle.api.execution;

import org.gradle.api.Task;
import org.gradle.api.tasks.TaskState;

/**
 * A {@link TaskExecutionListener} adapter class for receiving task execution events.
 *
 * The methods in this class are empty. This class exists as convenience for creating listener objects.
 */
@SuppressWarnings("deprecation")

// license that can be found in the LICENSE file.

// Test communication with multiple simultaneous goroutines.

package main

import "runtime"

const N = 1000 // sent messages
const M = 10   // receiving goroutines
const W = 2    // channel buffering
var h [N]int   // marking of send/recv

func r(c chan int, m int) {
	for {
		select {
		case r := <-c:
			if h[r] != 1 {
				println("r",
					"m=", m,

        assertEquals(
            "GROOVY",
            closure { uppercase(Locale.US) }.call("groovy")
        )
    }

    @Test
    fun `can adapt unary null receiving function using KotlinClosure1`() {
        fun closure(function: String?.() -> String?) = KotlinClosure1(function)

        assertEquals(
            null,
            closure { null }.call(null)
        )