*
   * @throws IllegalStateException if {@code node} is already present
   */
  @CanIgnoreReturnValue
  private NetworkConnections<N, E> addNodeInternal(N node) {
    NetworkConnections<N, E> connections = newConnections();
    checkState(nodeConnections.put(node, connections) == null);
    return connections;
  }

  @Override
  @CanIgnoreReturnValue
  public boolean addEdge(N nodeU, N nodeV, E edge) {

   *
   * @throws IllegalStateException if {@code node} is already present
   */
  @CanIgnoreReturnValue
  private GraphConnections<N, V> addNodeInternal(N node) {
    GraphConnections<N, V> connections = newConnections();
    checkState(nodeConnections.put(node, connections) == null);
    return connections;
  }

  @Override
  @CanIgnoreReturnValue
  public @Nullable V putEdgeValue(N nodeU, N nodeV, V value) {

    assertThat(c1.socket().isClosed).isFalse()
  }

  @Test fun cleanupPrioritizesEarliestEviction() {
    val pool = factory.newConnectionPool()
    val c1 = factory.newConnection(pool, routeA1, 75L)
    val c2 = factory.newConnection(pool, routeB1, 50L)

    // Running at time 75, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(75L)).isEqualTo(75L)

  inner class FakePlan(
    val id: Int,
  ) : RoutePlanner.Plan {
    var planningThrowable: Throwable? = null
    var canceled = false
    var connectState = ConnectState.READY
    val connection =
      factory.newConnection(
        pool = pool,
        route = factory.newRoute(address),
        idleAtNanos = defaultConnectionIdleAtNanos,
      )
    var retry: FakePlan? = null
    var retryTaken = false

  var hostnameVerifier: HostnameVerifier? = HttpsURLConnection.getDefaultHostnameVerifier()
  var uriHost: String = "example.com"
  var uriPort: Int = 1

  fun newConnection(
    pool: RealConnectionPool,
    route: Route,
    idleAtNanos: Long = Long.MAX_VALUE,
    taskRunner: TaskRunner = this.taskRunner,
  ): RealConnection {
    val result =
      RealConnection.newTestConnection(

		if host == o.Local {
			if found {
				return nil, fmt.Errorf("grid: local host found multiple times")
			}
			found = true
			// No connection to local.
			continue
		}
		m.targets[host] = newConnection(connectionParams{
			ctx:           ctx,
			id:            m.ID,
			local:         o.Local,
			remote:        host,
			handlers:      &m.handlers,
			blockConnect:  o.BlockConnect,

	publisher     *pubsub.PubSub[madmin.TraceInfo, madmin.TraceType]
	dialer        ConnDialer
	authFn        AuthFn

	blockConnect chan struct{}
}

// newConnection will create an unconnected connection to a remote.
func newConnection(o connectionParams) *Connection {
	c := &Connection{
		state:              StateUnconnected,
		Remote:             o.remote,
		Local:              o.local,

          localCertificates = listOf(),
        )

      return mapOf(
        Boolean::class.java to false,
        Call::class.java to FailingCall(),
        Connection::class.java to factory.newConnection(pool, route),
        Dispatcher::class.java to Dispatcher(),
        Handshake::class.java to handshake,
        HttpUrl::class.java to url,
        IOException::class.java to IOException("boom"),