// Play it back.
    val connection = connect(peer)
    connection.newStream(headerEntries("a", "android"), false)
    connection.withLock {
      if (!connection.isHealthy(System.nanoTime())) {
        throw ConnectionShutdownException()
      }
    }
    connection.writePing()
    connection.shutdown(ErrorCode.PROTOCOL_ERROR)
    assertThat(connection.openStreamCount()).isEqualTo(1)

// Accept accepts connections on the listener and serves requests
// to [DefaultServer] for each incoming connection.
// Accept blocks; the caller typically invokes it in a go statement.
func Accept(lis net.Listener) { DefaultServer.Accept(lis) }

// Can connect to RPC service using HTTP CONNECT to rpcPath.
var connected = "200 Connected to Go RPC"

// ServeHTTP implements an [http.Handler] that answers RPC requests.

        withConnection { connection ->
            connection.newBuild().forTasks("wrapper").run()
        }
        file('gradle/wrapper/gradle-wrapper.properties') << 'distributionSha256Sum=bad'

        when:
        def connector = this.connector()
        connector.useBuildDistribution()
        withConnection(connector) { ProjectConnection connection ->
            connection.newBuild().forTasks("help").run()
        }

        when:
        withConnectionToBuildSrc { connection ->
            def build = connection.newBuild()
            build.forTasks("help").run()
        }
        then:
        noExceptionThrown()
    }

    def "buildSrc with settings file can execute standalone"() {
        buildSrc.file("settings.gradle").touch()
        when:
        withConnectionToBuildSrc { connection ->
            def build = connection.newBuild()

        Map<String, CustomModel> result = withConnection { connection -> connection.action(new UseGradleBuildToFetchProjectModel()).run() }

        then:
        result != null
        result.keySet() == ['test', 'a', 'b', 'c'] as Set
        result.values()*.value as Set == [':', ':a', ':b', ':b:c'] as Set

        when:
        withConnector { connector ->
            connector.searchUpwards(true)

        1 * connectAction.execute(_) >> { ObjectConnection c -> connection = c }

        when:
        connection.connect()

        then:
        1 * completion.create(_) >> backingConnection

        when:
        connection.stop()

        then:
        1 * backingConnection.stop()
        1 * executor.stop()
        0 * _._
    }

	}

	// Call ConnectEx API.
	if err := fd.pfd.ConnectEx(ra); err != nil {
		select {
		case <-ctx.Done():
			return nil, mapErr(ctx.Err())
		default:
			if _, ok := err.(syscall.Errno); ok {
				err = os.NewSyscallError("connectex", err)
			}
			return nil, err
		}
	}
	// Refresh socket properties.

        try {
            URL url = location.getUri().toURL();
            URLConnection connection = url.openConnection();
            try {
                return new DefaultExternalResourceMetaData(location.getUri(), connection.getLastModified(), connection.getContentLength(), connection.getContentType(), null, null);
            } finally {
                connection.getInputStream().close();
            }
        } catch (FileNotFoundException e) {

 */
package okhttp3.internal.connection

/** Reuse a connection from the pool. */
internal class ReusePlan(
  val connection: RealConnection,
) : RoutePlanner.Plan {
  override val isReady = true

  override fun connectTcp() = error("already connected")

  override fun connectTlsEtc() = error("already connected")

  override fun handleSuccess() = connection

	s.pushQueue.ShutDown()
}

// Clients returns all currently connected clients. This method can be safely called concurrently,
// but care should be taken with the underlying objects (ie model.Proxy) to ensure proper locking.
// This method returns only fully initialized connections; for all connections, use AllClients
func (s *DiscoveryServer) Clients() []*Connection {
	s.adsClientsMutex.RLock()
	defer s.adsClientsMutex.RUnlock()