} else {
		if ddd {
			// standard_func(a, b, c...)
			//check.errorf(call.Ellipsis, "cannot use ... in call to non-variadic %s", call.Fun)
			check.errorf(call, NonVariadicDotDotDot, "cannot use ... in call to non-variadic %s", call.Fun)
			return
		}
		// standard_func(a, b, c)
	}

	// check argument count
	if nargs != npars {
		var at poser = call
		qualifier := "not enough"
		if nargs > npars {

Dmitri Shuralyov <******@****.***> 1697569678 -0400

  }
// Checks that the quantized XlaCallModule has been replaced by a CallOp, which
// calls the quantized entry function.
// CHECK: %[[CONST:.+]] = stablehlo.constant dense<{{.*}}> : tensor<2x3x2xi32>
// CHECK: %[[UNIFORM_QUANTIZE:.+]] = stablehlo.uniform_quantize %[[ARG_0]] : (tensor<3x4x2xf32>) -> tensor<3x4x2x!quant.uniform<i8:f32, {{.*}}>>

	// Retry the call until it succeeds or times out.
	var result echo.CallResult
	var err error
	_, _ = retry.UntilComplete(func() (any, bool, error) {
		result, err = sendAndValidate()
		if err != nil {
			return nil, false, err
		}
		return nil, true, nil
	}, opts.Retry.Options...)

	return result, err
}

type Caller struct {
	f *forwarder.Instance
}

func NewCaller() *Caller {
	return &Caller{

 */
package okhttp3

import okio.IOException
import okio.Timeout

/**
 * A call is a request that has been prepared for execution. A call can be canceled. As this object
 * represents a single request/response pair (stream), it cannot be executed twice.
 */
interface Call : Cloneable {
  /** Returns the original request that initiated this call. */
  fun request(): Request

  /**

     * candidates if the call is ambiguous.
     */
    public val isInBestCandidates: Boolean by validityAsserted(isInBestCandidates)
}

public typealias KtCallCandidateInfo = KaCallCandidateInfo

/**
 * A candidate that is applicable for a call. A candidate is applicable if the call's arguments are complete and are assignable to the

// systemstack runs fn on a system stack.
// If systemstack is called from the per-OS-thread (g0) stack, or
// if systemstack is called from the signal handling (gsignal) stack,
// systemstack calls fn directly and returns.
// Otherwise, systemstack is being called from the limited stack
// of an ordinary goroutine. In this case, systemstack switches
// to the per-OS-thread stack, calls fn, and switches back.

    } else {
      assertThat(events).doesNotContain("Canceled")
    }
    assertThat(events).contains("ResponseFailed")
    assertThat(events).contains("ConnectionReleased")

    val call2 = client.newCall(Request(server.url("/")))
    call2.execute().use {
      assertEquals(".", it.body.string())
    }

    val events2 = listener.eventSequence.filter { isConnectionEvent(it) }.map { it.name }
    val expectedEvents2 =

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package mockwebserver3

import okhttp3.ExperimentalOkHttpApi

/**
 * Handles a call's stream directly. Use this instead of [MockResponseBody] to begin sending
 * response data before all request data has been received.
 *
 * See [okhttp3.RequestBody.isDuplex].
 */
@ExperimentalOkHttpApi

        .build(),
    )
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    call.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {