*
   * @return {@code true} if the network was modified as a result of this call
   */
  @CanIgnoreReturnValue
  boolean addNode(N node);

  /**
   * Adds {@code edge} connecting {@code nodeU} to {@code nodeV}.
   *
   * <p>If the graph is directed, {@code edge} will be directed in this graph; otherwise, it will be
   * undirected.
   *

  }

  @Test
  fun staleConnectionNotReusedForNonIdempotentRequest() {
    // Capture the connection so that we can later make it stale.
    var connection: RealConnection? = null
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain ->
            connection = chain.connection() as RealConnection
            chain.proceed(chain.request())
          },
        ).build()

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.dcerpc.msrpc;

/**
 * MSRPC implementation for connecting to the SAM service.
 * This class provides functionality to establish a connection to the
 * Security Account Manager (SAM) database using the SAMR RPC interface.
 */
public class MsrpcSamrConnect2 extends samr.SamrConnect2 {

    /**

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.dcerpc.msrpc;

/**
 * MSRPC implementation for connecting to the SAM service (version 4).
 * This class provides functionality to establish a connection to the
 * Security Account Manager (SAM) database using the SAMR RPC interface version 4.
 */
public class MsrpcSamrConnect4 extends samr.SamrConnect4 {

    /**

/**
 * Performs either **preemptive** authentication before connecting to a proxy server, or
 * **reactive** authentication after receiving a challenge from either an origin web server or proxy
 * server.
 *
 * ## Preemptive Authentication
 *
 * To make HTTPS calls using an HTTP proxy server OkHttp must first negotiate a connection with
 * the proxy. This proxy connection is called a "TLS Tunnel" and is specified by

     */
    private String password;

    /**
     * Get the user's password which is used when connecting to the repository.
     *
     * @return password of user
     */
    public String getPassword() {
        return password;
    }

    /**
     * Set the user's password which is used when connecting to the repository.
     *
     * @param password password of the user
     */

   * - Both request discover no existing connection. They both make a connection.
   * - The first request "wins the race".
   * - The second request discovers it "lost the race" and closes the connection it just opened.
   * - The second request uses the coalesced connection from request1.
   * - The coalesced connection is violently closed after servicing the first request.

            if (newTransport == null) {
                throw new IOException("Failed to create new transport");
            }

            // Reconnect
            channel.setState(ChannelState.CONNECTING);
            // Connection would be ensured through proper transport interface

            // Re-establish channel binding
            manager.performChannelBinding(channel);

            // Update channel with new transport

     */
    protected abstract void doDisconnect(boolean hard) throws IOException;

    /**
     * Establishes a connection to the remote endpoint.
     *
     * @param timeout the maximum time to wait for the connection in milliseconds
     * @throws TransportException if the connection fails or times out
     */
    public synchronized void connect(final long timeout) throws TransportException {
        try {

     */
    @CanIgnoreReturnValue
    public Builder<N> addNode(N node) {
      mutableGraph.addNode(node);
      return this;
    }

    /**
     * Adds an edge connecting {@code nodeU} to {@code nodeV} if one is not already present.
     *
     * <p>If the graph is directed, the resultant edge will be directed; otherwise, it will be
     * undirected.
     *