CALL 'public final fun takeUnless <T> (predicate: kotlin.Function1<T of kotlin.takeUnless, kotlin.Boolean>): T of kotlin.takeUnless? [inline] declared in kotlin' type=kotlin.String? origin=null
                  <T>: kotlin.String
                  $receiver: GET_VAR 'p0: kotlin.String declared in <root>.CodeFragment.run' type=kotlin.String origin=null

    public List<Failure> getCauses() {
        return causes;
    }

    @Override
    public int indexOfStackFrame(int fromIndex, StackFramePredicate predicate) {
        int size = stackTrace.size();
        for (int i = fromIndex; i < size; i++) {
            if (predicate.test(stackTrace.get(i), getStackTraceRelevance(i))) {
                return i;
            }
        }
        return -1;
    }

// integer exit status that satisfies predicate, and emitting error output
// that matches regex.
# define ASSERT_EXIT(statement, predicate, regex) \
    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)

// Like ASSERT_EXIT, but continues on to successive tests in the
// test case, if any:
# define EXPECT_EXIT(statement, predicate, regex) \

// integer exit status that satisfies predicate, and emitting error output
// that matches regex.
# define ASSERT_EXIT(statement, predicate, regex) \
    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)

// Like ASSERT_EXIT, but continues on to successive tests in the
// test case, if any:
# define EXPECT_EXIT(statement, predicate, regex) \

import org.gradle.internal.os.OperatingSystem;
import org.gradle.jvm.toolchain.internal.JvmInstallationMetadataMatcher;

import java.io.File;
import java.util.Comparator;
import java.util.Optional;
import java.util.function.Predicate;

public class DaemonJavaToolchainQueryService {

    private final JavaInstallationRegistry javaInstallationRegistry;
    private final File currentJavaHome;

		// getResp.Count counts in objects that do not match the pred.
		// Instead of returning inaccurate count for non-empty selectors, we return nil.
		// Only set remainingItemCount if the predicate is empty.
		if opts.Predicate.Empty() {
			c := int64(getResp.Count - opts.Predicate.Limit)
			remainingItemCount = &c
		}
		return s.versioner.UpdateList(listObj, uint64(withRev), next, remainingItemCount)
	}

	// no continuation

 * A queue that gives priority to the most recently pushed element.
 */
internal
class ConcurrentGroupingQueue<T>(

    /**
     * Predicate to check whether the given most recently pushed element (the receiver)
     * supersedes the given less recent element (the argument).
     *
     * When the predicate returns true the argument is considered to be in the same group
     * as the receiver.
     */
    private

      }
    };
  }

  /** Returns a {@code Spliterator} filtered by the specified predicate. */
  static <T extends @Nullable Object> Spliterator<T> filter(
      Spliterator<T> fromSpliterator, Predicate<? super T> predicate) {
    checkNotNull(fromSpliterator);
    checkNotNull(predicate);
    class Splitr implements Spliterator<T>, Consumer<T> {
      @CheckForNull T holder = null;

      @Override

  /** Implementation of {@link #forPredicate(Predicate)}. */
  private static final class ForPredicate extends CharMatcher {

    private final Predicate<? super Character> predicate;

    ForPredicate(Predicate<? super Character> predicate) {
      this.predicate = checkNotNull(predicate);
    }

    @Override
    public boolean matches(char c) {
      return predicate.apply(c);
    }

		Field:    fields.Everything(),
		Limit:    options.Limit,
		Continue: options.Continue,
	}

	storageOpts := storage.ListOptions{
		ResourceVersionMatch: options.ResourceVersionMatch,
		Predicate:            pred,
		Recursive:            true,
	}
	ctx := context.Background()
	if lw.contextMetadata != nil {
		ctx = metadata.NewOutgoingContext(ctx, lw.contextMetadata)
	}