final TestCloseable closeable2 = new TestCloseable("closeable2");
  final TestCloseable closeable3 = new TestCloseable("closeable3");
  final TestCloseable closeable4 = new TestCloseable("closeable4");

  final Waiter waiter = new Waiter();
  final CountDownLatch futureCancelled = new CountDownLatch(1);
  final Exception exception = new Exception();
  final Closeable mockCloseable = Mockito.mock(Closeable.class);

  @Override

			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "ObjSizes")
				return
			}
			if zb0002 != uint32(dataUsageBucketLen) {
				err = msgp.ArrayError{Wanted: uint32(dataUsageBucketLen), Got: zb0002}
				return
			}
			for za0001 := range z.ObjSizes {
				z.ObjSizes[za0001], err = dc.ReadUint64()
				if err != nil {

      // (in startSignal.await()), and the others waiting for that thread's result.
      while (thread.isAlive() && thread.getState() != Thread.State.WAITING) {
        Thread.yield();
      }
    }
    gettersStartedSignal.countDown();
    gettersComplete.await();

    List<Object> resultList = Lists.newArrayListWithExpectedSize(nThreads);

          fail("")
        }
      },
    )
    assertThat(server.takeRequest().exchangeIndex)
      .isEqualTo(expectedSequenceNumber)
    responseDequeuedLatch!!.await()
    call.cancel()
    requestCanceledLatch!!.countDown()
    latch.await()
  }

  @ParameterizedTest
  @ArgumentsSource(ProtocolParamProvider::class)
  fun noRecoveryFromRefusedStreamWithRetryDisabled(protocol: Protocol) {

    peer.acceptFrame() // RST_STREAM
    peer.acceptFrame() // DEGRADED PING
    peer.acceptFrame() // AWAIT PING
    peer.sendFrame().ping(true, Http2Connection.DEGRADED_PING, 1) // DEGRADED PONG
    peer.sendFrame().ping(true, Http2Connection.AWAIT_PING, 0) // AWAIT PONG
    peer.play()

    // Play it back.
    val connection = connect(peer)

			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Totals")
				return
			}
			if zb0002 != uint32(60) {
				err = msgp.ArrayError{Wanted: uint32(60), Got: zb0002}
				return
			}
			for za0001 := range z.Totals {
				err = z.Totals[za0001].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Totals", za0001)
					return

	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 7 {
		err = msgp.ArrayError{Wanted: 7, Got: zb0001}
		return
	}
	err = dc.ReadExactBytes((z.VersionID)[:])
	if err != nil {
		err = msgp.WrapError(err, "VersionID")
		return
	}
	z.ModTime, err = dc.ReadInt64()
	if err != nil {

          call: Call,
          response: Response,
        ) {
          response.close()
          completionLatch.countDown()
        }
      }
    call.enqueue(callback)
    completionLatch.await()
    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart",
      "ProxySelectStart",
      "ProxySelectEnd",
      "DnsStart",
      "DnsEnd",
      "ConnectStart",

			continue
		}
		// Two flushes, to verify the error is sticky.
		for i := 0; i < 2; i++ {
			e = buf.Flush()
			if e != w.expect {
				t.Errorf("Flush %d/2 %v: got %v, wanted %v", i+1, w, e, w.expect)
			}
		}
	}
}

func TestNewReaderSizeIdempotent(t *testing.T) {
	const BufSize = 1000
	b := NewReaderSize(strings.NewReader("hello world"), BufSize)

     * concurrently, returning once any connection connects successfully.
     *
     * This implements Happy Eyeballs ([RFC 6555][rfc_6555]), balancing connect latency vs.
     * wasted resources.
     *
     * Defaults to enabled, call with [fastFallback] = false to revert to 4.x behaviour.
     *
     * [rfc_6555]: https://datatracker.ietf.org/doc/html/rfc6555
     */