}

      @Override
      public boolean remove(@Nullable Object object) {
        return object != null && Collections2.safeRemove(delegate, object);
      }

      @Override
      public boolean removeAll(Collection<?> c) {
        return standardRemoveAll(c);
      }
    };
  }

  @Override
  Iterator<E> elementIterator() {
    throw new AssertionError("should never be called");
  }

  /**

   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final boolean removeAll(Collection<?> oldElements) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the collection unmodified.
   *

          }
        };
      }

      @Override
      public Collection<V> values() {
        return new Maps.Values<Range<K>, V>(this) {
          @Override
          public boolean removeAll(Collection<?> c) {
            return removeEntryIf(compose(in(c), Entry::getValue));
          }

          @Override
          public boolean retainAll(Collection<?> c) {

			// Add deadlines such that immediate purge is not
			// perpetually hung here.
			w := xioutil.NewDeadlineWorker(globalDriveConfig.GetMaxTimeout())
			w.Run(func() error {
				return removeAll(entry)
			})
		}
	}
}

const almostFilledPercent = 0.05

func (s *xlStorage) diskAlmostFilled() bool {
	info, err := s.diskInfoCache.Get()
	if err != nil {
		return false

  // Inheritance is closed, and all subtypes are @DoNotCall, so this is safe to suppress.
  @SuppressWarnings("DoNotCall")
  public ImmutableCollection<V> removeAll(@Nullable Object key) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the multimap unmodified.
   *
   * @throws UnsupportedOperationException always

  // Inheritance is closed, and all subtypes are @DoNotCall, so this is safe to suppress.
  @SuppressWarnings("DoNotCall")
  public ImmutableCollection<V> removeAll(@Nullable Object key) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the multimap unmodified.
   *
   * @throws UnsupportedOperationException always

    builder = builder.add("", Instant.EPOCH)
    builder = builder.set("", "")
    builder = builder.set("", Date(0L))
    builder = builder.set("", Instant.EPOCH)
    builder = builder.removeAll("")
    val get: String? = builder[""]
    val headers: Headers = builder.build()
  }

  @Test
  fun httpLoggingInterceptor() {
    var interceptor: HttpLoggingInterceptor = HttpLoggingInterceptor()

	siteNames := rreq.SiteNames
	updatedPeers := make(map[string]madmin.PeerInfo)

	for _, pi := range info.Sites {
		updatedPeers[pi.DeploymentID] = pi
		peerMap[pi.Name] = pi
		if rreq.RemoveAll {
			siteNames = append(siteNames, pi.Name)
		}
	}
	for _, s := range siteNames {
		pinfo, ok := peerMap[s]
		if !ok {
			return st, errSRConfigMissingError(errMissingSRConfig)
		}

    assertThrows(UnsupportedOperationException.class, () -> values.add("4"));
    assertThrows(UnsupportedOperationException.class, () -> values.remove("four"));
    assertThrows(UnsupportedOperationException.class, () -> values.removeAll(singleton("four")));
    assertThrows(UnsupportedOperationException.class, () -> values.retainAll(singleton("four")));
    assertThrows(
        UnsupportedOperationException.class,
        () -> {

   * @param elementsToRemove the elements to remove
   * @return {@code true} if any element was removed from {@code iterator}
   */
  @CanIgnoreReturnValue
  public static boolean removeAll(Iterator<?> removeFrom, Collection<?> elementsToRemove) {
    checkNotNull(elementsToRemove);
    boolean result = false;
    while (removeFrom.hasNext()) {
      if (elementsToRemove.contains(removeFrom.next())) {