this.activations.put(id, settings);
    }

    private Set<String> getProfileIds(final Predicate<ActivationSettings> predicate) {
        return this.activations.entrySet().stream()
                .filter(e -> predicate.test(e.getValue()))
                .map(Map.Entry::getKey)
                .collect(toSet());
    }

    /**

        task.state.rethrowFailure()
    }

    protected static boolean assertHasMatchingCause(Throwable t, Predicate<String> predicate) {
        if (t == null) {
            return false
        }

        def cause = t
        while (true) {
            if (predicate.test(cause.getMessage())) {
                return true
            }
            def nextCause = cause.cause

  }

  /**
   * Waits until the given predicate returns true, invoking the garbage collector as necessary to
   * try to ensure that this will happen.
   *
   * @throws RuntimeException if timed out or interrupted while waiting
   */
  @SuppressWarnings("removal") // b/260137033
  public static void awaitDone(FinalizationPredicate predicate) {
    if (predicate.isDone()) {
      return;
    }

//
// DEPRECATED
// All cloudprovider specific predicates defined here are deprecated in favour of CSI volume limit
// predicate - MaxCSIVolumeCountPred.
//
// The predicate looks for both volumes used directly, as well as PVC volumes that are backed by relevant volume
// types, counts the number of unique volumes, and rejects the new pod if it would place the total count over

    }

    private static boolean anyChildMatches(ChildMap<FileSystemNode> children, Predicate<FileSystemNode> predicate) {
        return children.stream()
            .map(ChildMap.Entry::getValue)
            .anyMatch(predicate);
    }

        private final DescribedPredicate<? super JavaAnnotation<?>> predicate;

        AnnotatedMaybeInSupertypePredicate(DescribedPredicate<? super JavaAnnotation<?>> predicate) {
            super("annotated, maybe in a supertype, with " + predicate.getDescription());
            this.predicate = predicate;
        }

        @Override
        public boolean test(JavaMember input) {

            owner: KaSymbolWithTypeParameters,
        ): Boolean {
            return owner !is KaConstructorSymbol
        }
    }

    public companion object {
        public operator fun invoke(
            predicate: KaSession.(typeParameter: KaTypeParameterSymbol, owner: KaSymbolWithTypeParameters) -> Boolean
        ): KaTypeParameterRendererFilter {
            return object : KaTypeParameterRendererFilter {

import org.gradle.internal.classpath.types.ExternalPluginsInstrumentationTypeRegistry
import org.gradle.internal.classpath.types.InstrumentationTypeRegistry

import java.util.function.Predicate

import static java.util.function.Predicate.isEqual
import static org.gradle.internal.classpath.BasicCallInterceptionTestInterceptorsDeclaration.TEST_GENERATED_CLASSES_PACKAGE

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.jvm.inspection

import spock.lang.Specification

import java.util.function.Predicate

class InvalidJvmInstallationCacheInvalidatorTest extends Specification {
    def 'closing triggers cache invalidation'() {
        def cache = Mock(ConditionalInvalidation<JvmInstallationMetadata>)

        given:

   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#anyMatch} (same).
   */
  public final boolean anyMatch(Predicate<? super E> predicate) {
    return Iterables.any(getDelegate(), predicate);
  }

  /**
   * Returns {@code true} if every element in this fluent iterable satisfies the predicate. If this