}

    def nonBlockingActorAndProxyAreBothMarkedAsThreadSafe() {
        when:
        def actor = factory.createActor(target)

        then:
        actor instanceof ThreadSafe
        actor.getProxy(Runnable) instanceof ThreadSafe
    }

    def createsABlockingActorForATargetObject() {
        when:
        def actor = factory.createBlockingActor(target)

        then:
        actor != null
    }

        1 * actorFactory.createActor(processor1) >> actor1
        1 * actor1.getProxy(TestClassProcessor) >> asyncProcessor1

        when:
        processor.processTestClass(test)

        then:
        1 * factory.create() >> processor2
        1 * actorFactory.createActor(processor2) >> actor2
        1 * actor2.getProxy(TestClassProcessor) >> asyncProcessor2

        when:
        processor.stopNow()

        HttpProxySettings secureHttpProxySettings = Mock()

        1 * secureHttpProxySettings.getProxy() >> secureProxy

        when:
        S3ConnectionProperties properties = new S3ConnectionProperties(Mock(HttpProxySettings), secureHttpProxySettings, null, null)

        then:
        properties.getProxy().get() == secureProxy
    }

    def "should get non-secure http proxy for override host"() {

    @Override
    protected Action<String> createTestExecutor(Actor resultProcessorActor) {
        TestResultProcessor threadSafeResultProcessor = resultProcessorActor.getProxy(TestResultProcessor.class);
        TestClassExecutionListener threadSafeTestClassListener = resultProcessorActor.getProxy(TestClassExecutionListener.class);

        JUnitTestEventAdapter junitEventAdapter = new JUnitTestEventAdapter(threadSafeResultProcessor, clock, idGenerator);

        // Create a processor that processes events in its own thread
        resultProcessorActor = actorFactory.createActor(resultProcessor);
        this.resultProcessor = resultProcessorActor.getProxy(TestResultProcessor.class);
    }

    @Override
    public void processTestClass(TestClassRunInfo testClass) {
        if (stoppedNow) {
            return;
        }

        TestClassProcessor processor;

        return endpoint;
    }

    public Optional<HttpProxySettings.HttpProxy> getProxy() {
        if (endpoint.isPresent()) {
            if (endpoint.get().getScheme().equalsIgnoreCase("HTTP")) {
                return Optional.fromNullable(proxySettings.getProxy());
            } else {
                return Optional.fromNullable(secureProxySettings.getProxy());
            }
        }

        settings("proxyHost", prop).getProxy().port == value

        where:
        prop     | value
        null     | 80
        ""       | 80
        "notInt" | 80
        "0"      | 0
        "111"    | 111
    }

    def "uses specified proxy user and password"() {
        expect:
        def proxy = new TestSystemProperties("proxyHost", null, user, password).getProxy()

                repository.setProxy(getProxy(selector, repository));
            }
        }
    }

    private org.apache.maven.repository.Proxy getProxy(ProxySelector selector, ArtifactRepository repository) {
        if (selector != null) {
            RemoteRepository repo = RepositoryUtils.toRepo(repository);
            org.eclipse.aether.repository.Proxy proxy = selector.getProxy(repo);
            if (proxy != null) {

        proxyInfo.setHost(repository.getProxy().getHost());
        proxyInfo.setType(repository.getProxy().getProtocol());
        proxyInfo.setPort(repository.getProxy().getPort());
        proxyInfo.setNonProxyHosts(repository.getProxy().getNonProxyHosts());
        proxyInfo.setUserName(repository.getProxy().getUserName());
        proxyInfo.setPassword(repository.getProxy().getPassword());
        return proxyInfo;
    }

/**
 * <p>An {@code Actor} dispatches method calls to a target object in a thread-safe manner. Methods are called either by
 * calling {@link Dispatch#dispatch(Object)} on the actor, or using the proxy object
 * returned by {@link #getProxy(Class)}. Methods are delivered to the target object in the order they are called on the
 * actor, but are delivered to the target object by a single thread at a time. In this way, the target object does not need