* @param strict a strict object.
     * @return Metadata
     * @throws IOException            IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     *                                any.
     */
    public Metadata read(Reader reader, boolean strict) throws IOException, XmlPullParserException {
        try {
            return new Metadata(delegate.read(reader, strict));

import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;

        // another packet header, but since there's no more data, it will throw IOException
        assertThrows(IOException.class, () -> sis.read());
    }

    @Test
    @DisplayName("Reading with zero-length array returns 0")
    void readZeroLengthArrayReturnsZero() throws IOException {
        // Create stream with a message containing data
        byte[] data = new byte[] { 1, 2 };

package okhttp3.internal.connection

import java.io.IOException

/** Attempt routes one at a time until one connects. */
internal class SequentialExchangeFinder(
  override val routePlanner: RoutePlanner,
) : ExchangeFinder {
  override fun find(): RealConnection {
    var firstException: IOException? = null
    while (true) {
      if (routePlanner.isCanceled()) throw IOException("Canceled")

      try {

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.extractor.impl;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.codelibs.core.exception.IORuntimeException;
import org.codelibs.core.io.FileUtil;

     * @return module name of the dependency at the given path, or empty if the dependency is not modular
     * @throws IOException if the module information of the specified dependency cannot be read
     */
    Optional<String> getModuleName(@Nonnull Path dependency) throws IOException;

    /**
     * Returns the Java module descriptor of the dependency at the given path.

     * Updates the dictionary file with content from an input stream.
     *
     * @param in The input stream containing the new dictionary content.
     * @throws IOException if an I/O error occurs.
     */
    public synchronized void update(final InputStream in) throws IOException {
        try (StemmerOverrideUpdater updater = new StemmerOverrideUpdater(null)) {
            reload(updater, in);
        }
    }

    @Override

  }

  override fun responseFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("responseFailed: $ioe")
  }

  override fun callEnd(call: Call) {
    logWithTime("callEnd")
  }

  override fun callFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("callFailed: $ioe")
  }

  override fun canceled(call: Call) {

                        throw new IOException("Interrupted during retry delay", e);
                    }
                }
            }
        }

        // All retries failed
        if (lastError instanceof IOException) {
            throw (IOException) lastError;
        } else {
            throw new IOException("RDMA operation failed after " + (retryCount + 1) + " attempts", lastError);

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.authenticator

import java.io.IOException
import java.net.Authenticator
import java.net.InetAddress
import java.net.InetSocketAddress
import java.net.Proxy
import okhttp3.Credentials
import okhttp3.Dns
import okhttp3.HttpUrl
import okhttp3.Request