*
   * @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
  @CheckForNull
  public V putEdgeValue(N nodeU, N nodeV, V value) {

   *
   * @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
  @CheckForNull
  public 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)

		s:        s,
		networkQ: timer.NewQueue(),
	}
}

func (m *Instance) Nodes() Nodes {
	return m.nodes
}

func (m *Instance) Clients() []*Client {
	return m.clients
}

func (m *Instance) NewConnection(src *Client, dest *Node) network.Connection {
	// Lookup the route between the source and destination
	networkLatency := m.s.NetworkLatencies[RouteKey{
		Src:  src.Locality(),
		Dest: dest.Locality(),
	}]

func EquallyWeightedConnectionFactory() WeightedConnectionFactory {
	return func(src *mesh2.Client, dest *mesh2.Node) *WeightedConnection {
		return &WeightedConnection{
			Connection: src.Mesh().NewConnection(src, dest),
			Weight:     1,
		}
	}
}

func PriorityWeightedConnectionFactory(selectPriority PrioritySelector, priorityWeightMap map[uint32]uint32) WeightedConnectionFactory {

)

type Connection interface {
	Name() string
	Request(onDone func())
	TotalRequests() uint64
	ActiveRequests() uint64
	Latency() *timeseries.Instance
}

func NewConnection(name string, request func(onDone func())) Connection {
	return &connection{
		request: request,
		helper:  NewConnectionHelper(name),
	}
}

type connection struct {
	request func(onDone func())

// connection by calling UpgradeRoundTripper.Connection().
type UpgradeRoundTripper interface {
	http.RoundTripper
	// NewConnection validates the response and creates a new Connection.
	NewConnection(resp *http.Response) (Connection, error)
}

// ResponseUpgrader knows how to upgrade HTTP requests and responses to
// add streaming support to them.
type ResponseUpgrader interface {

			return
		}
		defer srvConn.Close()

		spdyConn, err := spdystream.NewConnection(srvConn, true)
		if err != nil {
			srvErr <- fmt.Errorf("server: error creating spdy connection: %v", err)
			return
		}

		var pingsSent int64
		srvSPDYConn := newConnection(
			spdyConn,
			func(stream httpstream.Stream, replySent <-chan struct{}) error {
				// Echo all the incoming data.

		}
	case <-time.After(time.Millisecond * 500):
		t.Fatalf("Timed out")
	}
}

func TestProxyQueue(t *testing.T) {
	proxies := make([]*Connection, 0, 100)
	for p := 0; p < 100; p++ {
		conn := newConnection("", nil)
		conn.SetID(fmt.Sprintf("proxy-%d", p))
		proxies = append(proxies, conn)
	}

	t.Run("simple add and remove", func(t *testing.T) {
		t.Parallel()
		p := NewPushQueue()
		defer p.ShutDown()

	if err != nil {
		conn.Close()
		return nil, err
	}

	s.conn = conn

	return resp, nil
}

// NewConnection validates the upgrade response, creating and returning a new
// httpstream.Connection if there were no errors.
func (s *SpdyRoundTripper) NewConnection(resp *http.Response) (httpstream.Connection, error) {
	connectionHeader := strings.ToLower(resp.Header.Get(httpstream.HeaderConnection))