* (And even if annotations on local variables were permitted as an optional hint, no annotation
   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying
   * to get rid of, and {@code @NonNull} would be wrong for our use case for the same reason as
   * {@code requireNonNull}: Our use case is the one in which {@code T} has parametric nullness—and

   * (And even if annotations on local variables were permitted as an optional hint, no annotation
   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying
   * to get rid of, and {@code @NonNull} would be wrong for our use case for the same reason as
   * {@code requireNonNull}: Our use case is the one in which {@code T} has parametric nullness—and

   * (And even if annotations on local variables were permitted as an optional hint, no annotation
   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying
   * to get rid of, and {@code @NonNull} would be wrong for our use case for the same reason as
   * {@code requireNonNull}: Our use case is the one in which {@code T} has parametric nullness—and

   - [artifactId] tells maven what the artifact name is for this particular
       project. Each project should have a distinct artifactId.

   - [version] tells maven what release of this artifact we're trying to produce.
       The fact that a project has a distinct pom.xml should indicate a separate
       release cycle that is also distinct to that project, so a concrete version
       declaration is required.

 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link
 * Iterator#remove} operations. This utility takes the brute-force approach of trying <i>all</i>
 * possible sequences of these operations, up to a given number of steps. So, if the caller
 * specifies to use <i>n</i> steps, a total of <i>3^n</i> tests are actually performed.
 *

    assertEquals(1, map.size());
    assertEquals(ImmutableList.of(1), map.getInstance(type));
  }

  public void testGenericArrayType() {
    @SuppressWarnings("unchecked") // Trying to test generic array
    ImmutableList<Integer>[] array =
        (ImmutableList<Integer>[]) new ImmutableList<?>[] {ImmutableList.of(1)};

    // The task thread waits for the latch, so we expect a timeout here.
    try {
      future.get(20, MILLISECONDS);
      fail("Should have timed out trying to get the value.");
    } catch (TimeoutException expected) {
    } finally {
      latch.countDown();
    }
  }

  /**
   * Tests that a canceled future throws a cancellation exception.
   *

        /**
         * Indicates whether the requested artifact was resolved. Note that the artifact might have been successfully
         * resolved despite {@link #getExceptions()} indicating transfer errors while trying to fetch the artifact from some
         * of the specified remote repositories.
         *
         * @return {@code true} if the artifact was resolved, {@code false} otherwise.
         */
        boolean isResolved();

 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link
 * Iterator#remove} operations. This utility takes the brute-force approach of trying <i>all</i>
 * possible sequences of these operations, up to a given number of steps. So, if the caller
 * specifies to use <i>n</i> steps, a total of <i>3^n</i> tests are actually performed.
 *

  It means warning users that since the network is missing, certain features and
  operations will be unavailable, rather than simply waiting for those
  operations to fail, then trying to help users decipher the error messages they
  get as a result.

* Implications for Resolution

** Dependency Resolution

  This one is obvious...we only have access to the repositories using