assertFailsWith<IOException> {
      requestBody.writeUtf8("request body\n")
      requestBody.flush()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("stream was reset: CANCEL")
    }
    body.awaitSuccess()
    assertThat(eventRecorder.recordedEventTypes()).containsExactly(
      CallStart::class,
      ProxySelectStart::class,
      ProxySelectEnd::class,
      DnsStart::class,

  /*
   * We access this field racily but safely. For discussion of a similar situation, see the comments
   * on the fields of TimeoutFuture. This field is slightly different from the fields discussed
   * there: cancel() never reads this field, only writes to it. That makes the race here completely
   * harmless, rather than just 99.99% harmless.
   */
  @LazyInit private @Nullable List<@Nullable Present<V>> values;

        throw IllegalStateException(
          "Cannot stream a request body without chunked encoding or a known content length!",
        )
    }

  override fun cancel() {
    carrier.cancel()
  }

  /**
   * Prepares the HTTP headers and sends them to the server.
   *
   * For streaming requests with a body, headers must be prepared **before** the output stream has

            assertFailsWith<IOException> {
              response.trailers()
            }
          assertThat(exception.message).isIn(
            "Socket closed", // HTTP/1.1
            "stream was reset: CANCEL", // HTTP/2
          )
        }
      assertThat(trailersDelay).isGreaterThan(250.milliseconds)
      assertThat(trailersDelay).isLessThan(750.milliseconds)
    }
  }

  @Test

        this.function = function;
        this.primarySetupOffset = NTT_PRIMARY_SETUP_OFFSET;
        this.secondaryParameterOffset = NTT_SECONDARY_PARAMETER_OFFSET;
    }

    /**
     *
     * @return a cancel request
     */
    @Override
    public CommonServerMessageBlockRequest createCancel() {
        return new SmbComNtCancel(getConfig(), (int) getMid());
    }

    @Override

              assertThat(t).isInstanceOf(CancellationException.class);
              called = true;
            }
          }
        };
    addCallback(f, callback, directExecutor());
    f.cancel(true);
  }

  public void testThrowErrorFromGet() {
    Error error = new AssertionError("ASSERT!");
    ListenableFuture<String> f = UncheckedThrowingFuture.throwingError(error);

			continue
		}
		info := info
		wg.Add(connectionsPerPeer)
		for range connectionsPerPeer {
			go func() {
				defer wg.Done()
				ctx, cancel := context.WithTimeout(ctx, duration+10*time.Second)
				defer cancel()
				perfNetRequest(
					ctx,
					info.DeploymentID,
					adminPathPrefix+adminAPIVersionPrefix+adminAPISiteReplicationDevNull,
					r,
				)
			}()
		}
	}

	// responses from the remote server.
	// Channel will be closed after error or when remote closes.
	// responses *must* be read to either an error is returned or the channel is closed.
	responses *Stream
	newResp   func() Resp

	// Requests sent to the server.
	// If the handler is defined with 0 incoming capacity this will be nil.
	// Channel *must* be closed to signal the end of the stream.

		sshConfig.PasswordCallback = nil
	}

	sshConfig.AddHostKey(private)

	handleSFTPSession := func(channel ssh.Channel, sconn *ssh.ServerConn) {
		var remoteIP string

		if host, _, err := net.SplitHostPort(sconn.RemoteAddr().String()); err == nil {
			remoteIP = host
		}
		server := sftp.NewRequestServer(channel, NewSFTPDriver(sconn.Permissions, remoteIP), sftp.WithRSAllocator())
		defer server.Close()
		server.Serve()
	}

        };

    future = service.schedule(runnable, 5, MINUTES);
    future.cancel(true);
    assertTrue(future.isCancelled());
    delegateFuture = (ScheduledFuture<?>) delegateQueue.element();
    assertTrue(delegateFuture.isCancelled());

    delegateQueue.clear();

    future = service.scheduleAtFixedRate(runnable, 5, 5, MINUTES);
    future.cancel(true);
    assertTrue(future.isCancelled());