}
	return
}

// Just testing the rleBuffer used in the Zip64 test above. Not used by the zip code.
func TestRLEBuffer(t *testing.T) {
	b := new(rleBuffer)
	var all []byte
	writes := []string{"abcdeee", "eeeeeee", "eeeefghaaiii"}
	for _, w := range writes {
		b.Write([]byte(w))
		all = append(all, w...)
	}
	if len(b.buf) != 10 {
		t.Fatalf("len(b.buf) = %d; want 10", len(b.buf))
	}

    assertThat(Strings.commonPrefix("abcde", "xyz")).isEqualTo("");
    assertThat(Strings.commonPrefix("xyz", "abcde")).isEqualTo("");
    assertThat(Strings.commonPrefix("xyz", "abcxyz")).isEqualTo("");
    assertThat(Strings.commonPrefix("abc", "aaaaa")).isEqualTo("a");
    assertThat(Strings.commonPrefix("aa", "aaaaa")).isEqualTo("aa");
    assertThat(Strings.commonPrefix(new StringBuilder("abcdef"), "abcxyz")).isEqualTo("abc");

        assertEquals("YWJjZA==", Base64Util.encode(data2));

        // Test case 3: Double padding
        final byte[] data3 = "abcde".getBytes();
        assertEquals("YWJjZGU=", Base64Util.encode(data3));

        // Test case 4: No padding
        final byte[] data4 = "abcdef".getBytes();
        assertEquals("YWJjZGVm", Base64Util.encode(data4));
    }

    assertThat(Strings.commonPrefix("abcde", "xyz")).isEqualTo("");
    assertThat(Strings.commonPrefix("xyz", "abcde")).isEqualTo("");
    assertThat(Strings.commonPrefix("xyz", "abcxyz")).isEqualTo("");
    assertThat(Strings.commonPrefix("abc", "aaaaa")).isEqualTo("a");
    assertThat(Strings.commonPrefix("aa", "aaaaa")).isEqualTo("aa");
    assertThat(Strings.commonPrefix(new StringBuilder("abcdef"), "abcxyz")).isEqualTo("abc");

			testRemaining{0, 0},
		},
	}, {
		maker: makeSparse{makeReg{5, "abcde"}, sparseHoles{{2, 3}}, 8},
		tests: []testFnc{
			testRemaining{8, 5},
			testWrite{"ab\x00\x00\x00cde", 8, nil},
			testWrite{"a", 0, ErrWriteTooLong},
			testRemaining{0, 0},
		},
	}, {
		maker: makeSparse{makeReg{5, "abcde"}, sparseHoles{{2, 3}}, 8},
		tests: []testFnc{

import okio.buffer

class ResponseCommonTest {
  @Test fun peekShorterThanResponse() {
    val response = newResponse(responseBody("abcdef"))
    val peekedBody = response.peekBody(3)
    assertThat(peekedBody.string()).isEqualTo("abc")
    assertThat(response.body.string()).isEqualTo("abcdef")
  }

  @Test fun peekLongerThanResponse() {
    val response = newResponse(responseBody("abc"))
    val peekedBody = response.peekBody(6)

    assertThat(response.body.string()).isEqualTo("ABCDE")
    val request = server.takeRequest()
    assertThat(request.requestLine).isEqualTo("POST /foo HTTP/2")
    assertArrayEquals(postBytes, request.body?.toByteArray())
    assertThat(request.headers["Content-Length"]!!.toInt()).isEqualTo(postBytes.size)
  }

  @Test
  fun connectionReuse() {
    server.enqueue(MockResponse(body = "ABCDEF"))

    assertThat(ping.type).isEqualTo(Http2.TYPE_PING)
    val data1 = peer.takeFrame()
    assertThat(data1.type).isEqualTo(Http2.TYPE_DATA)
    assertThat(data1.streamId).isEqualTo(3)
    assertArrayEquals("abcdef".toByteArray(), data1.data)
  }

  @Test fun readSendsWindowUpdateHttp2() {
    val windowSize = 100
    val windowUpdateThreshold = 50

    // Write the mocking script.

  public void testAddEscapes() {
    char[] cs = {'a', 'b', 'c'};
    CharEscaperBuilder builder = new CharEscaperBuilder().addEscapes(cs, "Z");
    Escaper escaper = builder.toEscaper();
    assertThat(escaper.escape("abcdef")).isEqualTo("ZZZdef");
  }

    )
    val startNanos = System.nanoTime()
    val connection = server.url("/").toUrl().openConnection()
    connection.setDoOutput(true)
    connection.getOutputStream().write("ABCDEF".toByteArray(StandardCharsets.UTF_8))
    val inputStream = connection.getInputStream()
    assertThat(inputStream.read()).isEqualTo(-1)
    val elapsedNanos = System.nanoTime() - startNanos