absl::Status ParseTextProto(absl::string_view text_proto,
                            Message* parsed_proto) {
  TextFormat::Parser parser;
  // Attempt to parse as text.
  ArrayInputStream input_stream(text_proto.data(), text_proto.size());
  if (parser.Parse(&input_stream, parsed_proto)) {
    return absl::OkStatus();
  }
  parsed_proto->Clear();
  return absl::InvalidArgumentError(
      absl::StrCat("Could not parse text proto: ", text_proto));
}

        });
    }

    private void visitImpl(FileVisitor visitor, File expandedDir, InputStream inputStream) throws IOException {
        checkFormat(inputStream);

        AtomicBoolean stopFlag = new AtomicBoolean();
        DetailsImpl.NoCloseTarArchiveInputStream tar = new DetailsImpl.NoCloseTarArchiveInputStream(inputStream);
        ReadableResourceInternal resource = this.resource.get();
        TarArchiveEntry entry;

        def result = resource.withContent(new Action<InputStream>() {
            @Override
            void execute(InputStream input) {
                assert input.text == "1234"
            }
        })
        result.bytesRead == 4

        def result2 = resource.withContent(new Action<InputStream>() {
            @Override
            void execute(InputStream inputStream) {
                assert inputStream.read() == '1'

            assert content == [0xc4, 0xc5, 0xc6] as byte[]

            assert decoder.inputStream.read() == -1
            assert decoder.inputStream.read(buffer) == -1
            assert decoder.inputStream.read(buffer, 0, 1) == -1
        }
    }

    def "ignores close on InputStream"() {
        def inputStream = Mock(InputStream)

        when:
        decodeFrom(inputStream) { Decoder decoder ->

    }

    public static StreamByteBuffer of(InputStream inputStream) throws IOException {
        StreamByteBuffer buffer = new StreamByteBuffer(chunkSizeInDefaultRange(inputStream.available()));
        buffer.readFully(inputStream);
        return buffer;
    }

    public static StreamByteBuffer of(InputStream inputStream, int len) throws IOException {

            }
            throw e
        }
        return outerCloseable
    }

    private
    fun decryptingInputStream(inputStream: InputStream): InputStream {
        val cipher = newEncryptionSession().decryptingCipher(inputStream::read)
        return CipherInputStream(inputStream, cipher)
    }

    private
    fun encryptingOutputStream(outputStream: OutputStream): OutputStream {

        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() {

                }

                try ( InputStream is = f.getInputStream() ) {
                    verifyRandom(bufSize, length, is);
                }

            }
            finally {
                f.delete();
            }
        }
    }


    static void verifyRandom ( int bufSize, long length, InputStream is ) throws IOException {
        verifyRandom(bufSize, length, true, is);

        }
        return clientConfiguration;
    }

    public void put(InputStream inputStream, Long contentLength, URI destination) {
        if (contentLength < s3ConnectionProperties.getMultipartThreshold()) {
            putSingleObject(inputStream, contentLength, destination);
        } else {
            putMultiPartObject(inputStream, contentLength, destination);
        }
    }

    val inputStream = connection.getInputStream()
    assertThat(inputStream.read()).isEqualTo('A'.code)
    assertThat(inputStream.read()).isEqualTo('B'.code)
    assertThat(inputStream.read()).isEqualTo('C'.code)
    assertThat(inputStream.read()).isEqualTo('D'.code)
    assertThat(inputStream.read()).isEqualTo('E'.code)
    assertThat(inputStream.read()).isEqualTo('F'.code)