final InputStream in = ResourceUtil.getResourceAsStream("extractor/program/test.hpp");
        final ExtractData extractData = tikaExtractor.getText(in, null);
        final String content = extractData.getContent();
        CloseableUtil.closeQuietly(in);
        logger.info(content);
        assertTrue(content.contains("テスト"));
    }

    public void test_getTika_sh() {

import java.io.File;
import java.io.InputStream;
import java.util.List;

public class DaemonExecHandleBuilder {
    public ExecHandle build(List<String> args, File workingDir, DaemonOutputConsumer outputConsumer, InputStream inputStream, ExecHandleBuilder builder) {
        builder.commandLine(args);
        builder.setWorkingDir(workingDir);
        builder.setStandardInput(inputStream);
        builder.redirectErrorStream();

        def encoder = new EncodedStream.EncodedOutput(outputStream)

        when:
        encoder.flush()

        then:
        def inputStream = new ByteArrayInputStream(outputStream.toByteArray())
        def decoder = new EncodedStream.EncodedInput(inputStream)
        decoder.read() < 0
    }

    def "can encode and decode a string"() {
        def outputStream = new ByteArrayOutputStream()

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

@ServiceScope(Scope.Global.class)
public interface StreamHasher {
    /**
     * Returns the hash of the given input stream. The stream will not be closed by the method.
     */
    HashCode hash(InputStream inputStream);

    /**

        if (response == null) {
            return null;
        }

        try (InputStream inputStream = response.openStream();
             ExternalResourceReadResponse responseCloser = response) {
            return action.execute(inputStream, responseCloser.getMetaData());
        } catch (IOException e) {
            throw ResourceExceptions.getFailed(location.getUri(), e);
        }

import org.gradle.internal.UncheckedException;

import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * An {@code InputStream} which reads from the source {@code InputStream}. In addition, when the {@code InputStream} is
 * closed, all threads blocked reading from the stream will receive an end-of-stream.
 */

        Objects.requireNonNull(request, "request");
        Reader reader = request.getReader();
        InputStream inputStream = request.getInputStream();
        if (reader == null && inputStream == null) {
            throw new IllegalArgumentException("reader or inputStream must be non null");
        }
        try {
            InputSource source = null;

import java.io.IOException;
import java.io.InputStream;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;

/**
 * Forwards the contents of an {@link InputStream} to the process' stdin
 */
public class ForwardStdinStreamsHandler implements StreamsHandler {
    private final InputStream input;
    private final CountDownLatch completed = new CountDownLatch(1);

        }
    }

    protected static class ProgressLoggingInputStream extends InputStream {
        private final InputStream inputStream;
        private final ResourceOperation resourceOperation;

        public ProgressLoggingInputStream(InputStream inputStream, ResourceOperation resourceOperation) {
            this.inputStream = inputStream;
            this.resourceOperation = resourceOperation;
        }

        @Override

        LOGGER.debug("Attempting to upload stream to: {}", destination);
        InputStream inputStream = resource.open();
        try {
            gcsClient.put(inputStream, resource.getContentLength(), destination.getUri());
        } finally {
            inputStream.close();
        }
    }