}

    private void addCleanRule(Project project) {
        project.getTasks().addRule(new CleanRule(project.getTasks()));
    }

    private void addAssemble(Project project) {
        project.getTasks().register(ASSEMBLE_TASK_NAME, assembleTask -> {
            assembleTask.setDescription("Assembles the outputs of this project.");

        project.getTasks().create("noIsolation", WorkerTask.class);

        project.getTasks().create("classloaderIsolation", WorkerTask.class, new Action<WorkerTask>() {
            @Override
            public void execute(WorkerTask workerTask) {
                workerTask.setIsolationMode(IsolationMode.CLASSLOADER);
            }
        });

            @SuppressWarnings("deprecation")
            public void run() {
                project.getConvention().getPlugins().put("projectReports", convention);
            }
        });

        project.getTasks().register(TASK_REPORT, TaskReportTask.class, taskReportTask -> {

        }
    }

    private static Set<String> getTaskNames(ProjectInternal project) {
        return project.getTasks().getNames();
    }

    private static boolean hasTask(String taskName, ProjectInternal project) {
        return project.getTasks().getNames().contains(taskName) || project.getTasks().findByName(taskName) != null;
    }

    }

    @Override
    public void apply(Project target) {
        project = target;
        String lifecycleTaskName = getLifecycleTaskName();
        lifecycleTask = target.getTasks().register(lifecycleTaskName);
        cleanTask = target.getTasks().register(cleanName(lifecycleTaskName), Delete.class, new Action<Delete>() {
            @Override
            public void execute(Delete task) {
                task.setGroup("IDE");

            it.delete(project.getTasks().withType(GenerateProjectFileTask.class));
        });
    }

    private Task createSolutionTask(VisualStudioSolution solution) {
        GenerateSolutionFileTask solutionFileTask = project.getTasks().create(solution.getName() + "VisualStudioSolution", GenerateSolutionFileTask.class);
        solutionFileTask.setVisualStudioSolution(solution);

        getCleanTask().configure(withDescription("Cleans Eclipse wtp configuration files."));

        project.getTasks().named(EclipsePlugin.ECLIPSE_TASK_NAME, dependsOn(getLifecycleTask()));
        project.getTasks().named(cleanName(EclipsePlugin.ECLIPSE_TASK_NAME), dependsOn(getCleanTask()));

        EclipseModel model = project.getExtensions().getByType(EclipseModel.class);

import spock.lang.Specification

class TaskNameResolverTest extends Specification {
    def tasks = Mock(TaskContainerInternal)
    def project = Mock(ProjectInternal)

    def setup() {
        _ * project.getTasks() >> tasks
    }

    private final TaskNameResolver resolver = new TaskNameResolver()

    def "eagerly locates task with given name for single project"() {
        def task = task('task')

        when:

            import ${Map.name};
            import ${LinkedHashMap.name};

            public class SomePlugin implements Plugin<Project> {
                public void apply(Project project) {
                    project.getTasks().register("someTask", SomeTask.class, t -> {
                        t.getFlag().set(true);
                        t.getMessage().set("some value");
                        t.getNumber().set(1.23);

            task.getArchiveBaseName().convention(extension.getArchivesName());
        });
    }

    private void configureBuildConfigurationRule(Project project) {
        project.getTasks().addRule(new BuildConfigurationRule(project.getConfigurations(), project.getTasks()));
    }

    private void configureConfigurations(final Project project) {