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

/**
 * Exception that occurs when an artifact file is used, but has not been resolved.
 *
 * TODO it may be better for artifact.getFile() to throw it - perhaps it is a runtime exception?
 */
public class DependencyResolutionRequiredException extends Exception {
    public DependencyResolutionRequiredException(Artifact artifact) {

        // TODO currently this is first wins, but really we should take the latest by comparing either the
        // snapshot timestamp, or some other timestamp later encoded into the metadata.
        // TODO this needs to be repeated here so the merging doesn't interfere with the written metadata
        //  - we'd be much better having a pristine input, and an ongoing metadata for merging instead

                    result.getMissingArtifacts(),
                    request.getRemoteRepositories());
        }

        // this should never happen since we checked all possible error sources before but better be sure
        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(
                    "Unknown error during artifact resolution, " + request + ", " + result.getExceptions(),

     * Whether the artifact should be added to the classpath depends on other
     * dependency properties.
     *
     * @return if the artifact can be added to the class path
     *
     * @deprecated A value of {@code true} does not mean that the dependency should
     * be placed on the classpath. See {@code JavaPathType} instead for better analysis.
     */
    @Deprecated
    boolean isAddedToClasspath();

      <version>1.0</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>surefire</groupId>
      <artifactId>surefire-booter</artifactId>
      <version>1.1</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>maven</groupId>
      <artifactId>wagon-api</artifactId>

            }
        }
        return null;
    }

    private boolean isSafelyCacheable(RepositorySystemSession session, Artifact artifact) {
        /*
         * The workspace/reactor is in flux so we better not assume definitive information for any of its
         * artifacts/projects.
         */

        WorkspaceReader workspace = session.getWorkspaceReader();
        if (workspace == null) {

 * under the License.
 */
package org.apache.maven.artifact.resolver.filter;

import org.apache.maven.artifact.Artifact;

/**
 * Filter to only retain objects in the given artifactScope or better.
 *
 */
abstract class AbstractScopeArtifactFilter implements ArtifactFilter {

    private boolean compileScope;

    private boolean runtimeScope;

    private boolean testScope;

            // that would happen here should cause the build to fail at a later stage
            // (when actually parsing the POM) and will lead to a better exception being
            // displayed to the user, so just bail out and return false.
        }
        return false;
    }

        return managedVersionMap;
    }

    @Override
    public boolean equals(Object other) {
        if (other == this) {
            return true;
        } else if (!(other instanceof MavenProject)) {
            return false;
        }

        MavenProject that = (MavenProject) other;

        return Objects.equals(getArtifactId(), that.getArtifactId())

                "Inactive only ||${project.basedir}||",
                "<plugin-in-inactive-only>Inactive only ||${project.basedir}||</plugin-in-inactive-only>");
    }

    // Some better conventions for the test poms needs to be created and each of these tests
    // that represent a verification of a specification item needs to be a couple lines at most.