if (includeTestDir) {
            String d = getBuild().getTestOutputDirectory();
            if (d != null) {
                list.add(d);
            }
        }
        String d = getBuild().getOutputDirectory();
        if (d != null) {
            list.add(d);
        }
        for (Artifact a : getArtifacts()) {
            final File f = a.getFile();

        basicToolchains.add(basicToolchainModel);
        basicToolchains.add(basicToolchainModel);
        groupedToolchains.put("basic", basicToolchains);

        List<ToolchainModel> rareToolchains = new ArrayList<>();
        ToolchainModel rareToolchainModel = new ToolchainModel();
        rareToolchainModel.setType("rare");
        rareToolchains.add(rareToolchainModel);

    public void setSource(String source) {
        this.source = source;
    }

    @Override
    public void add(Problem.Severity severity, String message, int line, int column, Exception cause) {
        Problem problem = new DefaultProblem(message, severity, source, line, column, cause);

        problems.add(problem);
    }

        this();
        this.metadata = metadata;
    }

    public MetadataGraphNode addIncident(MetadataGraphNode node) {
        inNodes.add(node);
        return this;
    }

    public MetadataGraphNode addExident(MetadataGraphNode node) {
        exNodes.add(node);
        return this;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;

class Graph {

    final Map<String, Set<String>> graph = new LinkedHashMap<>();

    synchronized void addEdge(String from, String to) throws CycleDetectedException {
        if (graph.computeIfAbsent(from, l -> new HashSet<>()).add(to)) {
            List<String> cycle = visitCycle(graph, Collections.singleton(to), new HashMap<>(), new LinkedList<>());
            if (cycle != null) {
                // remove edge which introduced cycle

            if (pluginDeclaration != null) {
                pluginDeclarations.add(pluginDeclaration);
            }
            pluginIssues
                    .computeIfAbsent(issueLocality, k -> new LinkedHashSet<>())
                    .add(issue);
        }

        private synchronized void reportPluginMojoIssue(

        ArrayList<Artifact> result = new ArrayList<>(2);
        result.add(session.getArtifact(pomArtifact));
        if (!ArtifactIdUtils.equalsVersionlessId(pomArtifact, projectArtifact)) {
            result.add(session.getArtifact(projectArtifact));
        }
        return Collections.unmodifiableList(result);
    }

    @Nonnull
    @Override

    }

    private void getDownstreamProjects(String projectId, Set<String> projectIds, boolean transitive) {
        for (String id : sorter.getDependents(projectId)) {
            if (projectIds.add(id) && transitive) {
                getDownstreamProjects(id, projectIds, transitive);
            }
        }
    }

    public List<MavenProject> getUpstreamProjects(MavenProject project, boolean transitive) {

        }

        if (!d.getExclusions().isEmpty()) {
            List<String> exclusions = new ArrayList<>();

            for (Exclusion exclusion : d.getExclusions()) {
                exclusions.add(exclusion.getGroupId() + ':' + exclusion.getArtifactId());
            }

            artifact.setDependencyFilter(new ExcludesArtifactFilter(exclusions));
        }

        return artifact;
    }

            }

            if (build.getFilters() != null) {
                List<String> filters = new ArrayList<>();
                for (String filter : build.getFilters()) {
                    filters.add(alignToBaseDirectory(filter, basedir));
                }
                build.setFilters(filters);
            }

            build.setOutputDirectory(alignToBaseDirectory(build.getOutputDirectory(), basedir));