default <T> T withWritableCache(BiFunction<? super ArtifactCacheMetadata, ? super ArtifactCacheLockingAccessCoordinator, T> function) {
        return function.apply(getWritableCacheMetadata(), getWritableCacheAccessCoordinator());
    }

    default <T> Optional<T> withReadOnlyCache(BiFunction<? super ArtifactCacheMetadata, ? super ArtifactCacheLockingAccessCoordinator, T> function) {

            context().tryEvaluate(this.owner, "fallback") { "result" }
        }

        then:
        result == "fallback"
    }

    BiFunction<EvaluationContext.EvaluationOwner, TestEvaluation, String> evaluateInLambda() {
        return new BiFunction<EvaluationContext.EvaluationOwner, TestEvaluation, String>() {
            @Override

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ExcludeSpec;

import java.util.Collection;
import java.util.function.BiFunction;
import java.util.function.Function;

public abstract class Optimizations {
    public static ExcludeSpec optimizeAnyOf(ExcludeSpec one, ExcludeSpec two, BiFunction<ExcludeSpec, ExcludeSpec, ExcludeSpec> onMiss) {
        // fast path for two
        if (one == null) {
            return two;

import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.RandomAccess;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;

class ImmutableCollections {

    private static final List<?> EMPTY_LIST = new AbstractImmutableList<Object>() {
        @Override

 */
package org.codelibs.fess.entity;

import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;

import org.apache.commons.lang3.StringUtils;

import com.google.common.base.CaseFormat;

public class ParamMap<K, V> implements Map<K, V> {

import org.gradle.api.Transformer;
import org.gradle.api.specs.Spec;
import org.gradle.internal.Factory;

import java.io.Serializable;
import java.util.concurrent.Callable;
import java.util.function.BiFunction;
import java.util.function.Supplier;

/**
 * Provides a mechanism for creating Java lambdas that can be stored to the configuration cache.
 *
 * The methods on this class are meant to be statically imported.
 */

 * limitations under the License.
 */

package org.gradle.internal;

import java.util.function.BiFunction;
import java.util.function.BinaryOperator;

/**
 * Utility class to help with using {@link java.util.stream.Stream#reduce(Object, BiFunction, BinaryOperator)}.
 * Promote to a more shared subproject if useful.
 */
public abstract class Combiners {

    /**

package org.gradle.api.internal.provider;

import org.gradle.api.provider.Provider;

import javax.annotation.Nullable;
import java.util.function.BiFunction;

public class BiProvider<R, A, B> extends AbstractMinimalProvider<R> {

    private final Class<R> type;
    private final BiFunction<? super A, ? super B, ? extends R> combiner;
    private final ProviderInternal<A> left;
    private final ProviderInternal<B> right;

import java.util.InvalidPropertiesFormatException;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

class WrapperProperties extends Properties {

    final Supplier<Map<String, String>> getter;

import java.io.File;
import java.util.Collections;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toSet;

public class FileBasedInstallationFactory {

    public static Set<InstallationLocation> fromDirectory(File rootDirectory, String supplierName, BiFunction<File, String, InstallationLocation> locationFactory) {