private static final String PLUGIN_MANAGEMENT = "plugin-management";

        public Model merge(Model target, Model source) {
            Build targetBuild = target.getBuild();
            if (targetBuild == null) {
                targetBuild = Build.newInstance();
            }

            Map<Object, Object> context =

            return;
        }
        if (Features.buildConsumer(session.getUserProperties())) {
            Path buildDir =
                    project.getBuild() != null ? Paths.get(project.getBuild().getDirectory()) : null;
            if (buildDir != null) {
                Files.createDirectories(buildDir);
            }
            Path consumer = buildDir != null

     * Generates a name for a task that performs some action on the binary.
     */
    String taskName(String verb, String object);

    /**
     * The task that can be used to assemble this binary.
     */
    Task getBuild();

    /**
     * The task that can be used to check this binary.
     */
    Task getCheck();

    <T extends Task> void create(String name, Class<T> type, Action<? super T> config);

        Project prj = nonNull(project, "project");
        if (nonNull(scope, "scope") == ProjectScope.MAIN) {
            return prj.getBuild().getResources();
        } else if (scope == ProjectScope.TEST) {
            return prj.getBuild().getTestResources();
        } else {
            throw new IllegalArgumentException("Unsupported scope " + scope);
        }
    }

    @Override

            if (project.hasLifecyclePhase("test-compile")) {
                return new File(project.getBuild().getTestOutputDirectory());
            }
        } else {
            String type = artifact.getProperty("type", "");
            File outputDirectory = new File(project.getBuild().getOutputDirectory());

            // Check if the project is being built during this session, and if we can expect any output.

        private final Spec<Task> filter;

        public Filter(BuildState build, Spec<Task> filter) {
            this.build = build;
            this.filter = filter;
        }

        public BuildState getBuild() {
            return build;
        }

        public Spec<Task> getFilter() {
            return filter;
        }
    }

    @Override
    public void expandPluginConfiguration(Model model, ModelBuildingRequest request, ModelProblemCollector problems) {
        Build build = model.getBuild();

        if (build != null) {
            expand(build.getPlugins());

            PluginManagement pluginManagement = build.getPluginManagement();

            if (pluginManagement != null) {

    @Override
    public String taskName(String verb, String object) {
        return verb + StringUtils.capitalize(binary.getProjectScopedName()) + StringUtils.capitalize(object);
    }

    @Override
    public Task getBuild() {
        return binary.getBuildTask();
    }

    @Override
    public Task getCheck() {
        return binary.getCheckTask();
    }

    public <T extends Task> T findSingleTaskWithType(Class<T> type) {

        assertNotNull(result.getEffectiveModel());
        assertEquals("activated", result.getEffectiveModel().getProperties().get("profile.file"));
        Xpp3Dom conf = (Xpp3Dom)
                result.getEffectiveModel().getBuild().getPlugins().get(0).getConfiguration();
        assertNotNull(conf);
        assertEquals("1.5", conf.getChild("source").getValue());
        assertEquals("  1.5  ", conf.getChild("target").getValue());
    }

            return new org.gradle.operations.dependencies.variants.ProjectComponentIdentifier() {
                @Override
                public String getBuildPath() {
                    return projectComponentIdentifier.getBuild().getBuildPath();
                }

                @Override
                public String getProjectPath() {
                    return projectComponentIdentifier.getProjectPath();
                }