K k = (K) key;
      return keyPredicate.apply(k);
    }
    return false;
  }

  @Override
  public Collection<V> removeAll(@CheckForNull Object key) {
    return containsKey(key) ? unfiltered.removeAll(key) : unmodifiableEmptyCollection();
  }

  Collection<V> unmodifiableEmptyCollection() {
    if (unfiltered instanceof SetMultimap) {
      return emptySet();
    } else {

        Map<String, CtClass> oldInterfaces = collectImplementedInterfaces(oldClass)
        Map<String, CtClass> newInterfaces = collectImplementedInterfaces(newClass)

        newInterfaces.keySet().removeAll(oldInterfaces.keySet())

        if (newInterfaces.isEmpty()) {
            return null
        }

        List<String> changes = filterChangesToReport(newClass, newInterfaces)
        if (changes.isEmpty()) {

 * already in the multimap has no effect. This interface does not specify the ordering of the
 * multimap's keys. See the {@link Multimap} documentation for information common to all multimaps.
 *
 * <p>The {@link #get}, {@link #removeAll}, and {@link #replaceValues} methods each return a {@link
 * SortedSet} of values, while {@link Multimap#entries()} returns a {@link Set} of map entries.

                  return map.entrySet().containsAll(c);
                }

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

                @Override
                public boolean retainAll(Collection<?> c) {
                  return map.entrySet().retainAll(c);

      return standardContainsAll(collection);
    }

    @Override
    public boolean remove(Object object) {
      return standardRemove(object);
    }

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

    @Override
    public boolean retainAll(Collection<?> collection) {
      return standardRetainAll(collection);
    }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testEntrySet_removeAllPresent() {
    assertTrue(
        "multiset.entrySet.removeAll(presentEntry) returned false",
        getMultiset().entrySet().removeAll(singleton(Multisets.immutableEntry(e0(), 1))));
    assertFalse("multiset contains element after removing its entry", getMultiset().contains(e0()));
  }

    testers.add(SetEqualsTester.class);
    testers.add(SetRemoveTester.class);
    // SetRemoveAllTester doesn't exist because, Sets not permitting
    // duplicate elements, there are no tests for Set.removeAll() that aren't
    // covered by CollectionRemoveAllTester.
    return testers;
  }

  @Override
  protected List<TestSuite> createDerivedSuites(

  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveAllPropagatesToMultimap() {
    assertTrue(multimap().entries().removeAll(singleton(mapEntry(k0(), v0()))));
    expectMissing(mapEntry(k0(), v0()));
    assertEquals(getNumElements() - 1, multimap().size());
    assertFalse(multimap().containsEntry(k0(), v0()));
  }

func TestIsReqAuthenticated(t *testing.T) {
	ctx, cancel := context.WithCancel(GlobalContext)
	defer cancel()

	objLayer, fsDir, err := prepareFS(ctx)
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(fsDir)
	if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {
		t.Fatalf("unable initialize config file, %s", err)
	}

	initAllSubsystems(ctx)

	initConfigSubsystem(ctx, objLayer)

                val isAtLeastGroovy4 = VersionNumber.parse(groovyVersion).major >= 4
                val groovyGroup = if (isAtLeastGroovy4) "org.apache.groovy" else "org.codehaus.groovy"
                removeAll { it.group == groovyGroup }
                add("$groovyGroup:groovy") {
                    version { prefer(groovyVersion) }
                    because("We use the packaged groovy")
                }