return Collections.emptySet();
  }

  protected Collection<Method> suppressForUnmodifiableMap() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForUnmodifiableSortedMap() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEnumMap() {
    return Collections.emptySet();
  }

    return Collections.emptySet();
  }

  protected Collection<Method> suppressForCheckedSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForCheckedSortedSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForAbstractSet() {
    return Collections.emptySet();
  }

  }

  private Collection<Method> suppressForEmptyNavigableMap() {
    return Collections.emptySet();
  }

  private Collection<Method> suppressForEmptySortedMap() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForSingletonMap() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForHashMap() {
    return Collections.emptySet();
  }

    StringBuilder sb = newStringBuilderForCollection(collection.size()).append('[');
    boolean first = true;
    for (Object o : collection) {
      if (!first) {
        sb.append(", ");
      }
      first = false;
      if (o == collection) {
        sb.append("(this Collection)");
      } else {
        sb.append(o);
      }
    }
    return sb.append(']').toString();

    assertEquals(Collections.emptyList(), list);
  }

  public void testNewLinkedListFromCollection() {
    LinkedList<Integer> list = Lists.newLinkedList(SOME_COLLECTION);
    assertEquals(SOME_COLLECTION, list);
  }

  public void testNewLinkedListFromIterable() {
    LinkedList<Integer> list = Lists.newLinkedList(SOME_ITERABLE);
    assertEquals(SOME_COLLECTION, list);
  }

  @J2ktIncompatible

  }

  protected Collection<Method> suppressForSingletonSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForHashSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForLinkedHashSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEnumSet() {
    return Collections.emptySet();
  }

    assertEquals(Collections.emptyList(), list);
  }

  public void testNewLinkedListFromCollection() {
    LinkedList<Integer> list = Lists.newLinkedList(SOME_COLLECTION);
    assertEquals(SOME_COLLECTION, list);
  }

  public void testNewLinkedListFromIterable() {
    LinkedList<Integer> list = Lists.newLinkedList(SOME_ITERABLE);
    assertEquals(SOME_COLLECTION, list);
  }

  @J2ktIncompatible

    Iterable<String> iterable = Collections.singletonList("foo");
    assertEquals("foo", Iterables.getLast(iterable, "bar"));
  }

  public void testGetLast_withDefault_empty() {
    Iterable<String> iterable = Collections.emptyList();
    assertEquals("bar", Iterables.getLast(iterable, "bar"));
  }

  public void testGetLast_withDefault_empty_null() {
    Iterable<String> iterable = Collections.emptyList();

                .getOrDefault(artifact.getGroupId(), Collections.emptyMap())
                .getOrDefault(artifact.getArtifactId(), Collections.emptyMap())
                .values()
                .stream()
                .map(MavenProject::getVersion)
                .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
        if (!versions.isEmpty()) {

            Collections.synchronizedMap(new WeakHashMap<>());
    private final Map<org.eclipse.aether.artifact.Artifact, Artifact> allArtifacts =
            Collections.synchronizedMap(new WeakHashMap<>());
    private final Map<org.eclipse.aether.repository.RemoteRepository, RemoteRepository> allRepositories =
            Collections.synchronizedMap(new WeakHashMap<>());