throw new IOException( "Error reading jcifs/smb1/util/mime.map resource" );
        }
        is.close();
    }

    public String getMimeType( String extension ) throws IOException {
        return getMimeType( extension, "application/octet-stream" );
    }
    public String getMimeType( String extension, String def ) throws IOException {
        int state, t, x, i, off;
        byte ch;

 */
package org.codelibs.core.io;

import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import org.codelibs.core.exception.IORuntimeException;

/**
 * {@link OutputStream}用のユーティリティクラスです。
 *
 * @author shot
 */
public abstract class OutputStreamUtil {

    @Override public Response intercept(Chain chain) throws IOException {
      for (Certificate certificate : chain.connection().handshake().peerCertificates()) {
        String pin = CertificatePinner.pin(certificate);
        if (denylist.contains(pin)) {
          throw new IOException("Denylisted peer certificate: " + pin);
        }
      }
      return chain.proceed(chain.request());
    }

        return queryBuilder.rewrite(queryShardContext);
    }

    @Override
    public void visit(final QueryBuilderVisitor visitor) {
        queryBuilder.visit(visitor);
    }

    @Override
    public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
        return queryBuilder.toXContent(builder, params);

    val plan0 = routePlanner.addPlan()
    plan0.tcpConnectThrowable = IOException("boom 0!")
    val plan1 = routePlanner.addPlan()
    plan1.tcpConnectThrowable = IOException("boom 1!")

    taskRunner.newQueue().execute("connect") {
      assertFailsWith<IOException> {
        finder.find()
      }.also { expected ->
        assertThat(expected).hasMessage("boom 0!")

      DELIMITER_DOT, DELIMITER_SPACE, DELIMITER_SEMICOLON -> {
        throw IOException("unexpected delimiter")
      }
    }

    // "002F" or "0000..002C"
    val sourceCodePoint0 = readHexadecimalUnsignedLong()
    val sourceCodePoint1 =
      when (select(optionsDot)) {
        DELIMITER_DOT -> {
          if (readByte() != '.'.code.toByte()) throw IOException("expected '..'")
          readHexadecimalUnsignedLong()
        }

    return suite;
  }

  public void testToString() throws IOException {
    URL resource = getClass().getResource("testdata/i18n.txt");
    assertEquals(I18N, Resources.toString(resource, UTF_8));
    assertThat(Resources.toString(resource, US_ASCII)).isNotEqualTo(I18N);
  }

  public void testToByteArray() throws IOException {
    URL resource = getClass().getResource("testdata/i18n.txt");

  @Synchronized fun receivedPingCount(): Int = receivedPingCount

  @Synchronized fun receivedPongCount(): Int = receivedPongCount

  @Throws(IOException::class)
  override fun onReadMessage(text: String) {
    listener.onMessage(this, text)
  }

  @Throws(IOException::class)
  override fun onReadMessage(bytes: ByteString) {
    listener.onMessage(this, bytes)
  }

  override fun find(): RealConnection {
    var firstException: IOException? = null
    try {
      while (tcpConnectsInFlight.isNotEmpty() || routePlanner.hasNext()) {
        if (routePlanner.isCanceled()) throw IOException("Canceled")

        // Launch a new connection if we're ready to.
        val now = taskRunner.backend.nanoTime()

 */
package org.codelibs.fess.crawler.client.smb;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;