IOException ioException = exception;
            assertNotNull(ioException);
        }

        @Test
        @DisplayName("Should work in catch blocks for IOException")
        void testCatchAsIOException() {
            assertDoesNotThrow(() -> {
                try {
                    throw new TransportException("Test exception");
                } catch (IOException e) {

    }

    private void parse(final byte[] material) throws IOException {
        for (int i = 0; i < 8; i++) {
            if (material[i] != NTLMSSP_SIGNATURE[i]) {
                throw new IOException("Not an NTLMSSP message.");
            }
        }
        if (readULong(material, 8) != 1) {
            throw new IOException("Not a Type 1 message.");
        }

        // Should throw IOException when file doesn't exist
        try {
            cache.close();
            fail("Expected IOException for non-existent file");
        } catch (IOException e) {
            // Expected - file doesn't exist
        }
    }

    @Test
    public void testMemoryCacheWithBinaryData() throws IOException {
        // Test with binary data containing all byte values

     * @param writer a writer object.
     * @param model a model object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, Model model) throws IOException {
        try {
            delegate.write(writer, model.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException(e);
        }
    } // -- void write( Writer, Model )

    /**
     * Method write.

          throw new IOException();
        }

        @Override
        public Appendable append(@Nullable CharSequence csq, int start, int end)
            throws IOException {
          throw new IOException();
        }

        @Override
        public Appendable append(char c) throws IOException {
          throw new IOException();
        }

        failedChannel.setState(ChannelState.ESTABLISHED);

        when(mockChannelManager.getLoadBalancer()).thenReturn(mockLoadBalancer);
    }

    @Test
    void testHandleFailure() {
        IOException error = new IOException("Connection failed");

        failover.handleFailure(failedChannel, error);

        assertEquals(ChannelState.FAILED, failedChannel.getState());
        verify(mockChannelManager).removeChannel(failedChannel);

  }

  @Override
  public OutputStream openStream() throws IOException {
    outputStreamOpened = true;
    bytes.reset(); // truncate
    return new Out();
  }

  private final class Out extends TestOutputStream {

    Out() throws IOException {
      super(bytes, options);
    }

    @Override
    public void close() throws IOException {
      outputStreamClosed = true;
      super.close();
    }
  }

        if (this.handle.isStale()) {
            throw new IOException("DCERPC pipe is no longer open");
        }

        int have = this.handle.sendrecv(buf, off, length, inB, getMaxRecv());

        final int fraglen = Encdec.dec_uint16le(inB, 8);
        if (fraglen > getMaxRecv()) {
            throw new IOException("Unexpected fragment length: " + fraglen);
        }

    }

    /**
     * Test constructor with a token that has an incorrect OID.
     *
     * @throws IOException if an I/O error occurs
     */
    @Test
    void testConstructorWithWrongOid() throws IOException {
        byte[] wrongOidToken = createGssApiWrapper(new ASN1ObjectIdentifier("1.2.3.4.5"), new byte[0]);

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param coreExtensions a coreExtensions object.
     * @throws IOException IOException if any.
     */
    public void write(Writer writer, CoreExtensions coreExtensions) throws IOException {
        XmlSerializer serializer = new MXSerializer();
        serializer.setProperty("http://xmlpull.org/v1/doc/properties.html#serializer-indentation", "  ");