assertEquals(11, list.getAllPageCount());
                assertEquals(200, list.getCurrentEndRecordNumber());
                assertEquals(2, list.getCurrentPageNumber());
                assertEquals(101, list.getCurrentStartRecordNumber());
                assertEquals(offset, list.getOffset());
                assertEquals(100, list.getPageSize());
                assertEquals(100, list.getStart());

    skipHelper(50, 50, new SlowSkipper(new ByteArrayInputStream(bytes), 0));
    skipHelper(100, -1, new ByteArrayInputStream(bytes));
    assertThrows(EOFException.class, () -> skipHelper(101, 0, new ByteArrayInputStream(bytes)));
  }

  private static void skipHelper(long n, int expect, InputStream in) throws IOException {
    ByteStreams.skipFully(in, n);
    assertEquals(expect, in.read());

    assertCorrectSlice(100, 5, 10, 10);
    assertCorrectSlice(100, 5, 100, 95);
    assertCorrectSlice(100, 100, 0, 0);
    assertCorrectSlice(100, 100, 10, 0);
    assertCorrectSlice(100, 101, 10, 0);
  }

  /**
   * Tests that the default slice() behavior is correct when the source is sliced starting at an
   * offset that is greater than the current length of the source, a stream is then opened to that

	_ = x[ErrNegativeExpires-96]
	_ = x[ErrAuthHeaderEmpty-97]
	_ = x[ErrExpiredPresignRequest-98]
	_ = x[ErrRequestNotReadyYet-99]
	_ = x[ErrUnsignedHeaders-100]
	_ = x[ErrMissingDateHeader-101]
	_ = x[ErrInvalidQuerySignatureAlgo-102]
	_ = x[ErrInvalidQueryParams-103]
	_ = x[ErrBucketAlreadyOwnedByYou-104]
	_ = x[ErrInvalidDuration-105]
	_ = x[ErrBucketAlreadyExists-106]
	_ = x[ErrMetadataTooLarge-107]

      webSocketCloseTimeout: Long = RealWebSocket.CANCEL_AFTER_CLOSE_MILLIS,
    ) {
      val url = "http://example.com/websocket"
      val response =
        Response.Builder()
          .code(101)
          .message("OK")
          .request(Request.Builder().url(url).build())
          .headers(responseHeaders!!)
          .protocol(Protocol.HTTP_1_1)
          .build()
      webSocket =

	}
}

func createTestInput(n int) []byte {
	input := make([]byte, n)
	for i := range input {
		// 101 and 251 are arbitrary prime numbers.
		// The idea is to create an input sequence
		// which doesn't repeat too frequently.
		input[i] = byte(i % 251)
		if i%101 == 0 {
			input[i] ^= byte(i / 101)
		}
	}
	return input
}

func TestReaderWriteTo(t *testing.T) {

            24066, 20197, 29702, 953, 1609, 1110, 21512, 949, 34920, 12461, 351, 20840, 21069,
            35201, 20107, 33258, 12424, 1580, 232, 1101, 20214, 12481, 12300, 3652, 26009, 3586,
            25163, 12301, 3592, 21644, 21487, 33021, 12304, 12451, 21830, 8211, 322, 1096, 2325,

            24066, 20197, 29702, 953, 1609, 1110, 21512, 949, 34920, 12461, 351, 20840, 21069,
            35201, 20107, 33258, 12424, 1580, 232, 1101, 20214, 12481, 12300, 3652, 26009, 3586,
            25163, 12301, 3592, 21644, 21487, 33021, 12304, 12451, 21830, 8211, 322, 1096, 2325,

   00D8; 00F8; Case map
   00D9; 00F9; Case map
   00DA; 00FA; Case map
   00DB; 00FB; Case map
   00DC; 00FC; Case map
   00DD; 00FD; Case map
   00DE; 00FE; Case map
   00DF; 0073 0073; Case map
   0100; 0101; Case map
   0102; 0103; Case map
   0104; 0105; Case map
   0106; 0107; Case map
   0108; 0109; Case map
   010A; 010B; Case map
   010C; 010D; Case map
   010E; 010F; Case map
   0110; 0111; Case map

    containing an IP address we must match that address against the URL's IP address, even when the
    two addresses are encoded differently, such as `192.168.1.1` and `0::0:0:FFFF:C0A8:101`. Note
    that OkHttp incorrectly rejected valid certificates resulting in a failure to connect; at no
    point were invalid certificates accepted.