{maxPartSz, mkSPObj(maxPartSz)},
	}

	for i, test := range testSP {
		{
			// nil range
			o, l, skip, sn, ps, err := test.oi.GetDecryptedRange(nil)
			if err != nil {
				t.Errorf("Case %d: unexpected err: %v", i, err)
			}
			if skip != 0 || sn != 0 || ps != 0 || o != 0 || l != getEncSize(test.decSz) {
				t.Errorf("Case %d: test failed: %d %d %d %d %d", i, o, l, skip, sn, ps)
			}
		}

        .Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()

    val response1Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

        println("Response 1 response:          $it")
        println("Response 1 cache response:    ${it.cacheResponse}")
        println("Response 1 network response:  ${it.networkResponse}")

    val type: Int,
  ) : MappedRange {
    val b1: Int
      get() =
        when (type) {
          TYPE_IGNORED -> 119
          TYPE_VALID -> 120
          TYPE_DISALLOWED -> 121
          else -> error("unexpected type: $type")
        }
  }

  data class Inline1(
    override val rangeStart: Int,
    private val mappedTo: ByteString,
  ) : MappedRange {
    val b1: Int
      get() {

        .build();

    String response1Body;
    try (Response response1 = client.newCall(request).execute()) {
      if (!response1.isSuccessful()) throw new IOException("Unexpected code " + response1);

      response1Body = response1.body().string();
      System.out.println("Response 1 response:          " + response1);

	got := entries.entries().names()
	if !reflect.DeepEqual(got, want) {
		t.Errorf("got unexpected result: %#v", got)
	}

	// Try with prefix
	entries = org
	entries.forwardTo("src/compress/zlib/reader_t")
	got = entries.entries().names()
	if !reflect.DeepEqual(got, want) {
		t.Errorf("got unexpected result: %#v", got)
	}
}

func Test_metaCacheEntries_merge(t *testing.T) {

            if (!perMessageDeflate) throw ProtocolException("Unexpected rsv1 flag")
            true
          } else {
            false
          }
      }

      else -> {
        if (reservedFlag1) throw ProtocolException("Unexpected rsv1 flag")
      }
    }

    val reservedFlag2 = b0 and B0_FLAG_RSV2 != 0
    if (reservedFlag2) throw ProtocolException("Unexpected rsv2 flag")

        eqCount = skipAll('='.code.toByte())
      }
      if (eqCount == 0) break // We peeked a scheme name.
      if (eqCount > 1) return // Unexpected '=' characters.
      if (skipCommasAndWhitespace()) return // Unexpected ','.

      val parameterValue =
        when {
          startsWith('"'.code.toByte()) -> readQuotedString()
          else -> readToken()

  override fun connectTlsEtc() = error("already connected")

  override fun handleSuccess() = connection

  override fun cancel() = error("unexpected cancel")

  override fun retry() = error("unexpected retry")

		if err != nil {
			if err != io.EOF {
				t.Error("unexpected error on ReadRune:", err)
			}
			break
		}
		got += string(r1)
		// Put it back and read it again.
		if err = r.UnreadRune(); err != nil {
			t.Fatal("unexpected error on UnreadRune:", err)
		}
		r2, _, err := r.ReadRune()
		if err != nil {
			t.Fatal("unexpected error reading after unreading:", err)
		}
		if r1 != r2 {

              throw IOException("unexpected delimiter")
            }
          }

          mappedTo.writeUtf8CodePoint(readHexadecimalUnsignedLong().toInt())
        }
      }

      TYPE_DISALLOWED, TYPE_DISALLOWED_STD3_VALID, TYPE_IGNORED, TYPE_VALID -> {
        Unit
      }

      else -> {
        throw IOException("unexpected type")
      }
    }

    skipRestOfLine()