It is more than simply understanding that m2 cannot go and check for the
  latest version of some snapshot artifact. If m2 is offline, SCM operations
  cannot succeed; no artifact downloads can take place, regardless of whether
  they are snapshot versions; artifact deployment cannot take place; certain
  types of tests cannot be setup, since the container used to run them cannot be

        Path target = getArtifactPath(artifact);
        return Files.isRegularFile(target) ? target.toFile() : null;
    }

    /**
     * We are interested in project success events, in which case we call
     * the {@link #installIntoProjectLocalRepository(MavenProject)} method.
     * The mojo started event is also captured to determine the lifecycle
     * phases the project has been through.

        <field>
          <name>sendOnSuccess</name>
          <version>4.0.0+</version>
          <defaultValue>true</defaultValue>
          <type>boolean</type>
          <description>Whether to send notifications on success.</description>
        </field>
        <field>
          <name>sendOnWarning</name>
          <version>4.0.0+</version>
          <defaultValue>true</defaultValue>
          <type>boolean</type>

    }

    /**
     * Append message content in success style.
     * By default, bold green
     *
     * @param message the message to append
     * @return the current builder
     */
    @Nonnull
    default MessageBuilder success(Object message) {
        return style(".success:-bold,f:green", message);
    }

    /**
     * Append message content in failure style.

        assertThrows(
                ArtifactNotFoundException.class,
                () -> artifactResolver.resolve(k, remoteRepositories(), localRepository()),
                "Resolution succeeded when it should have failed");
    }

    @Test
    void testResolutionOfAnArtifactWhereOneRemoteRepositoryIsBadButOneIsGood() throws Exception {
        Artifact l = createRemoteArtifact("l", "1.0-SNAPSHOT");

        boolean success = true;
        if (filter != null) {
            for (Artifact artifact : getTrail()) {
                if (!filter.include(artifact)) {
                    success = false;
                }
            }
        }
        return success;
    }

    @Override
    public String toString() {

    SESSION_STARTED,
    SESSION_ENDED,
    PROJECT_SKIPPED,
    PROJECT_STARTED,
    PROJECT_SUCCEEDED,
    PROJECT_FAILED,
    MOJO_SKIPPED,
    MOJO_STARTED,
    MOJO_SUCCEEDED,
    MOJO_FAILED,
    FORK_STARTED,
    FORK_SUCCEEDED,
    FORK_FAILED,
    FORKED_PROJECT_STARTED,
    FORKED_PROJECT_SUCCEEDED,
    FORKED_PROJECT_FAILED,

                    } catch (ChecksumFailedException e) {
                        // if we catch a ChecksumFailedException, it means the transfer/read succeeded, but the
                        // checksum doesn't match. This could be a problem with the server (ibiblio HTTP-200 error

 */
public class Result<T> {

    /**
     * Success without warnings
     *
     * @param model
     */
    public static <T> Result<T> success(T model) {
        return success(model, Collections.emptyList());
    }

    /**
     * Success with warnings
     *
     * @param model
     * @param problems
     */
    public static <T> Result<T> success(T model, Iterable<? extends ModelProblem> problems) {

     * source MUST BE relative from the {@link RemoteRepository#getUrl()} root.
     *
     * @return {@code true} if operation succeeded, {@code false} if source does not exist.
     * @throws RuntimeException If failed (and not due source not exists).
     */
    boolean get(@Nonnull URI relativeSource, @Nonnull Path target);

    /**