/**
 * Builds consumer POMs from project models, transforming them into a format suitable for downstream consumers.
 * <p>
 * A consumer POM is a simplified version of a project's POM that is published for consumption by other projects.
 * It removes build-specific information and internal details while preserving essential information like
 * dependencies, repositories, and distribution management.
 * <p>

    - [Other notable changes](#other-notable-changes-5)
- [v1.2.1](#v121)
  - [Downloads for v1.2.1](#downloads-for-v121)
  - [Changes since v1.2.0](#changes-since-v120)
    - [Other notable changes](#other-notable-changes-6)
- [v1.2.0](#v120)
  - [Downloads for v1.2.0](#downloads-for-v120)
  - [Changes since v1.1.1](#changes-since-v111)
    - [Major Themes](#major-themes)
    - [Other notable improvements](#other-notable-improvements)

    /**
     * Returns the file paths of all dependencies, regardless of which tool option those paths should be placed on.
     * The returned list may contain a mix of Java class path, Java module path, and other types of path elements.
     * This collection has the same content as {@code getDependencies.values()} except that it does not contain
     * null elements.
     *
     * @return the paths of all dependencies
     */

# relevant variables in their environment. Because of 'set -o allexport' above
# (which is equivalent to "set -a"), every variable in the file is exported
# for other files to use.
#
# Separately, if TFCI is set *and* there are also additional TFCI_ variables
# set in the shell environment, those variables will be restored after the
# TFCI env has been loaded. This is useful for e.g. on-demand "generic" jobs

   * {@link MoreExecutors#directExecutor}. Normally, when the first future completes, all the other
   * tasks would be called recursively. Here, we detect that the delegate executor is executing
   * inline, and maintain a queue to dispatch tasks iteratively. There is one instance of this class
   * per call to submit() or submitAsync(), and each instance supports only one call to execute().
   *

        SmbResourceLocatorImpl child = locator("smb://server/share/dir/file");
        assertTrue(base.overlaps(child));

        SmbResourceLocatorImpl other = locator("smb://server/share/other");
        assertFalse(base.overlaps(other));
    }

    @Test
    @DisplayName("isRoot and isRootOrShare reflect path state")
    void testIsRootAndShare() {
        assertTrue(locator("smb://server/").isRoot());

   * rate is applied to networking (limiting bandwidth), where past underutilization typically
   * translates to "almost empty buffers", which can be filled immediately.
   *
   * On the other hand, past underutilization could mean that "the server responsible for handling
   * the request has become less ready for future requests", i.e. its caches become stale, and

 *   <li>To wrap nullable references for storage in a collection that does not support {@code null}
 *       (though there are <a
 *       href="https://github.com/google/guava/wiki/LivingWithNullHostileCollections">several other
 *       approaches to this</a> that should be considered first)
 * </ul>
 *
 * <p>A common alternative to using this class is to find or create a suitable <a

    @CanIgnoreReturnValue
    Builder<R, C, V> combine(Builder<R, C, V> other) {
      this.cells.addAll(other.cells);
      return this;
    }

    /**
     * Returns a newly-created immutable table.
     *
     * <p>Prefer the equivalent method {@link #buildOrThrow()} to make it explicit that the method
     * will throw an exception if there are duplicate key pairs. The {@code build()} method will
     * soon be deprecated.

    List<String> alreadyThere = Lists.newArrayList("already", "there");

    boolean changed = Iterators.addAll(alreadyThere, Iterators.<String>emptyIterator());
    assertThat(alreadyThere).containsExactly("already", "there").inOrder();
    assertFalse(changed);
  }

  public void testAddAllToList() {
    List<String> alreadyThere = Lists.newArrayList("already", "there");