connector.useGradleUserHomeDir(context.getGradleUserHomeDir());
            try (ProjectConnection connection = connector.connect()) {
                connection.getModel(BuildEnvironment.class);
            }
        } finally {
            connector.disconnect();
        }
    }

    private GradleScenarioInvoker createScenarioInvoker(File gradleUserHome) {

                read = true;
                return tar;
            }
        }

        @Override
        public FilePermissions getPermissions() {
            return new DefaultFilePermissions(entry.getMode());
        }

        @Override
        protected String getEntryName() {
            return entry.getName();
        }

        @Override
        protected TarArchiveEntry getArchiveEntry() {

            return calculationState.supplier.getOwningProject().getOwner();
        } else {
            return RootScriptDomainObjectContext.INSTANCE.getModel();
        }
    }

    /**
     * Visits the dependencies required to calculate the value.
     */
    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {

        buildProcessState.close();
    }

    /**
     * This is used by consumers 2.1-rc-1 and later
     */
    @Override

                .nagUser();
        }
    }

    private GradleVersion determineTargetGradleVersion(ProjectConnection connection) {
        BuildEnvironment buildEnvironment = connection.getModel(BuildEnvironment.class);
        return GradleVersion.version(buildEnvironment.getGradle().getGradleVersion());
    }

    private static OutputStream teeOutput(OutputStream capture, OutputStream user) {

        for (MavenProject mavenProject : projects) {
            if (!"maven-plugin".equals(mavenProject.getPackaging())) {
                Prerequisites prerequisites =
                        mavenProject.getModel().getDelegate().getPrerequisites();
                if (prerequisites != null && prerequisites.getMaven() != null) {
                    logger.warn(
                            "The project {} uses prerequisites"

        source.getAST().getStatementBlock().visit(transformer);
        for (Object method : source.getAST().getMethods()) {
            MethodNode methodNode = (MethodNode) method;
            methodNode.getCode().visit(transformer);
        }
    }

    public static ClassNode getScriptClass(SourceUnit source) {
        if (source.getAST().getStatementBlock().getStatements().isEmpty() && source.getAST().getMethods().isEmpty()) {

    def propertyWalker = Mock(PropertyWalker)
    def inspectionScheme = Stub(InspectionScheme) {
        getPropertyWalker() >> propertyWalker
    }
    def domainObjectContext = Mock(DomainObjectContext) {
        getModel() >> RootScriptDomainObjectContext.INSTANCE
    }

    def isolatableFactory = new TestIsolatableFactory()
    def classLoaderHierarchyHasher = Mock(ClassLoaderHierarchyHasher)

    public List<Exception> getExceptions() {
        return exceptions;
    }

    @Override
    public Node getRoot() {
        return root;
    }

    @Override
    public List<Node> getNodes() {
        return nodes;
    }

    @Override
    public List<Path> getPaths() {
        return paths;
    }

    @Override
    public Map<PathType, List<Path>> getDispatchedPaths() {

        then:
        concurrent.finished()
    }

    def useToolingApi(ToolingApi target) {
        target.withConnection { ProjectConnection connection ->
            try {
                def model = connection.getModel(IdeaProject)
                assert model != null
                //a bit more stress:
                connection.newBuild().forTasks('tasks').run()
            } catch (Exception e) {