}
            return resp.getAvailable();
        } catch (final SmbException se) {
            throw seToIoe(se);
        }
    }

    @Override
    public void close() {
        // ignore, the shared file descriptor is closed by the pipe handle
    }

    class ResourceManagementTests {

        @Test
        @DisplayName("close operation should work correctly")
        void testClose() {
            // When/Then
            assertDoesNotThrow(() -> mockResource.close(), "Close operation should not throw exception");
            verify(mockResource).close();
        }

        @Test
        @DisplayName("resource should be AutoCloseable")

    owner,
    repo,
    pull_number: pr_number
  });
  if (pr_resp.status != 200 || pr_resp.data.state != 'closed') {
    console.log(`PR:{pr_number} is not found or closed.  Not a valid condition to create an issue.`);
    console.log(pr_resp);
    throw `PR:{pr_number} needs to be valid and closed (merged)`;
  }
  const pr_title = pr_resp.data.title;
  // Assign to PR owner and reviewers

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbTransportPool#close()
     */
    @Override
    public boolean close() throws CIFSException {
        boolean inUse = false;

        // Cleanup first
        cleanup();
        log.debug("Closing pool");

        // Create a snapshot of connections to close
        List<SmbTransportImpl> toClose = new ArrayList<>(this.connections);

        return false;
    }

    /**
     * {@inheritDoc}
     *
     *
     * @see jcifs.CIFSContext#close()
     */
    @Override
    public boolean close() throws CIFSException {
        if (!this.closed) {
            Runtime.getRuntime().removeShutdownHook(this);
        }
        return false;
    }

    /**
     * {@inheritDoc}
     *

 * writes to, reads from, and closes the pipe in a single operation.
 * <li><code>TransactNamedPipe</code> A message-type pipe call that
 * writes to and reads from an existing pipe descriptor in one operation.
 * <li><code>CreateFile</code>, <code>ReadFile</code>,
 * <code>WriteFile</code>, and <code>CloseFile</code> A byte-type pipe can
 * be opened, written to, read from and closed using the standard Win32
 * file operations.

      return multiset().subMultiset(fromElement, CLOSED, toElement, OPEN).elementSet();
    }

    @Override
    public SortedSet<E> headSet(@ParametricNullness E toElement) {
      return multiset().headMultiset(toElement, OPEN).elementSet();
    }

    @Override
    public SortedSet<E> tailSet(@ParametricNullness E fromElement) {
      return multiset().tailMultiset(fromElement, CLOSED).elementSet();
    }

    @Override

        }
        return ioe;
    }

    /**
     * Closes this input stream and releases any system resources associated with the stream.
     *
     * @throws IOException if a network error occurs
     */

    @Override
    public void close() throws IOException {
        try {
            file.close();
            tmp = null;
        } catch (final SmbException se) {

package okhttp3.internal.connection

import okhttp3.Call
import okhttp3.Connection
import okhttp3.Route
import okio.IOException

/**
 * Listener for connection events. Extend this class to monitor the new connections and closes.
 *
 * All event methods must execute fast, without external locking, cannot throw exceptions,
 * attempt to mutate the event parameters, or be reentrant back into the client.

        handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
    }

    /**
     * Closes the LSA policy handle.
     *
     * @throws IOException if an I/O error occurs
     */
    public void close() throws IOException {
        final MsrpcLsarClose rpc = new MsrpcLsarClose(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0) {