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

		return errLockNotFound
	}
	return err
}

// Call makes a REST call to the remote endpoint using the msgp codec
func (restClient *ReconnectRESTClient) Call(method string, args LockArgs) (status bool, err error) {
	buf, err := args.MarshalMsg(nil)
	if err != nil {
		return false, err
	}
	body := bytes.NewReader(buf)
	respBody, err := restClient.rest.Call(context.Background(), method,
		url.Values{}, body, body.Size())

        assertEquals(200, dfsRootEnum.info.level);
        assertNotNull(dfsRootEnum.info.e);
    }

    @Test
    @DisplayName("getEntries should return consistent results on multiple calls")
    void testGetEntries_multipleCallsConsistency() throws Exception {
        // Setup test data
        netdfs.DfsEnumArray200 testArray = new netdfs.DfsEnumArray200();
        testArray.count = 2;

  override fun callStart(call: Call) {
    startNs = System.nanoTime()

    logWithTime("callStart: ${call.request()}")
  }

  override fun dispatcherQueueStart(
    call: Call,
    dispatcher: Dispatcher,
  ) {
    logWithTime("dispatcherQueueStart: $call queuedCallsCount=${dispatcher.queuedCallsCount()}")
  }

  override fun dispatcherQueueEnd(
    call: Call,
    dispatcher: Dispatcher,
  ) {

// LTYPEC spec3	{ outcode(int($1), &$2); }
	CALL	AX
	JCS	2(PC)
	JMP	*AX // JMP AX
	CALL	*foo(SB)
	JCS	2(PC)
	JMP	$4
	JCS	2(PC)
	JMP	label // JMP 16
	CALL	foo(SB)
//	CALL	(AX*4) // TODO: This line is silently dropped on the floor!
	CALL	foo+4(SB)(AX*4)
	CALL	*4(SP) // CALL 4(SP)
	CALL	*(AX) // CALL (AX)
	CALL	*(SP) // CALL (SP)
//	CALL	*(AX*4) // TODO: This line is silently dropped on the floor!

      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          continuation.resumeWithException(e)
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          continuation.resume(response) { _, value, _ ->
            value.closeQuietly()
          }
        }
      },
    )

  public abstract boolean isVarArgs();

  /**
   * Invokes with {@code receiver} as 'this' and {@code args} passed to the underlying method and
   * returns the return value; or calls the underlying constructor with {@code args} and returns the
   * constructed instance.
   *
   * @throws IllegalAccessException if this {@code Constructor} object enforces Java language access

            .build()

        val exchange = call.interceptorScopedExchange
        val followUp = followUpRequest(response, exchange, chain)

        if (followUp == null) {
          if (exchange != null && exchange.isDuplex) {
            call.timeoutEarlyExit()
          }
          closeActiveExchange = false
          call.eventListener.followUpDecision(call, response, null)
          return response
        }

 *
 * Each instance processes a single event on [call], and then adds a successor [EventListenerRelay]
 * on the same [call] to process the next event.
 *
 * By forcing the list of listeners to change after every event, we can detect if buggy code caches
 * a stale [EventListener] in a field or local variable.
 */
class EventListenerRelay(
  val call: Call,
  val eventRecorder: EventRecorder,
) {

        .Builder()
        .status("HTTP/1.1 200 ${"O".repeat(256 * 1024)}K")
        .body("I'm not even supposed to be here today.")
        .build(),
    )
    val call = client.newCall(Request(url = server.url("/")))
    assertFailsWith<IOException> {
      call.execute()
    }
  }

  /** Use a header that exceeds the limits on its own. */
  @Test
  fun largeResponseHeader() {
    server.enqueue(
      MockResponse