projectStream.wait(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        try {
                            projectOs.writeTo(originalSystemOUtStream);
                        } catch (IOException e) {
                            throw new RuntimeException(e);
                        }

 * under the License.
 */
package org.apache.maven.project;

import org.apache.maven.artifact.Artifact;

/**
 * This exception is thrown if an application attempts to attach
 * two of the same artifacts to a single project.
 *
 * TODO Make this a checked exception, and modify the API of MavenProjectHelper.
 * Currently, this modification would create compatibility problems for existing plugins.

        if (!(o instanceof ProjectBuildingResult)) {
            return false;
        }

        final ProjectBuildingResult r = (ProjectBuildingResult) o;

        return r.getProblems().stream().anyMatch(p -> p.getMessage().contains(problemMessage));
    }

    @Override
    public void describeTo(Description description) {
        description.appendText("a ProjectBuildingResult with message ").appendValue(problemMessage);

            try {
                String version = resolveVersion(artifact, request);
                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

                    ClassRealm classRealm = world.newRealm(realmId, null);

                    logger.debug("Created new class realm {}", realmId);

                    return classRealm;
                } catch (DuplicateRealmException e) {
                    realmId = id + '-' + random.nextInt();
                }
            }
        }
    }

    public ClassRealm getMavenApiRealm() {

                    new InstallRequest().setArtifacts(session.toArtifacts(request.getArtifacts()));

            InstallResult result = repositorySystem.install(session.getSession(), installRequest);
        } catch (InstallationException e) {
            throw new ArtifactInstallerException(e.getMessage(), e);
        }
    }

                    .setArtifacts(session.toArtifacts(artifacts));

            DeployResult result = session.getRepositorySystem().deploy(session.getSession(), deployRequest);
        } catch (DeploymentException e) {
            throw new ArtifactDeployerException("Unable to deploy artifacts", e);
        }
    }

            ArtifactVersion version2 = node2.getArtifact().getSelectedVersion();

            return version1.compareTo(version2) <= 0 ? node1 : node2;
        } catch (OverConstrainedVersionException exception) {
            // TODO log message or throw exception?

            return null;
        }
    }

                            session, reactorContext, projectBuild.getProject(), taskSegment);
                    if (reactorBuildStatus.isHalted()) {
                        break;
                    }
                } catch (Exception e) {
                    break; // Why are we just ignoring this exception? Are exceptions are being used for flow control
                }
            }
        }
    }

        return context.getValue(expression) != null;
    }

    public Object getValue(String expression) {
        try {
            return context.getValue(expression);
        } catch (JXPathNotFoundException e) {
            return null;
        }
    }

    public boolean xPathExpressionEqualsValue(String expression, String value) {
        return context.getValue(expression) != null