val bodySource = response.body.source()
    assertThat(bodySource.readByte()).isEqualTo('d'.code.toByte())

    // The second byte of this request will be delayed by 750ms so we should time out after 250ms.
    val startNanos = System.nanoTime()
    bodySource.use {
      assertFailsWith<IOException> {
        bodySource.readByte()
      }.also { expected ->
        // Timed out as expected.

    val response1 = get(server.url("/"))
    val source = response1.body.source()
    assertThat(source.readUtf8(5)).isEqualTo("ABCDE")
    source.close()
    assertFailsWith<IllegalStateException> {
      source.readByte()
    }
    assertThat(cache.writeAbortCount()).isEqualTo(1)
    assertThat(cache.writeSuccessCount()).isEqualTo(0)
    val response2 = get(server.url("/"))

        final byte[] result = FileUtil.readBytes(emptyFile);
        assertThat(result.length, is(0));
    }

    /**
     * Test readBytes with null file throws exception
     */
    @Test
    public void testReadBytes_NullFile() {
        try {
            FileUtil.readBytes(null);
            fail("Expected IllegalArgumentException");

pkg io, method (*SectionReader) Size() int64
pkg io, type ByteReader interface { ReadByte }
pkg io, type ByteReader interface, ReadByte() (uint8, error)
pkg io, type ByteScanner interface { ReadByte, UnreadByte }
pkg io, type ByteScanner interface, ReadByte() (uint8, error)
pkg io, type ByteScanner interface, UnreadByte() error
pkg io, type Closer interface { Close }

            readParams.setAccessible(true);
            readParams.invoke(cancel, buffer, 0);

            Method readBytes = SmbComNtCancel.class.getDeclaredMethod("readBytesWireFormat", byte[].class, int.class);
            readBytes.setAccessible(true);
            readBytes.invoke(cancel, buffer, 0);

            // Then - buffer should remain unchanged
            assertArrayEquals(originalBuffer, buffer);

                { getInputStream(jarEntry).use { jarInput -> jarInput.readBytes() } }
            }
        }
    }

    private
    fun directoryClassBytesIndexFor(dir: File): ClassBytesIndex = { classFilePath ->
        dir.resolve(classFilePath).takeIf { it.isFile }?.let { classFile -> { classFile.readBytes() } }
    }

    private

			z.LifecycleConfigXML, err = dc.ReadBytes(z.LifecycleConfigXML)
			if err != nil {
				err = msgp.WrapError(err, "LifecycleConfigXML")
				return
			}
		case "ObjectLockConfigXML":
			z.ObjectLockConfigXML, err = dc.ReadBytes(z.ObjectLockConfigXML)
			if err != nil {
				err = msgp.WrapError(err, "ObjectLockConfigXML")
				return
			}
		case "VersioningConfigXML":
			z.VersioningConfigXML, err = dc.ReadBytes(z.VersioningConfigXML)

              readBytesDelivered = readBuffer.read(sink, minOf(byteCount, readBuffer.size))
              readBytes.update(total = readBytesDelivered)

              val unacknowledgedBytesRead = readBytes.unacknowledged
              if (errorExceptionToDeliver == null &&
                unacknowledgedBytesRead >= connection.okHttpSettings.initialWindowSize / 2
              ) {

	}
}

func loadProcIOMetrics(ctx context.Context, io procfs.ProcIO, m MetricValues) {
	if io.RChar > 0 {
		m.Set(processIORCharBytes, float64(io.RChar))
	}

	if io.ReadBytes > 0 {
		m.Set(processIOReadBytes, float64(io.ReadBytes))
	}

	if io.WChar > 0 {
		m.Set(processIOWCharBytes, float64(io.WChar))
	}

	if io.WriteBytes > 0 {
		m.Set(processIOWriteBytes, float64(io.WriteBytes))
	}

            byte[] arr = new byte[15];
            assertEquals(0, response.readParameterWordsWireFormat(arr, idx));
        }
    }

    @Nested
    @DisplayName("readBytesWireFormat tests")
    class ReadBytes {

        @Test
        @DisplayName("Returns 0 with null array")
        void nullArray() {
            assertEquals(0, response.readBytesWireFormat(null, 0));
        }

        @ParameterizedTest