permissions:
  contents: read

jobs:
  stale:
    permissions:
      issues: write  # for actions/stale to close stale issues
      pull-requests: write  # for actions/stale to close stale PRs
    runs-on: ubuntu-latest
    env:
      ACTIONS_STEP_DEBUG: true
    steps:
    - name: Close Stale Issues
      uses: actions/stale@v8
      with:
        repo-token: ${{ secrets.GITHUB_TOKEN }}

   * any exceptions thrown when attempting to close a closeable will be suppressed. Otherwise, the
   * <i>first</i> exception to be thrown from an attempt to close a closeable will be thrown and any
   * additional exceptions that are thrown after that will be suppressed.
   */
  @Override
  public void close() throws IOException {
    Throwable throwable = thrown;

    // close closeables in LIFO order
    while (!stack.isEmpty()) {

    try:
        yield dep_a
    finally:
        dep_a.close()


async def dependency_b(dep_a=Depends(dependency_a)):
    dep_b = generate_dep_b()
    try:
        yield dep_b
    finally:
        dep_b.close(dep_a)


async def dependency_c(dep_b=Depends(dependency_b)):
    dep_c = generate_dep_c()
    try:
        yield dep_c
    finally:

                }
                assertThat(path1, is(notNullValue()));
                assertThat(is, is(notNullValue()));
                count++;
            } finally {
                CloseableUtil.close(is);
            }
        });
        assertTrue(count > 0);
    }

    /**
     * @throws Exception
     */
    @Test
    public void testForEachJarFile() throws Exception {

        /**
         * Verifies that the close method can be called without throwing an exception.
         * @throws CIFSException if an error occurs during close.
         */
        @Test
        public void testClose() throws CIFSException {
            assertDoesNotThrow(() -> smbPipeHandle.close(), "close() should not throw an exception on a mock object.");
            // Verify that the close method was called

	if savePointer, ok := db.Dialector.(SavePointerDialectorInterface); ok {
		// close prepared statement, because SavePoint not support prepared statement.
		// e.g. mysql8.0 doc: https://dev.mysql.com/doc/refman/8.0/en/sql-prepared-statements.html
		var (
			preparedStmtTx   *PreparedStmtTX
			isPreparedStmtTx bool
		)
		// close prepared statement, because SavePoint not support prepared statement.

    @Test
    @DisplayName("ensureOpen throws after close() is called")
    void testEnsureOpenAfterClose() throws CIFSException {
        target.close();
        CIFSException ex = assertThrows(SmbException.class, () -> target.ensureOpen());
        assertTrue(ex.getMessage().contains("Pipe handle already closed"));
    }

    @Test
    @DisplayName("close() calls handle.close when open and handle.release otherwise; releases tree")

import okhttp3.internal.toImmutableList
import okhttp3.tls.internal.TlsUtil.newKeyManager
import okhttp3.tls.internal.TlsUtil.newTrustManager

/**
 * Certificates to identify which peers to trust and also to earn the trust of those peers in kind.
 * Client and server exchange these certificates during the handshake phase of a TLS connection.
 *
 * ### Server Authentication
 *

    System.out.println("MESSAGE: " + bytes.hex());
  }

  @Override public void onClosing(WebSocket webSocket, int code, String reason) {
    webSocket.close(1000, null);
    System.out.println("CLOSE: " + code + " " + reason);
  }

  @Override public void onFailure(WebSocket webSocket, Throwable t, Response response) {
    t.printStackTrace();
  }

  public static void main(String... args) {
    new WebSocketEcho().run();
  }

package jcifs.smb1.dcerpc.msrpc;

/**
 * Microsoft RPC LSA close handle request.
 * This class implements the LSARPC close handle operation for closing
 * LSA policy handles when they are no longer needed.
 */
public class MsrpcLsarClose extends lsarpc.LsarClose {

    /**
     * Creates a new request to close an LSA policy handle.
     *
     * @param policyHandle the policy handle to close
     */