plan = this,
        nextPlan = retryTlsConnection,
        throwable = e,
      )
    } finally {
      user.removePlanToCancel(this)
      if (!success) {
        javaNetSocket?.closeQuietly()
        rawSocket.closeQuietly()
      }
    }
  }

  /** Does all the work necessary to build a full HTTP or HTTPS connection on a raw socket. */
  @Throws(IOException::class)
  private fun connectSocket() {

        CloseableUtil.closeQuietly(in);
        logger.info(content);
        assertTrue(content.contains("テスト"));
    }

    public void test_getTika_hpp() {
        final InputStream in = ResourceUtil.getResourceAsStream("extractor/program/test.hpp");
        final ExtractData extractData = tikaExtractor.getText(in, null);
        final String content = extractData.getContent();
        CloseableUtil.closeQuietly(in);

        closeQuietly(viewPath);
        final Path imagePath = ResourceUtil.getImagePath(themeName);
        closeQuietly(imagePath);
        final Path cssPath = ResourceUtil.getCssPath(themeName);
        closeQuietly(cssPath);
        final Path jsPath = ResourceUtil.getJavaScriptPath(themeName);
        closeQuietly(jsPath);
    }

    /**

        connection.start()
      } catch (e: IOException) {
        logger.log(Level.INFO, "Http2Server connection failure: $e")
        socket?.closeQuietly()
      } catch (e: Exception) {
        logger.log(Level.WARNING, "Http2Server unexpected failure", e)
        socket?.closeQuietly()
      }
    }
  }

  private fun doSsl(socket: Socket): SSLSocket {
    val sslSocket =
      sslSocketFactory.createSocket(

package okhttp3.coroutines

import kotlin.coroutines.resumeWithException
import kotlinx.coroutines.suspendCancellableCoroutine
import okhttp3.Call
import okhttp3.Callback
import okhttp3.Response
import okhttp3.internal.closeQuietly
import okio.IOException

suspend fun Call.executeAsync(): Response =
  suspendCancellableCoroutine { continuation ->
    continuation.invokeOnCancellation {
      this.cancel()
    }
    this.enqueue(

        maskCursor.close()
      }
    }

    sinkBuffer.write(messageBuffer, dataSize)
    sink.flush()
  }

  override fun close() {
    messageDeflater?.closeQuietly()
    sink.closeQuietly()
  }

            try {
              checkUpgradeSuccess(response)
            } catch (e: IOException) {
              failWebSocket(e, response)
              response.closeQuietly()
              response.socket?.sink?.closeQuietly()
              response.socket?.source?.closeQuietly()
              return
            }

          // Apply the extensions. If they're unacceptable initiate a graceful shut down.

package okhttp3.internal.cache

import java.io.Closeable
import java.io.EOFException
import java.io.Flushable
import java.io.IOException
import okhttp3.internal.cache.DiskLruCache.Editor
import okhttp3.internal.closeQuietly
import okhttp3.internal.concurrent.Lockable
import okhttp3.internal.concurrent.Task
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.concurrent.assertLockHeld
import okhttp3.internal.deleteContents

        }
    }

    public void test_closeQuietly_nonExistentDirectory() {
        Path nonExistentDir = tempDir.resolve("non-existent");
        themeHelper.closeQuietly(nonExistentDir);
        // Should not throw exception
        assertTrue(true);
    }

    public void test_closeQuietly_existingDirectory() throws IOException {

        throw ProtocolException("Expected continuation opcode. Got: ${opcode.toHexString()}")
      }
    }
  }

  @Throws(IOException::class)
  override fun close() {
    messageInflater?.closeQuietly()
    source.closeQuietly()
  }