* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.resource.transport.gcp.gcs;

import org.gradle.internal.resource.connector.ResourceConnectorFactory;
import org.gradle.internal.service.Provides;
import org.gradle.internal.service.ServiceRegistration;
import org.gradle.internal.service.ServiceRegistrationProvider;

        1 * mockSftpClient1.connected >> false
        1 * mockSftpClient2.connected >> false
        sftpClientFactory.idleClients.size() == 0
        sftpClientFactory.allClients.size() == 1
        client3 == mockSftpClient3
    }

    def "reuses a different client when an existing client is no longer connected"() {
        def mockSftpClient1 = Mock(LockableSftpClient)

	return nil
}

// Connect wraps syscall.Connect.
func (sw *Switch) Connect(s int, sa syscall.Sockaddr) (err error) {
	so := sw.sockso(s)
	if so == nil {
		return syscall.Connect(s, sa)
	}
	sw.fmu.RLock()
	f := sw.fltab[FilterConnect]
	sw.fmu.RUnlock()

	af, err := f.apply(so)
	if err != nil {
		return err
	}
	so.Err = syscall.Connect(s, sa)
	if err = af.apply(so); err != nil {

class OpenIdConnect(SecurityBase):
    """
    OpenID Connect authentication class. An instance of it would be used as a
    dependency.
    """

    def __init__(
        self,
        *,
        openIdConnectUrl: Annotated[
            str,
            Doc(
                """
            The OpenID Connect URL.
            """
            ),
        ],
        scheme_name: Annotated[

            rootProject.name = 'root'
'''
        projectDir.file('child1').mkdirs()

        when:
        toolingApi.withConnector { connector ->
            connector.searchUpwards(true)
            connector.forProjectDirectory(projectDir.file('child1'))
        }
        EclipseProject child = loadToolingModel(EclipseProject)

        then:
        child.name == 'child1'

package org.gradle.internal.resource.transport.gcp.gcs;

import org.gradle.authentication.Authentication;
import org.gradle.internal.UncheckedException;
import org.gradle.internal.resource.connector.ResourceConnectorFactory;
import org.gradle.internal.resource.connector.ResourceConnectorSpecification;
import org.gradle.internal.resource.transfer.ExternalResourceConnector;

import java.util.Collections;
import java.util.Set;

  ): Http2Connection {
    peer.setClient(client)
    peer.sendFrame().settings(settings!!)
    peer.acceptFrame() // ACK
    peer.play()
    return connect(peer)
  }

  /** Builds a new connection to `peer` with settings acked.  */
  private fun connect(
    peer: MockHttp2Peer,
    pushObserver: PushObserver = IGNORE,
    listener: Http2Connection.Listener = Http2Connection.Listener.REFUSE_INCOMING_STREAMS,

            }
            print "[$line]"
        }
    }
}
'''
        executer.withStdinPipe(new PipedOutputStream() {
            @Override
            void connect(PipedInputStream snk) throws IOException {
                super.connect(snk)
                write(TextUtil.toPlatformLineSeparators("abc\n123").bytes)
                close()
            }
        })

        when:
        run "echo"

  private var writerTask: Task? = null

  /** Null until this web socket is connected. Only accessed by the reader thread. */
  private var reader: WebSocketReader? = null

  // All mutable web socket state is guarded by this.

  /** Null until this web socket is connected. Note that messages may be enqueued before that. */
  private var writer: WebSocketWriter? = null

        private EmbeddedGradleProvider() {}

        @Override
        public void applyTo(GradleConnector gradleConnector) {
            DefaultGradleConnector connector = (DefaultGradleConnector) gradleConnector;
            connector.embedded(true);
            connector.useClasspathDistribution();
        }

        @Override
        public void applyTo(GradleRunner gradleRunner) {
        }
    }