for (Plugin plugin : plugins) {
            if (plugin.getGroupId() == null
                    || (plugin.getGroupId() != null
                            && plugin.getGroupId().trim().isEmpty())) {
                addViolation(
                        problems,
                        Severity.FATAL,
                        Version.V20,
                        prefix + prefix2 + "(groupId:artifactId)",

        multimap.asMap().entrySet(), immutableEntry(sampleKey, sampleValueAsCollection));

    // Test #values()

    assertMultimapRemainsUnmodified(multimap, originalEntries);
    if (!multimap.isEmpty()) {
      Collection<V> values = multimap.asMap().entrySet().iterator().next().getValue();

      assertCollectionIsUnmodifiable(values, sampleValue);
    }

    // Test #entries()

 * may be equal only if at least one of the bounds is closed:
 *
 * <ul>
 *   <li>{@code [a..a]} : a singleton range
 *   <li>{@code [a..a); (a..a]} : {@linkplain #isEmpty empty} ranges; also valid
 *   <li>{@code (a..a)} : <b>invalid</b>; an exception will be thrown
 * </ul>
 *
 * <h3>Warnings</h3>
 *
 * <ul>

                    .append(" (")
                    .append(localRepository.getBasedir())
                    .append(")");
        }

        if (remoteRepositories != null && !remoteRepositories.isEmpty()) {
            for (RemoteRepository repository : remoteRepositories) {
                repos.append(", ");

                if (repository != null) {
                    repos.append(repository.getId())

    MavenArtifact(String repositoryUrl, Resource resource) {
        if (repositoryUrl == null) {
            this.repositoryUrl = "";
        } else if (!repositoryUrl.endsWith("/") && !repositoryUrl.isEmpty()) {
            this.repositoryUrl = repositoryUrl + '/';
        } else {
            this.repositoryUrl = repositoryUrl;
        }
        this.resource = resource;

    private static final String WORKSPACE = "WORKSPACE";

    @Override
    public Optional<CIInfo> detectCI() {
        String workspace = System.getenv(WORKSPACE);
        if (workspace != null && !workspace.trim().isEmpty()) {
            return Optional.of(new CIInfo() {
                @Override
                public String name() {
                    return NAME;
                }
            });
        }

      JdkBackedImmutableMultiset.create(ImmutableList.of());

  RegularImmutableMultiset() {}

  static <E> ImmutableMultiset<E> create(Collection<? extends Entry<? extends E>> entries) {
    if (entries.isEmpty()) {
      return ImmutableMultiset.of();
    } else {
      return JdkBackedImmutableMultiset.create(entries);
    }
  }

  @Override
  public int count(@Nullable Object element) {

    this.queue = checkNotNull(queue);
  }

  @Override
  protected @Nullable T computeNext() {
    // TODO(b/192579700): Use a ternary once it no longer confuses our nullness checker.
    if (queue.isEmpty()) {
      return endOfData();
    }
    return queue.remove();
  }

        DfsReferral dr = new DfsReferral();
        dr.pathConsumed = path.length();

        dfs.insert(path, dr);

        assertNotNull(dfs.referrals);
        assertFalse(dfs.referrals.map.isEmpty());
        String key = "\\server\\share\\folder";
        assertTrue(dfs.referrals.map.containsKey(key.toLowerCase()));
    }

    @Test
    void testInsert_WithTrailingSlash() {

    Set<MethodSignature> found = getAllFauxveridden(descendant, ancestor);
    Set<MethodSignature> missing = ImmutableSortedSet.copyOf(difference(required, found));
    if (!missing.isEmpty()) {
      fail(
          rootLocaleFormat(
              "%s should hide the public static methods declared in %s: %s",
              descendant.getSimpleName(), ancestor.getSimpleName(), missing));
    }
  }