import org.gradle.internal.execution.workspace.ImmutableWorkspaceProvider

import java.time.Duration
import java.util.concurrent.CountDownLatch
import java.util.function.BiFunction

class AssignImmutableWorkspaceStepConcurrencyTest extends StepSpecBase<IdentityContext> {
    def workspacesRoot = temporaryFolder.file("workspaces").createDir()

            val irClass = irFile.declarations.single { it is IrClass && it.metadata is FirMetadataSource.CodeFragment } as IrClass
            val irFunction = irClass.declarations.single { it is IrFunction && it !is IrConstructor } as IrFunction
            EvaluatorFragmentInfo(irClass.descriptor, irFunction.descriptor, emptyList())
        }

        return JvmIrCodegenFactory(
            configuration,
            PhaseConfig(jvmPhases),

  return ret;
}

char* TF_FunctionDebugString(TF_Function* func, size_t* len) {
  const auto& debug_str = DebugString(func->record->fdef());
  *len = debug_str.size();
  char* ret = static_cast<char*>(malloc(*len + 1));
  memcpy(ret, debug_str.c_str(), *len + 1);
  return ret;
}

// On success, returns a set of TF_Function instances from `text_proto` of

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

/**
 * A wrapper for {@link Properties} that notifies a listener about accesses.
 */
@SuppressWarnings("UnsynchronizedOverridesSynchronized")

import javax.annotation.Nullable;
import java.io.File;

import static com.google.common.base.Preconditions.checkNotNull;
import static org.gradle.api.internal.lambdas.SerializableLambdas.bifunction;
import static org.gradle.api.internal.lambdas.SerializableLambdas.transformer;

@ServiceScope({Scope.Global.class, Scope.Project.class})
public class DefaultFilePropertyFactory implements FilePropertyFactory, FileFactory {

    }

    @Override
    public int size() {
        return (int) entry.getSize();
    }

    @Override
    public byte[] getContent() throws IOException {
        return withInputStream(new IoFunction<InputStream, byte[]>() {
            @Override
            public byte[] apply(InputStream inputStream) throws IOException {
                int size = size();
                if (size >= 0) {

import org.gradle.process.ExecSpec;
import org.gradle.process.JavaExecSpec;

import javax.annotation.Nullable;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.function.BiFunction;

public class DefaultProviderFactory implements ProviderFactory {
    @Nullable
    private final ValueSourceProviderFactory valueSourceProviderFactory;
    @Nullable

        AGENT(ClasspathElementTransformFactoryForAgent::new),
        LEGACY(ClasspathElementTransformFactoryForLegacy::new);

        private final BiFunction<ClasspathBuilder, ClasspathWalker, ClasspathElementTransformFactory> factoryMaker

        TransformFactoryType(BiFunction<ClasspathBuilder, ClasspathWalker, ClasspathElementTransformFactory> factoryMaker) {
            this.factoryMaker = factoryMaker
        }

 */
package org.codelibs.fess.helper;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.regex.Matcher;

import javax.annotation.PostConstruct;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.lang.StringUtil;

        private boolean opened;

        public StreamZipEntry(java.util.zip.ZipEntry entry) {
            super(entry);
        }

        @Override
        public <T> T withInputStream(IoFunction<InputStream, T> action) throws IOException {
            if (opened) {
                throw new IllegalStateException("The input stream for " + getName() + " has already been opened.  It cannot be reopened again.");
            }