*  **Canceling batches of calls is now the application's responsibility.**
    The API to cancel calls by tag has been removed and replaced with a more
    general mechanism. The dispatcher now exposes all in-flight calls via its
    `runningCalls()` and `queuedCalls()` methods. You can write code that
    selects calls by tag, host, or whatever, and invokes `Call.cancel()` on the
    ones that are no longer necessary.

    val response1 = call1.execute()
    waitForDataFrames(Http2Connection.OKHTTP_CLIENT_WINDOW_SIZE)

    // Cancel the call and discard what we've buffered for the response body. This should free up
    // the connection flow-control window so new requests can proceed.
    call1.cancel()
    assertThat(
      response1.body.source().discard(1, TimeUnit.SECONDS),
      "Call should not have completed successfully.",

                        withPsiEntry("psi", psi, analysisSession::getModule)
                    }
            }

            // Specially handle @ExtensionFunctionType
            if (dispatchReceiver?.resolvedType?.isExtensionFunctionType == true) {
                firstArgIsExtensionReceiver = true
            }

  // operator is "In", and the values array contains only "value". The requirements are ANDed.
  // +optional
  map<string, string> matchLabels = 1;

  // matchExpressions is a list of label selector requirements. The requirements are ANDed.
  // +optional
  repeated LabelSelectorRequirement matchExpressions = 2;
}

    )
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    call.cancel()
    call.cancel()
    assertThat(listener.recordedEventTypes()).containsExactly("Canceled")
  }

  private fun assertSuccessfulEventOrder(responseMatcher: Matcher<Response?>?) {
    val call =
      client.newCall(
        Request.Builder()

    internal var connectTimeout = 10_000
    internal var readTimeout = 10_000
    internal var writeTimeout = 10_000
    internal var pingInterval = 0
    internal var webSocketCloseTimeout = RealWebSocket.CANCEL_AFTER_CLOSE_MILLIS.toInt()
    internal var minWebSocketMessageToCompress = RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE
    internal var routeDatabase: RouteDatabase? = null
    internal var taskRunner: TaskRunner? = null

 log.Println("Connected")

 // Subscribe to subject
 log.Printf("Subscribing to subject 'bucketevents'\n")
 natsConnection.Subscribe("bucketevents", func(msg *nats.Msg) {

  // Handle the message
  log.Printf("Received message '%s\n", string(msg.Data)+"'")
 })

 // Keep the connection alive
 runtime.Goexit()
}
```

```
go run nats.go
2016/10/12 06:39:18 Connected

                "//tensorflow/c:logging",
                "//tensorflow/c:ops",
                "//tensorflow/cc/saved_model:fingerprinting_impl",
                "//tensorflow/cc/saved_model:loader_lite_impl",
                "//tensorflow/cc/saved_model:metrics_impl",
                "//tensorflow/compiler/tf2tensorrt:op_converter_registry_impl",
                "//tensorflow/core/common_runtime:core_cpu_impl",

     */
    private val FirResolvedTypeRef.correspondingTypePsi: KtUserType?
        get() {
            val sourcePsi = when {
                // array type for vararg parameters is not present in the code, so no need to handle it
                delegatedTypeRef?.source?.kind == KtFakeSourceElementKind.ArrayTypeFromVarargParameter -> null

                // but the array's underlying type is present with a fake source, and needs to be handled

public final class okhttp3/CacheControl$Companion {
	public final fun parse (Lokhttp3/Headers;)Lokhttp3/CacheControl;
}

public abstract interface class okhttp3/Call : java/lang/Cloneable {
	public abstract fun cancel ()V
	public abstract fun clone ()Lokhttp3/Call;
	public abstract fun enqueue (Lokhttp3/Callback;)V
	public abstract fun execute ()Lokhttp3/Response;
	public abstract fun isCanceled ()Z
	public abstract fun isExecuted ()Z