v := xlMetaDataDirDecoder{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodexlMetaDataDirDecoder(b *testing.B) {
	v := xlMetaDataDirDecoder{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))

    }

    private fun unescape(s: String): String =
      buildString {
        val buffer = Buffer().writeUtf8(s)
        while (!buffer.exhausted()) {
          val c = buffer.readUtf8CodePoint()
          if (c != '\\'.code) {
            append(c.toChar())
            continue
          }
          when (buffer.readUtf8CodePoint()) {
            '\\'.code -> append('\\')
            '#'.code -> append('#')

  private val deflaterSink = DeflaterSink(deflatedBytes, deflater)

  /** Deflates [buffer] in place as described in RFC 7692 section 7.2.1. */
  @Throws(IOException::class)
  fun deflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      deflater.reset()
    }

    deflaterSink.write(buffer, buffer.size)
    deflaterSink.flush()

    if (deflatedBytes.endsWith(EMPTY_DEFLATE_BLOCK)) {

            buffer[6] = 0x00;
            buffer[7] = 0x00;
            // Capabilities (DFS)
            buffer[8] = 0x08;
            buffer[9] = 0x00;
            buffer[10] = 0x00;
            buffer[11] = 0x00;
            // Maximal access
            buffer[12] = (byte) 0xFF;
            buffer[13] = 0x01;
            buffer[14] = 0x1F;
            buffer[15] = 0x00;

            // When

  @Before
  fun setUp() {
    beforePublicSuffixTest()
  }

  @Test
  fun allPublicSuffixes() {
    val buffer = Buffer()
    FileSystem.SYSTEM.read(pathForTests) {
      val length = readInt()
      buffer.write(this, length.toLong())
    }
    while (!buffer.exhausted()) {
      var publicSuffix = buffer.readUtf8LineStrict()
      if (publicSuffix.contains("*")) {

    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        this.supportSearchBits = (buffer[bufferIndex] & SMB_SUPPORT_SEARCH_BITS) == SMB_SUPPORT_SEARCH_BITS;
        this.shareIsInDfs = (buffer[bufferIndex] & SMB_SHARE_IS_IN_DFS) == SMB_SHARE_IS_IN_DFS;
        return 2;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

import okio.Buffer
import okio.ByteString.Companion.encodeUtf8
import okio.GzipSink
import okio.Source
import okio.buffer
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension

class CompressionInterceptorTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  val source =
    Buffer().apply {
      write("Hello World".encodeUtf8())

        final int zt = zterm ? 1 : 0;

        this.length = this.maximum_length = (short) ((len + zt) * 2);
        this.buffer = new short[len + zt];

        int i;
        for (i = 0; i < len; i++) {
            this.buffer[i] = (short) str.charAt(i);
        }
        if (zterm) {
            this.buffer[i] = (short) 0;
        }
    }

    @Override
    public String toString() {

	// Confirm that when Reader panics, the empty buffer remains empty
	var buf2 Buffer
	defer func() {
		recover()
		check(t, "TestReadFromPanicReader (2)", &buf2, "")
	}()
	buf2.ReadFrom(panicReader{panic: true})
}

func TestReadFromNegativeReader(t *testing.T) {
	var b Buffer
	defer func() {
		switch err := recover().(type) {
		case nil:
			t.Fatal("bytes.Buffer.ReadFrom didn't panic")
		case error:

    @Override
    protected int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    protected int readParametersWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        this.available = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;