RemoteService2 outgoingService2

        abstract ObjectConnection getConnection()

        void addIncoming(RemoteService1 value) {
            connection.addIncoming(RemoteService1.class, value)
        }

        void addIncoming(RemoteService2 value) {
            connection.addIncoming(RemoteService2.class, value)
        }

        void setupOutgoingService1(){

        connection.queueIncoming(new ChannelMessage(new ChannelIdentifier(Worker.name), new MethodInvocation(Worker.class.getMethod("doStuff", String), ["param 1"] as Object[])))

        when:
        connectionBuilder.addIncoming(Worker, worker)
        connectionBuilder.connect()
        connection.stop()
        connectionBuilder.stop()

        then:
        1 * worker.doStuff("param 1")
        0 * worker._

        cleanup:

        }
    }

    public void execute(WorkerProcessContext workerProcessContext) {
        stopReceived = new CountDownLatch(1);
        workerProcessContext.getServerConnection().addIncoming(TestListenerInterface.class, this);
        workerProcessContext.getServerConnection().connect();
        try {
            stopReceived.await();
        } catch (InterruptedException e) {

        and:
        1 * factory.create(_, _, _) >> processor
        1 * connection.addOutgoing(TestResultProcessor) >> resultProcessor
        1 * connection.addIncoming(RemoteTestClassProcessor, worker)
        1 * connection.useParameterSerializers(_)
        1 * connection.connect() >> {
            start {
                worker.startProcessing()

                connection.addIncoming(WorkerLoggingProtocol.class, defaultWorkerLoggingProtocol);

                if (shouldPublishJvmMemoryInfo) {
                    connection.useParameterSerializers(WorkerJvmMemoryInfoSerializer.create());
                    connection.addIncoming(WorkerJvmMemoryInfoProtocol.class, memoryStatus);
                }
            }));

     *
     * @param type The type.
     * @param instance The handler instance. Incoming messages on the given type are delivered to this handler.
     */
    <T> void addIncoming(Class<T> type, T instance);

    /**
     * Use the given Classloader to deserialize method parameters for method invocations received from the peer, for those types where Java serialization is used.
     */

                    }
                } finally {
                    lock.unlock();
                }
            }
        });
        connection.addIncoming(TestResultProcessor.class, resultProcessor);
        RemoteTestClassProcessor remoteProcessor = connection.addOutgoing(RemoteTestClassProcessor.class);
        connection.connect();
        remoteProcessor.startProcessing();

                } catch (Exception e) {
                    throw WorkerProcessException.runFailed(getBaseName(), e);
                }
                workerProcess.getConnection().addIncoming(ResponseProtocol.class, receiver);
                workerProcess.getConnection().useJavaSerializationForParameters(workerImplementation.getClassLoader());

                    ObjectConnection connection = workerProcess.getConnection();
                    RequestProtocol requester = connection.addOutgoing(RequestProtocol.class);
                    connection.addIncoming(ResponseProtocol.class, receiver);
                    connection.useJavaSerializationForParameters(workerImplementation.getClassLoader());

            } catch (ExecException e) {
                e.printStackTrace()
                assertTrue(startFails);
                return;
            }
            proc.getConnection().addIncoming(TestListenerInterface.class, exceptionListener);
            proc.getConnection().connect()
        }

        public void waitForStop() {
            if (startFails) {
                return;
            }