// Configure the connector and create the connection
        GradleConnector connector = GradleConnector.newConnector();

        if (args.length > 0) {
            connector.useInstallation(new File(args[0]));
            if (args.length > 1) {
                connector.useGradleUserHomeDir(new File(args[1]));
            }
        }

        connector.forProjectDirectory(new File("."));

    }

    private getModelWithProjectConnection(TestFile rootDir, Class modelType = GradleProject, boolean searchUpwards = true) {
        def connector = connector()
        connector.forProjectDirectory(rootDir)
        connector.searchUpwards(searchUpwards)
        return withConnection(connector) { it.getModel(modelType) }
    }

    }

    static void distributionProgressMessage(connector, String message) {
        connector.distribution = new ConfigurableDistribution(delegate: connector.distribution, operation: { it.description = message })
    }

    static void distributionOperation(connector, Closure operation) {
        connector.distribution = new ConfigurableDistribution(delegate: connector.distribution, operation: operation)
    }

class ToolingApiConnector {
    GradleConnector connector
    private final OutputStream stdout
    private final OutputStream stderr

    ToolingApiConnector(GradleConnector connector, OutputStream stdout, OutputStream stderr) {
        this.stderr = stderr
        this.stdout = stdout
        this.connector = connector
    }

    def connect() {
        new ToolingApiConnection(connector.connect(), stdout, stderr) as ProjectConnection

    }

    def "cannot create new project connection after disconnect"() {
        setup:
        def connector = toolingApi.connector()
        withConnection(connector) { connection ->
            connection.getModel(EclipseProject)
        }
        connector.disconnect()

        when:
        connector.connect()

        then:
        def e = thrown(RuntimeException)

    }

    def <T> T withConnection(@DelegatesTo(ProjectConnection) Closure<T> cl) {
        def connector = connector()
        withConnection(connector, cl)
    }

    def <T> T withConnection(connector, @DelegatesTo(ProjectConnection) Closure<T> cl) {
        return withConnectionRaw(connector, cl)
    }

        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
        server.addConnector(connector)
        try {

        // Configure the connector and create the connection
        GradleConnector connector = GradleConnector.newConnector();

        if (args.length > 0) {
            connector.useInstallation(new File(args[0]));
            if (args.length > 1) {
                connector.useGradleUserHomeDir(new File(args[1]));
            }
        }

        connector.forProjectDirectory(new File("../sample-build"));

    final File projectDir = new File('project-dir')
    final GradleConnector connector = new DefaultGradleConnector(connectionFactory, distributionFactory)

    def canCreateAConnectionGivenAProjectDirectory() {
        DefaultProjectConnection connection = Mock()

        when:
        def result = connector.forProjectDirectory(projectDir).connect()

        then:
        result == connection

        and:

        given:
        startIdleDaemon()
        assert !registry.all.empty

        connector.connector.connect(_ as Address) >> { throw new ConnectException("Problem!", new RuntimeException("foo")) }

        when:
        def connection = connector.maybeConnect( { true } as ExplainingSpec)

        then:
        !connection

        registry.all.empty
    }