&& session.getProjects().size() > 1) {
            final Set<Plugin> unsafePlugins = executionPlan.getNonThreadSafePlugins();
            if (!unsafePlugins.isEmpty()) {
                for (String s : MultilineMessageHelper.format(
                        "Your build is requesting parallel execution, but this project contains the following "

            String str1 = request.getClassifier();
            String classifier = str1 != null && !str1.isEmpty()
                    ? request.getClassifier()
                    : type != null ? type.getClassifier() : "";
            String str = request.getExtension();
            String extension =
                    str != null && !str.isEmpty() ? request.getExtension() : type != null ? type.getExtension() : "";

    }

    public void setMojos(List<LifecycleMojo> mojos) {
        this.mojos = mojos;
    }

    public void set(String goals) {
        mojos = new ArrayList<>();

        if (goals != null && !goals.isEmpty()) {
            String[] mojoGoals = goals.split(",");
            mojos = Arrays.stream(mojoGoals).map(fromGoalIntoLifecycleMojo).collect(Collectors.toList());
        }
    }

    public void extend(MavenExecutionRequest mavenExecutionRequest) {
        Map<String, PropertyContributor> effectivePropertyContributors = lookup.lookupMap(PropertyContributor.class);
        if (!effectivePropertyContributors.isEmpty()) {
            HashMap<String, String> userPropertiesMap = new HashMap<>((Map) mavenExecutionRequest.getUserProperties());
            for (PropertyContributor contributor : effectivePropertyContributors.values()) {

                    .append(" (")
                    .append(localRepository.getBasedir())
                    .append(")");
        }

        if (remoteRepositories != null && !remoteRepositories.isEmpty()) {
            for (RemoteRepository repository : remoteRepositories) {
                repos.append(", ");

                if (repository != null) {
                    repos.append(repository.getId())

        // it means that we have "old" settings (as those are new in 4.0)
        // so add central to the computed settings for backward compatibility.
        if (effective.getRepositories().isEmpty()
                && effective.getPluginRepositories().isEmpty()) {
            Repository central = Repository.newBuilder()
                    .id("central")
                    .name("Central Repository")

    }

    public MavenExecutionResult addException(Throwable t) {
        exceptions.add(t);

        return this;
    }

    public boolean hasExceptions() {
        return !getExceptions().isEmpty();
    }

    public BuildSummary getBuildSummary(MavenProject project) {
        return buildSummaries.get(project);
    }

    public void addBuildSummary(BuildSummary summary) {

            throws MetadataGraphTransformationException {
        try {
            if (dirtyGraph == null || dirtyGraph.isEmpty()) {
                return null;
            }

            MetadataGraph cleanGraph = conflictResolver.resolveConflicts(dirtyGraph, scope);

            if (cleanGraph == null || cleanGraph.isEmpty()) {
                return null;
            }

            ClasspathContainer cpc = new ClasspathContainer(scope);

        } else {
            return "";
        }
    }

    @Override
    public boolean isMavenVersion(String versionRange) {
        if (Objects.requireNonNull(versionRange, "versionRange cannot be null").isEmpty()) {
            throw new IllegalArgumentException("versionRange cannot be empty");
        }

        VersionConstraint constraint;
        try {

        if (properties.containsKey(REMAINING_PROJECTS) && !(str1 != null && !str1.isEmpty())) {
            String propertyValue = properties.getProperty(REMAINING_PROJECTS);
            Stream.of(propertyValue.split(PROPERTY_DELIMITER))
                    .filter(str -> str != null && !str.isEmpty())
                    .forEach(request.getProjectActivation()::activateOptionalProject);