public void testMethodsThrowWhenClosed() throws IOException {
    CharSequenceReader reader = new CharSequenceReader("");
    reader.close();

    assertThrows(IOException.class, () -> reader.read());

    assertThrows(IOException.class, () -> reader.read(new char[10]));

    assertThrows(IOException.class, () -> reader.read(new char[10], 0, 10));

    assertThrows(IOException.class, () -> reader.read(CharBuffer.allocate(10)));

        // Arrange
        int access = 0x01;
        IOException expectedException = new IOException("Network error");
        // Simulate IOException during RPC call
        doThrow(expectedException).when(mockDcerpcHandle).sendrecv(any(MsrpcSamrOpenDomain.class));

        // Act & Assert
        IOException thrown = assertThrows(IOException.class, () -> {

    /** Append space-prefixed lengths to [writer]. */
    @Throws(IOException::class)
    internal fun writeLengths(writer: BufferedSink) {
      for (length in lengths) {
        writer.writeByte(' '.code).writeDecimalLong(length)
      }
    }

    @Throws(IOException::class)
    private fun invalidLengths(strings: List<String>): Nothing = throw IOException("unexpected journal line: $strings")

    /**

        assertTrue(exception instanceof RuntimeException);
    }

    @Test
    public void testConstructorWithMessageAndCause() {
        String message = "Test error message";
        IOException cause = new IOException("IO error");
        CurlException exception = new CurlException(message, cause);

        assertEquals(message, exception.getMessage());
        assertSame(cause, exception.getCause());

       * propagate the never indexed flag of a header.
       */
      @Throws(IOException::class)
      fun readHeaders() {
        while (!source.exhausted()) {
          val b = source.readByte() and 0xff
          when {
            b == 0x80 -> {
              // 10000000
              throw IOException("index == 0")
            }
            b and 0x80 == 0x80 -> {
              // 1NNNNNNN

     * @throws IOException if an I/O error occurs
     */
    public long readUnsignedInt() throws IOException {
        return readInt() & 0xffffffffL;
    }

    /**
     * Reads an unsigned 16-bit short value.
     * @return the unsigned short value as an integer
     * @throws IOException if an I/O error occurs
     */
    public int readUnsignedShort() throws IOException {

        throw new IllegalStateException(e);
      }
    }

    @Override
    public float readFloat() {
      try {
        return input.readFloat();
      } catch (IOException e) {
        throw new IllegalStateException(e);
      }
    }

    @Override
    public double readDouble() {
      try {
        return input.readDouble();
      } catch (IOException e) {

  }

  public void testCopyTo_appendable() throws IOException {
    StringBuilder builder = new StringBuilder();

    assertEquals(STRING.length(), source.copyTo(builder));
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());

    assertEquals(STRING, builder.toString());
  }

  public void testCopyTo_charSink() throws IOException {
    TestCharSink sink = new TestCharSink();

            .toFile();
      } catch (IOException e) {
        throw new IllegalStateException("Failed to create directory", e);
      }
    }

    @Override
    File createTempFile(String prefix) throws IOException {
      return java.nio.file.Files.createTempFile(
              Paths.get(JAVA_IO_TMPDIR.value()),

 * limitations under the License.
 */
package okhttp3.internal.cache

import java.io.IOException
import okio.Buffer
import okio.ForwardingSink
import okio.Sink

/** A sink that never throws IOExceptions, even if the underlying sink does. */
internal open class FaultHidingSink(
  delegate: Sink,
  val onException: (IOException) -> Unit,
) : ForwardingSink(delegate) {
  private var hasErrors = false

  override fun write(