}

    @Override
    int assignPort() {
        int port = delegate.assignPort()
        portsAllocated.add(port)
        return port
    }

    @Override
    void releasePort(int port) {
        delegate.releasePort(port)
        portsAllocated.removeAll { it == port }
    }

    @Override
    Statement apply(Statement base, Description description) {
        return new Statement() {
            @Override

        port2 >= PortAllocator.MIN_PRIVATE_PORT
        port2 <= PortAllocator.MAX_PRIVATE_PORT

        and:
        port2 != port1

        cleanup:
        port1 && portAllocator.releasePort(port1)
        port2 && portAllocator.releasePort(port2)
    }

    /**
     * Assign and reserve a port
     * @return the port assigned
     */
    int assignPort()

    /**
     * Release a previously assigned port
     * @param port
     */
    void releasePort(int port)

        then:
        1 * base.evaluate() >> {
            portAllocator.assignPort()
            portAllocator.assignPort()
        }
        2 * delegate.assignPort()

        and:
        2 * delegate.releasePort(_)
    }

        if (port > 0) {
            return "HTTP proxy: $port"
        }
        return "HTTP proxy (not started)"
    }

    void stop() {
        proxyServer?.stop()
        portFinder.releasePort(port)
    }

    void configureProxy(GradleExecuter executer, String proxyScheme, String userName = null, String password = null) {
        configureProxyHost(executer, proxyScheme)

        if (userName) {

        }
    }

    private void releaseConnector() {
        def port = connector.port
        server.removeConnector(connector)
        connector.stop()
        portAllocator.releasePort(port)
    }

    private boolean createConnector() {
        def assignedPort = portAllocator.assignPort()
        connector = new ServerConnector(server)
        connector.port = assignedPort

    public int assignPort() {
        try {
            lock.lock()
            return reservePort()
        } finally {
            lock.unlock()
        }
    }

    @Override
    public void releasePort(int port) {
        if (port == null || port < MIN_PRIVATE_PORT || port > MAX_PRIVATE_PORT) {
            return
        }

        try {
            lock.lock()

        executer.withArgument("-DsocksProxyPort=${port}")
        executer.withArgument("-DsocksNonProxyHosts=127.*")
    }

    void stop() {
        socksServer?.stop()
        portFinder.releasePort(port)
    }

    @Override
    String toString() {
        if (port > 0) {
            return "SOCKS proxy: $port"
        } else {
            return "SOCKS (not started)"
        }
    }

                } else {
                    throw e
                }
            }
        }

        FixedAvailablePortAllocator.instance.releasePort(port)
    }

    // We do this to work around an issue in JDK 8 where tools.jar doesn't show up on the classpath and we
    // get a ClassDefNotFound error.
    static def getBootstrapClass() {