package org.gradle.internal.remote.internal

import org.gradle.internal.remote.internal.hub.protocol.InterHubMessage

import java.util.concurrent.BlockingQueue
import java.util.concurrent.LinkedBlockingQueue

class TestConnection implements RemoteConnection<InterHubMessage> {
    private static final Object END = new Object()
    private final BlockingQueue<Object> incoming = new LinkedBlockingQueue<>()

    }

    private TestConnection newDelegateConnection() {
        TestConnection delegate = Mock(TestConnection)
        ConnectionMetaDataVersion1 connectionMetaData = Mock()
        1 * delegate.getMetaData() >> connectionMetaData
        1 * connectionMetaData.getVersion() >> "2.6-rc-1"
        delegate
    }

import org.gradle.internal.dispatch.MethodInvocation
import org.gradle.internal.dispatch.StreamCompletion
import org.gradle.internal.remote.internal.ConnectCompletion
import org.gradle.internal.remote.internal.TestConnection
import org.gradle.internal.remote.internal.hub.protocol.ChannelIdentifier
import org.gradle.internal.remote.internal.hub.protocol.ChannelMessage
import org.gradle.test.fixtures.concurrent.ConcurrentSpec

class DefaultPhasedBuildActionExecuterTest extends ConcurrentSpec {
    // Tests based on DefaultBuildActionExecuterTest

    def asyncConnection = Mock(AsyncConsumerActionExecutor) {
        getDisplayName() >> 'testConnection'
    }
    def connection = Mock(ConsumerConnection)
    def parameters = Stub(ConnectionParameters)
    def phasedAction = Stub(PhasedBuildAction)

        BoundedDispatch<String> handler = Mock()
        def connection1 = new TestConnection()
        def connection2 = new TestConnection()

        given:
        hub.addHandler("channel", handler)
        hub.addConnection(connection1)
        hub.addConnection(connection2)

        when:

            getToolingApiResourcesDir(connectionImplementation),
            ClasspathUtil.getClasspathForClass(TestConnection.class),
            ClasspathUtil.getClasspathForClass(ActorFactory.class),
            ClasspathUtil.getClasspathForClass(Logger.class),
            ClasspathUtil.getClasspathForClass(GroovyObject.class),

import org.gradle.util.ConcurrentSpecification

import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit

class DefaultDaemonConnectionTest extends ConcurrentSpecification {
    final TestConnection connection = new TestConnection()
    final DefaultDaemonConnection daemonConnection = new DefaultDaemonConnection(new SynchronizedDispatchConnection<Message>(connection), executorFactory)

    def cleanup() {
        connection.disconnect()

import org.gradle.tooling.model.idea.IdeaProject
import spock.lang.Specification

class PhasedActionAwareConsumerConnectionTest extends Specification {

    final target = Mock(TestConnection) {
        getMetaData() >> Stub(ConnectionMetaDataVersion1) {
            getVersion() >> "4.8"
        }
    }
    final adapter = Stub(ProtocolToModelAdapter)
    final modelMapping = Stub(ModelMapping)

    this.server = server

    // Test designed for Conscrypt and JSSE
    platform.assumeNotBouncyCastle()
  }

  @ParameterizedTest
  @MethodSource("connectionTypes")
  fun testConnection(socketMode: SocketMode) {
    // https://github.com/square/okhttp/pull/6554
    assumeFalse(
      socketMode is TlsInstance &&
        socketMode.socketMode == Channel &&
        socketMode.protocol == HTTP_2 &&