}

    def "should default invalid disableAuthentication parameter"() {
        expect:
        new GcsConnectionProperties("http://some", null, value).requiresAuthentication()
        then:
        where:
        value << ['foo', 'true-ish', 'false-y', '1']
    }

    Optional<URI> getEndpoint() {
        return Optional.fromNullable(endpoint);
    }

    Optional<String> getServicePath() {
        return Optional.fromNullable(servicePath);
    }

    boolean requiresAuthentication() {
        return !disableAuthentication;
    }

    private static URI configureEndpoint(String property) {
        URI uri = null;
        if (StringUtils.isNotBlank(property)) {
            try {

        JsonFactory jsonFactory = new GsonFactory();
        Storage.Builder builder = new Storage.Builder(transport, jsonFactory, null);
        if (gcsConnectionProperties.requiresAuthentication()) {
            Supplier<Credential> credentialSupplier = getCredentialSupplier(transport, jsonFactory);
            builder.setHttpRequestInitializer(new RetryHttpInitializerWrapper(credentialSupplier));
        }

        server.addConnector(sslConnector)
        if (server.started) {
            sslConnector.start()
        }

    }

    void requireAuthentication(String path = '/*', String username, String password) {
        securityHandlerWrapper.requireAuthentication(path, username, password)
    }

    int getPort() {
        return connector.localPort
    }

    int getSslPort() {

    }

    @Override
    Server getServer() {
        delegate.server
    }

    @Override
    void destroy() {
        delegate.destroy()
    }

    void requireAuthentication(String path, String username, String password) {
        if (realm != null) {
            assert realm.username == username
            assert realm.password == password

        HttpServerFixture.super.start()
    }

    @Override
    protected void after() {
        stop()
    }

    void withBasicAuth(String username, String password) {
        requireAuthentication(username, password)
    }

        assert !inlinedCredentials : "Inlined credentials are not supported with the configuration cache"
        with (server) {
            requireAuthentication(username, password)
            // or else insecure protocol enforcement is skipped
            useHostname()
            start()
        }
        def remoteRepo = new IvyHttpRepository(server, ivyRepo)

        assert !inlinedCredentials : "Inlined credentials are not supported with the configuration cache"
        with (server) {
            requireAuthentication(username, password)
            // or else insecure protocol enforcement is skipped
            useHostname()
            start()
        }
        def remoteRepo = new MavenHttpRepository(server, mavenRepo)

            }
        }))
    }

    private Action withAuthentication(String path, String username, String password, Action action) {
        requireAuthentication(path, username, password)

        return new Action() {
            @Override
            HttpResourceInteraction getInteraction() {
                return action.interaction
            }